Discussion :

[athlon64]

Bonjour,

j'ai un programme d'automate cellulaire, que j'aimerais optimiser pour gagner en vitesse d’affiche. Le fonctionnement du programme se définit comme suivant :

1-Les cellules sont des carrés d'une matrice dont je définie le nombre.

2-Au démarrage chaque cellule peut prendre deux valeurs possibles(true =vivant, false =morte)

3-L'état de chaque cellule évolue à l'instant t1 en fonction du nombre de cellules qui l'entourent au temps t.

4-La matrice évolue ainsi de t(0)->t(n) avec n qui tend vers l'infinie.

5-Ainsi à l’instant t(n) par exemple, je fige la matrice, je relève les valeurs pour calculer le nouvel état à t(n+1).



Le programme contient deux boucles de calculs principales.
-la première est celle qui calcule la valeur que prendra chaque cellule à l'instant suivante.
-la seconde est celle qui utilise GDI+ (graphics.FillRectangle) pour tracer la couleur de chaque cellule en fonction de la valeur calculée.

L'affichage est fluide lorsque que j'ai 100*100 par exemple, 10 000 cellules à traiter une par une ça passe.

quand je passe à 1000*1000, =>1 million de cellules à traiter, l’affichage devient très lente et pourtant j'ai une charge de processeur qui ne dépasse jamais 25% au total et jamais 50% par coeur. Le programme passe la majorité de son temps dans la boucle d'affichage.

j'ai cherché pas mal de solution sur le net et après plusieurs tests, j'ai gardé openMP qui s'avère de très loin le plus efficace comparé à parrallel_for de la <ppl> et parrallel_for_fixed.

j'ai ainsi optimisé la première boucle de calcul qui divise la boucle sur 4 threads, ça n'a pas apporté grand chose pratiquement rien car le gros du temps est passé dans la boucle d'affichage. J'ai trouvé aucune solution pour partager le travail entre les 4 coeurs. GDI+ ne supportant pas les threads apparemment.


Quelqu’un pourrait m'aider pour augmenter la fluidité svp ?

code coeur de la boucle d'affichage

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
for(int colonne=0;colonne<m_nTaille;colonne++)//pour chaque colone de la  ligne choisie
		{
 
			if ( m_Cellules[ligne*m_nTaille+colonne] == true)
 
			{	
				g.FillRectangle(&CaseVivante, ZonesCellule); //couleur "CaseVivante" pour la cellule vivante
			}
 
			else
 
			{
				g.FillRectangle(&CaseMorte, ZonesCellule);//couleur "CaseMorte" pour la cellule morte
			}
}

[athlon64]

précisions :
miniature 1 = 10 000 cases
miniature 2 = 1 million de cases

[athlon64]

personne ne peut aider ?

[Invité]

salut,

je présume,..., qu'à un moment il faut envoyer les données depuis le cpu vers la carte graphique.
Je sais pas comment gère winapi, dgi, mais tu peux déjà tenter de minimiser le nombre d'accès que tu vas faire vers ta carte.

Genre au lieu de faire un if/else, tu colories tout en noir, et tu affiches que les cellules vivantes par exemple.
Si tu vois que ca diminue le temps, alors faut que tu essaies de bufferiser ta surface et de tout afficher ensuite (d'un seul coup)

[athlon64]

en fait c'est déjà ce que je fais , j'ai un objet graphique en mémoire qui la taille
de l’écran, ensuite je construis l'image sue je veux puis je projeté sur l’écran.

J'en reviens à penser que les performances de GDI+ ont atteint leu limites.

faudrait peut être penser à une autre technologie.

[athlon64]

voilà, j'ai obtenu des réponses sur un forum de microsoft anglophone et en plus de mes recherches, j'ai eu la conclusion suivante.

Il faut utiliser Direct2D. Car GDI+ a atteint ses limites tout simplement.

[athlon64]

Je reviens sur ce poste par hasard.

Je précise que j'avais utilisé direct2D.
Les graphismes étaient plus beaux, l'antialiasing était géré puis surtout au niveau de la vitesse c'était le jour et la nuit.

[oodini]

Tu as pensé à OpenCL ou CUDA ?