Comment le processeur et le processeur graphique interagissent-ils pour le rendu des graphiques informatiques?

L'unité de traitement centrale (CPU) et l'unité de traitement graphique (GPU) de votre ordinateur interagissent à chaque instant où vous utilisez votre ordinateur pour vous fournir une interface visuelle nette et réactive. Continuez à lire pour mieux comprendre comment ils travaillent ensemble.

photo par sskennel.

La session de questions et réponses d'aujourd'hui nous parvient avec la permission de SuperUser, une sous-division de Stack Exchange, un groupe de sites Web de questions-réponses animé par la communauté..

La question

Le lecteur de SuperUser Sathya a posé la question:

Ici vous pouvez voir une capture d'écran d'un petit programme C ++ appelé Triangle.exe avec un triangle tournant basé sur l'API OpenGL.

Certes, c'est un exemple très basique mais je pense que cela s'applique à d'autres opérations de cartes graphiques.

J'étais juste curieux et voulais connaître le processus en entier en double-cliquant sur Triangle.exe sous Windows XP jusqu'à ce que je puisse voir le triangle tourner sur le moniteur. Que se passe-t-il, comment le processeur (qui gère d’abord le fichier .exe) et le GPU (qui affiche finalement le triangle à l’écran) interagissent-ils??

Je suppose que l’affichage de ce triangle rotatif implique principalement le matériel / logiciel suivant, entre autres:

Matériel

• Disque dur
• Mémoire système (RAM)
• CPU
• Mémoire vidéo
• GPU
• affichage LCD

Logiciel

• Système opérateur
• API DirectX / OpenGL
• Pilote Nvidia

Quelqu'un peut-il expliquer le processus, peut-être avec une sorte d'organigramme pour l'illustration?

Cela ne devrait pas être une explication complexe qui couvre chaque étape (supposez que cela irait au-delà de la portée), mais une explication qu'un informaticien intermédiaire peut suivre.

Je suis à peu près sûr que beaucoup de personnes qui s'appelleraient même des informaticiens ne pourraient pas décrire ce processus correctement.

La réponse

Bien que plusieurs membres de la communauté aient répondu à la question, Oliver Salzburg a fait un effort supplémentaire en y répondant non seulement par une réponse détaillée, mais également par d'excellents graphiques..

Image de JasonC, disponible comme fond d'écran ici.

Il écrit:

J'ai décidé d'écrire un peu sur l'aspect de la programmation et sur la manière dont les composants se parlent. Peut-être que ça va nous éclairer sur certains domaines.

La présentation

Que faut-il pour avoir cette seule image, celle que vous avez postée dans votre question, dessinée à l'écran?

Il y a plusieurs façons de dessiner un triangle à l'écran. Pour simplifier, supposons qu'aucun tampon de vertex n'a été utilisé. (UNE vertex bufferest une zone de mémoire où vous stockez des coordonnées.) Supposons que le programme dit simplement au pipeline de traitement graphique de chaque sommet (un sommet est juste une coordonnée dans l’espace) d’une ligne.

Mais, avant de pouvoir dessiner quoi que ce soit, nous devons d'abord exécuter un échafaudage. Nous verrons Pourquoi plus tard:

// Efface l'écran et le tampon de profondeur glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Réinitialiser la matrice de vue modèle actuelle glMatrixMode (GL_MODELVIEW); glLoadIdentity (); // Dessin à l'aide de triangles glBegin (GL_TRIANGLES); // glColor3f rouge (1.0f, 0.0f, 0.0f); // sommet du triangle (avant) glVertex3f (0.0f, 1.0f, 0.0f); // Green glColor3f (0.0f, 1.0f, 0.0f); // gauche du triangle (avant) glVertex3f (-1.0f, -1.0f, 1.0f); // Blue glColor3f (0.0f, 0.0f, 1.0f); // droite du triangle (avant) glVertex3f (1.0f, -1.0f, 1.0f); // Fait Dessin glEnd ();

Alors qu'est-ce que ça fait?

Lorsque vous écrivez un programme qui veut utiliser la carte graphique, vous choisissez généralement une sorte d’interface avec le pilote. Certaines interfaces bien connues du pilote sont:

• OpenGL
• Direct3D
• CUDA

