Le modèle de couche
Introduction
Pour la plupart des développeurs Web, le modèle fondamental d'une page Web est le DOM. Le rendu est le processus, souvent obscur, qui consiste à transformer cette représentation d'une page en une image à l'écran. Ces dernières années, les navigateurs récents ont modifié le fonctionnement du rendu pour tirer parti des cartes graphiques. On parle souvent d'accélération matérielle. Que signifie vraiment ce terme lorsqu'on parle d'une page Web normale (c'est-à-dire qui n'est pas Canvas2D ou WebGL) ? Cet article explique le modèle de base qui sous-tend l'affichage avec accélération matérielle du contenu Web dans Chrome.
De grosses mises en garde
Nous parlons ici de WebKit, et plus précisément du port Chromium de WebKit. Cet article traite des détails d'implémentation de Chrome, et non des fonctionnalités de la plate-forme Web. La plate-forme Web et les normes ne codifient pas ce niveau de détail de l'implémentation. Il n'est donc pas garanti que les informations de cet article s'appliquent à d'autres navigateurs. Toutefois, la connaissance des éléments internes peut être utile pour le débogage avancé et l'optimisation des performances.
Notez également que l'intégralité de cet article traite d'un élément central de l'architecture de rendu de Chrome, qui évolue très rapidement. Cet article ne traite que des éléments qui ne sont pas susceptibles de changer, mais nous ne pouvons pas garantir qu'ils seront toujours d'actualité dans six mois.
Il est important de comprendre que Chrome dispose de deux chemins de rendu différents depuis un certain temps : le chemin avec accélération matérielle et l'ancien chemin logiciel. À l'heure où nous écrivons ces lignes, toutes les pages suivent le chemin d'accélération matérielle sur Windows, ChromeOS et Chrome pour Android. Sur Mac et Linux, seules les pages qui nécessitent une composition pour une partie de leur contenu empruntent le chemin accéléré (voir ci-dessous pour en savoir plus sur ce qui nécessite une composition), mais bientôt toutes les pages emprunteront également le chemin accéléré.
Enfin, nous allons examiner le moteur de rendu et les fonctionnalités qui ont un impact important sur les performances. Lorsque vous essayez d'améliorer les performances de votre propre site, il peut être utile de comprendre le modèle de calque, mais il est également facile de se tirer une balle dans le pied : les calques sont des constructions utiles, mais en créer un grand nombre peut entraîner une surcharge dans l'ensemble de la pile graphique. Vous voilà prévenu !
Du DOM à l'écran
Présentation des couches
Une fois qu'une page est chargée et analysée, elle est représentée dans le navigateur sous la forme d'une structure que de nombreux développeurs Web connaissent : le DOM. Toutefois, lors de l'affichage d'une page, le navigateur dispose d'une série de représentations intermédiaires qui ne sont pas directement exposées aux développeurs. La plus importante de ces structures est une couche.
Dans Chrome, il existe en fait plusieurs types de calques : les RenderLayers, qui sont responsables des sous-arborescences du DOM, et les GraphicsLayers, qui sont responsables des sous-arborescences des RenderLayers. C'est ce dernier qui nous intéresse le plus ici, car les GraphicsLayers sont importés dans le GPU en tant que textures. À partir de maintenant, j'utiliserai simplement le terme "couche" pour désigner GraphicsLayer.
Petite précision sur la terminologie des GPU : qu'est-ce qu'une texture ? Il s'agit d'une image bitmap qui est déplacée de la mémoire principale (RAM) vers la mémoire vidéo (VRAM, sur votre GPU). Une fois sur le GPU, vous pouvez la mapper à une géométrie de maillage. Dans les jeux vidéo ou les programmes de CAO, cette technique est utilisée pour donner une "peau" aux modèles 3D squelettiques. Chrome utilise des textures pour transférer des parties du contenu d'une page Web vers le GPU. Les textures peuvent être mappées à moindre coût à différentes positions et transformations en les appliquant à un maillage rectangulaire très simple. C'est ainsi que fonctionne le CSS 3D, qui est également idéal pour le défilement rapide (nous y reviendrons plus tard).
Examinons quelques exemples pour illustrer le concept de couche.
Un outil très utile pour étudier les calques dans Chrome est l'option "Afficher les bordures des calques composites" dans les paramètres (c'est-à-dire la petite icône en forme de roue dentée) des outils de développement, sous l'en-tête "Rendu". Il met simplement en évidence l'emplacement des calques à l'écran. Activons-le. Ces captures d'écran et exemples sont tous tirés de la dernière version de Chrome Canary, Chrome 27 au moment de la rédaction de cet article.
Figure 1 : Page à une seule couche
<!doctype html>
<html>
<body>
<div>I am a strange root.</div>
</body>
</html>
Cette page ne comporte qu'une seule couche. La grille bleue représente les tuiles, que vous pouvez considérer comme des sous-unités d'un calque que Chrome utilise pour importer des parties d'un grand calque à la fois dans le GPU. Ils ne sont pas vraiment importants ici.
Figure 2 : Élément dans sa propre couche
<!doctype html>
<html>
<body>
<div style="transform: rotateY(30deg) rotateX(-30deg); width: 200px;">
I am a strange root.
</div>
</body>
</html>
En appliquant une propriété CSS 3D à l'élément <div> pour le faire pivoter, nous pouvons voir à quoi il ressemble lorsqu'un élément obtient son propre calque : notez la bordure orange, qui délimite un calque dans cette vue.
Critères de création de calques
Qu'est-ce qui a également sa propre couche ? Les heuristiques de Chrome ont évolué au fil du temps et continuent de le faire, mais actuellement, l'un des éléments suivants déclenche la création d'une couche :
- Propriétés CSS de transformation 3D ou de perspective
<video>éléments utilisant le décodage vidéo accéléré- Éléments
<canvas>avec un contexte 3D (WebGL) ou un contexte 2D accéléré - Plug-ins composites (par exemple, Flash)
- Éléments avec une animation CSS pour leur opacité ou utilisant une transformation animée
- Éléments avec filtres CSS accélérés
- L'élément comporte un descendant qui possède une couche de composition (en d'autres termes, si l'élément comporte un élément enfant qui se trouve dans sa propre couche).
- L'élément a un frère avec un z-index inférieur qui possède une couche de composition (en d'autres termes, il est affiché au-dessus d'une couche composite).
Implications pratiques : Animation
Nous pouvons également déplacer les calques, ce qui les rend très utiles pour l'animation.
Figure 3 : Calques animés
<!doctype html>
<html>
<head>
<style>
div {
animation-duration: 5s;
animation-name: slide;
animation-iteration-count: infinite;
animation-direction: alternate;
width: 200px;
height: 200px;
margin: 100px;
background-color: gray;
}
@keyframes slide {
from {
transform: rotate(0deg);
}
to {
transform: rotate(120deg);
}
}
</style>
</head>
<body>
<div>I am a strange root.</div>
</body>
</html>
Comme nous l'avons vu, les couches sont très utiles pour déplacer du contenu Web statique. Dans le cas de base, Chrome peint le contenu d'un calque dans un bitmap logiciel avant de l'importer dans le GPU en tant que texture. Si ce contenu ne change pas à l'avenir, il n'est pas nécessaire de le repeindre. C'est une bonne chose : le repeint prend du temps qui peut être consacré à d'autres tâches, comme l'exécution de JavaScript. Si le repeint est long, il entraîne des problèmes ou des retards dans les animations.
Regardez par exemple cette vue de la chronologie des outils de développement : il n'y a aucune opération de peinture pendant que ce calque tourne d'avant en arrière.
Non valide. Remise en peinture
Toutefois, si le contenu du calque change, il doit être repeint.
Figure 4 : Repeindre des calques
<!doctype html>
<html>
<head>
<style>
div {
animation-duration: 5s;
animation-name: slide;
animation-iteration-count: infinite;
animation-direction: alternate;
width: 200px;
height: 200px;
margin: 100px;
background-color: gray;
}
@keyframes slide {
from {
transform: rotate(0deg);
}
to {
transform: rotate(120deg);
}
}
</style>
</head>
<body>
<div id="foo">I am a strange root.</div>
<input id="paint" type="button" value="repaint">
<script>
var w = 200;
document.getElementById('paint').onclick = function() {
document.getElementById('foo').style.width = (w++) + 'px';
}
</script>
</body>
</html>
Chaque fois que l'utilisateur clique sur l'élément d'entrée, l'élément rotatif s'élargit de 1 px. Cela entraîne une réorganisation et un rafraîchissement de l'élément entier, qui est ici une couche entière.
Pour voir ce qui est peint, vous pouvez utiliser l'outil "Afficher les rectangles de peinture" dans les outils de développement, également sous l'en-tête "Rendu" des paramètres des outils de développement. Après l'avoir activé, vous remarquerez que l'élément animé et le bouton clignotent en rouge lorsque vous cliquez sur le bouton.
Les événements de peinture s'affichent également dans la chronologie des outils de développement. Les lecteurs attentifs remarqueront peut-être qu'il y a deux événements de peinture : un pour la couche et un pour le bouton lui-même, qui est repeint lorsqu'il passe de l'état enfoncé à l'état non enfoncé.
Notez que Chrome n'a pas toujours besoin de repeindre l'intégralité du calque. Il essaie de ne repeindre que la partie du DOM qui a été invalidée. Dans ce cas, l'élément DOM que nous avons modifié correspond à la taille de l'ensemble de la couche. Mais dans de nombreux autres cas, une couche contiendra de nombreux éléments DOM.
La question suivante est évidente : qu'est-ce qui provoque une invalidation et force un repeint ? Il est difficile de répondre de manière exhaustive à cette question, car de nombreux cas particuliers peuvent forcer l'invalidation. La cause la plus fréquente est la modification du DOM en manipulant les styles CSS ou en provoquant une réorganisation. Tony Gentilcore a publié un excellent article de blog sur les causes de la réorganisation, et Stoyan Stefanov a écrit un article qui traite de la peinture plus en détail (mais qui se termine par la peinture, et non par cette composition sophistiquée).
Le meilleur moyen de déterminer si cela affecte un élément sur lequel vous travaillez est d'utiliser les outils "Timeline" et "Show Paint Rects" des outils de développement pour voir si vous redessinez des éléments alors que vous ne le souhaitez pas, puis d'essayer d'identifier où vous avez modifié le DOM juste avant cette réorganisation/ce redessin. Si la peinture est inévitable, mais semble prendre un temps déraisonnable, consultez l'article d'Eberhard Gräther sur le mode de peinture continue dans les outils de développement.
Synthèse : du DOM à l'écran
Comment Chrome transforme-t-il le DOM en image d'écran ? En théorie, il :
- Prend le DOM et le divise en couches
- Peint chacune de ces couches indépendamment dans des bitmaps logiciels
- Les importe dans le GPU en tant que textures
- Il assemble les différentes couches pour former l'image finale à l'écran.
Tout cela doit se produire la première fois que Chrome produit un frame d'une page Web. Mais il peut ensuite prendre des raccourcis pour les images suivantes :
- Si certaines propriétés CSS changent, il n'est pas nécessaire de repeindre quoi que ce soit. Chrome peut simplement recomposer les calques existants qui se trouvent déjà sur le GPU en tant que textures, mais avec des propriétés de composition différentes (par exemple, à des positions différentes, avec des opacités différentes, etc.).
- Si une partie d'un calque est invalidée, elle est repeinte et réimportée. Si son contenu reste le même, mais que ses attributs composites changent (par exemple, s'il est traduit ou si son opacité change), Chrome peut le laisser sur le GPU et le recomposer pour créer une nouvelle image.
Comme vous l'avez compris, le modèle de composition basé sur les calques a des implications importantes sur les performances de rendu. La composition est relativement peu coûteuse lorsque rien n'a besoin d'être peint. Par conséquent, éviter de repeindre les calques est un bon objectif global lorsque vous essayez de déboguer les performances de rendu. Les développeurs avertis examineront la liste des déclencheurs de composition ci-dessus et se rendront compte qu'il est possible de forcer facilement la création de calques. Mais attention à ne pas les créer à l'aveugle, car ils ne sont pas sans frais : ils occupent de la mémoire dans la RAM du système et sur le GPU (particulièrement limité sur les appareils mobiles), et en avoir beaucoup peut entraîner d'autres frais généraux dans la logique qui permet de suivre ceux qui sont visibles. Un grand nombre de calques peut également augmenter le temps de pixellisation si les calques sont volumineux et se chevauchent beaucoup, ce qui n'était pas le cas auparavant. Cela peut entraîner ce que l'on appelle parfois un "overdraw". Utilisez donc vos connaissances à bon escient !
C'est tout pour aujourd'hui. Restez à l'écoute pour découvrir d'autres articles sur les implications pratiques du modèle de couches.