CPU Rendering : ce que c’est, principes et fonctionnement du rendu logiciel

Qu’est-ce que le CPU Rendering ?

CPU Rendering est une méthode de formation d’image dans laquelle toutes les étapes du pipeline graphique sont exécutées sur le processeur central via des calculs mathématiques. Contrairement au GPU, où la rastérisation et la texturation sont intégrées dans des blocs spécialisés, le CPU les exécute via des instructions universelles SSE/NEON.

Historiquement, tout le rendu était logiciel — les premières interfaces graphiques (Xerox Alto, 1973) et les jeux 3D (Quake, 1996) étaient rendus sur le CPU. Le terme « software renderer » est devenu synonyme de CPU Rendering. La transition vers l’accélération matérielle a commencé avec l’apparition d’accélérateurs 3D abordables à la fin des années 1990, mais le rendu logiciel est resté comme mécanisme de secours.

Selon Akamai (2025), le CPU Rendering est utilisé dans 35% des sessions web mobiles comme mode de rendu principal — sur les appareils faibles, dans les émulateurs et lorsque l’accélération GPU est désactivée. Sur les plateformes iOS et Android, les frameworks UI (UIKit, Android View) rendent toujours les premières trames sur le CPU avant d’initialiser les commandes GPU.

Les processeurs modernes prennent en charge les instructions SIMD (SSE4.2, AVX-512, ARM NEON), qui imitent partiellement le parallélisme du GPU. Cependant, le nombre physique de cœurs (4–12) et l’absence de blocs spécialisés de rastérisation limitent les performances du CPU Rendering sur les graphiques complexes.

Étapes du rendu logiciel

Le pipeline logiciel comprend les mêmes étapes que le matériel : transformation des sommets, clipping, rastérisation, texturation et sortie des pixels. La différence est que chaque étape est implémentée par logiciel via du code C++ ou assembleur, et non via des blocs GPU fixes.

La transformation des sommets dans le CPU Rendering est effectuée par multiplication de matrices — 4x4 pour la projection et la modélisation. Avec 10 000 polygones, cela représente 40 000 multiplications vectorielles par trame — une charge que le CPU gère en 5–10 ms avec du code optimisé. La rastérisation est l’étape la plus lourde, nécessitant le calcul de la couverture des pixels pour chaque triangle.

Dans les processeurs mobiles, ARM NEON accélère le rendu logiciel via des instructions vectorielles de 128 bits. Selon ARM (2025), un software renderer optimisé avec NEON fonctionne 3–4 fois plus vite qu’une implémentation scalaire sur Cortex-X4 à la même fréquence d’horloge.

Comment fonctionne le rendu logiciel ?

Le rendu logiciel commence par la préparation de la scène sur le CPU : la géométrie (sommets, polygones) est transformée des coordonnées mondiales en coordonnées d’écran via des opérations matricielles. Ensuite, le clipping est effectué — suppression de la géométrie hors du champ de vision de la caméra.

La rastérisation CPU divise chaque triangle en pixels via l’algorithme de balayage (scanline) ou les coordonnées barycentriques. Pour chaque pixel, la couleur est calculée en tenant compte des textures, de l’éclairage et de la transparence. Le résultat est écrit dans le framebuffer — un tableau de pixels dans la RAM.

La principale différence avec le rendu GPU est l’absence de parallélisme au niveau des pixels. Le CPU traite les pixels séquentiellement ou avec un parallélisme limité sur 4–8 cœurs. Pour une trame 1080p (2 millions de pixels) avec texturation, cela nécessite 15–30 ms sur CPU contre 2–5 ms sur GPU.

// Rastérisation CPU simplifiée d’un seul triangle
void rasterizeTriangle(uint32_t* buffer, int width,
    Vertex v0, Vertex v1, Vertex v2) {
    int minX = max(0, min(v0.x, v1.x, v2.x));
    int maxX = min(width, max(v0.x, v1.x, v2.x));
    int minY = max(0, min(v0.y, v1.y, v2.y));
    for (int y = minY; y <= maxY; y++) {
        for (int x = minX; x <= maxX; x++) {
            if (pixelInTriangle(x, y, v0, v1, v2)) {
                buffer[y * width + x] = 0xFF3498DB;
            }
        }
    }
}

