« Les cartes graphiques/Les cartes d'affichage » : différence entre les versions

Contenu supprimé Contenu ajouté
Ligne 136 :
====Le multibuffering et la synchronisation verticale====
 
Sur les toutes premières cartes graphiques, le ''framebuffer'' ne pouvait contenir qu'une seule image. L'ordinateur écrivait donc une image dans le ''framebuffer'' et celle-ci était envoyée à l'écran dès que possible. Cependant, écran et ordinateur n'étaient pas forcément synchronisés. Rien n’empêchait à l’ordinateur d'écrire dans le ''framebuffer'' pendant que l'image était envoyée à l'écran. Et cela peut causer des artefacts qui se voient à l'écran. Un exemple typique est celui des traitements de texte. Lorsque le texte affiché est modifié, le traitement de texte efface l'image dans le ''framebuffer'' et recalcule la nouvelle image à afficher. Ce faisant, une image blanche peut apparaitre durant quelques millisecondes à l'écran, entre le moment où l'image précédente est effacée et le moment où la nouvelle image est disponible. Ce phénoméne de ''flickering''; d'artefacts liés à une modification de l'image pendant qu'elle est affichée, est des plus désagréabledésagréables.
 
Pour éviter cela, on peut utiliser la technique du '''''double buffering'''''. L'idée derrière cette technique est de calculer une image en avance et de les mémoriser celle-ci dans le ''framebuffer''. Mais cela demande que le ''framebuffer'' ait une taille suffisante, qu'il puisse mémoriser plusieurs images sans problèmes. Le ''framebuffer'' est alors divisé en deux portions, une par image, auquelles nous donnerons le nom de tampons d'affichage. L'idée est de mémoriser l'image qui s'affiche à l'écran dans le premier tampon d'affichage et une image en cours de calcul dans le second. Le tampon pour l'image affichée s'appelle le tampon avant, ou encore le ''front buffer'', alors que celui avec l'image en cours de calcul s'appelle le ''back buffer''.
Ligne 142 :
[[File:Double buffering.png|centre|vignette|upright=2|Double buffering]]
 
Quand l'image dans le ''back-buffer'' est complète, elle est copiée dans le ''front buffer'' pour être affichée. L'ancienne image dans le ''front buffer'' est donc éliminée au profit de la nouvelle image. Le remplacement peut se faire par une copie réelle, l'image étant copiée le premier tampon vers le second. C'est ce qui est fait quand le remplacement est réalisé par le logiciel, et non par la carte graphique elle-même. PArPar exemple, c'est ce qui se passait sur les très anciennes versions de Windows, sur les vielles cartes graphiques, pour afficher le bureau et l'interface graphique du système d'exploitation. Mais une solution plus simple consiste à intervertir les deux tampons, le ''back buffer'' devenant le ''front buffer'' et réciproquement. Une telle interversion fait qu'on a pas besoin de copier les données de l'image, ce qui est une opération très lente. L'interversion des deux tampons peut se faire au niveau matériel. Rappelez-vous que plus haut, nous avions vu qu'il y a un circuit qui détermine l'adresse du pixel à lire à partir de deux compteurs X et Y, ainsi que de l'adresse du premier pixel. L'adresse du premier pixel n'est autre que l'adresse à laquelle commence le ''front buffer''. En changeant cette adresse pour la faire pointer vers l'ancien ''back buffer'', l’interversion se fait automatiquement.
 
On peut faire face à deux situations, suivant que le remplacement des deux images est synchronisée avec l'écran, ou non.
Ligne 152 :
[[File:Tearing (simulated).jpg|centre|vignette|upright=2|''Tearing'' (simulé)]]
 
La seconde méthode attend que la première image soit affichée avant de faire le remplacement. Elle porte le nom de '''synchronisation verticale''', aussi appelée vsync, et vous en avez peut-être déjà entendu parléparler. C'est une option présente dans les options de nombreux jeux vidéos, ainsi que dans les réglages du pilote de la carte graphique. Avec cette technique, le ''tearing'' disparait tout simplement. Mais le défaut de la vsync est qu'elle impose un temps d'attente avant de remplacer l'image affichée. Le temps d'attente lié à la synchronisation verticale est d'autant plus grand que l'écran affiche peu d'images par secondes. Pour un écran qui affiche 60 images par secondesseconde maximum, le délai ajouté par la synchronisation verticale est d'environ 1 seconde/60 = 16.666... millisecondes. Cela n'a l'air de rien, mais cela peut se ressentir. D'où l'impression qu'ont certains joueurs de jeux vidéos que leur souris est plus lente quand ils jouent avec la synchronisation verticale activée. Et encore, cela suppose que l'ordinateur peut sortir 60 images par secondes sans problèmes.
 