Pour cet exemple, nous allons nous en tenir à OpenGL. Maintenant votre interface avec le conducteur est ce qui vous donne tous les outils dont vous avez besoin pour réaliser votre programme parler à la carte graphique (ou au pilote, qui ensuite pourparlers à la carte).

Cette interface est destinée à vous donner certaines outils. Ces outils prennent la forme d’une API que vous pouvez appeler depuis votre programme..

Cette API est ce que nous voyons être utilisé dans l'exemple ci-dessus. Regardons de plus près.

L'échafaudage

Avant de pouvoir réellement dessiner, vous devrez effectuer une installer. Vous devez définir votre fenêtre d'affichage (la zone qui sera réellement rendue), votre perspective (la caméra dans votre monde), quel anti-aliasing vous utiliserez (pour aplanir les bords de votre triangle)…

Mais nous ne regarderons rien de tout cela. Nous allons juste jeter un coup d'oeil sur les choses que vous devrez faire chaque image. Comme:

Effacement de l'écran

Le pipeline graphique ne va pas effacer l'écran pour chaque image. Vous devrez le dire. Pourquoi? C'est pourquoi:

Si vous n'effacez pas l'écran, vous aurez simplement attirer c'est chaque image. C'est pourquoi nous appelons glClear avec leGL_COLOR_BUFFER_BIT ensemble. L'autre bit (GL_DEPTH_BUFFER_BIT) demande à OpenGL d'effacer le profondeurtampon. Ce tampon est utilisé pour déterminer quels pixels sont devant (ou derrière) d'autres pixels.

Transformation

Source de l'image

La transformation est la partie où nous prenons toutes les coordonnées en entrée (les sommets de notre triangle) et appliquons notre matrice ModelView. C'est la matrice qui explique comment notre modèle (les sommets) sont pivotés, mis à l'échelle et traduits (déplacés).

Ensuite, nous appliquons notre matrice de projection. Cela déplace toutes les coordonnées pour qu'elles soient correctement orientées vers notre caméra..

Maintenant, nous transformons encore une fois, avec notre matrice Viewport. Nous faisons cela pour mesurer notre modèle à la taille de notre moniteur. Nous avons maintenant un ensemble de sommets prêts à être rendus.!

Nous reviendrons sur la transformation un peu plus tard.

Dessin

