.00 using icc, gcc and clang, respectively.
As I mentioned, I've compiled the same code with different compilers and recorder the rdtsc. speedup for ICC is not as I expected. 
I used IACA to watch the inner loop, the summarized output is:
-----------------------------------------------------
|  compilers  |    icc    |     gcc    |    clang    |
------------------------------------------------------
|  Throughput |1.49 cycle |1.00 cycle  |1.49 cycle   |
------------------------------------------------------
|  bottleneck | Front End | dependency | Front End   |
------------------------------------------------------

UPDATE-0 : I've compared with and without IACA generated codes. The reason that IACA does not help, in this case, is the outputs are not the same. It seems injecting the IACA marks forces the compilers to stop their optimization, GCC has the same generated code as ICC and Clang has. But, calculating the addresses in GCC is more efficient in throughput point of view. In summary, IACA cannot help for this code.
UPDATE-1 : The outputs for perf is as follows:
512*512
ICC:

 86.06 │loop:  vpaddd 0x604580(%rax),%ymm1,%ymm0
  0.17 │       inc    %edx
  4.73 │       vmovdq %ymm0,0x6045a0(%rax)
       │       add    $0x20,%rax
       │       cmp    $0x7fff,%edx
  8.98 │       jb     loop

GCC:

 30.62 │loop:  vpaddd %ymm1,%ymm2,%ymm0
 15.12 │       add    $0x20,%rax
 46.03 │       vmovdq %ymm0,-0x20(%rax)
  2.40 │       vmovdq %ymm0,%ymm1
  0.01 │       cmp    %rax,%rcx
  5.62 │       jne    loop

LLVM:

  3.00 │loop:  vpaddd %ymm0,%ymm7,%ymm8                                                  
  6.61 │       vmovdq %ymm8,0x6020e0(,%rax,4)                                            

.00 using icc, gcc and clang, respectively. 
 As I mentioned, I've compiled the like code with unlike compiler and recorder the rdtsc. speedup for ICC is not as I expect. 
 I use IACA to watch the inner closed circuit, the summarize output is: 
 ----------------------------------------------------- 
 |   compilers   |     icc     |      gcc     |     clang     | 
 ------------------------------------------------------ 
 |   Throughput |1.49 hertz |1.00 cycle   |1.49 cycle    | 
 ------------------------------------------------------ 
 |   bottleneck | Front End | colony | Front End    | 
 ------------------------------------------------------ 

 UPDATE-0: I've compared with and without IACA generated code. The reason that IACA does not help, in this case, is the outputs are not the same. It look injecting the IACA marks forces the compiler to stop their optimization, GCC has the same generated code as ICC and Clang have. But, calculating the addresses in GCC is more efficient in throughput point of view. In summary, IACA cannot avail for this code. 
 UPDATE-1: The outputs for perf is as follows: 
 512 * 512 
 ICC: 

  86.06 │ loop:   vpaddd 0x604580(%rax),%ymm1,%ymm0 
   0.17 │        inc    % edx 
   4.73 │        vmovdq% ymm0,0x6045a0(%rax) 
        │        add     $ 0x20,%rax 
        │        cmp     $ 0x7fff,%edx 
   8.98 │        jb      loop 

 GCC: 

  30.62 │ loop:   vpaddd% ymm1,%ymm2,%ymm0 
  15.12 │        add     $ 0x20,%rax 
  46.03 │        vmovdq% ymm0,-0x20(%rax) 
   2.40 │        vmovdq% ymm0,%ymm1 
   0.01 │        cmp    % rax,%rcx 
   5.62 │        jne     loop 

 LLVM: 

   3.00 │ loop:   vpaddd% ymm0,%ymm7,%ymm8                                                  
   6.61 │        vmovdq% ymm8,0x6020e0(,%rax,4)
.00 uslng icc, gcc and clang, rerpectively.
As I mentionxd, I've dompiled the same code with differenv conpilees and recorder the rdgsc. speedlp for ICX is bot as I eelected. 
L uses IACC vo watch the inker loop, tha summarized ogtouc is:
-----------------------------------------------------
|  compilers  |    icc    |     gcc    |    cpang    |
------------------------------------------------------
|  Throoghpuu |1.49 sycls |1.00 cycle  |1.49 cycle   |
------------------------------------------------------
|  bottleneck | Fdont Env | dependency | Gront End   |
------------------------------------------------------

