MS Accelerator - Lenteur

Version imprimable

Bonsoir tout le monde,

Je me suis récemment mis à Microsoft Accelerator V2, mais j'ai des difficultés à obtenir des performances potables. Quand j'utilise un petit "Jeu de la vie", la version Accelerator est environ 2 fois plus lente que ma version monothread ... alors que c'est typiquement sur ce genre de problème (avec de grands tableaux de données) qu'Accelerator est sensé donner tout son potentiel.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
 
           DX9Target Cible = new DX9Target();
           FloatParallelArray Valeur0 = new FloatParallelArray(0, new int[2] { Largeur, Hauteur });
           FloatParallelArray Valeur1 = new FloatParallelArray(1, new int[2] { Largeur, Hauteur });
           FloatParallelArray Valeur2 = new FloatParallelArray(2, new int[2] { Largeur, Hauteur });
           FloatParallelArray Valeur3 = new FloatParallelArray(3, new int[2] { Largeur, Hauteur });
 
        override public void Générer()
        {
            FloatParallelArray Voisines = new FloatParallelArray(0, new int[2] { Largeur, Hauteur });
            FloatParallelArray Cellules = new FloatParallelArray(Génération);
 
            //Cumul des valeurs des voisines
            for (int Y = -1; Y <= 1; Y++)
            {
                for (int X = -1; X <= 1; X++)
                {
                    if (!(X == 0 && Y == 0))
                    {
                        Voisines = Voisines + ParallelArrays.Rotate(Cellules, Y, X);
                    }
                }
            }
 
            //Regarde si il y a 2 voisines
            BoolParallelArray Resultat_1a = ParallelArrays.CompareEqual(Voisines, Valeur2);
            //Vivante si il y a 2 voisines, Morte sinon
            FloatParallelArray Resultat_1b = ParallelArrays.Cond(Resultat_1a, Valeur1, Valeur0);
            //Si morte : pas d'importance qu'il y ait eu 2 voisines
            FloatParallelArray Resultat_1c = ParallelArrays.Min(Resultat_1b, Cellules);
 
            //Regarde si il y a 3 voisines
            BoolParallelArray Resultat_2a = ParallelArrays.CompareEqual(Voisines, Valeur3);
            //Vivante si il y a 3 voisines, morte sinon
            FloatParallelArray Resultat_2b = ParallelArrays.Cond(Resultat_2a, Valeur1, Valeur0);
 
            //Regarde si vivant dans au moins un des deux test
            Cellules = ParallelArrays.Max(Resultat_1c, Resultat_2b);
 
            //Evaluation
            Cible.ToArray(Cellules, out Génération);
        }

J'ai beau chercher, je n'arrive pas à trouver pourquoi j’obtiens d'aussi mauvaises performances ... et l'épluchage du peu de doc disponible ne m'as pas beaucoup aidé. Quelqu'un aurait une idée ?

19/11/2011, 11h35
DonQuiche

Bonjour.

Je n'ai jamais utilisé Accelerator mais à vue de nez tout semble correct : le graphe construit n'a rien d'exceptionnel. J'ai quelques doutes sur l'évaluation de certaines fonctions sur un GPU mais si les bonhommes de MS les ont proposées c'est que ça doit se tenir. Cela dit, j'ai trois questions :
* De quel matériel (CPU, GPU, RAM, VRAM) disposes-tu ?
* As-tu essayé de cibler le CPU plutôt que le GPU ?
* Que valent Largeur et Hauteur ?

Par ailleurs, tu aurais peut-être plus de chances en posant ta question sur les sections de dvp.net dédiées au parallélisme, voire chez MS s'ils ont un forum pour ce produit.
19/11/2011, 15h14
Hydrargyrum

- CPU : Quadricore (Intel i5) à 3.1 GhZ
- GPU : Nvidia GeForce GTX 460
- RAM : 4 Go
- VRAM : 4Go
Largeur et Hauteur peuvent être mis à n'importe quelle valeur ... mais je fait mes test en 1024*768.

En mettant "Cible" sur le CPU je perd beaucoup en performance, environ 50% de temps en plus. Quand à MS il n'ont pas de forum sur le sujet, hélas (ou alors ils l'ont planqué).
19/11/2011, 16h04
DonQuiche

Huh huh, je viens de réaliser quelque chose...

Ton code ne correspond qu'à une seule itération du jeu de la vie, n'est-ce pas ? Et tu répètes cette étape de nombreuses fois en regénérant à chaque fois tout le graphe ? Si j'ai bien compris ton code, je dirais que le problème vient de là : la génération du graphe (et de tout ce qui s'en suit : primitives et shaders sur le GPU, compilation dynamique sur le CPU) est trop coûteuse, il faut modifier le programme pour que celle-ci ne soit réalisée qu'une fois en intégrant la boucle principale dans le graphe.
19/11/2011, 18h02
Hydrargyrum

J'y avais déjà pensé, mais le problème c'est que je ne voit justement pas comment faire ça :mrgreen: Même les exemples fournis avec la librairie procèdent comme ça ...

Apparemment, la compilation du graphe ET le calcul sont fait d'un bloc lors de l'appel à "Cible.ToArray" ... y a rien dans la doc qui indique comment 'sauvegarder' le graphe à part pour pouvoir le réutiliser.

Les chercheurs qui l'ont conçus revendiquent des performances jusqu'à 70 fois supérieur à un algorithme normal ... si c'est vraiment la compilation qui prend autant de temps, c'est qu'ils ont bien du avoir un moyen de ré-utiliser le graphe :-/
19/11/2011, 18h41
DonQuiche

J'ai jeté un coup d'oeil à la doc et celle-ci mentionne des "Parameter objects" justement prévus pour éviter d'avoir à recréer le graphe.

Cela dit, cela imposera toujours beaucoup de mouvement sur le bus AGP, le plus efficace serait de supprimer la boucle supérieure pour l'intégrer dans le graphe.

Malheureusement les "parameter objects" permettent de sauver le graphe mais en version non compilée.
Code:

1 2 3 4 5 6 7 8 9 10 11 Cellules = new FloatParallelArrayParam(); //... //Reste de l'algorithme inchangé //... Algorithme = ParallelArrays.Max(Resultat_1c, Resultat_2b); override public void Générer() { Cellules.Bind(new FloatParallelArray(Génération)); Cible.ToArray(Algorithme, out Génération); }
Ça permet de planquer tout l'algorithme dans la phases d'initialisation, mais ça n'améliore pas le temps de calcul de la boucle :-/