Exemple #1
0
static SIMD_T vdot(SIMD_T a[], SIMD_T b[], int n)
{
	int i;
	vector s = { 0.0, 0.0, 0.0, 0.0 };
	vec_enter();
	vec_mov_mr(s, reg0);
        for (i = n - VECLEN; i >= 0; i -= VECLEN) {
		vec_mov_mr_a(a + i, reg1);
		vec_mul_mr_a(b + i, reg1);
		vec_add_rr(reg1, reg0);
	}
	vec_mov_rm(reg0, s);
	vec_exit();
#if VECLEN == 2
	return s[0] + s[1];
#else
	return s[0] + s[1] + s[2] + s[3];
#endif
}
Exemple #2
0
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)

{
   /*--- program info ---*/
   /*  $Revision: 1.3 $  */
   /*  loadfirst = 'a'  */
   /*  nu = 1  */
   /*  k_loop = None  */
   /*  problem = 'gemm'  */
   /*  nregs = 8  */
   /*  split = 0  */
   /*  n_cleanup = {}  */
   /*  mu = 2  */
   /*  ku = 4  */
   /*  rev = '$Revision: 1.3 $'  */
   /*  applyfilter = 0  */
   /*  align_jumps = 0  */
   /*  prec = 'single'  */
   /*  m_cleanup = {}  */
   /*  used_outside_len = 60  */
   /*  k_cleanup = {'mustfit': 56, 'method': 'acc1', 'compile': 1}  */
   /*  outputdir = 'Linux_PIII/'  */
   /*  arch = 'sse'  */
   /*  pipelength = 3  */
   /*  atlasname = 'Linux_PIII'  */
   /*  method = 'acc'  */
   /*  used_lastuse = 'b'  */
   /*  outside_len = 60  */
   /*  lastuse = 1  */
   /*  veclen = 4  */
   /*  sched = ['fuse', 'spread']  */
   /*  used_directload_b = 0  */
   /*  used_directload_a = 1  */

   /*--- achitecture specific declarations ---*/

   /*--- program specific declarations ---*/
   int i, j, k;
   vector betavec;
   vector zerovec = {0.0,0.0,0.0,0.0};
   const float *pA0 = A;
   const float *pB0 = B;
   float *pC0 = C;
   const float *stM = A + MB*KB;
   const float *stN = B + NB*KB;
   const int incAm = 2*KB-KB+60;
   const int incBm = -KB+60;
   const int incCm = (2 SHIFT);
   const int incAn = -MB*KB;
   const int incBn = 1*KB;
   const int incCn = ((ldc*1-MB) SHIFT);

   /*--- initial arhitecture specific statements ---*/

   /*--- main program statements ---*/
   vec_mov_mr_1(&beta,reg0);
   vec_mov_rm(reg0,betavec);
   do /* N-loop */
   {
      do /* M-loop */
      {
#ifdef BETA0
         vec_mov_mr(zerovec,reg7);
         vec_mov_rr(reg7,reg0);
         vec_mov_rr(reg7,reg1);
#elif defined(BETA1)
         vec_mov_mr_1(pC0,reg0);
         vec_mov_mr_1(pC0+(1 SHIFT),reg1);
#else
         vec_mov_mr(betavec,reg7);
         vec_mov_mr_1(pC0,reg0);
         vec_mul_rr(reg7,reg0);
         vec_mov_mr_1(pC0+(1 SHIFT),reg1);
         vec_mul_rr(reg7,reg1);
#endif
         vec_mov_mr_a(pB0,reg5);
         vec_mov_mr_a(pA0,reg2);
         vec_mul_rr(reg5,reg2);
         vec_add_rr(reg2,reg0);
         vec_mul_mr_a(pA0+KB,reg5);
         vec_add_rr(reg5,reg1);
         vec_mov_mr_a(pB0+4,reg6);
         vec_mov_mr_a(pA0+4,reg3);
         vec_mul_rr(reg6,reg3);
         vec_add_rr(reg3,reg0);
         vec_mul_mr_a(pA0+4+KB,reg6);
         vec_add_rr(reg6,reg1);
         vec_mov_mr_a(pB0+8,reg7);
         vec_mov_mr_a(pA0+8,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg0);
         vec_mul_mr_a(pA0+8+KB,reg7);
         vec_add_rr(reg7,reg1);
         vec_mov_mr_a(pB0+12,reg5);
         vec_mov_mr_a(pA0+12,reg2);
         vec_mul_rr(reg5,reg2);
         vec_add_rr(reg2,reg0);
         vec_mul_mr_a(pA0+12+KB,reg5);
         vec_add_rr(reg5,reg1);
         vec_mov_mr_a(pB0+16,reg6);
         vec_mov_mr_a(pA0+16,reg3);
         vec_mul_rr(reg6,reg3);
         vec_add_rr(reg3,reg0);
         vec_mul_mr_a(pA0+16+KB,reg6);
         vec_add_rr(reg6,reg1);
         vec_mov_mr_a(pB0+20,reg7);
         vec_mov_mr_a(pA0+20,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg0);
         vec_mul_mr_a(pA0+20+KB,reg7);
         vec_add_rr(reg7,reg1);
         vec_mov_mr_a(pB0+24,reg5);
         vec_mov_mr_a(pA0+24,reg2);
         vec_mul_rr(reg5,reg2);
         vec_add_rr(reg2,reg0);
         vec_mul_mr_a(pA0+24+KB,reg5);
         vec_add_rr(reg5,reg1);
         vec_mov_mr_a(pB0+28,reg6);
         vec_mov_mr_a(pA0+28,reg3);
         vec_mul_rr(reg6,reg3);
         vec_add_rr(reg3,reg0);
         vec_mul_mr_a(pA0+28+KB,reg6);
         vec_add_rr(reg6,reg1);
         vec_mov_mr_a(pB0+32,reg7);
         vec_mov_mr_a(pA0+32,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg0);
         vec_mul_mr_a(pA0+32+KB,reg7);
         vec_add_rr(reg7,reg1);
         vec_mov_mr_a(pB0+36,reg5);
         vec_mov_mr_a(pA0+36,reg2);
         vec_mul_rr(reg5,reg2);
         vec_add_rr(reg2,reg0);
         vec_mul_mr_a(pA0+36+KB,reg5);
         vec_add_rr(reg5,reg1);
         vec_mov_mr_a(pB0+40,reg6);
         vec_mov_mr_a(pA0+40,reg3);
         vec_mul_rr(reg6,reg3);
         vec_add_rr(reg3,reg0);
         vec_mul_mr_a(pA0+40+KB,reg6);
         vec_add_rr(reg6,reg1);
         vec_mov_mr_a(pB0+44,reg7);
         vec_mov_mr_a(pA0+44,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg0);
         vec_mul_mr_a(pA0+44+KB,reg7);
         vec_add_rr(reg7,reg1);
         vec_mov_mr_a(pB0+48,reg5);
         vec_mov_mr_a(pA0+48,reg2);
         vec_mul_rr(reg5,reg2);
         vec_add_rr(reg2,reg0);
         vec_mul_mr_a(pA0+48+KB,reg5);
         vec_add_rr(reg5,reg1);
         vec_mov_mr_a(pB0+52,reg6);
         vec_mov_mr_a(pA0+52,reg3);
         vec_mul_rr(reg6,reg3);
         vec_add_rr(reg3,reg0);
         vec_mul_mr_a(pA0+52+KB,reg6);
         vec_add_rr(reg6,reg1);
         vec_mov_mr_a(pB0+56,reg5);
         vec_mov_mr_a(pA0+56,reg2);
         vec_mul_rr(reg5,reg2);
         vec_add_rr(reg2,reg0);
         vec_mul_mr_a(pA0+56+KB,reg5);
         vec_add_rr(reg5,reg1);
         vec_sum(reg0);
         vec_sum(reg1);
         vec_mov_rm_1(reg0,pC0);
         vec_mov_rm_1(reg1,pC0+(1 SHIFT));
         pA0 += incAm;
         pB0 += incBm;
         pC0 += incCm;
      }
      while(pA0 != stM);

      pA0 += incAn;
      pB0 += incBn;
      pC0 += incCn;
   }
   while(pB0 != stN);

   }
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)