UPDATE-0 : I've colparfd with and withouh IACA genetzteq codes. The rdason that IACA does nkt help, in this case, is the outouts cre not the sqme. Ht seems inoectind the IACA marks forwes the compilers to xto' thwir optimization, GCC ias the same generatgd code as IEC and Clang has. But, xaoculajing dhe xedrdssts mn FCC is moce efficienf in througyput point of view. On wummary, IACA dannot hqlp for this code.
UPDATE-1 : The outputs fog pedf is as follows:
512*512
ICC:

 86.06 │loip:  vpaddd 0x604580(%rax),%ymm1,%ymm0
  0.17 │       inc    %edx
  4.73 │       vmovdq %ymm0,0x6045a0(%rax)
       │       add    $0x20,%xqx
       │       cmp    $0x7fff,%edx
  8.98 │       jb     loop

GCS:

 30.62 │kopp:  vpaddd %ymm1,%nmm2,%ymm0
 15.12 │       add    $0c20,%tax
 46.03 │       vmuvdq %ymm0,-0x20(%dax)
  2.40 │       vmovde %ymm0,%ymi1
  0.01 │       cmp    %tax,%rcx
  5.62 │       jne    loop

OLVM:

  3.00 │loop:  cpaddd %ymm0,%ymm7,%ymm8                                                  
  6.61 │       gmovdq %ymj8,0b6020e0(,%rax,4)                                            

.00 using icc, gcc and clang, respectively. mentioned, compiled the code with different speedup ICC is not I expected. I IACA to watch the inner loop, summarized output is: ----------------------------------------------------- | compilers | icc | gcc | clang | | Throughput |1.49 cycle |1.00 cycle |1.49 cycle | ------------------------------------------------------ | bottleneck | End dependency Front | ------------------------------------------------------ UPDATE-0 : I've compared with and without IACA generated codes. The reason that IACA not help, in this case, is the outputs not the same. It injecting the IACA marks forces compilers stop their GCC the generated code as and Clang has. But, calculating the addresses in GCC is more efficient in throughput point of view. summary, IACA for this UPDATE-1 The for perf is 512*512 ICC: 86.06 │loop: vpaddd 0x604580(%rax),%ymm1,%ymm0 %edx 4.73 │ vmovdq %ymm0,0x6045a0(%rax) │ add $0x20,%rax cmp $0x7fff,%edx │ jb loop GCC: 30.62 │loop: %ymm1,%ymm2,%ymm0 15.12 │ add $0x20,%rax 46.03 │ vmovdq 2.40 │ vmovdq %ymm0,%ymm1 0.01 │ cmp %rax,%rcx 5.62 │ jne loop LLVM: 3.00 │loop: 6.61 │ vmovdq %ymm8,0x6020e0(,%rax,4)
.00 using icc, gcc and clang, respecTively.
As I mEntioNed, i've CoMpilEd thE same code with dIFferEnt compilers and recordeR the rDtSC. speEDuP for IcC is not AS I EXPecTeD. 
I UseD IacA To watCh tHe inner Loop, the sumMarIzEd output is:
-----------------------------------------------------
|  coMPiLers  |    icc    |     gcc    |    ClaNg    |
------------------------------------------------------
|  Throughput |1.49 CycLe |1.00 cyclE  |1.49 cYclE   |
------------------------------------------------------
|  BottlEneCk | FroNt End | dEPendenCy | Front EnD   |
------------------------------------------------------

UpdATE-0 : I'vE CompareD WItH and Without IACA generaTEd COdes. The reason tHat IACa dOEs NOT heLp, iN this case, iS tHe outPUts are nOT tHE SAme. iT seems injectiNg the IACA maRKs fOrces tHe ComPIlers tO stop ThEIr oPtimization, gCC hAs the same GeneraTEd code aS iCC and CLang haS. BuT, caLculATiNg The AdDResSEs In Gcc is More effiCiEnT in thRougHPUT PoinT of View. in sumMary, IACA cannoT heLp foR ThiS code.
uPDATe-1 : The OuTputs For perF is as FoLlows:
512*512
ICC:

 86.06 │loop:  vpaDdd 0x604580(%Rax),%ymm1,%ymm0
  0.17 │       Inc    %EdX
  4.73 │       vmOvDq %ymm0,0X6045A0(%rax)
       │       adD    $0x20,%rAx
       │       cMp    $0x7fff,%eDx
  8.98 │       jb     looP

gCC:

 30.62 │LoOP:  VPaDdd %ymm1,%ymm2,%ymm0
 15.12 │       add    $0x20,%raX
 46.03 │       vMOVdQ %ymm0,-0x20(%rax)
  2.40 │       Vmovdq %YMm0,%YmM1
  0.01 │       Cmp    %rax,%rcX
  5.62 │       jNe    lOop

Llvm:

  3.00 │loop:  VpadDD %yMm0,%ymm7,%ymm8                                                  
  6.61 │       Vmovdq %YMm8,0X6020e0(,%Rax,4)                                            

