> ## 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.

# SetShaderScratchSpaceX (consoles XBOX Series)

> Permet de contrôler directement les registres SPI_TMPRING_SIZE et COMPUTE_TMPRING_SIZE et, respectivement, les anneaux graphiques et de calcul.

Permet de contrôler directement les registres SPI\_TMPRING\_SIZE et COMPUTE\_TMPRING\_SIZE et, respectivement, les anneaux graphiques et de calcul.

## Syntaxe

```cpp theme={null}
void SetShaderScratchSpaceX(  
         D3D12XBOX_SET_SHADER_SCRATCH_SPACE_FLAGS Flags,  
         D3D12_GPU_VIRTUAL_ADDRESS Destination,  
         UINT64 SizeBytes,  
         UINT SizePerWaveInBytes  
)  
```

### Paramètres

*Flags*   \_In\_\
Type : [D3D12XBOX\_SET\_SHADER\_SCRATCH\_SPACE\_FLAGS](/fr/reference/graphics/d3d12_xs/enums/d3d12xbox_set_shader_scratch_space_flags_xs)

Choisissez le calcul, les graphiques ou les deux.

*Destination*   \_In\_\
Type : D3D12\_GPU\_VIRTUAL\_ADDRESS

Adresse de base de l'espace de travail (scratch) ; elle doit être alignée sur 1 Ko ou être null. Définir cette valeur sur null reprogramme les valeurs par défaut actuellement définies par le pilote.

*SizeBytes*   \_In\_\
Type : UINT64

Taille de l'espace de travail, alignée sur 1 Ko ; doit être égale à 0 si l'adresse est null.

*SizePerWaveInBytes*   \_In\_\
Type : UINT

Taille de l'espace de travail par vague ; elle doit être alignée sur 1 Ko, être inférieure ou égale à la taille totale de l'espace de travail et être égale à 0 si l'adresse est null.

### Valeur de retour

Type : void

## Remarques

Notre matériel prend en charge les modifications en pipeline des registres tmpring\_size, mais un vidage complet du pipeline est nécessaire lorsque l'adresse mémoire sous-jacente de l'espace de travail est réutilisée. Il en résulte ce qui suit : par défaut, le pilote graphique alloue un seul espace de travail pour les graphiques et le calcul, et définit les registres tmpring\_size de manière à ne pouvoir accueillir que quelques vagues par SIMD. Cela signifie que l'occupation est faible lorsque l'espace de travail est activé dans les shaders. Par défaut, comme il n'existe qu'une seule allocation de calcul, le calcul asynchrone ne peut pas être utilisé simultanément avec le calcul graphique, ce qui signifie que les shaders utilisant un espace de travail ne peuvent pas du tout être utilisés en calcul asynchrone. Les développeurs peuvent remplacer les tailles d'espace de travail via l'API spécialisée de création d'appareil XBOX, mais ne peuvent pas remplacer ce comportement.

Cette API permet de reprogrammer ce comportement par défaut afin d'obtenir une occupation plus élevée et un meilleur chevauchement du travail entre les graphiques et le calcul asynchrone. Aucune synchronisation n'est effectuée en interne et aucune vérification des pointeurs mémoire n'est faite pour éviter leur réutilisation ; il est donc très important que les utilisateurs implémentent leur propre synchronisation afin de garantir qu'aucune réutilisation de mémoire ne se produit lorsque le registre tmpring\_size est reprogrammé.

Il est possible d'interroger la taille d'espace de travail requise par vague à l'aide des API suivantes

```cpp theme={null}
UINT GetScratchSize(
    ID3D12PipelineState* pPso)
{
    ComPtr<ID3DBlob> blob;

    // Retrieve scratch size, if present
    HRESULT hr = pPso->GetInformationX(D3D12XBOX_PIPELINE_STATE_INFORMATION_TYPE_SCRATCH_SIZE_PER_WAVE_IN_UNITS_OF_256DW, 0, &blob);
    if (FAILED(hr))
        return 0;

    const UINT* pValue = (UINT*)blob->GetBufferPointer();

    return *pValue * 1024;
}
```

Voici un exemple de définition possible, permettant par exemple à 8 vagues de partager l'espace de travail (notez qu'en pratique, ce nombre de vagues est trop faible)

```cpp theme={null}
    const UINT scratchSizePerWaveBytes = GetScratchSize(pso.Get());
    const UINT scratchSize = scratchSizePerWaveBytes * 8;

    pCmdList->SetShaderScratchSpaceX(D3D12XBOX_SET_SHADER_SCRATCH_SPACE_FLAGS_GRAPHICS,
        pScratch0->GetGPUVirtualAddress(),
        scratchSize,
        scratchSizePerWaveBytes);
    pCmdList->SetPipelineState(pso.Get());
    pCmdList->DrawInstanced(128, 1, 0, 0);
```

Enfin, le matériel ne prend pas en charge une occupation supérieure à 16 lorsque SCRATCH\_EN est activé, car la programmation de tmpring\_size ne permet pas de spécifier plus de 32 vagues par unité de calcul.

## Configuration requise

**En-tête :** d3d12\_xs.h

**Bibliothèque :** d3d12\_xs.lib

**Plateformes prises en charge :** XBOX Series X|S

## Voir aussi

[ID3D12GraphicsCommandList6](/fr/reference/graphics/d3d12_xs/interfaces/ID3D12GraphicsCommandList6/id3d12graphicscommandlist6)


## Related topics

- [Répertoire des rubriques NDA : liens actifs vers Microsoft Learn](/fr/nda/nda-topic-directory.md)
- [Page Scratch](/fr/tools/tools-console/wdp/windows-device-portal-on-xbox-scratch.md)
- [GetShaderStackSize (consoles XBOX Series)](/fr/reference/graphics/d3d12/interfaces/id3d12stateobjectproperties/methods/id3d12stateobjectproperties_getshaderstacksize_public.md)
- [ShaderCacheControl (consoles XBOX Series)](/fr/reference/graphics/d3d12/interfaces/id3d12device9/methods/id3d12device9_shadercachecontrol_public.md)
- [SetComputeRootShaderResourceView](/fr/reference/graphics/d3d12/interfaces/id3d12graphicscommandlist/methods/id3d12graphicscommandlist_setcomputerootshaderresourceview_public.md)