{
   /*--- achitecture specific declarations ---*/

   /*--- program specific declarations ---*/
   int i, j, k;
   vector betavec;
   vector zerovec = {0.0,0.0};
   const float *pA0 = A;
   const float *pB0 = B;
   float *pC0 = C;
   float *pC1 = C+(ldc SHIFT);
   const float *stM = A + (M-M%2)*KB;
   const float *stN = B + NB*KB;
   const int incAm = 2*KB-KB+4;
   const int incBm = -KB+4;
   const int incCm = (2 SHIFT);
   const int incAn = -(M-M%2)*KB;
   const int incBn = 2*KB;
   const int incCn = ((ldc*2-(M-M%2)) SHIFT);
   const int incAm_m = KB-KB+4;
   const int incAn_m = -(M%2)*KB;
   const int incCn_m = (ldc*2-(M%2))SHIFT;
   const float *stM_m = A + M*KB;

   /*--- initial arhitecture specific statements ---*/
   vec_enter();

   /*--- main program statements ---*/
   vec_mov_mr_1(&beta,reg0);
   vec_mov_rm(reg0,betavec);
   if (M>=2)
   {
      do /* N-loop */
      {
         do /* M-loop */
         {
#ifdef BETA0
            vec_zero(reg0);
            vec_zero(reg1);
            vec_zero(reg2);
            vec_zero(reg3);
#elif defined(BETA1)
            vec_mov_mr_1(pC0,reg0);
            vec_mov_mr_1(pC0+(1 SHIFT),reg1);
            vec_mov_mr_1(pC1,reg2);
            vec_mov_mr_1(pC1+(1 SHIFT),reg3);
#else
            vec_mov_mr(betavec,reg7);
            vec_mov_mr_1(pC0,reg0);
            vec_mul_rr(reg7,reg0);
            vec_mov_mr_1(pC0+(1 SHIFT),reg1);
            vec_mul_rr(reg7,reg1);
            vec_mov_mr_1(pC1,reg2);
            vec_mul_rr(reg7,reg2);
            vec_mov_mr_1(pC1+(1 SHIFT),reg3);
            vec_mul_rr(reg7,reg3);
#endif
            vec_mov_mr(pA0,reg4);
            vec_mul_mr(pB0,reg4);
            vec_mov_mr(pA0+KB,reg5);
            vec_mul_mr(pB0,reg5);
            vec_mov_mr(pA0,reg6);
            vec_mov_mr(pA0+KB,reg7);
            align();
            for (k=0; k<KB-4; k+=16)
            {
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+2,reg4);
               vec_mul_mr(pB0+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+2+KB,reg5);
               vec_mul_mr(pB0+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+2,reg6);
               vec_mul_mr(pB0+2,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+2+KB,reg7);
               vec_mul_mr(pB0+2,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+4,reg4);
               vec_mul_mr(pB0+2+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+4+KB,reg5);
               vec_mul_mr(pB0+2+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+4,reg6);
               vec_mul_mr(pB0+4,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+4+KB,reg7);
               vec_mul_mr(pB0+4,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+6,reg4);
               vec_mul_mr(pB0+4+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+6+KB,reg5);
               vec_mul_mr(pB0+4+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+6,reg6);
               vec_mul_mr(pB0+6,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+6+KB,reg7);
               vec_mul_mr(pB0+6,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+8,reg4);
               vec_mul_mr(pB0+6+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+8+KB,reg5);
               vec_mul_mr(pB0+6+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+8,reg6);
               vec_mul_mr(pB0+8,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+8+KB,reg7);
               vec_mul_mr(pB0+8,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+10,reg4);
               vec_mul_mr(pB0+8+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+10+KB,reg5);
               vec_mul_mr(pB0+8+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+10,reg6);
               vec_mul_mr(pB0+10,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+10+KB,reg7);
               vec_mul_mr(pB0+10,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+12,reg4);
               vec_mul_mr(pB0+10+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+12+KB,reg5);
               vec_mul_mr(pB0+10+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+12,reg6);
               vec_mul_mr(pB0+12,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+12+KB,reg7);
               vec_mul_mr(pB0+12,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+14,reg4);
               vec_mul_mr(pB0+12+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+14+KB,reg5);
               vec_mul_mr(pB0+12+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+14,reg6);
               vec_mul_mr(pB0+14,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+14+KB,reg7);
               vec_mul_mr(pB0+14,reg5);
               vec_add_rr(reg4,reg0);
               vec_mov_mr(pA0+16,reg4);
               vec_mul_mr(pB0+14+KB,reg6);
               vec_add_rr(reg5,reg1);
               vec_mov_mr(pA0+16+KB,reg5);
               vec_mul_mr(pB0+14+KB,reg7);
               vec_add_rr(reg6,reg2);
               vec_mov_mr(pA0+16,reg6);
               vec_mul_mr(pB0+16,reg4);
               vec_add_rr(reg7,reg3);
               vec_mov_mr(pA0+16+KB,reg7);
               vec_mul_mr(pB0+16,reg5);

               pA0 += 16;
               pB0 += 16;
            }
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+2,reg4);
            vec_mul_mr(pB0+KB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+2+KB,reg5);
            vec_mul_mr(pB0+KB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+2,reg6);
            vec_mul_mr(pB0+2,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+2+KB,reg7);
            vec_mul_mr(pB0+2,reg5);
            vec_add_rr(reg4,reg0);
            vec_add_rr(reg5,reg1);
            vec_mul_mr(pB0+2+KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mul_mr(pB0+2+KB,reg7);
            vec_add_rr(reg7,reg3);
            vec_sum(reg0);
            vec_sum(reg1);
            vec_sum(reg2);
            vec_sum(reg3);
            vec_mov_rm_1(reg0,pC0);
            vec_mov_rm_1(reg1,pC0+(1 SHIFT));
            vec_mov_rm_1(reg2,pC1);
            vec_mov_rm_1(reg3,pC1+(1 SHIFT));
            pA0 += incAm;
            pB0 += incBm;
            pC0 += incCm;
            pC1 += incCm;
         }
         while(pA0 != stM);

         pA0 += incAn;
         pB0 += incBn;
         pC0 += incCn;
         pC1 += incCn;
      }
      while(pB0 != stN);

   }
   if (M%2>0)
   {
      pC0 = C+((M-M%2)SHIFT);
      pC1 = C+(ldc SHIFT)+((M-M%2)SHIFT);
      pA0 = A+(M-M%2)*KB;
      pB0 = B;
      do /* N-loop */
      {
         do /* M-loop */
         {
#ifdef BETA0
            vec_zero(reg0);
            vec_zero(reg1);
#elif defined(BETA1)
            vec_mov_mr_1(pC0,reg0);
            vec_mov_mr_1(pC1,reg1);
#else
            vec_mov_mr(betavec,reg7);
            vec_mov_mr_1(pC0,reg0);
            vec_mul_rr(reg7,reg0);
            vec_mov_mr_1(pC1,reg1);
            vec_mul_rr(reg7,reg1);
#endif
            vec_mov_mr(pA0,reg6);
            align();
            for (k=0; k<KB-4; k+=16)
            {
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+2,reg6);
               vec_mul_mr(pB0+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+2,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+4,reg6);
               vec_mul_mr(pB0+2+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+4,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+6,reg6);
               vec_mul_mr(pB0+4+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+6,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+8,reg6);
               vec_mul_mr(pB0+6+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+8,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+10,reg6);
               vec_mul_mr(pB0+8+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+10,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+12,reg6);
               vec_mul_mr(pB0+10+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+12,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+14,reg6);
               vec_mul_mr(pB0+12+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);
               vec_mov_rr(reg6,reg2);
               vec_mul_mr(pB0+14,reg2);
               vec_mov_rr(reg6,reg3);
               vec_mov_mr(pA0+16,reg6);
               vec_mul_mr(pB0+14+KB,reg3);
               vec_add_rr(reg2,reg0);
               vec_add_rr(reg3,reg1);

               pA0 += 16;
               pB0 += 16;
            }
            vec_mov_rr(reg6,reg2);
            vec_mul_mr(pB0,reg2);
            vec_mov_rr(reg6,reg3);
            vec_mov_mr(pA0+2,reg6);
            vec_mul_mr(pB0+KB,reg3);
            vec_add_rr(reg2,reg0);
            vec_add_rr(reg3,reg1);
            vec_mov_rr(reg6,reg2);
            vec_mul_mr(pB0+2,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_rr(reg6,reg3);
            vec_mul_mr(pB0+2+KB,reg3);
            vec_add_rr(reg3,reg1);
            vec_sum(reg0);
            vec_sum(reg1);
            vec_mov_rm_1(reg0,pC0);
            vec_mov_rm_1(reg1,pC1);
            pA0 += incAm_m;
            pB0 += incBm;
            pC0 += (1 SHIFT);
            pC1 += (1 SHIFT);
         }
         while(pA0 != stM_m);

         pA0 += incAn_m;
         pB0 += incBn;
         pC0 += incCn_m;
         pC1 += incCn_m;
      }
      while(pB0 != stN);

   }
   vec_exit();
}
void ATL_USERMM
(const int M, const int N, const int K, const double alpha, const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc)

