> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Vue d'ensemble de la mémoire graphique de la XBOX Series X|S > Mémoire virtuelle graphique de la XBOX Series X|S : espace d'adressage CPU/GPU unifié, pages de 64 Ko et de 2 Mo, tas XMemAlloc et extensions de ressources en mosaïque. ## Introduction Le système de mémoire virtuelle graphique a été reconstruit pour le Microsoft Game Development Kit (GDK). Bien que les mécanismes internes soient entièrement nouveaux, l'ensemble général des fonctionnalités n'est pas très différent de celui du système d'exploitation ERA de la XBOX One. L'ensemble des fonctionnalités comprend : * Un espace d'adressage virtuel CPU et GPU unifié pour la mémoire graphique, occupant les 1 024 premiers Go de l'espace d'adressage virtuel, les 4 premiers Go étant réservés aux allocations graphiques particulières qui nécessitent des adresses 32 bits. * Une taille de page native de 64 Ko pour les graphiques, ainsi qu'une taille de page plus grande de 2 Mo. * Des attributs graphiques spécifiés au moment de l'allocation de mémoire, notamment lecture/écriture, exécution et cohérence avec le cache du GPU. * XMemAlloc, un tas en mode utilisateur flexible et rapide pour la mémoire graphique, y compris la capacité d'intercepter les allocations provenant de diverses bibliothèques de titres XBOX. * Des API d'allocation et de mappage de pages physiques accessibles aux titres. * Un accès direct du GPU aux mappages de pages du GPU au moyen des API d'extension des ressources en mosaïque et du mappage de pages de Direct3D 12. * Une taille d'allocation de la mémoire des tables de pages du GPU contrôlable par le titre, qui est allouée au moment de l'initialisation (aucune allocation à l'exécution). ## Initialisation du système de mémoire graphique Avant d'allouer de la mémoire graphique, le titre doit initialiser le système de mémoire graphique dans le noyau. Il s'agit d'une nouvelle exigence du Microsoft Game Development Kit (GDK). La façon la plus simple d'initialiser le système de mémoire graphique est de créer un appareil Direct3D 12 au moyen de l'API [D3D12CreateDevice](/fr-CA/reference/graphics/d3d12_x/functions/d3d12createdevice). Si le titre doit allouer ou réserver de la mémoire graphique avant la création de l'appareil Direct3D 12, l'API [D3D12ConfigureVirtualMemoryX](/fr-CA/reference/graphics/d3d12_xs/functions/d3d12configurevirtualmemoryx) (XBOX Series X|S)/[D3DConfigureVirtualMemory](/fr-CA/reference/graphics/d3d12_x/functions/d3dconfigurevirtualmemory) (XBOX One) peut également être utilisée pour initialiser le système de mémoire graphique. La création d'un appareil Direct3D 12 équivaut à appeler **D3D12ConfigureVirtualMemoryX** avec les paramètres par défaut. ## Nouveaux indicateurs pour l'allocation de mémoire graphique Une nouvelle API de titre, [XMemVirtualAlloc](/fr-CA/reference/system/xmem/functions/xmemvirtualalloc), a été introduite pour remplacer la version étendue de VirtualAlloc présente dans l'ERA de la XBOX One. Dans le Microsoft Game Development Kit (GDK), VirtualAlloc est désormais limitée au comportement « standard » de la plateforme, identique à celui de Windows pour ordinateur de bureau. L'API standard VirtualFree est utilisée pour libérer et/ou désengager la mémoire allouée avec [XMemVirtualAlloc](/fr-CA/reference/system/xmem/functions/xmemvirtualalloc). Une nouvelle API [XMemVirtualQuery](/fr-CA/reference/system/xmem/functions/xmemvirtualquery) a été ajoutée pour récupérer l'ensemble complet des indicateurs de protection CPU et GPU pour une adresse virtuelle donnée. [XMemVirtualAlloc](/fr-CA/reference/system/xmem/functions/xmemvirtualalloc) accepte une nouvelle combinaison d'indicateurs XMem qui indiquent des demandes de mémoire graphique et/ou de mémoire d'outils. Un indicateur d'allocation MEM\_GRAPHICS pour VirtualAlloc dans l'ERA de la XBOX One équivaut à un indicateur XMem XMEM\_GRAPHICS pour [XMemVirtualAlloc](/fr-CA/reference/system/xmem/functions/xmemvirtualalloc). Un nouvel indicateur, **XMEM\_GRAPHICS\_32BIT\_ADDRESS**, combiné à XMEM\_GRAPHICS, alloue de la mémoire graphique, mais limite l'adresse virtuelle attribuée automatiquement à la plage de 2 Go à 4 Go. Sans l'indicateur **XMEM\_GRAPHICS\_32BIT\_ADDRESS**, les adresses virtuelles attribuées automatiquement se situent au-dessus de 4 Go et en dessous de la fin de la plage couverte par la table de pages graphiques (159 Go par défaut). L'adresse virtuelle de fin des tables de pages graphiques est définie par la quantité de mémoire consacrée aux tables de pages graphiques et peut être ajustée avant la première allocation graphique au moyen de l'API **D3D12ConfigureVirtualMemoryX**.  La sémantique des indicateurs de taille de page a également changé. L'ERA de la XBOX One utilisait MEM\_LARGE\_PAGES pour les pages de 64 Ko et MEM\_4MB\_PAGES pour les pages de 4 Mo. Le Microsoft Game Development Kit (GDK) utilise maintenant **MEM\_64K\_PAGES** pour les pages de 64 Ko et **MEM\_2MB\_PAGES** pour les pages de 2 Mo. Notez que le code de titre existant qui utilise MEM\_LARGE\_PAGES doit être mis à jour avec soin et de manière exhaustive pour utiliser MEM\_64K\_PAGES. Les pages de 4 Mo ne sont pas prises en charge dans le Microsoft Game Development Kit (GDK). Enfin, les indicateurs de protection de page pour les graphiques ont également changé. Les indicateurs PAGE\_GPU\_\* de l'ERA de la XBOX One ont été remplacés par une énumération PAGE\_GRAPHICS\_\* et un indicateur PAGE\_GRAPHICS\_COHERENT afin de mieux correspondre aux modèles existants de protection des pages du CPU. Toutes les allocations graphiques effectuées au moyen de XMemGraphics doivent inclure un seul des indicateurs de protection suivants : * PAGE\_GRAPHICS\_NOACCESS * PAGE\_GRAPHICS\_READONLY * PAGE\_GRAPHICS\_READWRITE * PAGE\_GRAPHICS\_EXECUTE * PAGE\_GRAPHICS\_EXECUTE\_READ * PAGE\_GRAPHICS\_EXECUTE\_READWRITE PAGE\_GRAPHICS\_COHERENT peut être combiné avec n'importe lequel des indicateurs de protection mentionnés précédemment pour indiquer de la mémoire cohérente pour le GPU, également appelée mémoire « onion ». PAGE\_GRAPHICS\_NOCACHE ne peut être utilisé que sur le matériel XBOX Series X|S et indique que la mémoire ne doit pas être mise en cache par le GPU (contournement de la mise en cache). Cet indicateur de mémoire est utilisé pour la mémoire des tampons de commandes ainsi que pour la mémoire de réécriture des clôtures sur la XBOX Series X|S. Dans le cas de la mémoire des tampons de commandes, il est essentiel que le matériel de prélecture des tampons de commandes ne mette pas en cache des contenus de mémoire qui n'ont pas encore été écrits par le CPU. Dans le cas de la mémoire de réécriture des clôtures, où une visibilité rapide des données de réécriture par le CPU est souhaitée, la désactivation de la mise en cache par le GPU garantit que les réécritures de fin de pipeline sont immédiatement visibles en mémoire pour le CPU, au lieu de demeurer dans une ligne de cache des caches du GPU. Le tableau suivant présente le guide de correspondance entre les indicateurs de l'ERA de la XBOX One et ceux du Microsoft Game Development Kit (GDK) utilisés pour allouer les types de mémoire graphique courants, ainsi que les types de mémoire [XMemAlloc](/fr-CA/reference/system/xmem/functions/xmemalloc) correspondants. \| Description | Type XMemAlloc | Indicateurs de protection de l'ERA de la XBOX One | Indicateurs de protection du Microsoft Game Development Kit (GDK) | Indicateurs de protection de la XBOX Series X|S | | --- | --- | --- | --- | --- | | Mémoire « Garlic » : combinaison d'écritures CPU et non cohérente pour le GPU | `XALLOC_MEMTYPE_GRAPHICS_WRITECOMBINE` | `PAGE_READWRITE | PAGE_WRITECOMBINE` | `PAGE_READWRITE | PAGE_WRITECOMBINE | PAGE_GRAPHICS_READWRITE` | `PAGE_READWRITE | PAGE_WRITECOMBINE | PAGE_GRAPHICS_READWRITE` | | Mémoire « Onion » : mise en cache par le CPU et cohérente pour le GPU | `XALLOC_MEMTYPE_GRAPHICS_CACHEABLE` | `PAGE_READWRITE | PAGE_GPU_COHERENT` | `PAGE_READWRITE | PAGE_GRAPHICS_COHERENT | PAGE_GRAPHICS_READWRITE` | `PAGE_READWRITE | PAGE_GRAPHICS_COHERENT | PAGE_GRAPHICS_READWRITE` | | Tampon de commandes « Garlic » | `XALLOC_MEMTYPE_GRAPHICS_COMMAND_BUFFER_WRITECOMBINE` | `PAGE_READWRITE | PAGE_WRITECOMBINE | PAGE_GPU_EXECUTE` | `PAGE_READWRITE | PAGE_WRITECOMBINE | PAGE_GRAPHICS_EXECUTE_READWRITE` | `PAGE_READWRITE | PAGE_WRITECOMBINE | PAGE_GRAPHICS_EXECUTE_READWRITE | PAGE_GRAPHICS_NOCACHE` | | Tampon de commandes « Onion » | `XALLOC_MEMTYPE_GRAPHICS_COMMAND_BUFFER_CACHEABLE` | `PAGE_READWRITE | PAGE_GPU_EXECUTE | PAGE_GPU_COHERENT` | `PAGE_READWRITE | PAGE_GRAPHICS_EXECUTE_READWRITE | PAGE_GRAPHICS_COHERENT` | `PAGE_READWRITE | PAGE_GRAPHICS_EXECUTE_READWRITE | PAGE_GRAPHICS_NOCACHE | PAGE_GRAPHICS_COHERENT` | | Mémoire « Garlic en cache » : mise en cache par le CPU, non cohérente pour le GPU et en lecture seule | `XALLOC_MEMTYPE_GRAPHICS_CACHEABLE_NONCOHERENT_GPU_READONLY` | `PAGE_READWRITE | PAGE_GPU_READONLY` | `PAGE_READWRITE | PAGE_GRAPHICS_READONLY` | `PAGE_READWRITE | PAGE_GRAPHICS_READONLY` | | Mémoire de réécriture des clôtures : mise en cache par le CPU et cohérente pour le GPU | `XALLOC_MEMTYPE_GRAPHICS_GPU_UNCACHED` | s.o. (utilisait XALLOC\_MEMTYPE\_GRAPHICS\_CACHEABLE) | `PAGE_READWRITE | PAGE_GRAPHICS_COHERENT | PAGE_GRAPHICS_READWRITE` | `PAGE_READWRITE | PAGE_GRAPHICS_COHERENT | PAGE_GRAPHICS_NOCACHE | PAGE_GRAPHICS_READWRITE` | ## XMemAlloc pour le Microsoft Game Development Kit (GDK) Le tas de mémoire en mode utilisateur XMemAlloc a été intégré au Microsoft Game Development Kit (GDK) avec un minimum de modifications. Il réside désormais dans sa propre DLL (xmem.dll) et sa propre bibliothèque de liaison (xmem.lib). Les API XMemAlloc existantes, notamment [XMemAlloc](/fr-CA/reference/system/xmem/functions/xmemalloc), [XMemFree](/fr-CA/reference/system/xmem/functions/xmemfree) et [XMemSetAllocationHooks](/fr-CA/reference/system/xmem/functions/xmemsetallocationhooks), sont toujours présentes et fonctionnent de la même façon que dans l'ERA de la XBOX One. Un nouvel indicateur **Address32BitMapping** a été ajouté à la structure [XALLOC\_ATTRIBUTES](/fr-CA/reference/system/xmem/structs/xalloc_attributes) qui est transmise à [XMemAlloc](/fr-CA/reference/system/xmem/functions/xmemalloc) et à [XMemFree](/fr-CA/reference/system/xmem/functions/xmemfree). Ce nouvel indicateur signale que l'appelant souhaite allouer de la mémoire et que cette allocation doit avoir une adresse 32 bits. Le pilote graphique en mode utilisateur Direct3D 12 du Microsoft Game Development Kit (GDK) utilise cet indicateur lors de la création de certaines allocations de mémoire, notamment les tas de descripteurs et la mémoire des objets d'état de pipeline. Ces allocations ont une longue durée de vie et sont toujours alignées sur des pages de 64 Ko; elles n'ont donc pas besoin d'être gérées dans un tas. Les demandes d'allocation peuvent plutôt être transmises à [XMemVirtualAlloc](/fr-CA/reference/system/xmem/functions/xmemvirtualalloc) avec l'indicateur **XMEM\_GRAPHICS\_32BIT\_ADDRESS**. Le pilote graphique Direct3D 12 de l'ERA de la XBOX One utilisait en arrière-plan un mécanisme complexe et coûteux pour remapper des allocations arbitraires du titre dans l'espace d'adressage 32 bits, sans que l'implémentation de XMemAlloc ni le titre soient informés du besoin d'adresses 32 bits. Le pilote graphique du Microsoft Game Development Kit (GDK) a abandonné ce système complexe au profit d'une approche beaucoup plus simple et rapide qui communique clairement au titre et à l'implémentation de XMemAlloc le besoin d'une allocation 32 bits. ## Modifications de la mémoire des tas de descripteurs de Direct3D 12.X Le pilote graphique Direct3D 12.X de l'ERA de la XBOX One créait un second alias de mémoire, mis en cache par le CPU et en lecture seule, pour tous les tas de descripteurs visibles par le GPU. Le code qui lisait les descripteurs sur le CPU utilisait cet alias en lecture seule mis en cache pour améliorer les performances de lecture du CPU. Ce second alias de mémoire n'est plus présent dans le Microsoft Game Development Kit (GDK); toute lecture par le CPU à partir de tas de descripteurs visibles par le GPU est donc une lecture CPU non mise en cache à partir de mémoire à combinaison d'écritures. Notez que les tas de descripteurs de cibles de rendu et de profondeur-gabarit (**D3D12\_DESCRIPTOR\_HEAP\_TYPE\_RTV** et **D3D12\_DESCRIPTOR\_HEAP\_TYPE\_DSV**) sont toujours créés en tant que mémoire mise en cache par le CPU, qu'ils soient créés comme visibles par le GPU ou non. ## Prise en charge de la mémoire « Garlic en cache » sur la XBOX One et la XBOX Series X|S Sur la XBOX One, le Microsoft Game Development Kit (GDK) ne prend plus en charge la création de mappages de mémoire mis en cache par le CPU et en lecture seule, et non cohérents pour le GPU et en lecture-écriture. Les indicateurs de protection de page du Microsoft Game Development Kit (GDK) utilisés pour cette combinaison non autorisée sont **`PAGE_READONLY | PAGE_GRAPHICS_READWRITE`**. Sur la XBOX Series X|S, le Microsoft Game Development Kit (GDK) prend en charge la création des 3 types de mappages de mémoire mis en cache et non cohérents. Ces 3 types sont : CPU en lecture-écriture et GPU en lecture seule, CPU en lecture seule et GPU en lecture-écriture, et CPU en lecture-écriture et GPU en lecture-écriture. Lorsque vous utilisez ces types de mémoire graphique, vous devez prendre des précautions particulières pour éviter la corruption de la mémoire causée par la mise en cache non cohérente par le CPU et le GPU. Veuillez garder à l'esprit les règles suivantes lorsque vous utilisez de la mémoire garlic en cache : 1. Avant de lire ou d'écrire de la mémoire garlic en cache, sur le CPU ou le GPU, videz les caches. 2. Une fois les écritures dans la mémoire garlic en cache terminées, sur le CPU ou le GPU, videz les caches. 3. Utilisez des primitives de synchronisation pour contrôler l'accès exclusif en écriture à la mémoire garlic en cache. Évitez les écritures simultanées provenant de plus d'un client. 4. Lorsque vous examinez les modèles d'accès en lecture/écriture, considérez des lignes de cache complètes de 64 octets à la fois, puisque cette taille correspond à l'unité de mémoire chargée dans les caches du CPU et du GPU, puis réécrite. Il n'est pas toujours possible de garantir que des écritures partielles de lignes de cache sont générées par le CPU ou le GPU, en particulier pour la mémoire mise en cache. La mémoire garlic en cache, ainsi que toute autre mémoire graphique mise en cache par le CPU, est créée par le gestionnaire de mémoire du Microsoft Game Development Kit (GDK) en tant que mémoire chiffrée. Le GPU de la XBOX Series X|S peut écrire dans ce type de mémoire, mais en raison des inefficacités des écritures partielles liées au chiffrement de la mémoire, la bande passante non cohérente maximale n'est pas toujours atteinte. Si vous décidez d'utiliser de la mémoire garlic en cache dans votre titre, assurez-vous de disposer d'un moyen efficace de désactiver complètement la mémoire garlic en cache à des fins de test, en la remplaçant par de la mémoire graphique cohérente mise en cache. Cette capacité vous permettra de déterminer rapidement si une mauvaise utilisation de la mémoire garlic en cache est responsable d'une corruption de données ou de blocages du GPU. ## Voir aussi [Graphiques](/fr-CA/build/core-features/graphics/gc-graphics-toc) ## Related topics - [Vue d'ensemble de XBOX Series X|S](/fr/paths/series-xs/overview.md) - [Vue d'ensemble de Windows & ROG XBOX Ally](/fr/paths/windows/overview.md) - [Vue d'ensemble du portage](/fr/paths/porting/overview.md) - [Répertoire des rubriques NDA : liens actifs vers Microsoft Learn](/fr-CA/nda/nda-topic-directory.md) - [Vue d'ensemble d'Unity](/fr/paths/unity/overview.md)