> ## 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. # Pavage > Pavage Cette rubrique décrit les avantages et les inconvénients du pavage sur puce (onchip) et hors puce (offchip). * [Actions liées au pavage](#ID4EU) * [Mode de pavage sur puce](#ID4EAC) * [Mode de pavage hors puce](#ID4ELC) * [Heuristique utilisée pour exécuter les vagues DS en mode sur puce ou hors puce](#ID4E3C) * [Activation du pavage hors puce](#ID4EQD) * [Définition des paramètres de pavage](#ID4E5D) ## Actions liées au pavage Le pavage sur XBOX One effectue les actions suivantes, qu'il soit effectué sur puce ou hors puce. 1. Le GPU répartit en groupes de threads tous les patchs générés par chaque dessin individuel. 2. Pour chaque groupe de threads, le GPU alloue une certaine quantité de mémoire de stockage de données local (LDS) dans une unité de calcul (CU). Tous les threads nécessaires du nuanceur de sommets (VS) et du nuanceur de coque (HS) sont planifiés sur cette CU. 3. Pour chaque groupe de threads, le GPU exécute autant de threads VS que de points de contrôle d'entrée, multiplié par le nombre de patchs par groupe de threads. ```cpp theme={null} VS threads = (input control points) x (patches per threadgroup) ``` Les threads sont toujours regroupés à raison de 64 threads par vague par étape de nuanceur. 1. Pour chaque groupe de threads, le GPU exécute également autant de threads HS que de points de contrôle de sortie, multiplié par le nombre de patchs par groupe de threads. ```cpp theme={null} HS threads = (output control points) x (patches per threadgroup) ``` Les threads sont toujours regroupés à raison de 64 threads par vague par étape de nuanceur. 1. Tous les threads HS doivent s'exécuter simultanément en tant que groupe de threads, car des barrières de synchronisation peuvent être nécessaires. Ce fonctionnement est semblable à celui des groupes de threads des nuanceurs de calcul, sauf que dans ce cas, la synchronisation est implicite et n'est pas spécifiée dans le langage HLSL (High-Level Shader Language). 2. Le paveur du GPU génère ensuite les threads du nuanceur de domaine (DS) à exécuter, en fonction des facteurs de pavage calculés par le HS (également regroupés à raison de 64 threads par vague). ## Mode de pavage sur puce Par défaut, le pilote Direct3D 12 configure toujours le GPU en mode de pavage sur puce. En mode de pavage sur puce, toutes les données des points de contrôle d'entrée et de sortie et les constantes par patch sont stockées dans la LDS, y compris les facteurs constants. Comme la LDS est une mémoire interne au GPU, aucune bande passante mémoire supplémentaire n'est générée, et l'accès aux données est garanti à faible latence. Toutefois, comme ces données sont nécessaires aux threads DS générés par le pavage des patchs d'un groupe de threads, tous ces threads DS doivent s'exécuter dans la même CU que celle qui a exécuté les threads VS et HS du même groupe de threads. Cela limite considérablement la capacité du GPU à équilibrer la charge de travail entre les 12 CU disponibles, en particulier lorsque les facteurs de pavage sont élevés. Avec des facteurs de pavage élevés, un seul groupe de threads peut générer de nombreuses vagues de threads DS, et la mémoire LDS utilisée est bloquée pour toute autre utilisation, y compris pour d'autres groupes de threads qui pourraient autrement s'exécuter dans la CU. (La LDS est également utilisée pour les données locales des groupes de threads dans les nuanceurs de calcul, pour les valeurs d'interpolation des PS et pour le mode GS sur puce.) ## Mode de pavage hors puce Le pavage hors puce est une option qui permet d'utiliser une mémoire autre que la LDS avec les nuanceurs de coque et de domaine. Le mode de pavage hors puce du GPU est activé en spécifiant l'indicateur [D3D12XBOX\_PIPELINE\_STATE\_FLAG\_GS\_ONCHIP\_TS\_OFFCHIP](/fr-CA/reference/graphics/d3d12_x/enums/d3d12_pipeline_state_flags) ou [D3D12XBOX\_PIPELINE\_STATE\_FLAG\_GS\_OFFCHIP\_TS\_OFFCHIP](/fr-CA/reference/graphics/d3d12_x/enums/d3d12_pipeline_state_flags). Ce mode utilise la même quantité de LDS que le mode sur puce, mais le HS écrit également tous les points de contrôle de sortie, les facteurs de pavage et les constantes par patch dans une mémoire tampon. Une heuristique est ensuite utilisée pour exécuter certaines vagues DS dans la même CU en mode sur puce, en lisant les données à partir de la LDS, et pour exécuter d'autres vagues DS dans d'autres CU en mode hors puce, en lisant les données à partir de la mémoire. Cela permet au GPU de libérer la mémoire LDS du groupe de threads avant que toutes les vagues DS soient terminées, ou même lancées, et cela permet également au GPU de mieux équilibrer la charge des vagues DS entre toutes les CU. L'avantage du pavage hors puce est que la mémoire LDS est libérée pour d'autres usages graphiques. L'obtention réelle d'une amélioration des performances grâce au pavage hors puce dépend énormément du code du titre. Il se peut qu'aucune amélioration des performances n'en résulte. ## Heuristique utilisée pour exécuter les vagues DS en mode sur puce ou hors puce L'heuristique utilisée pour exécuter certaines vagues DS en mode sur puce et d'autres en mode hors puce est exécutée par groupe de threads, comme suit. * Un thread du HS rassemble tous les facteurs de pavage de tous les patchs et calcule un facteur de pavage moyen pour l'ensemble du groupe de threads. Si cette valeur est inférieure à **TfThreshold**, le mode hors puce est désactivé pour l'ensemble du groupe de threads. Aucune donnée n'est écrite en mémoire et toutes les vagues DS s'exécutent dans la même CU. * Si le mode hors puce n'est pas désactivé pour le groupe de threads, les **DsWaveThreshold** premières vagues DS s'exécutent en mode sur puce, après quoi la mémoire LDS est récupérée et toutes les vagues DS restantes s'exécutent hors puce. ## Activation du pavage hors puce Les nuanceurs de coque et de domaine destinés à être utilisés avec le pavage hors puce doivent être compilés avec l'instruction `#define` suivante. ```cpp theme={null} __XBOX_ENABLE_HSOFFCHIP ``` La définition de cette valeur entraîne la précompilation des nuanceurs de coque ou de domaine pour le pavage hors puce, et évite une recompilation au moment de l'exécution. Les nuanceurs doivent correspondre : tous deux hors puce ou tous deux non hors puce. ## Définition des paramètres de pavage [Utilisation de D3D12XBOX\_TESSELLATION\_PARAMETERS\_DESC](#ID4EEE) ### Appel de HSSetTessellationParameters Pour utiliser le pavage hors puce, remplissez D3D12XBOX\_TESSELLATION\_PARAMETERS\_DESC et transmettez-la à **CreateGraphicsPipelineStateX**, à **CreateDerivedGraphicsPipelineStateX** ou à **CreatePipelineState**. Initialisez les valeurs par défaut de D3D12XBOX\_TESSELLATION\_PARAMETERS\_DESC en appelant **D3D12XboxInitializeDefaultTessellationParameters**. ```cpp theme={null} typedef struct D3D12XBOX_TESSELLATION_PARAMETERS_DESC { UINT PatchesPerThreadgroup; FLOAT TessellationFactorThreshold; UINT DsWaveThreshold; } D3D12XBOX_TESSELLATION_PARAMETERS_DESC; ``` Les champs de cette structure sont les suivants. | Champ | Description | | - | - | | **PatchesPerThreadgroup** | Nombre de patchs traités simultanément dans une unité de calcul du GPU. Actuellement, le pilote calcule pour ce champ une valeur qui maximise le nombre de patchs pouvant être traités simultanément. | | **TfThreshold** | Seuil du facteur de pavage. Il s'agit du facteur de pavage moyen minimal dans un groupe de threads qui amène le nuanceur de coque à passer dynamiquement du mode sur puce au mode hors puce. Ce champ n'est valide que lorsque le pavage hors puce est activé dans PipelineStateObject. Actuellement, le pilote calcule un facteur de pavage qui génère environ 256 threads DS (4 vagues). | | **DsWaveThreshold** | Seuil de vagues du nuanceur de domaine : il s'agit du nombre de vagues DS lancées par l'unité de pavage selon la méthode sur puce, avant de faire passer le traitement DS en mode hors puce, de libérer la mémoire LDS et de commencer à lancer des vagues DS vers d'autres CU. Actuellement, le pilote code cette valeur en dur à 4 vagues. Ce champ n'est valide que lorsque le pavage hors puce est activé dans PipelineStateObjects. | ## Related topics - [XPackageUninstallPackage](/reference/system/xpackage/functions/xpackageuninstallpackage.md) - [XPackageEnumeratePackages](/reference/system/xpackage/functions/xpackageenumeratepackages.md) - [XPackageEnumerateChunkAvailability](/reference/system/xpackage/functions/xpackageenumeratechunkavailability.md) - [XPackageFindChunkAvailability](/reference/system/xpackage/functions/xpackagefindchunkavailability.md) - [XPackageChunkAvailabilityCallback](/reference/system/xpackage/functions/xpackagechunkavailabilitycallback.md)