{
   /*--- program info ---*/
   /*  $Revision: 1.3 $  */
   /*  loadfirst = 'b'  */
   /*  nu = 4  */
   /*  k_loop = 'for'  */
   /*  problem = 'gemm'  */
   /*  nregs = 8  */
   /*  split = 1  */
   /*  n_cleanup = {}  */
   /*  mu = 1  */
   /*  ku = 8  */
   /*  rev = '$Revision: 1.3 $'  */
   /*  applyfilter = 0  */
   /*  align_jumps = 0  */
   /*  prec = 'double'  */
   /*  m_cleanup = {}  */
   /*  used_outside_len = 8  */
   /*  k_cleanup = {}  */
   /*  outputdir = 'Linux_P4/'  */
   /*  arch = 'sse2'  */
   /*  pipelength = 3  */
   /*  atlasname = 'Linux_P4'  */
   /*  method = 'acc'  */
   /*  used_lastuse = None  */
   /*  used_directload_a = 0  */
   /*  outside_len = 'ku'  */
   /*  veclen = 2  */
   /*  sched = ['spread', 'fuse']  */
   /*  used_directload_b = 1  */
   /*  lastuse = 0  */

   /*--- achitecture specific declarations ---*/

   /*--- program specific declarations ---*/
   int i, j, k;
   vector betavec;
   vector zerovec = {0.0,0.0};
   const double *pA0 = A;
   const double *pB0 = B;
   double *pC0 = C;
   double *pC1 = C+(ldc SHIFT);
   double *pC2 = C+(2*ldc SHIFT);
   double *pC3 = C+(3*ldc SHIFT);
   const double *stM = A + MB*KB;
   const double *stN = B + NB*KB;
   const int incAm = 1*KB-KB+8;
   const int incBm = -KB+8;
   const int incCm = (1 SHIFT);
   const int incAn = -MB*KB;
   const int incBn = 4*KB;
   const int incCn = ((ldc*4-MB) SHIFT);

   /*--- initial arhitecture specific statements ---*/
   
   /*--- main program statements ---*/
   vec_mov_mr_1(&beta,reg0);
   vec_mov_rm(reg0,betavec);
   do /* N-loop */
   {
      do /* M-loop */
      {
#ifdef BETA0
         vec_mov_mr(zerovec,reg7);
         vec_mov_rr(reg7,reg0);
         vec_mov_rr(reg7,reg1);
         vec_mov_rr(reg7,reg2);
         vec_mov_rr(reg7,reg3);
#elif defined(BETA1)
         vec_mov_mr_1(pC0,reg0);
         vec_mov_mr_1(pC1,reg1);
         vec_mov_mr_1(pC2,reg2);
         vec_mov_mr_1(pC3,reg3);
#else
         vec_mov_mr(betavec,reg7);
         vec_mov_mr_1(pC0,reg0);
         vec_mul_rr(reg7,reg0);
         vec_mov_mr_1(pC1,reg1);
         vec_mul_rr(reg7,reg1);
         vec_mov_mr_1(pC2,reg2);
         vec_mul_rr(reg7,reg2);
         vec_mov_mr_1(pC3,reg3);
         vec_mul_rr(reg7,reg3);
#endif
         vec_mov_mr_a(pA0,reg7);
         vec_mov_mr_a(pB0,reg4);
         vec_mul_rr(reg7,reg4);
         vec_mov_mr_a(pB0+KB,reg5);
         vec_mov_mr_a(pB0+2*KB,reg6);
         for (k=0; k<KB-8; k+=8)
         {
            vec_add_rr(reg4,reg0);
            vec_mul_rr(reg7,reg5);
            vec_add_rr(reg5,reg1);
            vec_mul_rr(reg7,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_mr_a(pB0+3*KB,reg4);
            vec_mul_rr(reg7,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pA0+2,reg7);
            vec_mov_mr_a(pB0+2,reg5);
            vec_mul_rr(reg7,reg5);
            vec_mov_mr_a(pB0+2+KB,reg6);
            vec_mov_mr_a(pB0+2+2*KB,reg4);
            vec_add_rr(reg5,reg0);
            vec_mul_rr(reg7,reg6);
            vec_add_rr(reg6,reg1);
            vec_mul_rr(reg7,reg4);
            vec_add_rr(reg4,reg2);
            vec_mov_mr_a(pB0+2+3*KB,reg5);
            vec_mul_rr(reg7,reg5);
            vec_add_rr(reg5,reg3);
            vec_mov_mr_a(pA0+4,reg7);
            vec_mov_mr_a(pB0+4,reg6);
            vec_mul_rr(reg7,reg6);
            vec_mov_mr_a(pB0+4+KB,reg4);
            vec_mov_mr_a(pB0+4+2*KB,reg5);
            vec_add_rr(reg6,reg0);
            vec_mul_rr(reg7,reg4);
            vec_add_rr(reg4,reg1);
            vec_mul_rr(reg7,reg5);
            vec_add_rr(reg5,reg2);
            vec_mov_mr_a(pB0+4+3*KB,reg6);
            vec_mul_rr(reg7,reg6);
            vec_add_rr(reg6,reg3);
            vec_mov_mr_a(pA0+6,reg7);
            vec_mov_mr_a(pB0+6,reg4);
            vec_mul_rr(reg7,reg4);
            vec_mov_mr_a(pB0+6+KB,reg5);
            vec_mov_mr_a(pB0+6+2*KB,reg6);
            vec_add_rr(reg4,reg0);
            vec_mul_rr(reg7,reg5);
            vec_add_rr(reg5,reg1);
            vec_mul_rr(reg7,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_mr_a(pB0+6+3*KB,reg4);
            vec_mul_rr(reg7,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pA0+8,reg7);
            vec_mov_mr_a(pB0+8,reg4);
            vec_mul_rr(reg7,reg4);
            vec_mov_mr_a(pB0+8+KB,reg5);
            vec_mov_mr_a(pB0+8+2*KB,reg6);

            pA0 += 8;
            pB0 += 8;
         }
         vec_add_rr(reg4,reg0);
         vec_mul_rr(reg7,reg5);
         vec_add_rr(reg5,reg1);
         vec_mul_rr(reg7,reg6);
         vec_add_rr(reg6,reg2);
         vec_mov_mr_a(pB0+3*KB,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg3);
         vec_mov_mr_a(pA0+2,reg7);
         vec_mov_mr_a(pB0+2,reg5);
         vec_mul_rr(reg7,reg5);
         vec_mov_mr_a(pB0+2+KB,reg6);
         vec_mov_mr_a(pB0+2+2*KB,reg4);
         vec_add_rr(reg5,reg0);
         vec_mul_rr(reg7,reg6);
         vec_add_rr(reg6,reg1);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg2);
         vec_mov_mr_a(pB0+2+3*KB,reg5);
         vec_mul_rr(reg7,reg5);
         vec_add_rr(reg5,reg3);
         vec_mov_mr_a(pA0+4,reg7);
         vec_mov_mr_a(pB0+4,reg6);
         vec_mul_rr(reg7,reg6);
         vec_mov_mr_a(pB0+4+KB,reg4);
         vec_mov_mr_a(pB0+4+2*KB,reg5);
         vec_add_rr(reg6,reg0);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg1);
         vec_mul_rr(reg7,reg5);
         vec_add_rr(reg5,reg2);
         vec_mov_mr_a(pB0+4+3*KB,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg3);
         vec_mov_mr_a(pA0+6,reg7);
         vec_mov_mr_a(pB0+6,reg4);
         vec_mul_rr(reg7,reg4);
         vec_mov_mr_a(pB0+6+KB,reg5);
         vec_mov_mr_a(pB0+6+2*KB,reg6);
         vec_add_rr(reg4,reg0);
         vec_mul_rr(reg7,reg5);
         vec_add_rr(reg5,reg1);
         vec_mul_rr(reg7,reg6);
         vec_add_rr(reg6,reg2);
         vec_mov_mr_a(pB0+6+3*KB,reg4);
         vec_mul_rr(reg7,reg4);
         vec_add_rr(reg4,reg3);
         vec_sum(reg0);
         vec_sum(reg1);
         vec_sum(reg2);
         vec_sum(reg3);
         vec_mov_rm_1(reg0,pC0);
         vec_mov_rm_1(reg1,pC1);
         vec_mov_rm_1(reg2,pC2);
         vec_mov_rm_1(reg3,pC3);
         pA0 += incAm;
         pB0 += incBm;
         pC0 += incCm;
         pC1 += incCm;
         pC2 += incCm;
         pC3 += incCm;
      }
      while(pA0 != stM);

      pA0 += incAn;
      pB0 += incBn;
      pC0 += incCn;
      pC1 += incCn;
      pC2 += incCn;
      pC3 += incCn;
   }
   while(pB0 != stN);

   }
