OSchip
/
OpenBLAS
Not watched
1
0
Fork 0
Code
Releases 66 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 4b4e493381
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4b4e493381'
${ noResults }
OpenBLAS/cpp_thread_test/omatcopy_rt_bench.c

444 lines
18 kB
Raw Blame History 

  1. #include "common.h"

  2. /* +r: %0 = src, %1 = dst, %2 = src_ld, %3 = dst_ld, %4 = dst_tmp */

  3. /* m: %5 = num_rows, %6 = alpha */

  4. /* xmm15 = alpha */

  5. #ifdef HAVE_AVX

  6. #define TRANS_4x4(a1_no,a2_no,a3_no,a4_no,t1_no,t2_no,t3_no,t4_no)\

  7.   "vunpcklps %%xmm"#a2_no",%%xmm"#a1_no",%%xmm"#t1_no"; vunpckhps %%xmm"#a2_no",%%xmm"#a1_no",%%xmm"#t2_no";"\

  8.   "vunpcklps %%xmm"#a4_no",%%xmm"#a3_no",%%xmm"#t3_no"; vunpckhps %%xmm"#a4_no",%%xmm"#a3_no",%%xmm"#t4_no";"\

  9.   "vunpcklpd %%xmm"#t3_no",%%xmm"#t1_no",%%xmm"#a1_no"; vunpckhpd %%xmm"#t3_no",%%xmm"#t1_no",%%xmm"#a2_no";"\

  10.   "vunpcklpd %%xmm"#t4_no",%%xmm"#t2_no",%%xmm"#a3_no"; vunpckhpd %%xmm"#t4_no",%%xmm"#t2_no",%%xmm"#a4_no";"

  11. 

  12. #define TRANS_4x8(a1_no,a2_no,a3_no,a4_no,t1_no,t2_no,t3_no,t4_no)\

  13.   "vunpcklps %%ymm"#a2_no",%%ymm"#a1_no",%%ymm"#t1_no"; vunpckhps %%ymm"#a2_no",%%ymm"#a1_no",%%ymm"#t2_no";"\

  14.   "vunpcklps %%ymm"#a4_no",%%ymm"#a3_no",%%ymm"#t3_no"; vunpckhps %%ymm"#a4_no",%%ymm"#a3_no",%%ymm"#t4_no";"\

  15.   "vunpcklpd %%ymm"#t3_no",%%ymm"#t1_no",%%ymm"#a1_no"; vunpckhpd %%ymm"#t3_no",%%ymm"#t1_no",%%ymm"#a2_no";"\

  16.   "vunpcklpd %%ymm"#t4_no",%%ymm"#t2_no",%%ymm"#a3_no"; vunpckhpd %%ymm"#t4_no",%%ymm"#t2_no",%%ymm"#a4_no";"

  17. 

  18. #define SAVE_4x4(b1_no,b2_no,b3_no,b4_no)\

  19.   "vmovups %%xmm"#b1_no",(%4); vmovups %%xmm"#b2_no",(%4,%3,1); leaq (%4,%3,2),%4;"\

  20.   "vmovups %%xmm"#b3_no",(%4); vmovups %%xmm"#b4_no",(%4,%3,1); leaq (%4,%3,2),%4;"

  21. 

  22. #define SAVE_4x8(b1_no,b2_no,b3_no,b4_no) SAVE_4x4(b1_no,b2_no,b3_no,b4_no)\

  23.   "vextractf128 $1,%%ymm"#b1_no",(%4); vextractf128 $1,%%ymm"#b2_no",(%4,%3,1); leaq (%4,%3,2),%4;"\

  24.   "vextractf128 $1,%%ymm"#b3_no",(%4); vextractf128 $1,%%ymm"#b4_no",(%4,%3,1); leaq (%4,%3,2),%4;"

  25. 

  26. #define COPY_4x16 "movq %1,%4; addq $16,%1;"\

  27.   "vmulps (%0),%%ymm15,%%ymm0; vmulps 32(%0),%%ymm15,%%ymm4; vmulps (%0,%2,1),%%ymm15,%%ymm1; vmulps 32(%0,%2,1),%%ymm15,%%ymm5; leaq (%0,%2,2),%0;"\

  28.   "vmulps (%0),%%ymm15,%%ymm2; vmulps 32(%0),%%ymm15,%%ymm6; vmulps (%0,%2,1),%%ymm15,%%ymm3; vmulps 32(%0,%2,1),%%ymm15,%%ymm7; leaq (%0,%2,2),%0;"\

  29.   TRANS_4x8(0,1,2,3,8,9,10,11) SAVE_4x8(0,1,2,3)\

  30.   TRANS_4x8(4,5,6,7,8,9,10,11) SAVE_4x8(4,5,6,7)

  31. 

  32. #define COPY_4x8 "movq %1,%4; addq $16,%1;"\

  33.   "vmulps (%0),%%ymm15,%%ymm0; vmulps (%0,%2,1),%%ymm15,%%ymm1; leaq (%0,%2,2),%0;"\

  34.   "vmulps (%0),%%ymm15,%%ymm2; vmulps (%0,%2,1),%%ymm15,%%ymm3; leaq (%0,%2,2),%0;"\

  35.   TRANS_4x8(0,1,2,3,8,9,10,11) SAVE_4x8(0,1,2,3)

  36. 

  37. #define COPY_4x4 "movq %1,%4; addq $16,%1;"\

  38.   "vmulps (%0),%%xmm15,%%xmm0; vmulps (%0,%2,1),%%xmm15,%%xmm1; leaq (%0,%2,2),%0;"\

  39.   "vmulps (%0),%%xmm15,%%xmm2; vmulps (%0,%2,1),%%xmm15,%%xmm3; leaq (%0,%2,2),%0;"\

  40.   TRANS_4x4(0,1,2,3,8,9,10,11) SAVE_4x4(0,1,2,3)

  41. 

  42. #define COPY_4x2 \

  43.   "vmovsd (%0),%%xmm0; vmovhpd (%0,%2,1),%%xmm0,%%xmm0; vmulps %%xmm15,%%xmm0,%%xmm0; leaq (%0,%2,2),%0;"\

  44.   "vmovsd (%0),%%xmm1; vmovhpd (%0,%2,1),%%xmm1,%%xmm1; vmulps %%xmm15,%%xmm1,%%xmm1; leaq (%0,%2,2),%0;"\

  45.   "vpermilps $216,%%xmm0,%%xmm0; vpermilps $216,%%xmm1,%%xmm1; vunpcklpd %%xmm1,%%xmm0,%%xmm2; vunpckhpd %%xmm1,%%xmm0,%%xmm3;"\

  46.   "vmovups %%xmm2,(%1); vmovups %%xmm3,(%1,%3,1); addq $16,%1;"

  47. 

  48. #define COPY_4x1 \

  49.   "vmovss (%0),%%xmm0; vinsertps $16,(%0,%2,1),%%xmm0,%%xmm0; leaq (%0,%2,2),%0;"\

  50.   "vinsertps $32,(%0),%%xmm0,%%xmm0; vinsertps $48,(%0,%2,1),%%xmm0,%%xmm0; leaq (%0,%2,2),%0;"\

  51.   "vmulps %%xmm15,%%xmm0,%%xmm0; vmovups %%xmm0,(%1); addq $16,%1;"

  52. 

  53. #define SAVE_2x4(c1_no,c2_no,t1_no,t2_no) \

  54.   "vunpcklps %%xmm"#c2_no",%%xmm"#c1_no",%%xmm"#t1_no"; vmulps %%xmm15,%%xmm"#t1_no",%%xmm"#t1_no";"\

  55.   "vmovsd %%xmm"#t1_no",(%4); vmovhpd %%xmm"#t1_no",(%4,%3,1); leaq (%4,%3,2),%4;"\

  56.   "vunpckhps %%xmm"#c2_no",%%xmm"#c1_no",%%xmm"#t2_no"; vmulps %%xmm15,%%xmm"#t2_no",%%xmm"#t2_no";"\

  57.   "vmovsd %%xmm"#t2_no",(%4); vmovhpd %%xmm"#t2_no",(%4,%3,1); leaq (%4,%3,2),%4;"

  58. 

  59. #define COPY_2x16 "movq %1,%4; addq $8,%1;"\

  60.   "vmovups (%0),%%ymm0; vmovups 32(%0),%%ymm2; vmovups (%0,%2,1),%%ymm1; vmovups 32(%0,%2,1),%%ymm3; leaq (%0,%2,2),%0;"\

  61.   "vextractf128 $1,%%ymm0,%%xmm4; vextractf128 $1,%%ymm2,%%xmm6; vextractf128 $1,%%ymm1,%%xmm5; vextractf128 $1,%%ymm3,%%xmm7;"\

  62.   SAVE_2x4(0,1,8,9) SAVE_2x4(4,5,8,9) SAVE_2x4(2,3,8,9) SAVE_2x4(6,7,8,9)

  63. 

  64. #define COPY_2x8 "movq %1,%4; addq $8,%1;"\

  65.   "vmovups (%0),%%ymm0; vmovups (%0,%2,1),%%ymm1; leaq (%0,%2,2),%0;"\

  66.   "vextractf128 $1,%%ymm0,%%xmm2; vextractf128 $1,%%ymm1,%%xmm3;"\

  67.   SAVE_2x4(0,1,4,5) SAVE_2x4(2,3,4,5)

  68. 

  69. #define COPY_2x4 "movq %1,%4; addq $8,%1;"\

  70.   "vmovups (%0),%%xmm0; vmovups (%0,%2,1),%%xmm1; leaq (%0,%2,2),%0;"\

  71.   SAVE_2x4(0,1,4,5)

  72. 

  73. #define COPY_2x2 \

  74.   "vmovsd (%0),%%xmm0; vmovhpd (%0,%2,1),%%xmm0,%%xmm0; vmulps %%xmm15,%%xmm0,%%xmm0; leaq (%0,%2,2),%0; vpermilps $216,%%xmm0,%%xmm0;"\

  75.   "vmovsd %%xmm0,(%1); vmovhpd %%xmm0,(%1,%3,1); addq $8,%1;"

  76. 

  77. #define COPY_2x1 \

  78.   "vmovss (%0),%%xmm0; vinsertps $16,(%0,%2,1),%%xmm0,%%xmm0; vmulps %%xmm15,%%xmm0,%%xmm0; leaq (%0,%2,2),%0; vmovsd %%xmm0,(%1); addq $8,%1;"

  79. 

  80. #define SAVE_1x4(c1_no)\

  81.   "vmulps %%xmm15,%%xmm"#c1_no",%%xmm"#c1_no"; vmovss %%xmm"#c1_no",(%4); vextractps $1,%%xmm"#c1_no",(%4,%3,1); leaq (%4,%3,2),%4;"\

  82.   "vextractps $2,%%xmm"#c1_no",(%4); vextractps $3,%%xmm"#c1_no",(%4,%3,1); leaq (%4,%3,2),%4;"

  83. 

  84. #define COPY_1x16 "movq %1,%4; addq $4,%1;"\

  85.   "vmovups (%0),%%xmm1;" SAVE_1x4(1) "vmovups 16(%0),%%xmm2;" SAVE_1x4(2)\

  86.   "vmovups 32(%0),%%xmm1;" SAVE_1x4(1) "vmovups 48(%0),%%xmm2;" SAVE_1x4(2) "addq %2,%0;"

  87. 

  88. #define COPY_1x8 "movq %1,%4; addq $4,%1;"\

  89.   "vmovups (%0),%%xmm1;" SAVE_1x4(1) "vmovups 16(%0),%%xmm2;" SAVE_1x4(2) "addq %2,%0;"

  90. 

  91. #define COPY_1x4 "movq %1,%4; addq $4,%1; vmovups (%0),%%xmm1;" SAVE_1x4(1) "addq %2,%0;"

  92. 

  93. #define COPY_1x2 "vmovsd (%0),%%xmm1; addq %2,%0; vmulps %%xmm15,%%xmm1,%%xmm1; vmovss %%xmm1,(%1); vextractps $1,%%xmm1,(%1,%3,1); addq $4,%1;"

  94. 

  95. #define COPY_1x1 "vmulss (%0),%%xmm15,%%xmm1; vmovss %%xmm1,(%1); addq %2,%0; addq $4,%1;"

  96. 

  97. #define COMPUTE(ndim){\

  98.   src = src_base; dst = dst_base;\

  99.   __asm__ __volatile__(\

  100.     "vbroadcastss %6,%%ymm15; movq %5,%%r11; cmpq $4,%%r11; jb "#ndim"32f;"\

  101.     #ndim"31:\n\t"\

  102.     COPY_4x##ndim "subq $4,%%r11; cmpq $4,%%r11; jnb "#ndim"31b;"\

  103.     #ndim"32:\n\t"\

  104.     "cmpq $2,%%r11; jb "#ndim"33f;"\

  105.     COPY_2x##ndim "subq $2,%%r11;"\

  106.     #ndim"33:\n\t"\

  107.     "testq %%r11,%%r11; jz "#ndim"34f;"\

  108.     COPY_1x##ndim "subq $1,%%r11;"\

  109.     #ndim"34:\n\t"\

  110.     :"+r"(src),"+r"(dst),"+r"(src_ld_bytes),"+r"(dst_ld_bytes),"+r"(dst_tmp):"m"(num_rows),"m"(ALPHA):"r11","cc","memory"\

  111.     ,"xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7","xmm8","xmm9","xmm10","xmm11","xmm12","xmm13","xmm14","xmm15");\

  112. }

  113. #endif

  114. 

  115. #ifndef FLOAT

  116.  #define FLOAT float

  117. #endif

  118. 

  119. #define ROWS_OF_BLOCK 384

  120. #ifndef BLASLONG

  121.  #define BLASLONG long

  122. #endif

  123. #include <stdint.h>

  124. #include <string.h>

  125. #ifdef HAVE_AVX

  126. int CNAME(BLASLONG rows, BLASLONG cols, FLOAT alpha, FLOAT *a, BLASLONG lda, FLOAT *b, BLASLONG ldb){

  127.   float *src, *dst, *dst_tmp, *src_base, *dst_base;

  128.   uint64_t src_ld_bytes = (uint64_t)lda * sizeof(float), dst_ld_bytes = (uint64_t)ldb * sizeof(float), num_rows = 0;

  129.   BLASLONG cols_left, rows_done; float ALPHA = alpha;

  130.   if(ALPHA==0.0){

  131.     dst_base = b;

  132.     for(cols_left=cols;cols_left>0;cols_left--) {memset(dst_base,0,rows*sizeof(float)); dst_base += ldb;}

  133.     return 0;

  134.   }

  135.   for(rows_done=0;rows_done<rows;rows_done+=num_rows){

  136.     num_rows = rows-rows_done;

  137.     if(num_rows > ROWS_OF_BLOCK) num_rows = ROWS_OF_BLOCK;

  138.     cols_left = cols; src_base = a + (int64_t)lda * (int64_t)rows_done; dst_base = b + rows_done;

  139.     if(ldb%1024>3 && ldb%1024<1021) for(;cols_left>15;cols_left-=16){COMPUTE(16) src_base += 16; dst_base += 16 * ldb;}

  140.     for(;cols_left>7;cols_left-=8){COMPUTE(8) src_base += 8; dst_base += 8 * ldb;}

  141.     for(;cols_left>3;cols_left-=4){COMPUTE(4) src_base += 4; dst_base += 4 * ldb;}

  142.     for(;cols_left>1;cols_left-=2){COMPUTE(2) src_base += 2; dst_base += 2 * ldb;}

  143.     if(cols_left>0){COMPUTE(1) src_base ++; dst_base += ldb;}

  144.   }

  145.   return 0;

  146. }

  147. #endif

  148. 

  149. int CNAME2(BLASLONG rows, BLASLONG cols, FLOAT alpha, FLOAT *a, BLASLONG lda, FLOAT *b, BLASLONG ldb)

  150. {

  151.     BLASLONG i, j;

  152.     FLOAT *a_offset, *a_offset1, *a_offset2, *a_offset3, *a_offset4;

  153.     FLOAT *b_offset, *b_offset1, *b_offset2, *b_offset3, *b_offset4;

  154. 

  155.     if (rows <= 0)  return 0;

  156.     if (cols <= 0)  return 0;

  157. 

  158.     a_offset = a;

  159.     b_offset = b;

  160. 

  161.     i = (rows >> 2);

  162.     if (i > 0) {

  163.         do {

  164.             a_offset1 = a_offset;

  165.             a_offset2 = a_offset1 + lda;

  166.             a_offset3 = a_offset2 + lda;

  167.             a_offset4 = a_offset3 + lda;

  168.             a_offset += 4 * lda;

  169. 

  170.             b_offset1 = b_offset;

  171.             b_offset2 = b_offset1 + ldb;

  172.             b_offset3 = b_offset2 + ldb;

  173.             b_offset4 = b_offset3 + ldb;

  174.             b_offset += 4;

  175. 

  176.             j = (cols >> 2);

  177.             if (j > 0) {

  178.                 do {

  179.                 /* Column 1 of MAT_B */

  180.                 *(b_offset1 + 0) = *(a_offset1 + 0)*alpha; // Row 1 of MAT_A

  181.                 *(b_offset2 + 0) = *(a_offset1 + 1)*alpha;

  182.                 *(b_offset3 + 0) = *(a_offset1 + 2)*alpha;

  183.                 *(b_offset4 + 0) = *(a_offset1 + 3)*alpha;

  184. 

  185.                 /* Column 2 of MAT_B */

  186.                 *(b_offset1 + 1) = *(a_offset2 + 0)*alpha; // Row 2 of MAT_A

  187.                 *(b_offset2 + 1) = *(a_offset2 + 1)*alpha;

  188.                 *(b_offset3 + 1) = *(a_offset2 + 2)*alpha;

  189.                 *(b_offset4 + 1) = *(a_offset2 + 3)*alpha;

  190. 

  191.                 /* Column 3 of MAT_B */

  192.                 *(b_offset1 + 2) = *(a_offset3 + 0)*alpha; // Row 3 of MAT_A

  193.                 *(b_offset2 + 2) = *(a_offset3 + 1)*alpha;

  194.                 *(b_offset3 + 2) = *(a_offset3 + 2)*alpha;

  195.                 *(b_offset4 + 2) = *(a_offset3 + 3)*alpha;

  196. 

  197.                 /* Column 4 of MAT_B */

  198.                 *(b_offset1 + 3) = *(a_offset4 + 0)*alpha; // Row 4 of MAT_A

  199.                 *(b_offset2 + 3) = *(a_offset4 + 1)*alpha;

  200.                 *(b_offset3 + 3) = *(a_offset4 + 2)*alpha;

  201.                 *(b_offset4 + 3) = *(a_offset4 + 3)*alpha;

  202. 

  203.                 a_offset1 += 4;

  204.                 a_offset2 += 4;

  205.                 a_offset3 += 4;

  206.                 a_offset4 += 4;

  207.                 b_offset1 += ldb * 4;

  208.                 b_offset2 += ldb * 4;

  209.                 b_offset3 += ldb * 4;

  210.                 b_offset4 += ldb * 4;

  211.                 

  212.                 j--;

  213.                 } while (j > 0);

  214.             } // if(j > 0)

  215. 

  216. 

  217.             if (cols & 2) {

  218.                 *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  219.                 *(b_offset2 + 0) = *(a_offset1 + 1)*alpha;

  220. 

  221.                 *(b_offset1 + 1) = *(a_offset2 + 0)*alpha;

  222.                 *(b_offset2 + 1) = *(a_offset2 + 1)*alpha;

  223. 

  224.                 *(b_offset1 + 2) = *(a_offset3 + 0)*alpha;

  225.                 *(b_offset2 + 2) = *(a_offset3 + 1)*alpha;

  226. 

  227.                 *(b_offset1 + 3) = *(a_offset4 + 0)*alpha;

  228.                 *(b_offset2 + 3) = *(a_offset4 + 1)*alpha;

  229. 

  230.                 a_offset1 += 2;

  231.                 a_offset2 += 2;

  232.                 a_offset3 += 2;

  233.                 a_offset4 += 2;

  234. 

  235.                 b_offset1 += ldb*2;

  236. 

  237.             }

  238. 

  239.             if (cols & 1) {

  240.                 *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  241. 

  242.                 *(b_offset1 + 1) = *(a_offset2 + 0)*alpha;

  243. 

  244.                 *(b_offset1 + 2) = *(a_offset3 + 0)*alpha;

  245. 

  246.                 *(b_offset1 + 3) = *(a_offset4 + 0)*alpha;

  247.             }

  248. 

  249.             i--;

  250.         } while (i > 0);

  251.     }

  252. 

  253. 

  254.     if (rows & 2) {

  255.         a_offset1 = a_offset;

  256.         a_offset2 = a_offset1 + lda;

  257.         a_offset += 2 * lda;

  258. 

  259.         b_offset1 = b_offset;

  260.         b_offset2 = b_offset1 + ldb;

  261.         b_offset3 = b_offset2 + ldb;

  262.         b_offset4 = b_offset3 + ldb;

  263.         b_offset += 2;

  264. 

  265.         j = (cols >> 2);

  266.         if (j > 0){

  267.             do {

  268.                 *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  269.                 *(b_offset2 + 0) = *(a_offset1 + 1)*alpha;

  270.                 *(b_offset3 + 0) = *(a_offset1 + 2)*alpha;

  271.                 *(b_offset4 + 0) = *(a_offset1 + 3)*alpha;

  272. 

  273.                 *(b_offset1 + 1) = *(a_offset2 + 0)*alpha;

  274.                 *(b_offset2 + 1) = *(a_offset2 + 1)*alpha;

  275.                 *(b_offset3 + 1) = *(a_offset2 + 2)*alpha;

  276.                 *(b_offset4 + 1) = *(a_offset2 + 3)*alpha;

  277.                 

  278.                 a_offset1 += 4;

  279.                 a_offset2 += 4;

  280.                 b_offset1 += ldb * 4;

  281.                 b_offset2 += ldb * 4;

  282.                 b_offset3 += ldb * 4;

  283.                 b_offset4 += ldb * 4;

  284. 

  285.                 j--;

  286.             } while (j > 0);

  287.         }

  288. 

  289. 

  290.         if (cols & 2){

  291.             *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  292.             *(b_offset2 + 0) = *(a_offset1 + 1)*alpha;

  293. 

  294.             *(b_offset1 + 1) = *(a_offset2 + 0)*alpha;

  295.             *(b_offset2 + 1) = *(a_offset2 + 1)*alpha;

  296. 

  297.             a_offset1 += 2;

  298.             a_offset2 += 2;

  299.             b_offset1 += ldb*2;

  300. 

  301.         }

  302. 

  303. 

  304.         if (cols & 1){

  305.             *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  306.             *(b_offset1 + 1) = *(a_offset2 + 0)*alpha;

  307.         }

  308.     } // if (rows & 2)

  309. 

  310. 

  311.     if (rows & 1) {

  312.         a_offset1 = a_offset;

  313.         a_offset += lda;

  314. 

  315.         b_offset1 = b_offset;

  316.         b_offset2 = b_offset1 + ldb;

  317.         b_offset3 = b_offset2 + ldb;

  318.         b_offset4 = b_offset3 + ldb;

  319. 

  320.         j = (cols >> 2);

  321.         if (j > 0){

  322.             do {

  323.                 *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  324.                 *(b_offset2 + 0) = *(a_offset1 + 1)*alpha;

  325.                 *(b_offset3 + 0) = *(a_offset1 + 2)*alpha;

  326.                 *(b_offset4 + 0) = *(a_offset1 + 3)*alpha;

  327.                 

  328.                 a_offset1 += 4;

  329.                 b_offset1 += ldb * 4;

  330.                 b_offset2 += ldb * 4;

  331.                 b_offset3 += ldb * 4;

  332.                 b_offset4 += ldb * 4;

  333.                 

  334.                 j--;

  335.             } while (j > 0);

  336.         }

  337. 

  338.         if (cols & 2){

  339.             *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  340.             *(b_offset2 + 0) = *(a_offset1 + 1)*alpha;

  341. 

  342.             a_offset1 += 2;

  343.             b_offset1 += ldb * 2;

  344.         }

  345. 

  346.         if (cols & 1){

  347.             *(b_offset1 + 0) = *(a_offset1 + 0)*alpha;

  348.         }

  349.     }

  350. 

  351.     return 0;

  352. }

  353. 

  354. 

  355. #ifndef CNAME

  356. int REF(BLASLONG rows, BLASLONG cols, FLOAT alpha, FLOAT *a, BLASLONG lda, FLOAT *b, BLASLONG ldb){

  357.   BLASLONG i,j;

  358.   FLOAT *aptr,*bptr;

  359.   if (rows <= 0)  return 0;

  360.   if (cols <= 0)  return 0;

  361.   aptr = a;

  362.   for(i=0;i<rows;i++){

  363.     bptr = &b[i];

  364.     for(j=0;j<cols;j++) bptr[j*ldb] = alpha * aptr[j];

  365.     aptr += lda;

  366.   }

  367.   return 0;

  368. }

  369. #include <stdio.h>

  370. #include <stdlib.h>

  371. #include <sys/time.h>

  372. int main(){

  373.   struct timeval time1,time2,time3,time4;

  374.   int testdim[5]={2000,4000,6000,8000,10000}; long length = testdim[4]*testdim[4];

  375.   const float alpha = 1.5; const long lda = testdim[4] - testdim[4]%60, ldb = testdim[4] - testdim[4]%70;

  376.   float *A = (float *)malloc(length*sizeof(float));

  377.   float *B1 = (float *)malloc(length*sizeof(float));

  378.   float *B2 = (float *)malloc(length*sizeof(float));

  379.   float *B3 = (float *)malloc(length*sizeof(float));

  380.   long count, rows, cols, iter, usec1, usec2, usec3; float tmpdif,maxdif,tmpdif2,maxdif2;

  381.   for(count=0;count<length;count++) A[count]=B1[count]=B2[count]=B3[count]=(float)rand()/(float)RAND_MAX;

  382.   for(iter=0;iter<5;iter++){

  383.     rows = testdim[iter] - testdim[iter] % 23;

  384.     cols = testdim[iter] - testdim[iter] % 53;

  385. #ifdef HAVE_AVX

  386.     CNAME(rows,cols,alpha,A,lda,B2,ldb);

  387. #endif

  388.     REF(rows,cols,alpha,A,lda,B1,ldb);

  389.     CNAME2(rows,cols,alpha,A,lda,B3,ldb);

  390.     printf("\nTest omatcopy_rt with rows = %ld and cols = %ld.\n",rows,cols);

  391.     gettimeofday(&time1,0);

  392. #ifdef HAVE_AVX

  393.     CNAME(rows,cols,alpha,A,lda,B2,ldb);

  394. #endif

  395.     gettimeofday(&time2,0);

  396.     REF(rows,cols,alpha,A,lda,B1,ldb);

  397.     gettimeofday(&time3,0);

  398.     CNAME2(rows,cols,alpha,A,lda,B3,ldb);

  399.     gettimeofday(&time4,0);

  400.     usec1 = (time2.tv_sec - time1.tv_sec) * 1000000 + (time2.tv_usec - time1.tv_usec);

  401.     usec2 = (time3.tv_sec - time2.tv_sec) * 1000000 + (time3.tv_usec - time2.tv_usec);

  402.     usec3 = (time4.tv_sec - time3.tv_sec) * 1000000 + (time4.tv_usec - time3.tv_usec);

  403.     printf("Reference C  implementation: %.2e M elements per second.\n",(double)rows*(double)cols/(double)usec2);

  404. #ifdef HAVE_AVX

  405.     printf("AVX-enhanced implementation: %.2e M elements per second.\n",(double)rows*(double)cols/(double)usec1);

  406. #endif

  407.     printf("4x4 blocked C implementation: %.2e M elements per second.\n",(double)rows*(double)cols/(double)usec3);

  408.     maxdif=0.0;

  409.     for(count=0;count<length;count++){

  410.       tmpdif = B2[count] - B1[count];

  411.       tmpdif2 = B3[count] - B1[count];

  412.       if(tmpdif<0) tmpdif*=-1.0;

  413.       if(tmpdif>maxdif) maxdif = tmpdif;

  414.       if(tmpdif2<0) tmpdif2 *=-1.0;

  415.       if(tmpdif2>maxdif2) maxdif2 = tmpdif2;

  416.     }

  417. #ifdef HAVE_AVX

  418.     printf("Maxdiff between output matrices: (AVX vx Ref %.2e\n",maxdif);

  419. #endif

  420.     printf("Maxdiff between output matrices: (4x4 vx Ref %.2e\n",maxdif2);

  421. #ifdef HAVE_AVX

  422.     CNAME(rows/2,cols/2,0.0,A,lda,B2,ldb);

  423. #endif

  424.     REF(rows/2,cols/2,0.0,A,lda,B1,ldb);

  425.     CNAME2(rows/2,cols/2,0.0,A,lda,B3,ldb);

  426.     maxdif=0.0;

  427.     maxdif2=0.0;

  428.     for(count=0;count<length;count++){

  429.       tmpdif = B2[count] - B1[count];

  430.       tmpdif2 = B3[count] - B1[count];

  431.       if(tmpdif<0) tmpdif*=-1.0;

  432.       if(tmpdif>maxdif) maxdif = tmpdif;

  433.       if(tmpdif2<0) tmpdif2 *=-1.0;

  434.       if(tmpdif2>maxdif2) maxdif2 = tmpdif2;

  435.     }

  436. #ifdef HAVE_AVX

  437.     printf("Maxdiff between output matrices after subsequent alpha=zero runs: AVX vs Ref %.2e\n",maxdif);

  438. #endif

  439.     printf("Maxdiff between output matrices after subsequent alpha=zero runs: 4x4 vs Ref %.2e\n",maxdif2);

  440.   }

  441.   free(A); free(B1); free(B2); free(B3); A=B1=B2=B3=NULL;

  442. }

  443. #endif