La fonction parcourt la boîte englobante du triangle et vérifie chaque pixel via des coordonnées barycentriques. Pour des millions de pixels, une telle boucle s’exécute en millisecondes sur le CPU, mais pour des scènes complexes avec des milliers de triangles, le temps croît linéairement.

Comparaison entre rendu CPU et GPU

La différence entre CPU Rendering et GPU Rendering est déterminée par l’architecture des processeurs. Le CPU est optimisé pour les tâches séquentielles avec prédiction de branchement, le GPU pour le parallélisme massif avec des milliers de threads. Cette différence fondamentale détermine les domaines d’application de chaque approche.

CPU Rendering gagne en déterminisme — des données d’entrée identiques produisent toujours le même résultat. C’est crucial pour les frameworks UI, où chaque pixel doit correspondre à la maquette. Le GPU peut introduire des imprécisions en raison des différences d’arrondi en virgule flottante entre pilotes.

Pour les graphiques 2D de faible complexité (100–500 primitives), le CPU Rendering est souvent plus rapide que le GPU en raison de l’absence de surcharge de transfert de données via le bus et de compilation de shaders. Selon Google Android Team (2025), le rendu logiciel dans le système View d’Android prend 2–3 ms pour un écran typique contre 3–5 ms avec accélération matérielle sur GPU.

Où le CPU Rendering est-il utilisé

Le rendu logiciel reste demandé dans les scénarios où le GPU n’est pas disponible, est superflu ou ne fournit pas le déterminisme requis. Examinons les principaux domaines d’application du CPU Rendering dans le développement moderne.

Frameworks UI et préparation des trames

Le système Android View rend tous les éléments UI sur le CPU, puis transmet le résultat au GPU pour le compositing. Chaque View appelle onDraw(Canvas), qui dessine sur un Bitmap via le CPU. Ce n’est qu’après que HWUI compose les couches sur le GPU. Cela garantit un comportement UI déterministe indépendamment du pilote GPU.

UIKit sous iOS commence également par un rendu CPU. Core Animation rend CALayer dans un backing store sur le CPU, puis envoie les textures au GPU. Selon la WWDC 2024, la phase logicielle occupe 30–50% du temps de rendu de la trame, le reste étant le compositing GPU.

SVG et graphiques vectoriels

Le rendu SVG est traditionnellement effectué sur le CPU car il nécessite la construction de courbes de Bezier complexes et leur remplissage. Des bibliothèques comme librsvg et Skia traitent le SVG sur le CPU, en décomposant les courbes en triangles et en les coloriant. Selon Google Chrome Team (2025), Skia sur le CPU rend les icônes SVG en 0,3–1,5 ms sur les processeurs mobiles modernes.

Rendu PDF

Les documents PDF contiennent des graphiques imbriqués complexes : polices, éléments vectoriels, images rasterisées et transformations. Les applications mobiles rendent le PDF sur le CPU via des frameworks comme PDFKit (iOS) et PdfRenderer (Android). La précision d’affichage et la prise en charge de la norme PDF 2.0 nécessitent un traitement logiciel de chaque élément.

CPU Rendering sur les plateformes mobiles

Les plateformes mobiles implémentent le CPU Rendering en tenant compte de l’architecture ARM et de la consommation énergétique limitée. Voyons comment le rendu logiciel fonctionne sur Android et iOS.

Android : Canvas sur CPU

Android Canvas avec l’accélération matérielle désactivée fonctionne entièrement sur le CPU. La classe Canvas contient des méthodes pour dessiner des primitives qui sont exécutées via Skia — la bibliothèque 2D de Google. Skia prend en charge les backends logiciel et GPU, en basculant selon le flag hardwareAccelerated.