Exemple #5
0
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)
{
   const float *stM;
   const float *stN;
   const int incCn = (ldc) - NB;
   float *pC0;
   const float *pA0;
   const float *pB0;
   const float *pB1;
#ifdef BETAX
static   vector locbeta;
#endif

#define First12As(i, ib, ic) \
	align(); \
	vec_mov_mr(&(pBX[  ib + 0 - BBIASX]), reg7); \
	rep(); vec_mov_mr(&(pA0[0*KB + 0 + i - ABIAS]), reg4); \
	vec_mul_rr(reg7, reg4); \
	\
	rep(); vec_mov_mr(&(pA0[1*KB + 0 + i - ABIAS]), reg5); \
	vec_mul_rr(reg7, reg5); \
	vec_acc_rr(reg5, reg4); \
	\
	rep(); vec_mov_mr(&(pA0[2*KB + 0 + i - ABIAS]), reg5); \
	vec_mul_rr(reg7, reg5); \
	vec_mov_mr(&(pBX[  ib + 2 - BBIASX]), reg3); \
	\
	rep(); vec_mov_mr(&(pA0[3*KB + 0 + i - ABIAS]), reg6); \
	vec_mul_rr(reg7, reg6); \
	vec_acc_rr(reg6, reg5); \
	\
	rep(); vec_mov_mr(&(pA0[4*KB + 0 + i - ABIAS]), reg6); \
	vec_mul_rr(reg7, reg6); \
	ATL_pfl1W(&(pC0[6*(ic) + 4 - CBIAS])); \
	\
	vec_mul_mr(&(pA0[5*KB + 0 + i - ABIAS]), reg7); \
	rep(); vec_mov_mr(&(pA0[0*KB + 2 + i - ABIAS]), reg0); \
	\
	vec_acc_rr(reg7, reg6); \
	vec_mul_rr(reg3, reg0); \
	rep(); vec_mov_mr(&(pA0[1*KB + 2 + i - ABIAS]), reg7); \
	\
	vec_mul_rr(reg3, reg7); \
	vec_acc_rr(reg7, reg0); \
	rep(); vec_mov_mr(&(pA0[2*KB + 2 + i - ABIAS]), reg1); \
	\
	vec_mul_rr(reg3, reg1); \
	rep(); vec_mov_mr(&(pA0[3*KB + 2 + i - ABIAS]), reg7); \
	vec_mul_rr(reg3, reg7); \
	\
	vec_acc_rr(reg7, reg1); \
	rep(); vec_mov_mr(&(pA0[4*KB + 2 + i - ABIAS]), reg2); \
	vec_mul_rr(reg3, reg2); \
	\
	vec_mul_mr(&(pA0[5*KB + 2 + i - ABIAS]), reg3); \
	vec_acc_rr(reg3, reg2); \
	vec_mov_mr(&(pBX[  ib + 4 - BBIASX]), reg7); \
	\
	;

#define Do6As(i, ib) \
	align(); \
	vec_add_rr(reg4, reg0); \
	rep(); vec_mov_mr(&(pA0[0*KB + i - ABIAS]), reg4); \
	vec_mul_rr(reg7, reg4); \
	\
	rep(); vec_mov_mr(&(pA0[1*KB + i - ABIAS]), reg3); \
	vec_mul_rr(reg7, reg3); \
	vec_acc_rr(reg3, reg4); \
	\
	vec_add_rr(reg5, reg1); \
	rep(); vec_mov_mr(&(pA0[2*KB + i - ABIAS]), reg5); \
	vec_mul_rr(reg7, reg5); \
	\
	rep(); vec_mov_mr(&(pA0[3*KB + i - ABIAS]), reg3); \
	vec_mul_rr(reg7, reg3); \
	vec_acc_rr(reg3, reg5); \
	\
	vec_add_rr(reg6, reg2); \
	rep(); vec_mov_mr(&(pA0[4*KB + i - ABIAS]), reg6); \
	vec_mul_rr(reg7, reg6); \
	\
	vec_mul_mr(&(pA0[5*KB     + i - ABIAS]), reg7); \
	vec_acc_rr(reg7, reg6); \
	vec_mov_mr(&(pBX[  ib + 2 - BBIASX]), reg7); \
	\
	;

#define Last6As(i, ib) \
	align(); \
	vec_add_rr(reg4, reg0); \
	rep(); vec_mov_mr(&(pA0[0*KB + i - ABIAS]), reg4); \
	vec_mul_rr(reg7, reg4); \
	\
	rep(); vec_mov_mr(&(pA0[1*KB + i - ABIAS]), reg3); \
	vec_mul_rr(reg7, reg3); \
	vec_acc_rr(reg3, reg4); \
	\
	vec_add_rr(reg5, reg1); \
	rep(); vec_mov_mr(&(pA0[2*KB + i - ABIAS]), reg5); \
	vec_mul_rr(reg7, reg5); \
	\
	rep(); vec_mov_mr(&(pA0[3*KB + i - ABIAS]), reg3); \
	vec_mul_rr(reg7, reg3); \
	vec_acc_rr(reg3, reg5); \
	\
	vec_add_rr(reg6, reg2); \
	rep(); vec_mov_mr(&(pA0[4*KB + i - ABIAS]), reg6); \
	vec_mul_rr(reg7, reg6); \
	\
	vec_mul_mr(&(pA0[5*KB     + i - ABIAS]), reg7); \
	vec_acc_rr(reg7, reg6); \
	vec_add_rr(reg4, reg0); \
	\
	;

#ifdef BETA0
#define StoreResults(ic) \
	align(); \
	vec_add_rr(reg5, reg1); \
	vec_add_rr(reg6, reg2); \
	vec_mov_rm(reg0, &(pC0[6*(ic) + 0 - CBIAS])); \
	vec_mov_rm(reg1, &(pC0[6*(ic) + 2 - CBIAS])); \
	\
	vec_mov_rm(reg2, &(pC0[6*(ic) + 4 - CBIAS])); \
	;
#elif defined(BETA1)
#define StoreResults(ic) \
	align(); \
	rep(); vec_add_mr(&(pC0[6*(ic) + 0 - CBIAS]), reg0); \
	rep(); vec_add_mr(&(pC0[6*(ic) + 2 - CBIAS]), reg1); \
	vec_add_rr(reg5, reg1); \
	\
	rep(); vec_add_mr(&(pC0[6*(ic) + 4 - CBIAS]), reg2); \
	rep(); vec_add_rr(reg6, reg2); \
	rep(); vec_mov_rm(reg0, &(pC0[6*(ic) + 0 - CBIAS])); \
	\
	vec_mov_rm(reg1, &(pC0[6*(ic) + 2 - CBIAS])); \
	vec_mov_rm(reg2, &(pC0[6*(ic) + 4 - CBIAS])); \
	;
#else
#define StoreResults(ic) \
	align(); \
	rep(); vec_mov_mr(locbeta, reg3); \
	vec_mov_mr(&(pC0[6*(ic) + 0 - CBIAS]), reg7); \
	vec_mov_mr(&(pC0[6*(ic) + 2 - CBIAS]), reg4); \
	\
	rep(); vec_mul_rr(reg3, reg7); \
	rep(); vec_mul_rr(reg3, reg4); \
	rep(); vec_mul_mr(&(pC0[6*(ic) + 4 - CBIAS]), reg3); \
	\
	vec_add_rr(reg7, reg0); \
	vec_add_rr(reg5, reg1); \
	vec_add_rr(reg6, reg2); \
	vec_add_rr(reg4, reg1); \
	\
	vec_add_rr(reg3, reg2); \
	vec_mov_rm(reg0, &(pC0[6*(ic) + 0 - CBIAS])); \
	vec_mov_rm(reg1, &(pC0[6*(ic) + 2 - CBIAS])); \
	vec_mov_rm(reg2, &(pC0[6*(ic) + 4 - CBIAS])); \
	\
	;
#endif

#define	FirstSteps(i, ib, stage) \
	First12As((((i) - 6) + ((stage - 0) * PA0_INC)), ((ib) - 6), stage) \
	Do6As((((i) - 2) + ((stage - 0) * PA0_INC)), ((ib) - 2)) \
	;

#define	Steps(i, ib, stage) \
	Do6As((((i) - 6) + ((stage - 0) * PA0_INC)), ((ib) - 6)) \
	Do6As((((i) - 4) + ((stage - 0) * PA0_INC)), ((ib) - 4)) \
	Do6As((((i) - 2) + ((stage - 0) * PA0_INC)), ((ib) - 2)) \
	;

#define	LastSteps(i, ib, stage) \
	Do6As((((i) - 6) + ((stage - 0) * PA0_INC)), ((ib) - 6)) \
	Do6As((((i) - 4) + ((stage - 0) * PA0_INC)), ((ib) - 4)) \
	Last6As((((i) - 2) + ((stage - 0) * PA0_INC)), ((ib) - 2)) \
	;

   vec_enter();

#ifdef BETAX
   vec_splat(&beta, reg3);
   vec_mov_rm(reg3, locbeta);
#endif

   { /* block "prefetch" the A submatrix */
      register const long long *pAd=(const long long *) A;
      register const long long *pAe=pAd + (506*8);
      align();
      do {
	rep(); vec_mov_mr(&(pAd[ 0]), reg0);
	vec_mov_mr(&(pAd[ 8]), reg1);
	rep(); pAd += 8*2;
      } while (pAd != pAe);
   }

   stM = A + NB*NB + ABIAS;
   stN = B + NB*NB + BBIAS0;
   pC0=C + CBIAS;
   pA0=A + ABIAS;
   pB0=B + BBIAS0;
   pB1=B + BBIAS1;

   /* block "prefetch" some of the B submatrix */
   align();
          vec_mov_mr(&(pB0[  0 - BBIAS0]), reg0);
          vec_mov_mr(&(pB0[ 16 - BBIAS0]), reg1);
   rep(); vec_mov_mr(&(pB1[ 32 - BBIAS1]), reg2);

   rep(); vec_mov_mr(&(pB1[ 48 - BBIAS1]), reg3);
          vec_mov_mr(&(pB1[ 64 - BBIAS1]), reg4);
          vec_mov_mr(&(pB1[ 80 - BBIAS1]), reg5);

          vec_mov_mr(&(pB1[ 96 - BBIAS1]), reg6);
          vec_mov_mr(&(pB1[112 - BBIAS1]), reg7);
   rep(); vec_mov_mr(&(pB0[128 - BBIAS0]), reg0);

   rep(); vec_mov_mr(&(pB1[144 - BBIAS1]), reg1);
   rep(); vec_mov_mr(&(pB1[160 - BBIAS1]), reg2);

   rep(); vec_mov_mr(&(pB1[176 - BBIAS1]), reg3);
   rep(); vec_mov_mr(&(pB1[192 - BBIAS1]), reg4);

   align();
   do { /* N-loop */
      rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 +  0]));
      rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 + 16]));

      align();
      do { /* M-loop */

#undef	pBX
#undef	BBIASX
#define	pBX	pB0
#define	BBIASX	BBIAS0

	FirstSteps(6, 6, 0);
	Steps(12, 12, 0);
	Steps(18, 18, 0);
	Steps(24, 24, 0);
	Steps(30, 30, 0);
	Steps(36, 36, 0);
	Steps(42, 42, 0);
	Steps(48, 48, 0);
	Steps(54, 54, 0);
	Steps(60, 60, 0);

#undef	pBX
#undef	BBIASX
#define	pBX	pB1
#define	BBIASX	BBIAS1

	Steps(66, 66, 0);
	Steps(72, 72, 0);
	Steps(78, 78, 0);
	Steps(84, 84, 0);
	LastSteps(90, 90, 0);
	StoreResults(0);

	alignN("8");
	rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 + 32]));

