Metal — qu'est-ce que c'est, API graphique et shaders

Qu'est-ce que Metal ?

Metal est une API bas niveau pour travailler avec le processeur graphique (GPU), présentée par Apple en 2014 avec iOS 8 et OS X Yosemite. Metal a été créé comme remplacement d'OpenGL et OpenCL dans le but de réduire la surcharge CPU et de fournir un accès plus direct au matériel GPU sur les appareils Apple.

Contrairement à OpenGL, où le pilote effectue de nombreuses vérifications et transformations sur le CPU, Metal utilise un modèle de gestion explicite des ressources. Le développeur contrôle l'allocation mémoire, la synchronisation et l'envoi des commandes GPU, offrant jusqu'à 50 % d'amélioration des performances par rapport à OpenGL ES sur le même matériel.

Metal prend en charge toutes les puces Apple de l'A7 (2013) au M4 Ultra (2025). L'API évolue constamment : Metal 3 (2022) a ajouté la prise en charge des mesh shaders et du ray tracing, Metal 3.1 (2023) — le partage rapide des ressources entre CPU et GPU, et Metal 4 (2025) — l'accélération matérielle des réseaux neuronaux sur GPU avec prise en charge FP8 et INT4.

Histoire de Metal

La première version de Metal (2014) fournissait une API de base pour le rendu graphique sur iOS. Metal 2 (2017) a ajouté les compute shaders et Metal Performance Shaders. Metal 3 (2022) a introduit MetalFX Upscaling — l'upscaling propre d'Apple pour les jeux, concurrent du NVIDIA DLSS et AMD FSR. MetalFX offre jusqu'à 2x d'amélioration des performances sur Mac avec M2.

Metal 4 (2025) s'est concentré sur l'apprentissage automatique et le ray tracing. Selon Apple (2025), Metal 4 sur M4 Ultra délivre jusqu'à 80 TFLOPS dans les tâches de calcul en FP16 et prend en charge le décodage matériel AV1. Metal est désormais également pris en charge sur Apple Vision Pro via le service compositor pour le rendu de contenu immersif.

Architecture Metal : périphérique et ressources

L'architecture Metal est construite autour du concept de gestion explicite : le développeur crée des objets MTLDevice (périphérique), MTLBuffer (buffers de données), MTLTexture (textures) et MTLCommandQueue (file d'attente de commandes). Contrairement à OpenGL, où l'état est stocké dans le contexte, Metal utilise des objets d'état compilés à l'avance.

MTLDevice — point d'entrée de l'API

MTLDevice représente un GPU physique ou virtuel. Toutes les ressources Metal sont créées via cet objet : buffers, textures, bibliothèques de shaders, pipelines. Sur les systèmes avec plusieurs GPU (Mac Pro), un périphérique spécifique peut être sélectionné. La méthode supportsFamily: vérifie la prise en charge des fonctionnalités : ray tracing, mesh shaders, MetalFX.

import Metal
 
// Obtention du périphérique GPU
guard let device = MTLCreateSystemDefaultDevice() else {
    fatalError("Metal non pris en charge")
}
 
// Vérification des capacités
let supportsRayTracing = device.supportsFamily(.metal3)
let gpuName = device.name // "Apple M4 Pro"
let maxBufferSize = device.maxBufferLength

La propriété maxBufferLength détermine la taille maximale de buffer prise en charge par le périphérique. Sur Apple Silicon avec Unified Memory, la limite atteint jusqu'à 128 Go (sur M4 Ultra). Cela permet de travailler avec de grands ensembles de données pour le ML et le calcul scientifique sans segmentation des buffers. Le périphérique gère également le pool mémoire via MTLHeap.

MTLBuffer et MTLTexture — données pour le GPU

MTLBuffer — une région mémoire contiguë accessible par le GPU. Les buffers sont utilisés pour les données de sommets, les matrices, les variables uniform. Modes : shared (accès CPU + GPU sur mémoire unifiée), private (GPU uniquement, plus rapide), managed (pour GPU discrets, avec synchronisation). Sur Apple Silicon, le mode shared est recommandé pour sa simplicité.

MTLTexture — un tableau multidimensionnel de pixels pour les textures et les render targets. Prend en charge les textures 1D, 2D, 3D, cube et array. Formats : RGBA8Unorm, BGRA8Unorm, RGBA16Float, R32Float, ASTC (compressé), profondeur (depth32Float) et stencil. Les indicateurs Texture Usage précisent comment la texture sera utilisée : rendu, lecture par shader, copie.