Pour comprendre les problèmes liés à la synchronisation verticale, rappelons que l'écran affiche une nouvelle image à intervalle régulier. Concrètement, l'écran affiche un certain nombre d'images par secondes, le nombre en question étant désigné sous le terme de "fréquence de rafraichissement". Or, la fréquence de rafraichissement de l'écran et le nombre d'images par secondes de l'ordinateur ne sont pas synchronisés l'un avec l'autre. La synchronisation verticale synchronise la fréquence de rafraichissement avec les FPS, ce qui réduit le ''tearing'' et élimine d'autres problèmes. Du moins,c 'est le cas à condition que l'ordinateur fournisse suffisamment l'images par secondes. Si l'écran a une fréquence de rafraichissement de 60 Hz (60 images par secondes), tout va bien tant que l'ordinateur fournit effectivement 60 images par secondes à l'écran, voire plus. Mais si le nombre d'images par secondes n'est pas raccord avec le nombre d'images par seconde affiché par l'écran, la synchronisation verticale entraine des différences de timings perceptibles.
 
Cela se voit avec les jeux vidéos, qui ont un nombre d'image par seconde très variable, et le temps qui s'écoule entre deux images varie grandement d'une image à l'autre. Or, le temps entre l'affichage de deux images est fixe avec la vsync activée. Ces différences de timings entrainent des sauts d'images quand un jeu vidéo calcule moins d'images par seconde que ce que peut accepter l'écran, ce qui donne une impression désagréable appelée le ''stuttering''. Un phénoméne très similaire apparait avec les vidéos/films encodés à 24 images par secondes qui s'affichent sur un écran à 60 Hz : l'écran affiche une image tous les 16.6666... millisecondes, alors que la vidéo veut afficher une image toutes les 41,666... millisecondes. orOr, 16.666... et 41.666... n'ont pas de diviseur entier commun : une image de film d'affiche tous les 2,5 images d'écran. Concrètement, écran et film sont désynchronisés. Si cela ne pose pas trop de problèmes sans la synchronisation verticale, cela en pose avec. Une image sur deux est décalée en termes de timings avec la synchronisation verticale, ce qui donne un effet bizarre, bien que léger, lors du visionnage sur un écran d'ordinateur.
 
Diverses solutions existent pour éliminer ces problèmes, et elles sont assez nombreuses. La première solution ajoute un troisième tampon d'affichage, ce qui donne la technique du '''''triple buffering'''''. L'utilité est de réduire le délai ajouté par la synchronisation verticale : utiliser le ''triple buffering'' sans synchronisation verticale n'a aucun sens. lL'idée est que l'ordinateur peut calculer une seconde image d'avance. Ainsi, si l'écran affiche l'image n°1, une image n°2 est terminée mais en attente, et une image n°3 est en cours de calcul. Le délai lié à la synchronisation verticale est réduit dans le cas où les FPS sont vraiment bas comparé à la fréquence d'affichage de l'écran, par exemple si on tourne à 40 images par secondes sur un écran à 60 Hz, du fait de l'image calculée en avance. Dans le cas où les FPS sont (temporairement) plus élevés que la fréquence d'affichage de l'écran, la troisième image finit son calcul avant que la seconde soit affichée. Dans ce cas, la seconde image est affichée avant la troisième. Il n'y a pas d'image supprimée ou abandonnée, peu importe la situation.
 
[[File:Triple buffering.png|centre|vignette|upright=2|Triple buffering]]
Ligne 164 :
La technologie '''''Fast Sync''''' sur les cartes graphiques NVIDIA est une amélioration du ''triple buffering'', qui se préoccupe du cas où les FPS sont (temporairement) plus élevés que la fréquence d'affichage de l'écran. Dans ce cas, avec le ''triple buffering'' simple, aucune image n'est abandonnée : on a deux images en attente, dont l'une est plus récente que l'autre. La technologie ''fast sync'' élimine la première image en attente et de la remplacer par la seconde, plus récente. L'avantage est que le délai d'affichage d'une image est réduit, le temps d'attente lié à la synchronisation verticale étant réduit au strict minimum.
 
Une autre solution est la ''synchronisation verticale adaptative'', qui consiste à désactiver la synchronisation verticale quand le nombre d'images par seconde descend sous la fréquence de rafraichissement de l'écran. Le principe est simple, mais il s'agit pourtant d'une technologie assez récente, introduite en 2016 sur les cartes NVIDIA. Notons qu'on peut combiner cette technologie avec la technologie ''fast sync'' : cette dernière fonctionne quand les FPS dépassent la fréquence de rafraichissement de l'écran, alors que la vsync adaptative fonctionne quand les FPS sont trop bas. C'est utile si les FPS sont très variables.
 
Une dernière possibilité est d'utiliser des technologies qui permettent à l'écran et la carte graphique d'utiliser une fréquence de rafraichissement variable. La fréquence de rafraichissement de l'écran s'adapte en temps réel à celle de la carte graphique. En clair, l'écran démarre l'affichage d'une nouvelle image quand la carte graphique le lui demande, pas à intervalle régulier. Évidemment, l'écran a une limite physique et ne peut pas toujours suivre la carte graphique. Dans ce cas, la carte graphique limite les FPS au maximum de ce que peut l'écran. Les premièrepremières technologies de ce type étaient le Gsync de NVIDIA et le Free Sync d'AMD, qui ont été suivies par les standards AdaptiveSync et MediaSync.
 
==L'historique des premières cartes graphiques==