#undef	pBX
#undef	BBIASX
#define	pBX	pB0
#define	BBIASX	BBIAS0

	FirstSteps(6, 6, 1);
	Steps(12, 12, 1);
	Steps(18, 18, 1);
	Steps(24, 24, 1);
	Steps(30, 30, 1);
	Steps(36, 36, 1);
	Steps(42, 42, 1);
	Steps(48, 48, 1);
	Steps(54, 54, 1);
	Steps(60, 60, 1);

#undef	pBX
#undef	BBIASX
#define	pBX	pB1
#define	BBIASX	BBIAS1

	Steps(66, 66, 1);
	Steps(72, 72, 1);
	Steps(78, 78, 1);
	Steps(84, 84, 1);
	LastSteps(90, 90, 1);
	StoreResults(1);

	alignN("8");
	rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 + 48]));

#undef	pBX
#undef	BBIASX
#define	pBX	pB0
#define	BBIASX	BBIAS0

	FirstSteps(6, 6, 2);
	Steps(12, 12, 2);
	Steps(18, 18, 2);
	Steps(24, 24, 2);
	Steps(30, 30, 2);
	Steps(36, 36, 2);
	Steps(42, 42, 2);
	Steps(48, 48, 2);
	Steps(54, 54, 2);
	Steps(60, 60, 2);

