Comment le processeur et le processeur graphique interagissent-ils lors de l'affichage des graphiques informatiques?

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 simplement curieux et je voulais tout savoir en cliquant deux fois 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 en premier le fichier .exe) et le GPU (qui affiche finalement le triangle à l'écran) interagissent?

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, avec peut-être une sorte d'organigramme à titre d'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 presque sûr que beaucoup de personnes qui se diraient même des professionnels de l'informatique ne pourraient pas décrire ce processus correctement.

Answer 1

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 cela va nous éclairer sur certains domaines.

La présentation

Que faut-il pour avoir cette seule image, 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é. (Avertex bufferest une zone de mémoire dans laquelle vous stockez des coordonnées.) Supposons que le programme communique simplement au pipeline de traitement graphique de chaque sommet (un sommet n'est qu'une coordonnée dans l'espace) d'affilée.

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

// Clear The Screen And The Depth Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

// Reset The Current Modelview Matrix
glMatrixMode(GL_MODELVIEW); 
glLoadIdentity();

// Drawing Using Triangles
glBegin(GL_TRIANGLES);

  // Red
  glColor3f(1.0f,0.0f,0.0f);
  // Top Of Triangle (Front)
  glVertex3f( 0.0f, 1.0f, 0.0f);

  // Green
  glColor3f(0.0f,1.0f,0.0f);
  // Left Of Triangle (Front)
  glVertex3f(-1.0f,-1.0f, 1.0f);

  // Blue
  glColor3f(0.0f,0.0f,1.0f);
  // Right Of Triangle (Front)
  glVertex3f( 1.0f,-1.0f, 1.0f);

// Done Drawing
glEnd();

Alors qu'est-ce que ça 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 rester avec OpenGL. Maintenant, votreinterface avec le piloteest ce qui vous donne tous les outils nécessaires pour rendre votre programmetalkto la carte graphique (ou le pilote, qui ensuiteparleà la carte).

Cette interface est tenue de vous donner certainsoutils. Ces outils se présentent sous la forme d'un API que vous pouvez appeler à partir de 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 réaliser un dessin, vous devez effectuer unsetup. Vous devez définir votre fenêtre de visualisation (la zone qui sera réellement rendue), votre perspective (lecamerade votre monde), quel anti-aliasing vous allez utiliser (pour lisser les bords de votre triangle) ...

Mais nous ne regarderons rien de tout cela. Nous allons juste jeter un coup d'œil sur ce 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 allez simplementdessiner par-dessusil chaque image. C'est pourquoi nous appelons glClear avec l'ensemble GL_COLOR_BUFFER_BIT. L'autre bit (GL_DEPTH_BUFFER_BIT) indique à OpenGL de supprimer leprofondeurtampon. 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 avec laquelleexpliquecomment nosmodè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 afin qu'elles soient correctement orientées vers notre caméra.

Maintenant, nous transformons encore une fois, avec notre matrice Viewport. Nous faisons cela pour adapter notremodè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 la constante GL_TRIANGLES.
^{Il y a aussi d'autres formes que vous pouvez dessiner. Comme une bande triangulaire ou un ventilateur triangulaire . 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 également uncolorpour chaque sommet, en appelant glColor3f avant en appelant 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, lorsque vous cliquez sur la fenêtre. L'application doit seulement capturer le message de la fenêtre signalant le clic. Ensuite, vous pouvez exécuter n’importe quelle action de votre programme.

Cela devient beaucoup plus difficile lorsque 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 tenant compte de votreperspective, vous pouvez calculer la direction d'un rayon, à partir du point de la souris, dans votre scène. Vous pouvez ensuite calculer si un objet de votre scène intersecteavec ce rayon . Vous savez maintenant 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 quebonesaffecte seulsommets. Les matrices affectent toujours tous les sommets dessinés de la même manière. Regardons un exemple.

Exemple

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

Si je veux le faire pivoter maintenant, je pourrais soit faire le calcul moi-même (sur le processeur) et simplement appeler glVertex3f avecothercoordonnées (qui sont pivotées). Ou je pourrais laisser le GPU faire tout le travail, en appelant glRotatef avant de dessiner:

// Rotate The Triangle On The Y axis
glRotatef(amount,0.0f,1.0f,0.0f);               

amount n'est bien sûr qu'une valeur fixe. Si vous voulezanimate, vous devrez garder une trace de amount et l'augmenter chaque image.

Alors, attendez, qu'est-il arrivé à toutes les discussions sur la matrice plus tôt?

Dans cet exemple simple, nous ne devons pas nous soucier des matrices. Nous appelons simplement glRotatef et cela s’occupe de tout cela pour nous.

glRotate produit une rotation de angle degrés autour du vecteur x y z. La matrice actuelle (voir glMatrixMode ) est multipliée par une matrice de rotation, le produit remplaçant la matrice actuelle, comme si glMultMatrix ont été appelés 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'il y a beaucoup de discussions à OpenGL. Mais cela ne dit rien nous . Où est la communication?

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

Envoyer un sommetau GPU sera si rapide que je ne saurais même pas comment l'exprimer. L'envoi de milliers de sommets de la CPU au GPU, chaque image, ne pose aucun problème.

Effacement de l'écranpeut prendre une milliseconde ou moins (rappelez-vous, 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 l'effacer, 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 en tant qu'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 3D est un enfer d'une bête.

Source de l'image

Answer 2

Il est difficile de comprendre exactement ce que vous ne comprenez pas.

Le GPU a une série de registres que le BIOS mappe. Celles-ci permettent à la CPU d'accéder à la mémoire du GPU et lui demandent d'effectuer des opérations. La CPU connecte des valeurs à ces registres pour mapper une partie de la mémoire du GPU afin que la CPU puisse y accéder. Ensuite, il charge des instructions dans cette mémoire. Il écrit ensuite une valeur dans un registre qui indique au GPU d’exécuter les instructions que le CPU charge dans sa mémoire.

Les informations comprennent le logiciel que le GPU doit exécuter. Ce logiciel est fourni avec le pilote, qui gère ensuite la répartition des responsabilités entre le processeur et le processeur graphique (en exécutant des parties de son code sur les deux périphériques).

Le pilote gère ensuite une série de "fenêtres" dans la mémoire du processeur graphique que le processeur peut lire et écrire. En règle générale, le modèle d'accès implique que la CPU écrit des instructions ou des informations dans la mémoire du GPU mappée, puis charge le GPU, par le biais d'un registre, d'exécuter ces instructions ou de traiter ces informations. Les informations incluent la logique des shader, les textures, etc.

Answer 3

J'étais simplement curieux et je voulais tout savoir en cliquant deux fois 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 en premier le fichier .exe) et le GPU (qui affiche finalement le triangle à l'écran) interagissent?

Admettons l'hypothèse que vous savez réellement comment un exécutable s'exécute sur un système d'exploitation et comment cet exécutable est envoyé de votre GPU vers le moniteur, mais que vous ne savez pas ce qui se passe entre les deux. Voyons donc l'aspect matériel et approfondissons l'aspect aspect du programmeur ...

Quelle est l'interface entre le processeur et le GPU?

À l’aide d’un pilote , la CPU peut communiquer via des fonctions de la carte mère telles que PCI vers la carte graphique et lui envoyer des commandes pour exécuter certaines instructions du processeur graphique accéder/mettre à jour la mémoire du GPU , charger un code à exécuter sur le GPU et plus ...

Mais vous ne pouvez pas vraiment parler directement du matériel ou du pilote à partir du code; alors, cela devra se faire via des API comme OpenGL, Direct3D, CUDA, HLSL, Cg. Tandis que le premier exécute des instructions GPU et/ou met à jour la mémoire du GPU, le dernier exécutera du code sur le GPU car il s'agit de langages physique/shader.

Pourquoi exécuter du code sur le GPU et non sur le CPU?

Bien que le processeur soit efficace pour exécuter nos programmes quotidiens de postes de travail et de serveurs, personne n’a beaucoup réfléchi à tous ces graphiques brillants que vous voyez dans les jeux de nos jours. À l'époque, il existait des moteurs de rendu logiciels qui utilisaient certaines caractéristiques 2D et 3D, mais ils étaient très contraignants. Donc, voici où le GPU est entré en jeu.

Le processeur graphique est optimisé pour l’un des calculs les plus importants en graphisme, la manipulation matricielle . Alors que le processeur doit calculer chaque multiplication dans une manipulation de matrice un par un (plus tard, des choses comme 3DNow! et SSE rattrapé), le GPU peut faire toutes ces multiplications à la fois! Parallélisme.

Mais les calculs parallèles ne sont pas la seule raison, une autre raison est que le GPU est beaucoup plus proche de la mémoire vidéo, ce qui le rend beaucoup plus rapide que de devoir faire des allers-retours avec le processeur, etc.

Comment ces instructions GPU/mémoire/code affichent-ils des graphiques?

Il manque un élément pour que tout fonctionne, nous avons besoin de quelque chose que nous puissions écrire, que nous pourrons ensuite lire et envoyer à l'écran. Nous pouvons le faire en créant un framebuffer . Quelle que soit l'opération que vous fassiez, vous mettrez éventuellement à jour les pixels dans le framebuffer; qui, outre l'emplacement, contient également des informations sur la couleur et la profondeur.

Donnons un exemple où vous vouliez dessiner un Sprite de sang (une image) quelque part; Tout d'abord, la texture de l'arbre elle-même est chargée dans la mémoire du processeur graphique, ce qui permet de la redessiner à volonté. Ensuite, pour dessiner le Sprite quelque part, nous pouvons le traduire à l’aide de sommets (le positionner correctement), le rastériser (le transformer d’un objet 3D en pixels) et mettre à jour le framebuffer. Pour en avoir une meilleure idée, voici un diagramme de flux de pipeline OpenGL de Wikipedia:

C’est l’essentiel de l’idée graphique, plus la recherche est un devoir pour le lecteur.

Answer 4

Pour garder les choses simples, nous pouvons le décrire comme ceci. Certaines adresses de mémoire sont réservées (par le BIOS et/ou le système d'exploitation) non pas pour RAM mais pour la carte vidéo. Toutes les données écrites avec ces valeurs (pointeurs) vont à la carte. Donc, en théorie, tout programme peut écrire directement sur la carte vidéo simplement en connaissant la plage d’adresses et c’est exactement ce qui se faisait jadis. En pratique, avec les systèmes d’exploitation modernes, cela est géré par le pilote vidéo et/ou la bibliothèque graphique située en haut (DirectX, OpenGL, etc.).

Answer 5

Les GPU sont généralement pilotés par DMA tampons. En d’autres termes, le pilote compile les commandes qu’il reçoit du programme d’espace utilisateur en un flux d’instructions (état du commutateur, dessin de cette manière, contextes de commutateur, etc.), qui sont ensuite copiées dans la mémoire du périphérique. Il ordonne ensuite au GPU d'exécuter ce tampon de commande via un registre PCI ou des méthodes similaires.

Ainsi, à chaque appel de tirage, etc., le pilote d’espace utilisateur compilera la commande, qui appelle ensuite le pilote d’espace du noyau via une interruption, puis soumet le tampon de commande à la mémoire du périphérique et demande au GPU de démarrer le rendu.

Sur les consoles, vous pouvez même vous amuser à faire tout cela vous-même, en particulier sur PS3.

Answer 6

Je pense que op ne sait pas exactement ce que le processeur demande à la carte graphique de faire et pourquoi les commandes liées aux graphiques (comme les commandes opengl ou direct3d) ne sont pas envoyées directement au processeur graphique.

Le processeur indique simplement au GPU ce qu'il doit rendre. Toutes les instructions passent d'abord par le processeur où elles sont configurées/initialisées pour permettre au GPU d'effectuer le rendu.

Answer 7

Je pense que le processeur envoie les données vidéo au GPU via le bus, puis le GPU les affiche. Donc, plus rapide GPU peut gérer plus de données de la CPU. De cette façon, une partie du traitement de cpuoffload à GPU. Par conséquent, vous obtenez une vitesse plus rapide dans les jeux.

C'est un peu comme le RAM où le processeur stocke des choses afin qu'il puisse être chargé et traité rapidement. Les deux rendent les jeux plus rapides.

Ou la carte son ou la carte réseau fonctionnent sur le même principe, c’est-à-dire obtenir des données et décharger un peu du travail du processeur.