Pour dessiner un triangle, nous pouvons simplement dire à OpenGL de commencer une nouvelle liste de triangles en appelant glBegin avec le GL_TRIANGLES constant.
^{Il y a aussi d'autres formes que vous pouvez dessiner. Comme une bande de triangle ou un ventilateur de triangle. Ce sont principalement des optimisations, car elles nécessitent moins de communication entre le processeur et le GPU pour dessiner le même nombre de triangles..}

Après cela, nous pouvons fournir une liste d’ensembles de 3 sommets qui devraient constituer chaque triangle. Chaque triangle utilise 3 coordonnées (comme nous sommes dans l'espace 3D). De plus, je fournis aussi un Couleur pour chaque sommet, en appelantglColor3f avant appel glVertex3f.

La nuance entre les 3 sommets (les 3 coins du triangle) est calculée par OpenGL.automatiquement. Il interpolera la couleur sur toute la surface du polygone.

Interaction

Maintenant, quand vous cliquez sur la fenêtre. L'application doit uniquement capturer le message de la fenêtre signalant le clic. Ensuite, vous pouvez exécuter n'importe quelle action de votre programme.

Cela obtient un lot plus difficile une fois que vous souhaitez commencer à interagir avec votre scène 3D.

Vous devez d’abord savoir clairement à quel pixel l’utilisateur a cliqué dans la fenêtre. Ensuite, en prenant votre la perspectiveen compte, vous pouvez calculer la direction d'un rayon, du point du clic de souris dans votre scène. Vous pouvez ensuite calculer si un objet de votre scène intersecte avec ce rayon. Maintenant, vous savez si l'utilisateur a cliqué sur un objet.

Alors, comment faites-vous la rotation?

Transformation

Je connais deux types de transformations généralement appliqués:

• Transformation basée sur la matrice
• Transformation à base d'os

La différence est que des os affecter seul sommets. Les matrices affectent toujours tous les sommets dessinés de la même manière. Regardons un exemple.

Exemple

Plus tôt, nous avons chargé notre matrice d'identité avant de dessiner notre triangle. La matrice d’identité est celle qui fournit simplement pas de transformation du tout. Donc, tout ce que je dessine, n’est affecté que par mon point de vue. Donc, le triangle ne sera pas tourné du tout.

Si je veux le faire pivoter maintenant, je peux soit faire le calcul moi-même (sur le processeur) et simplement appeler glVertex3f avecautre coordonnées (qui sont tournés). Ou je pourrais laisser le GPU faire tout le travail, en appelant glRotatefavant de dessiner:

// faire pivoter le triangle sur l'axe des ordonnées glRotatef (quantité, 0.0f, 1.0f, 0.0f); 

montant est, bien sûr, juste une valeur fixe. Si tu veux animer, vous devrez garder une trace de montantet l'augmenter chaque image.

Alors, attendez, ce qui est arrivé à tous les discours sur la matrice plus tôt?

Dans cet exemple simple, nous n’avons pas à nous soucier des matrices. Nous appelons simplement glRotatef et ça prend soin de tout ça pour nous.

glRotate produit une rotation de angle degrés autour du vecteur x y z. La matrice actuelle (seeglMatrixMode) est multipliée par une matrice de rotation, le produit remplaçant la matrice actuelle. IfglMultMatrix était appelé avec la matrice suivante comme argument:

x 2 ⁡ 1 - c + cx y ⁡ 1 - c - z ⁢ sx z ⁡ 1 - c + y ⁢ s 0 y ⁢ x 1 - c + z ⁢ sy 2 ⁡ 1 - c + cy ⁢ z ⁡ 1 - c - x ⁢ s 0 x z ⁡ 1 - c - y ⁢ sy ⁢ z ⁡ 1 - c + x sz 2 ⁡ 1 - c + c 0 0 0 0 1

Eh bien, merci pour ça!

Conclusion

Ce qui devient évident, c’est qu’on parle beaucoup à OpenGL. Mais ça ne dit rien nous n'importe quoi. Où est la communication?

La seule chose que OpenGL nous dit dans cet exemple est quand c'est fait. Chaque opération prendra un certain temps. Certaines opérations prennent incroyablement longtemps, d'autres sont incroyablement rapides.

Envoi d'un sommet pour le GPU sera si rapide, je ne saurais même pas comment l'exprimer. L'envoi de milliers de sommets de la CPU au GPU, chaque image, n'est probablement pas un problème..

Effacement de l'écran Cela peut prendre une milliseconde ou moins (gardez à l'esprit que vous ne disposez généralement que d'environ 16 millisecondes pour dessiner chaque image), en fonction de la taille de votre fenêtre d'affichage. Pour le supprimer, OpenGL doit dessiner chaque pixel de la couleur souhaitée, ce qui peut représenter des millions de pixels..

En dehors de cela, nous ne pouvons quasiment que demander à OpenGL les capacités de notre adaptateur graphique (résolution maximale, anti-aliasing maximum, profondeur de couleur maximale,…).

Mais nous pouvons également remplir une texture avec des pixels ayant chacun une couleur spécifique. Chaque pixel contient donc une valeur et la texture est un «fichier» géant rempli de données. Nous pouvons charger cela dans la carte graphique (en créant un tampon de texture), puis charger un shader, dire à ce shader d'utiliser notre texture comme entrée et exécuter des calculs extrêmement lourds sur notre "fichier"..

Nous pouvons alors "rendre" le résultat de notre calcul (sous la forme de nouvelles couleurs) dans une nouvelle texture.

C'est ainsi que vous pouvez faire en sorte que le processeur graphique fonctionne pour vous d'une autre manière. Je suppose que CUDA fonctionne de manière similaire à cet aspect, mais je n’ai jamais eu l’occasion de travailler avec elle.

Nous n’avons vraiment que légèrement touché le sujet. La programmation graphique en 3D est un enfer.

Source de l'image

Avez-vous quelque chose à ajouter à l'explication? Sound off dans les commentaires. Voulez-vous lire plus de réponses d'autres utilisateurs de Stack Exchange doués en technologie? Découvrez le fil de discussion complet ici.