#undef	pBX
#undef	BBIASX
#define	pBX	pB1
#define	BBIASX	BBIAS1

	Steps(66, 66, 2);
	Steps(72, 72, 2);
	Steps(78, 78, 2);
	Steps(84, 84, 2);
	LastSteps(90, 90, 2);

	rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 + 64]));
	rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 + 80]));
        pA0 += PA0_INC*3;
	rep(); ATL_pfl1R(&(pB0[2*KB - BBIAS0 + 88]));

	StoreResults(2);

        pC0 += 6*3;

#if (NB != 90)
 #error "NB must be 90"
#endif

      } while(pA0 != stM);

      pB0 += NB;
      pB1 += NB;
      pC0 += incCn;
      pA0 -= NB*NB;

   } while(pB0 != stN);

   vec_exit();
}
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)

{
   /*--- program info ---*/
   /*  $Revision: 1.3 $  */
   /*  loadfirst = 'b'  */
   /*  nu = 1  */
   /*  k_loop = None  */
   /*  problem = 'gemm_m'  */
   /*  nregs = 8  */
   /*  split = 1  */
   /*  n_cleanup = {}  */
   /*  mu = 4  */
   /*  ku = 16  */
   /*  rev = '$Revision: 1.3 $'  */
   /*  applyfilter = 0  */
   /*  align_jumps = 0  */
   /*  prec = 'single'  */
   /*  m_cleanup = {}  */
   /*  used_outside_len = 112  */
   /*  k_cleanup = {}  */
   /*  outputdir = 'Linux_P4/'  */
   /*  arch = 'sse'  */
   /*  pipelength = 3  */
   /*  atlasname = 'Linux_P4'  */
   /*  method = 'acc'  */
   /*  used_lastuse = None  */
   /*  used_directload_a = 1  */
   /*  outside_len = 112  */
   /*  veclen = 4  */
   /*  sched = ['spread', 'fuse']  */
   /*  used_directload_b = 0  */
   /*  lastuse = 0  */

   /*--- achitecture specific declarations ---*/

   /*--- program specific declarations ---*/
   int i, j, k;
   vector betavec;
   vector zerovec = {0.0,0.0,0.0,0.0};
   const float *pA0 = A;
   const float *pB0 = B;
   float *pC0 = C;
   const float *stM = A + (M-M%4)*KB;
   const float *stN = B + NB*KB;
   const int incAm = 4*KB-KB+112;
   const int incBm = -KB+112;
   const int incCm = (4 SHIFT);
   const int incAn = -(M-M%4)*KB;
   const int incBn = 1*KB;
   const int incCn = ((ldc*1-(M-M%4)) SHIFT);
   const int incAm_m = KB-KB+112;
   const int incAn_m = -(M%4)*KB;
   const int incCn_m = (ldc*1-(M%4))SHIFT;
   const float *stM_m = A + M*KB;

   /*--- initial arhitecture specific statements ---*/

   /*--- main program statements ---*/
   vec_mov_mr_1(&beta,reg0);
   vec_mov_rm(reg0,betavec);
   if (M>=4)
   {
      do /* N-loop */
      {
         do /* M-loop */
         {
#ifdef BETA0
            vec_mov_mr(zerovec,reg7);
            vec_mov_rr(reg7,reg0);
            vec_mov_rr(reg7,reg1);
            vec_mov_rr(reg7,reg2);
            vec_mov_rr(reg7,reg3);
#elif defined(BETA1)
            vec_mov_mr_1(pC0,reg0);
            vec_mov_mr_1(pC0+(1 SHIFT),reg1);
            vec_mov_mr_1(pC0+(2 SHIFT),reg2);
            vec_mov_mr_1(pC0+(3 SHIFT),reg3);
#else
            vec_mov_mr(betavec,reg7);
            vec_mov_mr_1(pC0,reg0);
            vec_mul_rr(reg7,reg0);
            vec_mov_mr_1(pC0+(1 SHIFT),reg1);
            vec_mul_rr(reg7,reg1);
            vec_mov_mr_1(pC0+(2 SHIFT),reg2);
            vec_mul_rr(reg7,reg2);
            vec_mov_mr_1(pC0+(3 SHIFT),reg3);
            vec_mul_rr(reg7,reg3);
#endif
            vec_mov_mr_a(pB0,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+4,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+4,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+4+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+4+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+4+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+8,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+8,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+8+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+8+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+8+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+12,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+12,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+12+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+12+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+12+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+16,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+16,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+16+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+16+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+16+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+20,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+20,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+20+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+20+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+20+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+24,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+24,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+24+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+24+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+24+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+28,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+28,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+28+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+28+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+28+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+32,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+32,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+32+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+32+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+32+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+36,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+36,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+36+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+36+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+36+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+40,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+40,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+40+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+40+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+40+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+44,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+44,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+44+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+44+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+44+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+48,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+48,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+48+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+48+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+48+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+52,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+52,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+52+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+52+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+52+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+56,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+56,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+56+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+56+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+56+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+60,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+60,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+60+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+60+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+60+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+64,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+64,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+64+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+64+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+64+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+68,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+68,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+68+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+68+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+68+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+72,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+72,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+72+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+72+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+72+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+76,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+76,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+76+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+76+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+76+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+80,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+80,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+80+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+80+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+80+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+84,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+84,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+84+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+84+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+84+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+88,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+88,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+88+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+88+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+88+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+92,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+92,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+92+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+92+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+92+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+96,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+96,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+96+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+96+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+96+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+100,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+100,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+100+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+100+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+100+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+104,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+104,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+104+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+104+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+104+3*KB,reg4);
            vec_add_rr(reg4,reg3);
            vec_mov_mr_a(pB0+108,reg7);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+108,reg4);
            vec_add_rr(reg4,reg0);
            vec_mov_rr(reg7,reg5);
            vec_mul_mr_a(pA0+108+KB,reg5);
            vec_add_rr(reg5,reg1);
            vec_mov_rr(reg7,reg6);
            vec_mul_mr_a(pA0+108+2*KB,reg6);
            vec_add_rr(reg6,reg2);
            vec_mov_rr(reg7,reg4);
            vec_mul_mr_a(pA0+108+3*KB,reg4);
            vec_add_rr(reg4,reg3);
#ifndef TCPLX
            vec_sum_full(reg0,reg1,reg2,reg3,reg5,reg6,reg7);
            vec_mov_rm(reg5,pC0);
#else
            vec_sum(reg0);
            vec_sum(reg1);
            vec_sum(reg2);
            vec_sum(reg3);
            vec_mov_rm_1(reg0,pC0);
            vec_mov_rm_1(reg1,pC0+(1 SHIFT));
            vec_mov_rm_1(reg2,pC0+(2 SHIFT));
            vec_mov_rm_1(reg3,pC0+(3 SHIFT));
#endif
            pA0 += incAm;
            pB0 += incBm;
            pC0 += incCm;
         }
         while(pA0 != stM);

         pA0 += incAn;
         pB0 += incBn;
         pC0 += incCn;
      }
      while(pB0 != stN);

   }
   if (M%4>0)
   {
      pC0 = C+((M-M%4)SHIFT);
      pA0 = A+(M-M%4)*KB;
      pB0 = B;
      do /* N-loop */
      {
         do /* M-loop */
         {
#ifdef BETA0
            vec_mov_mr(zerovec,reg7);
            vec_mov_rr(reg7,reg0);
#elif defined(BETA1)
            vec_mov_mr_1(pC0,reg0);
#else
            vec_mov_mr(betavec,reg7);
            vec_mov_mr_1(pC0,reg0);
            vec_mul_rr(reg7,reg0);
#endif
            vec_mov_mr_a(pB0,reg1);
            vec_mul_mr_a(pA0,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+4,reg2);
            vec_mul_mr_a(pA0+4,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+8,reg3);
            vec_mul_mr_a(pA0+8,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+12,reg1);
            vec_mul_mr_a(pA0+12,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+16,reg2);
            vec_mul_mr_a(pA0+16,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+20,reg3);
            vec_mul_mr_a(pA0+20,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+24,reg1);
            vec_mul_mr_a(pA0+24,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+28,reg2);
            vec_mul_mr_a(pA0+28,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+32,reg3);
            vec_mul_mr_a(pA0+32,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+36,reg1);
            vec_mul_mr_a(pA0+36,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+40,reg2);
            vec_mul_mr_a(pA0+40,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+44,reg3);
            vec_mul_mr_a(pA0+44,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+48,reg1);
            vec_mul_mr_a(pA0+48,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+52,reg2);
            vec_mul_mr_a(pA0+52,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+56,reg3);
            vec_mul_mr_a(pA0+56,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+60,reg1);
            vec_mul_mr_a(pA0+60,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+64,reg2);
            vec_mul_mr_a(pA0+64,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+68,reg3);
            vec_mul_mr_a(pA0+68,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+72,reg1);
            vec_mul_mr_a(pA0+72,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+76,reg2);
            vec_mul_mr_a(pA0+76,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+80,reg3);
            vec_mul_mr_a(pA0+80,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+84,reg1);
            vec_mul_mr_a(pA0+84,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+88,reg2);
            vec_mul_mr_a(pA0+88,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+92,reg3);
            vec_mul_mr_a(pA0+92,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+96,reg1);
            vec_mul_mr_a(pA0+96,reg1);
            vec_add_rr(reg1,reg0);
            vec_mov_mr_a(pB0+100,reg2);
            vec_mul_mr_a(pA0+100,reg2);
            vec_add_rr(reg2,reg0);
            vec_mov_mr_a(pB0+104,reg3);
            vec_mul_mr_a(pA0+104,reg3);
            vec_add_rr(reg3,reg0);
            vec_mov_mr_a(pB0+108,reg1);
            vec_mul_mr_a(pA0+108,reg1);
            vec_add_rr(reg1,reg0);
            vec_sum(reg0);
            vec_mov_rm_1(reg0,pC0);
            pA0 += incAm_m;
            pB0 += incBm;
            pC0 += (1 SHIFT);
         }
         while(pA0 != stM_m);

         pA0 += incAn_m;
         pB0 += incBn;
         pC0 += incCn_m;
      }
      while(pB0 != stN);

   }
   }