[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: sgemm questions



Ok, here is the fastest running example for the Athlon I have. I works for
a blocksize of n*32+4 and for a blocksize of 100 it gets around 2500
mflops. with moves="" it gets around 3100 mflops. There are several
strange aspects of this code: 
  The beginning of the k-loop is aligned on a
16-byte boundary with a macro. Without this, performance drops to 2000
mflops.
   A lot of code after the k-loop hurts performance pretty badly, so
therefore the k-loop is unrolled by 32, but the pipeline start and finish
code is only unrolled by 4. This gives the rather strange blocksizes
nb=p*32+4, p>=0

On 15 Nov 2000, Camm Maguire wrote:

> Hi Peter!  Great work on your generator!  I'd love to see a sample of
> what its producing!
> 
> Peter Soendergaard <soender@cs.utk.edu> writes:
> 
> > I have included a file with the macros I currently use, but I only use
> > very basic instructions. pfadd, pfmul, pfacc and some of the mmx
> > instructions to move 32 bits in and out of the vectors.
> > 
> > Which added instructions were you thinking of? prefetch{nta,t0,t1,t2},
> > flip-the-vector?
> > 
> 
> These and movntq.  But I've played a bit, and found that (apparently)
> 1) prefetchnta is no gain over prefetch
> 2) movntq seems to barely improve things for complex, and single
>    beta=0, but dramatically kills performance for single beta1,X.
> 
> So I think the facts justify a single AMD implementation.
> 

I also played around with movntq, but for the (very) few cases I
tried, I did not see any performance difference. I have yet to try any of
these things with level 2 blas.


> > I have not done any real tests for the SSE, I have more or less just
> > confirmed that I got working code, so I cant remember the exact
> > performance I got, but it was reasonable.
> > 
> 
> Great!  Please let me know if you have this under control and no
> longer need the kernels I've been submitting.  Then I'd have more time
> for things like chasing down atlas compile errors on odd platforms
> :-)!
> 
yep, I will just take all the fun work and let you do bug hunting in
Clints makefiles and macros.

cheers,
Peter

