assembleur et template

Bonjour,
J'écris une petite librairie d'arithmétique statique, contrairement à GMP qui est dynamique. Pour obtenir de bonne perf je dois écrire en assembleur.
Si je considere une addition de grand entier (>64 bits), j 'utilise un tableau de long int. Si je considère ma fonction addition je devrai tout d'abord loader mes datas (en assembleur x86-64, gas)
Code:

1 2 3 4 5 void vli256_add(boost::uint64_t * /*%%rdi*/, boost::uint64_t const * /*%%rsi*/) { asm ( "movq (%%rdi), %%r8 " // load la 1 ere data "movq 0x08(%%rdi), %%r9" // load la 2eme data successive
Cette structure marche très bien mais elle suppose que mes datas soit stockées sous le format AoS, pour divers raisons je souhaite utiliser le modèle SoA.

Je rappelle AoS : si on considère un grand entier A comme la suite de 2 long int (a0 et a1), en mémoire on a : a0a1 si je prend B C et D , j obtiendrai en mémoire a0a1 b0b1 c0c1 d0d1 le tout continue, en AoS, j obtiens
a0b0c0d0 a1b1c1d1. L'idée est d'ajouter un paramètre template pour permettre de passer d'une représentation à une autre. en pseudo code j'obtiendrai:
Code:

1 2 3 4 5 6 template< int n> void vli256_add(boost::uint64_t * /*%%rdi*/, boost::uint64_t const * /*%%rsi*/) { asm ( "movq (%%rdi), %%r8" //idem "movq 0x08*n(%%rdi), %%r9 "// n donne l offset n=1 SoA, n=4 AoS "
le pb et que n est dans une string donc il ne sera pas considéré un nombre.
Bref je ne sais pas trop comment mixer cette string d'assembleur et ce paramètre template ... (je suis un débutant en assembleur)

Pourquoi ne pas faire deux fonctions ?

Sinon, il me semble qu'il est impossible de faire ça avec des templates. Peut-être générer les deux fonctions avec une macro, si la fonction est trop longue ?

Sinon, au passage, je dois réagir à "Pour obtenir de bonne perf je dois écrire en assembleur."
C'est totalement faux !
Le c++ peut parfaitement produire du code parfaitement optimisé !
Au passage, le compilateur produira très probablement du code au moins aussi optimisé que toi, après avoir vu le code c++. Surtout que, comme tu le dis toi-même, "[tu es] un débutant en assembleur".

Donc mieux vaudrait pour toi écrire en c++. Quitte à optimiser certains bouts particulièrement critiques en assembleur, si le profilage et l'étude du code généré l'indique nécessaire. ;)

Ecris le truc en C++ deja, mates le code généré et avise aprés.
Ecrire de l'assembleur inline, c'ets aller au tas.

Bonsoir, bien sur, j'ai déjà écrit une une première release en C++ où je fais tout à la main (la gestion du carry bit), (je fais des opérations sur les polynômes avec des grands entier, ça marche, je fais de la programmation hybride OpeMP/CUDA), mais le chef n'est jamais content :mouarf:

Néanmoins la gestion du carry bit peut être fait par l'instruction assembleur adcq ... Je viens de terminer mon addition 196 en assembleur, ça ressemble à ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void add_196(unsigned long int* /* %%rdi */, unsigned long int const* /* %%rsi */){ asm( "movq (%%rdi), %%r8 \n" "movq 0x08(%%rdi), %%r9 \n" "movq 0x10(%%rdi), %%rcx \n" "addq (%%rsi), %%r8 \n" "adcq 0x08(%%rsi), %%r9 \n" "adcq 0x10(%%rsi), %%rcx \n" "movq %%r8, (%%rdi) \n" "movq %%r9, 0x08(%%rdi) \n" "movq %%rcx, 0x10(%%rdi) \n" : : : "rsi","rdi","rcx","r8","r9","memory" ); }
Une version pure C++ ressemble à ça ( le tout dans une boucle)
Code:

1 2 3 4 5 6 template <typename BaseInt, std::size_t Order> inline void kernels_addition_block(BaseInt* x, BaseInt const* y){ *x += *y; *(x+Order) += *x >> data_bits<BaseInt>::value; //carry bit <- C'est ce Order que je veux passer en parametre template *x &= data_mask<BaseInt>::value; // Remove the carry bit }
Pour revenir à ma question, peut on modifier la string de l'assembleur avec un paramètre template, je pense que non ... Bien que le compilo c'est le faire ...

Pour mon niveau débutant au assembleur c'est +- vrai, j'ai fait beaucoup de programmation SSE, mais on peut utiliser des instructions du C++ pour utiliser ces registres. Cette maudite instruction adc n'est pas dispo en C++

Comme les autres j'ai de gros doute sur le fait qu'in fine l'assembleur soit plus performant que du bon C++.

Ceci dit, pour répondre à ta question, il n'est pas possible de mixer le paramètre template directement dans une chaîne de caractère (les deux traitements n'ont pas lieu au même moment lors de la compilation).

La piste est probablement de générer les classes 'helper' (à la main ou avec Boost.Preprocessor si beaucoup), puis d'utiliser ton paramètre générique pour choisir la bonne. Boost.Preprocessor intervenant au moment du préprocessing peut aider à construire les chaînes de caractères adéquates en itérant sur un nombre de cas qui t'intéresse.

Il n'y a pas de soucis pour le compilo, je ne suis vraiment pas fan de taper de l'assembleur. Mais le boss il écrit des packages pour boost, alors on compte les instructions, de plus ajouter un carry me pause pas mal de pb pour les signes des entiers.

boost pp va fumer !

ps: de plus je fais du gpu et l'assembleur de CUDA permet de faire des multiplications avec des propagations de carry bit (en hardware), (cette instruction n'existe pas en X86.

Ce serait quelque chose de ce gout là peut être ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/stringize.hpp>
 
template<int n> struct asm_helper;
// ma répétition
#define HELPER_ASM_MOVQ(z, n, dummy) \
   template<> struct asm_helper<n>\
   {\
      static void do_it()\
      {\
       std::cout<<"movq " BOOST_PP_STRINGIZE(0x08*n) "(%%rdi), %%r9" <<"\n";\
      }\
   };
 
BOOST_PP_REPEAT(12, HELPER_ASM_MOVQ, d) 
 
 
template<int n> void function()
{
   asm_helper<n>::do_it();
}
 
int main()
{
   function<1>();
   function<10>();
   return 0;
}

Y'a peut être mieux niveau Boost.PP. J'avoue ne pas forcément le connaitre sur le bout des doigts.

Citation:

Envoyé par 3DArchi

Ce serait quelque chose de ce gout là peut être ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/stringize.hpp>
 
template<int n> struct asm_helper;
// ma répétition
#define HELPER_ASM_MOVQ(z, n, dummy) \
   template<> struct asm_helper<n>\
   {\
      static void do_it()\
      {\
       std::cout<<"movq " BOOST_PP_STRINGIZE(0x08*n) "(%%rdi), %%r9" <<"\n";\
      }\
   };
 
BOOST_PP_REPEAT(12, HELPER_ASM_MOVQ, d) 
 
 
template<int n> void function()
{
   asm_helper<n>::do_it();
}
 
int main()
{
   function<1>();
   function<10>();
   return 0;
}

Y'a peut être mieux niveau Boost.PP. J'avoue ne pas forcément le connaitre sur le bout des doigts.

Wai t'es un deus !!!!! je ne connaissais pas BOOST_PP_STRINGIZE ça déchire comme solution !

petie update

Hello, j'update ce post pour remercier tous les contributeurs :ccool:. Grace à votre aide, j'ai pu faire une librairie de grand entier entièrement basée sur boost PP. Et bien avoir des bon speeds up par rapport à GMP. J'ai d'ailleurs fait un petit site vlilib.org

Au plaisir,