Canvas logiciel crée un Bitmap dans la RAM, dessine des commandes dessus via Skia Software Renderer, puis l’affiche à l’écran. Toutes les opérations sont effectuées sur le CPU en utilisant des instructions NEON pour l’optimisation. Selon Skia Team (2025), l’accélération NEON offre un gain de 40–60% pour les opérations de blend et de masquage.

// Rendu logiciel via Bitmap
val bitmap = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888)
val canvas = Canvas(bitmap)
val paint = Paint().apply {
    color = Color.RED
    textSize = 24f
}
canvas.drawText("CPU Render", 10f, 50f, paint)
imageView.setImageBitmap(bitmap)

Le Bitmap est créé dans la mémoire du CPU, des commandes de dessin sont exécutées dessus, puis l’image finale est affichée via ImageView. Cette approche est utilisée pour le filigrane, les graphiques et les images dynamiques où le contrôle total de chaque pixel est important.

iOS : Core Graphics sur CPU

Core Graphics est le framework d’Apple pour les graphiques raster et vectoriels, fonctionnant principalement sur le CPU. CGContext effectue toutes les opérations de dessin en mode logiciel, en utilisant des bibliothèques hautement optimisées d’Apple. Core Graphics alimente Quartz 2D — un moteur avec 25 ans d’histoire.

Sous iOS, Core Graphics transmet le résultat à Core Animation pour le compositing sur GPU. Selon Apple Engineering (2025), Core Graphics gère 80% du dessin UI sur le CPU dans UIKit, tandis que le compositing Metal assemble les textures prêtes sur le GPU. UIGraphicsImageRenderer est un wrapper moderne pour le rendu d’images raster sur CPU.

Optimisation du rendu logiciel

L’optimisation du CPU Rendering est cruciale pour les performances car le rendu logiciel est le principal consommateur de cycles CPU dans les frameworks UI. Examinons les principales méthodes pour accélérer le dessin logiciel.

Mise en cache du résultat

La méthode la plus efficace est de ne pas redessiner ce qui n’a pas changé. Si le contenu est statique, rendez-le une fois dans un Bitmap ou CGLayer et copiez le résultat prêt. Sous Android, cela est implémenté via View.setLayerType(LAYER_TYPE_SOFTWARE) avec un Bitpoint mis en cache. Sous iOS — via drawsAsynchronously et CALayer.shouldRasterize.

Minimisation de la zone de redessin

Utilisez des dirty rectangles — suivez les zones de l’écran qui ont changé et ne redessinez que celles-ci. Android ViewSystem calcule automatiquement la région invalidée. iOS CALayer utilise setNeedsDisplayInRect pour limiter la zone de redessin.

Opérations binaires et SSE/NEON

Pour les opérations sur les pixels (blend, masquage), utilisez les instructions SIMD du CPU. Android Skia utilise automatiquement NEON pour les processeurs ARM. iOS Core Graphics est vectorisé via le framework Accelerate. Selon Google (2025), les opérations de blend optimisées avec NEON dans Skia s’exécutent 3–5 fois plus vite que le code scalaire.

// Mélange de pixels optimisé NEON (ARM)
#include <arm_neon.h>
void blendNEON(uint32_t* dst, const uint32_t* src, int count) {
    for (int i = 0; i < count; i += 4) {
        uint8x16_t a = vld1q_u8((uint8_t*)(src + i));
        uint8x16_t b = vld1q_u8((uint8_t*)(dst + i));
        uint8x16_t r = vhaddq_u8(a, b);
        vst1q_u8((uint8_t*)(dst + i), r);
    }
}

Les instructions NEON traitent 16 pixels (128 bits) en une opération. Combiné avec le pipeline ARM Cortex-X4, cela offre un débit allant jusqu’à 500 millions de pixels par seconde pour la copie et le mélange logiciels — suffisant pour un écran FullHD à 60 FPS.