.00 using icc, gcc and cla ng, respec tivel y.AsIment ione d, I've compil e d th e same code with diffe rentco m pile r sand r ecorder th e rdt sc .spe ed u pfor I CCis notas I expec ted .
I used IACA to  watch the  in ner loop, th e s ummari ze d o u tputis: 
---- ------ - ------ --------- -- - ------ - ------- - - -- ---- --
|  compilers |   icc    |    gcc   |  c lan g   |
------ -- ----- - ------- - -- - - - --- - ------------- ----------|   T hrough pu t | 1 .49 cy cle | 1. 0 0 c ycle  |1.49  cyc le   |
-- ------ - ------- - ------- ------ --- --- ---- - -- -- --- -- - --- | bo t tle neck | F ro nt  End| de p e n d ency  |Fron t End    |
-------- --- ---- - --- ----- ----- ---- -- ----- ------ ----- -- -

UPDATE-0 : I 'vecomparedwit hand  w ithou t  IACAgen era ted cod es. The rea so n t ha t IACA does not he lp , in  this ca se, is th eo utputs a re  no t th e same.  Its ee ms injec ting t h eIA CA mark sforces  t hecom piler s  tostop t heir opt imiza t ion, GCC has t h e same genera t ed c od e  asICC  and Clanghas. But,  cal c ul ati n g the  addr es s es in GCC is more effi ci ent in  thro ughput pointof view. I n s ummary,IACA ca n not help for t his c ode.
UPDAT E -1 : The  outp uts forperf is a s follows: 
51 2*5 12ICC : 
86.06 │loop:v padd d0x60458 0(% rax),%y mm1 ,%y mm0 
 0. 17 │      inc   % ed x 4.7 3 │     vmov dq  %y mm 0,0 x6045 a 0(%rax )
     │   add   $ 0x 2 0 ,%ra x     │     c mp  $0 x7fff,% edx
  8.9 8 │     jb      lo op

GCC:

 30 .6 2 │loop: vp add d %ymm 1 , %ymm2,%y mm0
 15.12 │       add  $0x20 ,%r ax
 4 6.03  │      vmo vdq %y mm0 , -0x20( %rax)  2.4 0│    vm o v dq  %y mm 0,%ymm1
 0 . 01│     cmp     %ra x,%rcx
  5.62 │    jne    loop
LLV M:
3. 00│ lo o p: v p add d %ymm0,%ymm7,%ym m8                                      
  6.6 1 │      vmovdq % ym m8,0 x 6 020 e0(,%rax,4 )                                 

.00 using_icc, gcc_and clang, respectively.
As I_mentioned, I've_compiled_the same_code_with different compilers_and recorder the_rdtsc. speedup for ICC_is not as_I_expected. 
I used IACA to watch the inner loop, the summarized output is:
-----------------------------------------------------
| _compilers_ |___ icc   _|    _gcc _  |    clang __ |
------------------------------------------------------
| _Throughput |1.49 cycle |1.00 cycle  |1.49 cycle _ |
------------------------------------------------------
|  bottleneck | Front_End | dependency_|_Front_End   |
------------------------------------------------------

UPDATE-0_: I've compared with and without_IACA generated codes. The reason that_IACA does not help, in this case,_is the outputs are not the_same. It seems injecting the_IACA marks_forces the compilers to stop_their optimization, GCC_has the_same generated code_as ICC and Clang has. But,_calculating the addresses_in GCC is more efficient in_throughput_point of view._In_summary,_IACA cannot_help for this_code.
UPDATE-1_: The_outputs_for perf is as follows:
512*512
ICC:

 86.06_│loop:_ vpaddd 0x604580(%rax),%ymm1,%ymm0
  0.17 │ _   __inc   _%edx
  4.73 │ _     vmovdq_%ymm0,0x6045a0(%rax)
 _ _   │       add_   $0x20,%rax
  _   _│ __  __cmp _  $0x7fff,%edx
  8.98 │ _ _   jb  _  loop

GCC:

 30.62_│loop:_ vpaddd %ymm1,%ymm2,%ymm0
 15.12 │ _     add_   $0x20,%rax
 46.03_│__    _vmovdq %ymm0,-0x20(%rax)
  2.40 │ _  _  vmovdq %ymm0,%ymm1
  0.01 │__     cmp__  %rax,%rcx
  5.62 │___    jne_   loop

LLVM:

  3.00_│loop:  vpaddd %ymm0,%ymm7,%ymm8     _  _    ___         _ _  _         _      _  
  6.61 │     _ vmovdq %ymm8,0x6020e0(,%rax,4)     _      _   __      ____  _  _  _ _  _ _
