[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 ---*/
}