MTLLibrary et compilation des shaders

MTLLibrary — une collection de fonctions GPU compilées (shaders). Une bibliothèque peut être créée à partir du code source MSL (Metal Shading Language) à l'exécution ou précompilée et incluse dans le bundle (.metallib). La précompilation est recommandée pour éliminer les délais d'initialisation.

MTLFunction représente une fonction shader spécifique. Les vertex shaders, fragment shaders, compute kernels et mesh shaders sont créés via la bibliothèque. Les fonctions sont mises en cache sur le GPU et réutilisées entre les trames. Les arguments des shaders sont passés via des buffers et des slots de texture avec liaison par index.

Rendu avec Metal : buffers de commandes

Le rendu dans Metal est organisé via des files d'attente de commandes asynchrones. Le développeur crée un MTLCommandBuffer, y encode des commandes de rendu ou de calcul et le soumet à MTLCommandQueue. Le GPU exécute les commandes séquentiellement tandis que le CPU peut continuer à travailler. La synchronisation se fait via des sémaphores ou completionHandler.

MTLCommandQueue et MTLCommandBuffer

MTLCommandQueue — une file d'attente de commandes créée à partir de MTLDevice. Une application peut avoir plusieurs files pour les graphiques, le calcul et la copie. Chaque file garantit l'exécution séquentielle des commandes. MTLCommandBuffer — un conteneur pour un lot de travail GPU. Après encodage, il est soumis et exécuté sur le GPU.

// Boucle de rendu principale
let commandQueue = device.makeCommandQueue()!
 
guard let commandBuffer = commandQueue.makeCommandBuffer()
else { return }
 
guard let descriptor = currentDrawable.texture.makeRenderPassDescriptor(
    attachment: 0
) else { return }
 
let encoder = commandBuffer.makeRenderCommandEncoder(
    descriptor: descriptor
)!
encoder.setRenderPipelineState(pipelineState)
encoder.drawPrimitives(type: .triangle,
    vertexStart: 0, vertexCount: 36)
encoder.endEncoding()
 
commandBuffer.present(currentDrawable)
commandBuffer.commit()

La méthode drawPrimitives exécute le rendu de géométrie. Le paramètre vertexCount spécifie le nombre de sommets. Un nouveau command buffer est créé pour chaque trame. Present synchronise le rendu avec le VSync de l'écran. Metal gère automatiquement la synchronisation avec l'affichage via CAMetalLayer.

État du pipeline de rendu

MTLRenderPipelineState — un état de pipeline de rendu compilé, incluant les vertex et fragment shaders, la configuration depth-stencil, le blending et le format des pixels de sortie. La création d'un pipeline state est une opération coûteuse, donc les objets sont mis en cache et réutilisés. Différents pipeline states sont créés pour différentes combinaisons de shaders.

Metal 3.1 a introduit le rendu rapide via Immutable Samplers qui sont mis en cache sur le GPU pour accélérer l'échantillonnage de textures. Metal prend en charge jusqu'à 31 textures par slot de shader sur Apple Silicon. Sur les appareils plus anciens avec A13 et moins, la limite est réduite à 16 slots. Il est recommandé de combiner les textures en Texture Atlases pour réduire le nombre d'échantillons.

Metal Shading Language et shaders

Metal Shading Language (MSL) est un langage de programmation de shaders basé sur C++14 avec des extensions pour le calcul GPU. MSL prend en charge les templates, la surcharge de fonctions, les espaces de noms et l'arithmétique d'adresses. Les shaders sont compilés en code GPU binaire via le backend LLVM d'Apple.

Vertex et fragment shaders

Vertex shader traite chaque sommet : transforme les coordonnées de l'espace monde à l'espace écran, calcule les normales et transmet les données au fragment shader. Fragment shader calcule la couleur de chaque pixel : applique les textures, l'éclairage et les effets de post-traitement.

// Vertex shader Metal
#include <metal_stdlib>
using namespace metal;
 
struct VertexIn {
    float3 position [[attribute(0)]];
    float3 normal   [[attribute(1)]];
};
 
struct VertexOut {
    float4 position [[position]];
    float3 worldNormal;
};
 
vertex VertexOut vertexMain(
    VertexIn in [[stage_in]],
    constant float4x4 &mvp [[buffer(0)]]
) {
    VertexOut out;
    out.position = mvp * float4(in.position, 1.0);
    out.worldNormal = in.normal;
    return out;
}

