tazvld a écrit :



J’ai raté un truc, comment un code assembleur peut-t-il fonctionner sur plusieurs plateformes et architecture ?









vampire7 a écrit :



La magie de la compilation conditionnelle…

Sinon moi j’ai raté un autre truc : depuis le temps qu’on nous dit que même pour la vitesse, l’assembleur ne vaut plus le coup, pourquoi continuer à l’utiliser ? D’autant plus que même l’utilisation d’instructions SIMD et autres peut être faite en C grâce aux “intrinsics”.





En lisant “assembleur”, j’ai plutôt pensé aux Intrinsics, qui permettent de coder presque directement les instructions SIMD en C (par exemple).



C’est assez moche à lire, mais je me suis amusé à le faire pour voir l’effet sur une multiplication de matrice avec des flottants doubles, avec un exemple donné par Ulrich Drepper dans un mémoire intéressant sur la… mémoire DRAM. Ça ressemble à ceci (je suis sous Linux si ça compte), on voit les opérations “_mm_store_pd” “_mm_add_pd” et “_mm_mul_pd” (“pd” pour précision double je suppose) :





// version intrinsics du PDF cpumemory.pdf de Ulrich Drepper

#include



double res[N][N] __attribute__ ((aligned (64)));

double mul1[N][N] __attribute__ ((aligned (64)));

double mul2[N][N] __attribute__ ((aligned (64)));



// juste la boucle interne, un peu complexe car partielle (j’ai la version sans Intrinsics)

                             \_mm\_prefetch (&rmul1[8], \_MM\_HINT\_NTA);   


                             for (k2 = 0, rmul2 = &mul2[k][j1]; k2 < SM; ++k2, rmul2 += N) {   


                                     \_\_m128d m1d = \_mm\_load\_sd (&rmul1[k2]);   


                                     m1d = \_mm\_unpacklo\_pd (m1d, m1d);   


                                     for (j2 = 0; j2 < SM; j2 += 2) {   


                                             // rres[j2] += rmul1[k2] * rmul2[j2];   


                                             \_\_m128d m2 = \_mm\_load\_pd (&rmul2[j2]);   


                                             \_\_m128d r2 = \_mm\_load\_pd (&rres[j2]);   


                                             \_mm\_store\_pd (&rres[j2], \_mm\_add\_pd (\_mm\_mul\_pd (m2, m1d), r2));   


                                     }   


                             }   

Le simple fait de passer de multiplications/additions simples à des opérations SIMD sur 2 flottants (c’est du SSE2 seulement je crois) fait quasiment doubler la vitesse, sur une de mes machines le temps mis passe de 1,86 à 0,94 s, sur des matrice plus grosses que le cache.