Quel est le moyen le plus efficace de multiplier 4 flotteurs par 4 flottants en utilisant SSE?

Question

J'ai actuellement le code suivant:

float a[4] = { 10, 20, 30, 40 }; 
float b[4] = { 0.1, 0.1, 0.1, 0.1 }; 
asm volatile("movups (%0), %%xmm0\n\t" 
      "mulps (%1), %%xmm0\n\t"    
      "movups %%xmm0, (%1)"    
      :: "r" (a), "r" (b)); 

J'ai d'abord les quelques questions:

(1) si je devais aligner les tableaux sur les limites de 16 octets, ça marcherait même? Depuis les tableaux sont alloués sur la pile est-il vrai que leur alignement est presque impossible?

voir la réponse choisie pour ce poste: Are stack variables aligned by the GCC __attribute__((aligned(x)))?

(2) Le code pourrait être refactorisé du tout pour le rendre plus efficace? Que faire si je mets les deux tableaux flottants dans des registres plutôt qu'un seul?

Merci

Answer 1

si je devais aligner les tableaux sur les limites de 16 octets, serait-il fonctionner même? Depuis les tableaux sont alloués sur la pile est-il vrai que leur alignement est presque impossible?

Il est nécessaire que l'alignement sur la pile fonctionne. Sinon, l'intrinsèque ne fonctionnerait pas. Je suppose que le post que vous avez cité a à voir avec la valeur exorbitante qu'il a choisie pour la valeur d'alignement.

-2:

Non, il ne devrait pas être une différence de performance. Voir ce site pour les horaires d'instruction de plusieurs processeurs.

---

Comment alignement des variables de pile fonctionne:

push ebp 
mov ebp, esp 
and esp, -16    ; fffffff0H 
sub esp, 200    ; 000000c8H 

Le et aligne la commencent de la pile à 16 octets.

Answer 2

Est-ce que GCC fournir un soutien pour le type de données __m128? Si oui, c'est votre meilleur plan pour garantir un type de données aligné sur 16 octets. Néanmoins, il y a __attribute__((aligned(16))) pour aligner les choses. Définissez vos tableaux comme suit

float a[4] __attribute__((aligned(16))) = { 10, 20, 30, 40 }; 
float b[4] __attribute__((aligned(16))) = { 0.1, 0.1, 0.1, 0.1 }; 

puis utilisez movaps à la place :)

Answer 3

(1) si je devais aligner les tableaux sur des limites de 16 octets, cela fonctionnerait-il même? Depuis les tableaux sont alloués sur la pile est-il vrai que leur alignement est presque impossible?

Non, il est assez simple d'aligner le pointeur de la pile à l'aide and:

and esp, 0xFFFFFFF0 ; aligned on a 16-byte boundary 

Mais vous devez utiliser ce GCC fournit, comme un type de 16 octets ou __attribute__ pour personnaliser l'alignement.

Answer 4

écrire en C, utiliser

gcc -S -mssse3 

si vous avez une version assez récente de gcc.

Answer 5

A propos du refactoring. Vous pouvez utiliser intrinsèque. Exemple:

#include <emmintrin.h> 

int main(void) 
{ 
    __m128 a1,b1; 

    a1=_mm_set_ps(10, 20,30,40); 
    b1=_mm_set_ps(0.1, 0.1, 0.1, 0.1); 

    a1=_mm_mul_ps(a1,b1); 

    return 0; 
} 

Avec gcc d'optimisation (-O2, -O3), il peut être un travail plus rapide, puis asm.

Answer 6

L'utilisation de intrinsic est beaucoup plus rapide en particulier avec l'optimisation. j'ai écrit test simple et comparer les deux versions (asm et intrinsèque)

unsigned long long time1; 
__m128 a1,b1; 


a1=_mm_set_ps(10, 20,30,40); 
b1=_mm_set_ps(0.1, 0.1, 0.1, 0.1); 
float a[4] = { 10, 20, 30, 40 }; 
float b[4] = { 0.1, 0.1, 0.1, 0.1 }; 

time1=__rdtsc(); 
a1=_mm_mul_ps(a1,b1); 
time1=__rdtsc() - time1 ; 
printf("Time: %llu\n",time1); 


time1=__rdtsc(); 
asm volatile("movups (%0), %%xmm0\n\t" 
       "mulps (%1), %%xmm0\n\t" 
       "movups %%xmm0, (%1)" 
       :: "r" (a), "r" (b)); 
time1=__rdtsc() - time1 ; 
printf("Time: %llu\n",time1); 

Version Intrinsèque 50-60 processeur horodatages Asm Version ~ 1000 proc horodatages

Vous pouvez le tester sur votre machine