Discussion :

[Kaluza]

Bonjour.

Je débute en métaprogrammation et je viens de découvrir boost::proto et avant de me lancer dans l'apprentissage de ces choses relativement complexe, j'aimerai savoir si je pourrais, à la fin, écrire quelque chose de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
int main()
{
    // Variables
    double a;
    double b;
    double x1;
    double x2;
 
    // Vector
    mylib::Vector3 u;
    mylib::Vector3 v;
 
    // Matrix
    mylib::Matrix2 m;
    mylib::Matrix2 n;
    mylib::Matrix2 o;
 
    // Input
    std::cin>>a;
    std::cin>>b;
    std::cin>>u[0]>>u[1]>>u[2];
    std::cin>>v[0]>>v[1]>>v[2];
    std::cin>>m[0][0]>>m[0][1]>>m[1][0]>>m[1][1];
    std::cin>>n[0][0]>>n[0][1]>>n[1][0]>>n[1][1];
 
    // Norm of the cross product of u and v
    x1 = mylib::norm(mylib::crossprod(u, v));
        /* Code that I want to be generated : 
        x1 = sqrt((u[2]*v[3]-u[3]*v[2])*
                  (u[2]*v[3]-u[3]*v[2])+
                  (u[3]*v[1]-u[1]*v[3])*
                  (u[3]*v[1]-u[1]*v[3])+
                  (u[1]*v[2]-u[2]*v[1])*
                  (u[1]*v[2]-u[2]*v[1])
                  ); */
 
    // Determinant of sin of all elements of m multiplied by a
    x2 = a*mylib::det(mylib::sin(m));
        /* Code that I want to be generated : 
        x2 = a*(std::sin(m[0][0])*std::sin(m[1][1])-
                std::sin(m[0][1])*std::sin(m[1][0])
                ); */
 
    // Multiplication of two matrix (with one transposition) and a scalar
    o = b*(mylib::transpose(m)*n);
        /* Code that I want to be generated : 
        o[0][0] = b*(m[0][0]*n[0][0]+m[1][0]*n[1][0]);
        o[0][1] = b*(m[0][0]*n[0][1]+m[1][0]*n[1][1]);
        o[1][0] = b*(m[0][1]*n[0][0]+m[1][1]*n[1][0]);
        o[1][1] = b*(m[0][1]*n[0][1]+m[1][1]*n[1][1]); */
 
    return 0;
}

C'est à dire :
- métaprogrammation ou boost::proto invisible dans la couche du dessus (ici c'est mylib qui fait appel à la métaprog ou à boost::proto, mais le main n'a pas besoin de savoir comment a été codé par exemple mylib::det() (cela serait une fonction "classique", ça ne changerait rien à la syntaxe de l'appel))
- code généré permettant d'éviter toute variable temporaire

Donc :
1) Est-ce possible de pouvoir faire quelque chose de ce type avec les expressions templates "basiques" (à mon avis non, mais bon) ?
2) Est-ce possible de pouvoir faire quelque chose de ce type avec boost::proto (là je croise les doigts) ?
3) Une fois la docs/les tutoriaux de boost::proto lus est-ce que je saurais faire ce genre de chose ou est-ce que cela est plus complexe ?
4) Y-a-t-il quelque chose de plus adapté que boost::proto pour faire ce genre de choses ou boost::proto correspond vraiment à l'outil idéal dont j'ai besoin ?

Merci beaucoup

[Kaluza]

Personne qui connait bien boost::proto dans le coin ?

[Flob90]

1/ Je dirais oui, pas forcément évident pour toutes les opérations mais ca doit pouvoir se faire au moins partiellement (*).

2/ Je dirais que oui, autant quand le faisant à la main avec des expressions templates (plus simple à écrire par contre).

3/Je pense que oui, la doc de proto est très bien faite.

4/ Je ne connais rien d'autre du genre de boost::proto, mais ca existe peut-être.

PS: Je ne sais pas si le sinus d'un matrice existe, mais si c'est le cas ce n'est probablement pas la définition que tu donnes. (Ca passerais plutôt par la définition du sin comme série entière).

(*) L'absence de "linéarité" de certains "calcul" peut demander réflexion.

[Kaluza]

Merci beaucoup.

