Bonjour,

je cherche à ecrire en C une routine optimisée pour calculer un produit scalaire de deux vecteurs (de taille variable). Comme cette routine sera appelée plusieurs milliers (millions) de fois, je cherche à gagner le moindre cycle processeurs. Ma plate-forme est un athlon-XP (sans SSE2 donc). Pour l'instant j'ai 2 variantes:

C-pure:

double dot(const double *a, const double *b, unsigned long n)

{

	register double res=0.0;

	register unsigned long i;

	



	for(i=(n/4)*4; i != 0; i -= 4)

	{

		register const double res1=a[i]   * b[i];

		register const double res2=a[i+1] * b[i+1];

		register const double res3=a[i+2] * b[i+2];

		register const double res4=a[i+3] * b[i+3];



		res += res1 + res2 + res3 +res4;

	}

	

	switch(n-i)

	{

	case 3: res += a[n-3] * b[n-3];

	case 2: res += a[n-2] * b[n-2];

	case 1: res += a[n-1] * b[n-1];

	}



	return(res);

}

et une C/Asm (plus rapide)

double dot(const double *a, const double *b, unsigned long n)

{

	double res;

	

	__asm__ __volatile__ ("fldz\n\t"

			      "testl	%1, %1\n\t"

			      "jbe	.fem.dot.end\n"

			      ".fem.dot.loop:\n\t"

			      "subl	$1, %1\n\t"

#	ifdef SSE

			      /*

			       * Theses 2 instructions do all the job!

			       * Whithout them, we get "only" 17% speedup

			       * note: 128 is an empirical value...

			       */

			      "prefetcht2 -128(%3, %1, 8)\n\t"

			      "prefetcht2 -128(%2, %1, 8)\n\t"

#	endif /* SSE */

			      "fldl	(%3, %1, 8)\n\t"

			      "fmull	(%2, %1, 8)\n\t"

			      "faddp	%0, %0(1)\n\t"

			      "jne	.fem.dot.loop\n"

			      ".fem.dot.end:"

			      : "=%%st" (res)

			      : "q" (n) , "q" (a), "q" (b));

	return(res);

}

Si il y a des grourous de l'optimisation de code, j'aimerai avoir vos avis!

Merci


ps. j'ai tester blas et atlas sans succès.

> Lire le journal (20 commentaires, moyenne: 2,6).

j'fais un peu de pub pour un p'tit projet que j'ecris sur mon temps libre et qui arrive doucement a maturite!

-> http://home.gna.org/haplo/(...)

> Lire le journal (6 commentaires, moyenne: 1,5).