Les attributs [[attribute(N)]] correspondent aux formats de sommets spécifiés dans MTLVertexDescriptor. Le buffer [buffer(0)] transmet la matrice MVP comme variable uniform. La position du sommet doit être marquée avec [[position]] pour être transmise au rasterizer. Tous les types vectoriels MSL — float2, float3, float4 — sont mappés sur les registres matériels du GPU.

Compute kernels

Compute shader (kernel) est une fonction GPU exécutée en dehors du pipeline graphique. Les fonctions kernel sont marquées avec le qualificatif kernel et s'exécutent dans des threads organisés en threadgroups. Les compute shaders sont utilisés pour le traitement d'images, la simulation physique, le ML et le post-traitement.

// Kernel de calcul pour flou d'image
kernel void blurKernel(
    texture2d<half> input  [[texture(0)]],
    texture2d<half> output [[texture(1)]],
    constant float &radius  [[buffer(0)]],
    uint2 gid [[thread_position_in_grid]]
) {
    if (gid.x >= input.get_width() ||
        gid.y >= input.get_height()) { return; }
    half4 color = input.read(gid);
    output.write(color, gid);
}

Le paramètre gid [[thread_position_in_grid]] contient l'index unique du thread. Texture2D<type> est spécialisé par type de pixel : half (FP16), float (FP32). Les compute kernels peuvent être lancés avec une taille de grille de plus d'un milliard de threads sur M4 Ultra. La taille maximale d'un threadgroup est de 1024 threads sur les GPU Apple Silicon.

Performances et Metal Performance Shaders

Metal Performance Shaders (MPS) est une bibliothèque de fonctions GPU optimisées fournie par Apple. MPS inclut des réseaux neuronaux convolutionnels (MPSNNConvolution), la multiplication matricielle (MPSMatrixMultiplication), le tri (MPSParallelSort) et le traitement d'images (MPSImageGaussianBlur). Toutes les fonctions sont optimisées pour des GPU Apple spécifiques.

MetalFX Upscaling

MetalFX est une technologie d'upscaling et d'anti-aliasing, concurrente de NVIDIA DLSS et AMD FSR. MetalFX propose deux modes : Spatial (upscaling spatial via l'algorithme FSR 2) et Temporal (upscaling temporel avec motion vectors). MetalFX Temporal offre une qualité proche du 4K natif à partir d'un rendu en 1440p.

Selon Apple (2025), MetalFX Temporal sur M4 Max offre jusqu'à 3x d'amélioration des performances dans les jeux tout en maintenant une qualité visuellement indiscernable de la résolution native. MetalFX fonctionne sur n'importe quel GPU prenant en charge Metal 3, sans cœurs tensoriels dédiés. L'intégration de MetalFX dans un projet nécessite environ 50 lignes de code.

Ray tracing dans Metal

Ray Tracing dans Metal 3 est pris en charge sur les puces M3, M4 et A17 Pro avec des unités d'accélération matérielle (Ray Tracing Accelerators). Metal fournit MTLAccelerationStructure pour la construction de BVH et MTLIntersectionFunction pour l'intersection de rayons dans les shaders. Des scènes massives avec des millions de triangles sont compilées en BVH en quelques millisecondes.

Selon Apple (2025), le ray tracing matériel sur M4 Ultra effectue jusqu'à 40 milliards d'intersections de rayons par seconde (Giga rays/s). C'est 4 fois plus rapide que le ray tracing logiciel sur M1 Ultra. Metal RT prend en charge les intersection queries, la géométrie dynamique et le Motion Blur pour des animations réalistes. Les réflexions et les ombres avec ray tracing fonctionnent en temps réel à 60 FPS.

Mémoire unifiée et Zero-Copy

Unified Memory est l'architecture Apple Silicon où le CPU et le GPU partagent la même mémoire physique. Metal sur Apple Silicon ne nécessite pas de copie de données entre le CPU et le GPU : MTLBuffer en mode shared est accessible aux deux processeurs sans copie. Cela élimine le principal goulot d'étranglement des GPU traditionnels (transferts PCIe).

Zero-Copy dans Metal permet au CPU d'écrire des données dans un buffer et au GPU de les lire sans délai. Selon Apple (2025), cela offre une amélioration des performances de 30 à 50 % par rapport aux GPU discrets dans les jeux et les tâches de ML. Pour les GPU discrets (Mac Pro avec Radeon), Metal prend en charge le mode managed avec synchronisation automatique via des memory barriers.