En fait la question était de savoir si on pouvait obtenir une syntaxe "normale" pour quelqu'un qui utilise une lib basée sur boost::proto. Comme tu as l'air de me dire que c'est le cas, alors c'est parti, je me lance là dedans...

Pour le P.S. : oui évidemment, mais je cherchais un exemple simple d'une fonction à appliquer à chaque élément d'une matrice et je trouvais que c'était plus "expressif" de cette manière.

[Joel F]

1) Est-ce possible de pouvoir faire quelque chose de ce type avec les expressions templates "basiques" (à mon avis non, mais bon) ?
2) Est-ce possible de pouvoir faire quelque chose de ce type avec boost::proto (là je croise les doigts) ?
3) Une fois la docs/les tutoriaux de boost::proto lus est-ce que je saurais faire ce genre de chose ou est-ce que cela est plus complexe ?
4) Y-a-t-il quelque chose de plus adapté que boost::proto pour faire ce genre de choses ou boost::proto correspond vraiment à l'outil idéal dont j'ai besoin ?

1/ oui
2/ oui
3/ va falloir cravacher. NT2 qui ets un projet de lib de calcul numerique sur proto est en dev depuis 1 an avec proto apres 2-3 ans de Expression Tempalte manuelle
4/ non

[Kaluza]

Merci de prévenir pour le 3). Je vais aller voir NT2, je ne connaissais pas. Aurais-tu en tête d'autres projets de ce genre Joel F ?

Moi c'est vraiment l'aspect "atteindre des perfs d'array C pour des calculs sur des matrices et des vecteurs de taille constante (maxi 4x4)".

Est-ce que quelqu'un saurait si il existe des "stages de formation" à la métaprogrammation/boost::proto ? Parce qu'à la limite, comme j'en aurai vraiment besoin, mon école doctorale ou mon labo pourrait peut être me financer une telle formation.

[Joel F]

Merci de prévenir pour le 3). Je vais aller voir NT2, je ne connaissais pas. Aurais-tu en tête d'autres projets de ce genre Joel F ?

Moi c'est vraiment l'aspect "atteindre des perfs d'array C pour des calculs sur des matrices et des vecteurs de taille constante (maxi 4x4)".

Ca se fait tres bien :o

Est-ce que quelqu'un saurait si il existe des "stages de formation" à la métaprogrammation/boost::proto ? Parce qu'à la limite, comme j'en aurai vraiment besoin, mon école doctorale ou mon labo pourrait peut être me financer une telle formation.

Non, j'essaye d'en saupoudrer dans les cours que je donne mais le public est en général à des lieux de ces problematiques

[Kaluza]

Non, j'essaye d'en saupoudrer dans les cours que je donne mais le public est en général à des lieux de ces problematiques

J'ai pour l'instant touché à 2 codes différents utilisés sur supercalculateurs et je ne sais pas trop quoi penser. Les physiciens doivent souvent apprendre l'info de leur côté (ce qui est mon cas), mais bon quand même.

Le fait est que sur l'un des codes (ça fait grosso modo 6 ans qu'il tournait comme ça, utilisé entre autres par la NASA), il m'a fallu moins d'une journée pour repérer la fonction la plus appelée par le programme et diviser son temps d'exécution par 100 en évitant des get() de tous les côtés et en utilisant des C-array au lieu de conteneurs assez complexes et finalement pas utiles.

Sur l'autre, qui est justement un code de relativité générale, les éléments de base (vecteurs et tenseurs) sont implémentés sous la forme d'objet tout ce qu'il y a de plus basique. Du coup, je n'ose même pas imaginer le temps qu'il est possible de gagner en codant ça proprement à grand renfort de metaprog (au moins un facteur 10).

Comme je dois de toutes façons réécrire un nouveau code (application différente de ce qui existe) qui tournera sur supercalculateur, j'espère pouvoir faire les choses proprement. Je trouve que c'est limite du gachis de massivement paralléliser si le code de départ n'est déjà pas clean.

(c'est moi qui ai gagné la compet étudiante de programmation parallèle d'Intel l'année dernière ... et j'ai passé énormément plus de temps à aller à la chasse aux instructions et aux objets inutiles sur monocore, qu'à paralléliser)

[Joel F]

Ca a pris un peu de retard because la vrai vie, mais je suis en train de traduire/augmenter les tutoriels de Eric Neibler sur Proto ainsi que mon tutorial de 3h sur proto a boostcon 2011.