> Take care,
> 
> 
> -- 
> Camm Maguire			     			camm@enhanced.com
> ==========================================================================
> "The earth is but one country, and mankind its citizens."  --  Baha'u'llah
> 
#define THREEDNOW
#include "SSE3Dnow.h"

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;
   const float *pA0 = A;
   const float *pB0 = B;
   float *pC0 = C;
   float *pC1 = C+ldc;
   const float *stM = A + NB*NB;
   const float *stN = B + NB*NB;
   const int incAm = 2*NB-NB;
   const int incBm = -NB;
   const int incCm = 2;
   const int incAn = -NB*NB;
   const int incBn = 2*NB;
   const int incCn = ldc*2-NB;

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

   /*--- main program statements ---*/
   vec_load_one(&beta,reg0);
   vec_mov_rm(reg0,&betavec);
   do /* N-loop */
   {
      do /* M-loop */
      {
#ifdef BETA0
         vec_zero(reg0);
         vec_zero(reg1);
         vec_zero(reg2);
         vec_zero(reg3);
#elif defined(BETA1)
         vec_load_one(pC0,reg0);
         vec_load_one(pC0+1,reg1);
         vec_load_one(pC1,reg2);
         vec_load_one(pC1+1,reg3);
#else
         vec_mov_mr(betavec,reg7);
         vec_load_one(pC0,reg0);
         vec_mul_rr(reg7,reg0);
         vec_load_one(pC0+1,reg1);
         vec_mul_rr(reg7,reg1);
         vec_load_one(pC1,reg2);
         vec_mul_rr(reg7,reg2);
         vec_load_one(pC1+1,reg3);
         vec_mul_rr(reg7,reg3);
#endif
         vec_mov_mr(pA0,reg4);
         vec_mul_mr(pB0,reg4);
         vec_mov_mr(pA0+NB,reg5);
         vec_mul_mr(pB0,reg5);
         vec_mov_mr(pA0,reg6);
         vec_mov_mr(pA0+NB,reg7);
         align();
         for (k=0; k<NB-4; k+=32)
         {
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+2,reg4);
            vec_mul_mr(pB0+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+2+NB,reg5);
            vec_mul_mr(pB0+NB,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+NB,reg7);
            vec_mul_mr(pB0+2,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+4,reg4);
            vec_mul_mr(pB0+2+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+4+NB,reg5);
            vec_mul_mr(pB0+2+NB,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+NB,reg7);
            vec_mul_mr(pB0+4,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+6,reg4);
            vec_mul_mr(pB0+4+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+6+NB,reg5);
            vec_mul_mr(pB0+4+NB,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+NB,reg7);
            vec_mul_mr(pB0+6,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+8,reg4);
            vec_mul_mr(pB0+6+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+8+NB,reg5);
            vec_mul_mr(pB0+6+NB,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+NB,reg7);
            vec_mul_mr(pB0+8,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+10,reg4);
            vec_mul_mr(pB0+8+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+10+NB,reg5);
            vec_mul_mr(pB0+8+NB,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+NB,reg7);
            vec_mul_mr(pB0+10,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+12,reg4);
            vec_mul_mr(pB0+10+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+12+NB,reg5);
            vec_mul_mr(pB0+10+NB,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+NB,reg7);
            vec_mul_mr(pB0+12,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+14,reg4);
            vec_mul_mr(pB0+12+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+14+NB,reg5);
            vec_mul_mr(pB0+12+NB,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+NB,reg7);
            vec_mul_mr(pB0+14,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+16,reg4);
            vec_mul_mr(pB0+14+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+16+NB,reg5);
            vec_mul_mr(pB0+14+NB,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+NB,reg7);
            vec_mul_mr(pB0+16,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+18,reg4);
            vec_mul_mr(pB0+16+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+18+NB,reg5);
            vec_mul_mr(pB0+16+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+18,reg6);
            vec_mul_mr(pB0+18,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+18+NB,reg7);
            vec_mul_mr(pB0+18,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+20,reg4);
            vec_mul_mr(pB0+18+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+20+NB,reg5);
            vec_mul_mr(pB0+18+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+20,reg6);
            vec_mul_mr(pB0+20,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+20+NB,reg7);
            vec_mul_mr(pB0+20,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+22,reg4);
            vec_mul_mr(pB0+20+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+22+NB,reg5);
            vec_mul_mr(pB0+20+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+22,reg6);
            vec_mul_mr(pB0+22,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+22+NB,reg7);
            vec_mul_mr(pB0+22,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+24,reg4);
            vec_mul_mr(pB0+22+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+24+NB,reg5);
            vec_mul_mr(pB0+22+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+24,reg6);
            vec_mul_mr(pB0+24,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+24+NB,reg7);
            vec_mul_mr(pB0+24,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+26,reg4);
            vec_mul_mr(pB0+24+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+26+NB,reg5);
            vec_mul_mr(pB0+24+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+26,reg6);
            vec_mul_mr(pB0+26,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+26+NB,reg7);
            vec_mul_mr(pB0+26,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+28,reg4);
            vec_mul_mr(pB0+26+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+28+NB,reg5);
            vec_mul_mr(pB0+26+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+28,reg6);
            vec_mul_mr(pB0+28,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+28+NB,reg7);
            vec_mul_mr(pB0+28,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+30,reg4);
            vec_mul_mr(pB0+28+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+30+NB,reg5);
            vec_mul_mr(pB0+28+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+30,reg6);
            vec_mul_mr(pB0+30,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+30+NB,reg7);
            vec_mul_mr(pB0+30,reg5);
            vec_add_rr(reg4,reg0);
            vec_mov_mr(pA0+32,reg4);
            vec_mul_mr(pB0+30+NB,reg6);
            vec_add_rr(reg5,reg1);
            vec_mov_mr(pA0+32+NB,reg5);
            vec_mul_mr(pB0+30+NB,reg7);
            vec_add_rr(reg6,reg2);
            vec_mov_mr(pA0+32,reg6);
            vec_mul_mr(pB0+32,reg4);
            vec_add_rr(reg7,reg3);
            vec_mov_mr(pA0+32+NB,reg7);
            vec_mul_mr(pB0+32,reg5);

            pA0 += 32;
            pB0 += 32;
         }
         vec_add_rr(reg4,reg0);
         vec_mov_mr(pA0+2,reg4);
         vec_mul_mr(pB0+NB,reg6);
         vec_add_rr(reg5,reg1);
         vec_mov_mr(pA0+2+NB,reg5);
         vec_mul_mr(pB0+NB,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+NB,reg7);
         vec_mul_mr(pB0+2,reg5);
         vec_add_rr(reg4,reg0);
         vec_add_rr(reg5,reg1);
         vec_mul_mr(pB0+2+NB,reg6);
         vec_add_rr(reg6,reg2);
         vec_mul_mr(pB0+2+NB,reg7);
         vec_add_rr(reg7,reg3);
         pA0 += 4;
         pB0 += 4;
         vec_sum(reg0);
         vec_sum(reg1);
         vec_sum(reg2);
         vec_sum(reg3);
         vec_store_one(reg0,pC0);
         vec_store_one(reg1,pC0+1);
         vec_store_one(reg2,pC1);
         vec_store_one(reg3,pC1+1);

         pA0 += incAm;
         pB0 += incBm;
         pC0 += incCm;
         pC1 += incCm;
      }
      while(pA0 != stM);

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

   vec_exit();
   /*--- standard architecture cleanup ---*/
}