store_structured (sm5 - asm)

Écriture à accès aléatoire de composants 1-4 32 bits dans une vue d’accès non ordonnée (UAV) de mémoire tampon structurée.

store_structured dst0[.write_mask], dstAddress[.select_component], dstByteOffset[.select_component], src0[.swizzle]
Élément Description
dst0
[in] Adresse des résultats de l’opération.
dstAddress
[in] Adresse à laquelle écrire.
dstByteOffset
[in] Index de la structure à écrire.
src0
[in] Composants à écrire.

Notes

Cette instruction effectue un composant de 1 à 4 composants *32 bits écrits de src0 à dst0 à l’adresse dans dstAddress et dstByteOffset. Aucune conversion de format.

dst0 doit être un UAV (u#). Dans le nuanceur de calcul, il peut également s’agir de la mémoire partagée du groupe de threads (g#).

dstAddress spécifie l’index de la structure à écrire.

L’emplacement des données écrites équivaut au pseudocode suivant qui affiche le décalage, l’adresse, le pointeur vers le contenu de la mémoire tampon, la progression de la source et les données stockées de manière linéaire.

                    BYTE *BufferContents;             // from dst0
                    UINT BufferStride;                // from dst0
                    UINT dstAddress, dstByteOffset;   // source registers
                    BYTE *WriteLocation;              // value to calculate

                    // calculate writing location
                     WriteLocation = BufferContents 
                                + BufferStride * dstAddress 
                                + dstByteOffset;

                    // calculate the number of components to write
                    switch (dstWriteMask)
                    {
                        x:    WriteComponents = 1; break;
                        xy:   WriteComponents = 2; break;
                        xyz:  WriteComponents = 3; break;
                        xyzw: WriteComponents = 4; break;
                        default:  // only these masks are valid                              
                    }

                    // copy the data from the source register with
                    //    the swizzle applied
                    memcpy(WriteLocation, swizzle(src0, src0.swizzle), 
                             WriteComponents * sizeof(INT32));

Ce pseudocode montre comment fonctionne l’opération, mais les données réelles ne doivent pas être stockées de manière linéaire. Si les données ne sont pas stockées linéairement, l’opération réelle de l’instruction doit correspondre au comportement de l’opération ci-dessus.

dst0 ne peut avoir qu’un masque d’écriture qui est l’un des suivants : .x, .xy, .xyz, .xyzw. Le masque d’écriture détermine le nombre de composants 32 bits à écrire sans lacunes.

L’adressage hors limites sur u# casued par dstAddress signifie que rien n’est écrit dans la mémoire hors limites.

Si dstByteOffset, y compris dstWriteMask, est ce qui provoque l’accès hors limites à vous#, le contenu entier de l’UAV devient non défini.

Les limites qui s’adressent à g# (limites de ce g# particulier, par opposition à toute mémoire partagée) pour tout composant 32 bits donné entraînent l’absence de définition de l’intégralité du contenu de toute la mémoire partagée.

dstByteOffset est un argument distinct de dstAddress , car il s’agit généralement d’un littéral. Cette séparation des paramètres n’a pas été effectuée pour les atomiques sur la mémoire structurée.

cs_4_0 et cs_4_1 prennent en charge cette instruction pour UAV et TGSM.

Cette instruction s’applique aux étapes de nuanceur suivantes :

Sommet Coque Domain Géométrie Pixel Calcul
X X

Étant donné que les uaVs sont disponibles à toutes les étapes du nuanceur pour Direct3D 11.1, cette instruction s’applique à toutes les étapes du nuanceur pour le runtime Direct3D 11.1, qui est disponible à partir de Windows 8.

Sommet Coque Domain Géométrie Pixel Calcul
X X X X X X

Modèle de nuanceur minimal

Cette instruction est prise en charge dans les modèles de nuanceur suivants :

Modèle de nuanceur Prise en charge
Modèle de nuanceur 5 Oui
Modèle de nuanceur 4.1 Non
Modèle de nuanceur 4 Non
Modèle de nuanceur 3 (DirectX HLSL) Non
Modèle de nuanceur 2 (DirectX HLSL) Non
Shader Model 1 (DirectX HLSL) Non

Shader Model 5 Assembly (DirectX HLSL)