[C++] Vitesse pour la copie des Vertex Buffers

Salut !

Je voudrais parler de la méthode la plus rapide pour afficher quelque chose à l'écran en se servant des Vertes Buffers.

En regardant plusieurs exemples sur comment les utiliser, j'ai remarqué que généralement, on copie les données que l'on va vouloir afficher dans un tableau, puis ensuite, on les recopie dans le Vertex Buffer avec par exemple memcpy.

Le problème est que l'on copie 2 fois la même chose, la première lorsque l'on fait les calculs de tout ce que l'on veut afficher, la deuxième quand on recopie dans le Vertex Buffer.

Je me demandais donc si on pouvait pas faire :
- Lock
- calculs dans le vertex buffer
- Unlock puis Affichage
au lieu de :
- calculs dans un tableau
- Lock
- recopier dans le Vertex Buffer
- Unlock puis Affichage

A priori ça semble plus rapide, le problème est que, peut-être que quand on fait Lock, l'ordinateur termine l'affichage qu'il est en train de faire avant de toucher au Vertex Buffer, donc on peut utiliser ce temps pour faire les calculs dans un tableau. Il faut alors comparer le temps qu'il y a entre "faire l'affichage" et "recopier le Vertex Buffer" pour voir quelle méthode est la plus rapide car je ne pense pas que ça dépende du temps qu'on met pour faire les calculs.
Moi, je pense qu'il n'y a pas trop de différences de vitesse entre les 2 méthodes, donc autant utiliser la première car quand on a beaucoup de données ça fait gagner beaucoup de mémoire vive.

Pourquoi alors on utilise toujours memcpy dans tous les exemples ?

Le problème c'est qu'entre un Lock et un Unlock ton GPU est "paralysé", il attend que le CPU ait fini en se tournant les pouces.

Donc si l'on passe généralement par un tableau intermédiaire, c'est pour éviter de passer trop de temps entre Lock et Unlock. Bien sûr si tu n'as pas beaucoup de calculs et que la majeure partie du temps est prise par la copie, tu peux te passer du tableau intermédiaire.

Ok merci !
Je comprends mieux pourquoi on a pris l'habitude de faire ça alors

salut, j'essaye de faire exactement la même chose mais avec OpenGL.

Personnellement j'obtiens des résultats pas bons en terme de vitesse lorsque j'écris directement dans le buffer et toi ?

En principe, il n'y a pas obligation de faire une copie intermediaire donc si tu peux l'éviter fais le. Et non le GPU n'est pas bloqué entre un lock et un unlock (par contre il faut bien étudier la logique des flags pour éviter la synchronisation forcée !).

Ceci dit
- faire des calculs dans un tableau intermediaire, permet si tu en as besoin d'en faire profiter le CPU plus tard sans devoir passer par le lock/unlock.
- en utilisant un vertex buffer du pool default, flagué dynamique ou non, tu vas te retrouver avec un pointeur sur de la mémoire potentiellement lente. Parce qu'elle peut etre de l'autre coté du bus graphique mais surtout parce qu'elle peut etre dans de la mémoire non cachée (parfois les deux à la fois). La mémoire non cachée est problématique parce que toute lecture d'un octet va forcer ton CPU a attendre de nombreux cycles sans rien faire, et parce que les écritures doivent être cohérentes pour bénéficier de l'optimisation du write combine (le CPU attend d'avoir assez d'octets contigus à écrire pour maximiser la vitesse d'écriture sur son bus mémoire).
- par contre, en utilisant un vertex buffer du pool managed, l'accès en lecture et en écriture est identique et les perfs sont aussi bonnes que si tu accédais à ta mémoire perso. D'ailleurs le pool managed a sa propre copie de ton buffer (en plus de celle du driver).

Donc si tu as des calculs à faire sur tes données et que tu as un vb dans le pool default, il vaut parfois mieux placer tes donner dans une structure intermédiaire pour y faire les calculs et ensuite utiliser une copie rapide qui met à profit le write combine. Mais sinon, pas d'obligation comme dit plus haut.

LeGreg