<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" version="2.0">
  <channel>
    <title>topic Re: gemm(A,A,A) like possible? in Intel® oneAPI Math Kernel Library</title>
    <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880471#M9474</link>
    <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/367365"&gt;tim18&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt; I think the documentation does answer the question; you are considering forcing a violation of the specification on which operands are unchanged. Besides, the reference implementation is Fortran, and compilers were expected to implement at least all "legal" optimizations, including those which rely on the caller's use of arguments being in compliance with Fortran. &lt;BR /&gt;You could compile the reference source code with invocation of an option which supports aliased arguments, such as ifort /assume:dummy_aliases (which had to be put in place because of the IMSL practice of supporting over-write, in violation of Fortran standard). Then you would have to test all 4 combinations of the TRANS arguments, to check whether your proposed practice breaks it.&lt;BR /&gt;&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;&lt;EM&gt;I think the documentation does answer the question; you are considering forcing a violation of the specification on which operands are unchanged.&lt;/EM&gt;&lt;/P&gt;
&lt;P&gt;Well, may be, may be not.&lt;/P&gt;
&lt;P&gt;The meaning of&lt;EM&gt;operands are unchanged &lt;/EM&gt;has always only had the meaning to me that these are not changed by the procedure itself (as for example in the case the procedure only reads the operands).&lt;/P&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Anyway, the behaviour I now see puzzles me.&lt;/P&gt;
&lt;P&gt;I have tried and tested a gemm(A,B,B, beta=0.0) like call for 2x2 matrices. And it really returns zero in B (i.e. returns a wrong result).&lt;/P&gt;
&lt;P&gt;Nonetheless, before I wrote anything of this thread, in one of my programs I had tried and written an expression along these lines, and it had worked. Only afterwards I started to hesitate and decided to ask here in the list. Now, though I have tried quite a few things, I don't know how it is possible. Any test I've done shows gemm(A,B,B, beta=0.0) doesn't work (for matrices 2x2), however, in the 'big' program it somehow works...&lt;/P&gt;
&lt;P&gt;In the program, the actual call is&lt;/P&gt;
&lt;P&gt;call gemm(W(:,:,i), G(:,:,1), G(:,:,1), beta = zz)&lt;/P&gt;
&lt;P&gt;where zz denotes a complex double precision zero, G and W are complex double precision matrices, the sizes of the first two indices is 36x36, i is some integer index.&lt;/P&gt;
&lt;P&gt;(I could understand if there were G(:,1,:) instead, but it is not...; the same for e.g. G(:,:,1) + 0.0 instead of the 2nd argument; again it's not.)&lt;/P&gt;
&lt;P&gt;Can anything happen so that such behaviour would be possible?&lt;/P&gt;
&lt;P&gt;(For the tests I used the same compiler, mkl and options all the time.)&lt;/P&gt;
&lt;P&gt;Thanks&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;
&lt;P&gt;&lt;/P&gt;</description>
    <pubDate>Sun, 22 Nov 2009 20:18:25 GMT</pubDate>
    <dc:creator>rudolfii</dc:creator>
    <dc:date>2009-11-22T20:18:25Z</dc:date>
    <item>
      <title>gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880469#M9472</link>
      <description>&lt;P&gt;Hello,&lt;/P&gt;
&lt;P&gt;not knowing the internals I don't know if it is possible to safely write matrix multiplication in the form like&lt;/P&gt;
&lt;P&gt;gemm(A, A, A)&lt;/P&gt;
&lt;P&gt;where (e.g.) all matrices are the same, or one has to use some temporary matrix as&lt;/P&gt;
&lt;P&gt;Z=A&lt;/P&gt;
&lt;P&gt;gemm(A,A,Z)&lt;/P&gt;
&lt;P&gt;A=Z&lt;/P&gt;
&lt;P&gt;(The code above should return A = A + A*A.)&lt;/P&gt;
&lt;P&gt;All documentation usually mentions that in gemm(A,B,C) A, B are untouched and C is overwritten. But this really does not answer the question since it somehow expects A, B, C to be different (or at least that C is different from A and B).&lt;/P&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Thanks!&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;</description>
      <pubDate>Sat, 21 Nov 2009 09:56:29 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880469#M9472</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-21T09:56:29Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880470#M9473</link>
      <description>&lt;DIV style="margin:0px;"&gt;&lt;/DIV&gt;
I think the documentation does answer the question; you are considering forcing a violation of the specification on which operands are unchanged. Besides, the reference implementation is Fortran, and compilers were expected to implement at least all "legal" optimizations, including those which rely on the caller's use of arguments being in compliance with Fortran. &lt;BR /&gt;You could compile the reference source code with invocation of an option which supports aliased arguments, such as ifort /assume:dummy_aliases (which had to be put in place because of the IMSL practice of supporting over-write, in violation of Fortran standard). Then you would have to test all 4 combinations of the TRANS arguments, to check whether your proposed practice breaks it.&lt;BR /&gt;</description>
      <pubDate>Sat, 21 Nov 2009 15:51:02 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880470#M9473</guid>
      <dc:creator>TimP</dc:creator>
      <dc:date>2009-11-21T15:51:02Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880471#M9474</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/367365"&gt;tim18&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt; I think the documentation does answer the question; you are considering forcing a violation of the specification on which operands are unchanged. Besides, the reference implementation is Fortran, and compilers were expected to implement at least all "legal" optimizations, including those which rely on the caller's use of arguments being in compliance with Fortran. &lt;BR /&gt;You could compile the reference source code with invocation of an option which supports aliased arguments, such as ifort /assume:dummy_aliases (which had to be put in place because of the IMSL practice of supporting over-write, in violation of Fortran standard). Then you would have to test all 4 combinations of the TRANS arguments, to check whether your proposed practice breaks it.&lt;BR /&gt;&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;&lt;EM&gt;I think the documentation does answer the question; you are considering forcing a violation of the specification on which operands are unchanged.&lt;/EM&gt;&lt;/P&gt;
&lt;P&gt;Well, may be, may be not.&lt;/P&gt;
&lt;P&gt;The meaning of&lt;EM&gt;operands are unchanged &lt;/EM&gt;has always only had the meaning to me that these are not changed by the procedure itself (as for example in the case the procedure only reads the operands).&lt;/P&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Anyway, the behaviour I now see puzzles me.&lt;/P&gt;
&lt;P&gt;I have tried and tested a gemm(A,B,B, beta=0.0) like call for 2x2 matrices. And it really returns zero in B (i.e. returns a wrong result).&lt;/P&gt;
&lt;P&gt;Nonetheless, before I wrote anything of this thread, in one of my programs I had tried and written an expression along these lines, and it had worked. Only afterwards I started to hesitate and decided to ask here in the list. Now, though I have tried quite a few things, I don't know how it is possible. Any test I've done shows gemm(A,B,B, beta=0.0) doesn't work (for matrices 2x2), however, in the 'big' program it somehow works...&lt;/P&gt;
&lt;P&gt;In the program, the actual call is&lt;/P&gt;
&lt;P&gt;call gemm(W(:,:,i), G(:,:,1), G(:,:,1), beta = zz)&lt;/P&gt;
&lt;P&gt;where zz denotes a complex double precision zero, G and W are complex double precision matrices, the sizes of the first two indices is 36x36, i is some integer index.&lt;/P&gt;
&lt;P&gt;(I could understand if there were G(:,1,:) instead, but it is not...; the same for e.g. G(:,:,1) + 0.0 instead of the 2nd argument; again it's not.)&lt;/P&gt;
&lt;P&gt;Can anything happen so that such behaviour would be possible?&lt;/P&gt;
&lt;P&gt;(For the tests I used the same compiler, mkl and options all the time.)&lt;/P&gt;
&lt;P&gt;Thanks&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;
&lt;P&gt;&lt;/P&gt;</description>
      <pubDate>Sun, 22 Nov 2009 20:18:25 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880471#M9474</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-22T20:18:25Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880472#M9475</link>
      <description>&lt;DIV style="margin:0px;"&gt;&lt;/DIV&gt;
The compiler would likely copy the array sections into new local arrays, so you would not be over-writing an input.&lt;BR /&gt;The ifort option -check:arg_temp_created should give you a run-time message if that happens.&lt;BR /&gt;For G(:,1,:) this would be mandatory.&lt;BR /&gt;</description>
      <pubDate>Sun, 22 Nov 2009 22:17:57 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880472#M9475</guid>
      <dc:creator>TimP</dc:creator>
      <dc:date>2009-11-22T22:17:57Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880473#M9476</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="margin-top: 5px; width: 100%;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/329367"&gt;rudolfii&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt;
&lt;P&gt;Hello,&lt;/P&gt;
&lt;P&gt;not knowing the internals I don't know if it is possible to safely write matrix multiplication in the form like&lt;/P&gt;
&lt;P&gt;gemm(A, A, A)&lt;/P&gt;
&lt;P&gt;where (e.g.) all matrices are the same, or one has to use some temporary matrix as&lt;/P&gt;
&lt;P&gt;Z=A&lt;/P&gt;
&lt;P&gt;gemm(A,A,Z)&lt;/P&gt;
&lt;P&gt;A=Z&lt;/P&gt;
&lt;P&gt;(The code above should return A = A + A*A.)&lt;/P&gt;
&lt;P&gt;All documentation usually mentions that in gemm(A,B,C) A, B are untouched and C is overwritten. But this really does not answer the question since it somehow expects A, B, C to be different (or at least that C is different from A and B).&lt;/P&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Thanks!&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;
&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;BR /&gt;No.</description>
      <pubDate>Sun, 22 Nov 2009 22:28:00 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880473#M9476</guid>
      <dc:creator>yuriisig</dc:creator>
      <dc:date>2009-11-22T22:28:00Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880474#M9477</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/367365"&gt;tim18&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt; The compiler would likely copy the array sections into new local arrays, so you would not be over-writing an input.&lt;BR /&gt;The ifort option -check:arg_temp_created should give you a run-time message if that happens.&lt;BR /&gt;For G(:,1,:) this would be mandatory.&lt;BR /&gt;&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Thanks.&lt;/P&gt;
&lt;P&gt;I tried different -check options (-check all; -check arg_temp_created), but none of those gave me any runtime- or compile-time message...&lt;/P&gt;
&lt;P&gt;I now have a program whose behaviour differs depending on how large the used matrices are. Until some size like A(7,7) I am obtaining zeros, for A(8,8) and bigger I am getting a good result of the calculation...&lt;/P&gt;
&lt;P&gt;But there is no warning of any kind (I suppose it'd be written to stdout or stderr; thus on the terminal under usual conditions).&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;</description>
      <pubDate>Sun, 22 Nov 2009 22:56:38 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880474#M9477</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-22T22:56:38Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880475#M9478</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="margin-top: 5px; width: 100%;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/329367"&gt;rudolfii&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Thanks.&lt;/P&gt;
&lt;P&gt;I tried different -check options (-check all; -check arg_temp_created), but none of those gave me any runtime- or compile-time message...&lt;/P&gt;
&lt;P&gt;I now have a program whose behaviour differs depending on how large the used matrices are. Until some size like A(7,7) I am obtaining zeros, for A(8,8) and bigger I am getting a good result of the calculation...&lt;/P&gt;
&lt;P&gt;But there is no warning of any kind (I suppose it'd be written to stdout or stderr; thus on the terminal under usual conditions).&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;
&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;BR /&gt;You fool about. I understand multiplication of matrixes a little: &lt;A href="http://www.thesa-store.com/products/" target="_blank"&gt;http://www.thesa-store.com/products/&lt;/A&gt;&lt;BR /&gt;</description>
      <pubDate>Sun, 22 Nov 2009 23:13:08 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880475#M9478</guid>
      <dc:creator>yuriisig</dc:creator>
      <dc:date>2009-11-22T23:13:08Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880476#M9479</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/312233"&gt;yuriisig&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt;
&lt;DIV style="margin:0px;"&gt;&lt;/DIV&gt;
&lt;BR /&gt;You fool about. I understand multiplication of matrixes a little: &lt;A href="http://www.thesa-store.com/products/" target="_blank"&gt;http://www.thesa-store.com/products/&lt;/A&gt;&lt;BR /&gt;&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Although you may, your contribution here is worth nothing...&lt;/P&gt;
&lt;P&gt;I need to have at least some idea about what has been happening in order to decide whether some rusults of calculations carried out by a 'wrong' code can be believed. As it seems, they can, although I don't know why.&lt;/P&gt;
&lt;P&gt;The very code has been meanwhile corrected as soon as I realized that gemm(A,B,B) is generally wrong.&lt;/P&gt;
&lt;P&gt;Ruda&lt;/P&gt;</description>
      <pubDate>Mon, 23 Nov 2009 00:26:18 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880476#M9479</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-23T00:26:18Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880477#M9480</link>
      <description>&lt;BR /&gt;Ruda,&lt;BR /&gt;&lt;BR /&gt;The Fortran specification in the section "Restrictions on entities associated with dummy arguments" states that if there is a partial overlap between the actual arguments associated with two different dummy arguments of the same procedure, theoverlapped portions cannot be defined during the execution of the procedure. These restrictions are intended to facilitate compiler optimizations in the procedure. &lt;BR /&gt;&lt;BR /&gt;Since the last matrixargument in gemm is defined during execution of gemm, it shall not be overlapped with the first two matrices. In other words, calling gemm(A,A,A) is not conforming to Fortran specification. &lt;BR /&gt;&lt;BR /&gt;Thanks&lt;BR /&gt;Dima&lt;BR /&gt;</description>
      <pubDate>Mon, 23 Nov 2009 06:34:17 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880477#M9480</guid>
      <dc:creator>Dmitry_B_Intel</dc:creator>
      <dc:date>2009-11-23T06:34:17Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880478#M9481</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/93647"&gt;Dmitry Baksheev (Intel)&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt;&lt;BR /&gt;Ruda,&lt;BR /&gt;&lt;BR /&gt;The Fortran specification in the section "Restrictions on entities associated with dummy arguments" states that if there is a partial overlap between the actual arguments associated with two different dummy arguments of the same procedure, theoverlapped portions cannot be defined during the execution of the procedure. These restrictions are intended to facilitate compiler optimizations in the procedure. &lt;BR /&gt;&lt;BR /&gt;Since the last matrixargument in gemm is defined during execution of gemm, it shall not be overlapped with the first two matrices. In other words, calling gemm(A,A,A) is not conforming to Fortran specification. &lt;BR /&gt;&lt;BR /&gt;Thanks&lt;BR /&gt;Dima&lt;BR /&gt;&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;BR /&gt;Thanks Dima!&lt;BR /&gt;I understand what you say (hopefully it also means that gemm(A,A,B) where A and B do not overlap is ok).&lt;BR /&gt;&lt;BR /&gt;The only thing that I'm still missing is why my code (having a gemm(A,B,B) call) worked. I understand that if, for any reason, a copy of the 2nd argument is made during the call, the result is ok (as in gemm(A,B+0.0,B)). But even when the checks are active, specifically arg_temp_created, there is no sign of making a temporary copy. And still it is correct...&lt;BR /&gt;&lt;BR /&gt;Thanks&lt;BR /&gt;Ruda&lt;BR /&gt;</description>
      <pubDate>Mon, 23 Nov 2009 09:33:35 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880478#M9481</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-23T09:33:35Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880479#M9482</link>
      <description>&lt;DIV style="margin:0px;"&gt;&lt;/DIV&gt;
&lt;P&gt;&lt;BR /&gt;Ruda,&lt;BR /&gt;&lt;BR /&gt;That improper use produced correct result should not be surprising, because it might have produced &lt;EM&gt;any&lt;/EM&gt; result. In general case, saylarge B, arbitrary beta, and copy-in/copy-out argument passing mechanism avoided, you will see that gemm(A,B,B) computes trash.&lt;/P&gt;
&lt;P&gt;Thanks&lt;BR /&gt;Dima&lt;/P&gt;</description>
      <pubDate>Mon, 23 Nov 2009 12:28:43 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880479#M9482</guid>
      <dc:creator>Dmitry_B_Intel</dc:creator>
      <dc:date>2009-11-23T12:28:43Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880480#M9483</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/93647"&gt;Dmitry Baksheev (Intel)&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt;
&lt;P&gt;&lt;BR /&gt;Ruda,&lt;BR /&gt;&lt;BR /&gt;That improper use produced correct result should not be surprising, because it might have produced &lt;EM&gt;any&lt;/EM&gt; result. In general case, saylarge B, arbitrary beta, and copy-in/copy-out argument passing mechanism avoided, you will see that gemm(A,B,B) computes trash.&lt;/P&gt;
&lt;P&gt;Thanks&lt;BR /&gt;Dima&lt;/P&gt;
&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;BR /&gt;I know that generally gemm(A,B,B) computes trash. But if it gives out a good result some time, isn't it a sign that a temporary copy was used? But then if yes, compiler should have said it was (with -check all). But it does not say anything. That surprises me...&lt;BR /&gt;&lt;BR /&gt;Thanks&lt;BR /&gt;Ruda&lt;BR /&gt;</description>
      <pubDate>Mon, 23 Nov 2009 12:45:10 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880480#M9483</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-23T12:45:10Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880481#M9484</link>
      <description>&lt;DIV style="margin:0px;"&gt;&lt;/DIV&gt;
&lt;BR /&gt;MKL functions may internally docopying that would improve performance. This should not be considered as a sign thata temporarycopy is always used. The functionwas not compiled with the compiler flags that would make it report of the copying.&lt;BR /&gt;&lt;BR /&gt;Thanks&lt;BR /&gt;Dima&lt;BR /&gt;</description>
      <pubDate>Mon, 23 Nov 2009 13:08:52 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880481#M9484</guid>
      <dc:creator>Dmitry_B_Intel</dc:creator>
      <dc:date>2009-11-23T13:08:52Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880482#M9485</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="width: 100%; margin-top: 5px;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/93647"&gt;Dmitry Baksheev (Intel)&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt; &lt;BR /&gt;MKL functions may internally docopying that would improve performance. This should not be considered as a sign thata temporarycopy is always used. The functionwas not compiled with the compiler flags that would make it report of the copying.&lt;BR /&gt;&lt;BR /&gt;Thanks&lt;BR /&gt;Dima&lt;BR /&gt;&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;BR /&gt;Thanks&lt;BR /&gt;Ruda&lt;BR /&gt;</description>
      <pubDate>Mon, 23 Nov 2009 13:12:20 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880482#M9485</guid>
      <dc:creator>rudolfii</dc:creator>
      <dc:date>2009-11-23T13:12:20Z</dc:date>
    </item>
    <item>
      <title>Re: gemm(A,A,A) like possible?</title>
      <link>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880483#M9486</link>
      <description>&lt;DIV style="margin:0px;"&gt;
&lt;DIV id="quote_reply" style="margin-top: 5px; width: 100%;"&gt;
&lt;DIV style="margin-left:2px;margin-right:2px;"&gt;Quoting - &lt;A href="https://community.intel.com/en-us/profile/329367"&gt;rudolfii&lt;/A&gt;&lt;/DIV&gt;
&lt;DIV style="background-color:#E5E5E5; padding:5px;border: 1px; border-style: inset;margin-left:2px;margin-right:2px;"&gt;&lt;EM&gt;
&lt;P&gt;&lt;/P&gt;
&lt;P&gt;Although you may...&lt;/P&gt;
&lt;/EM&gt;&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;/DIV&gt;
&lt;BR /&gt;Therefore I have written that you are engaged in nonsense. If there is no memory it is necessary to operate differently.&lt;BR /&gt;</description>
      <pubDate>Mon, 23 Nov 2009 16:00:48 GMT</pubDate>
      <guid>https://community.intel.com/t5/Intel-oneAPI-Math-Kernel-Library/gemm-A-A-A-like-possible/m-p/880483#M9486</guid>
      <dc:creator>yuriisig</dc:creator>
      <dc:date>2009-11-23T16:00:48Z</dc:date>
    </item>
  </channel>
</rss>

