store_structured (sm5 - asm)

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

Remarques

Cette instruction exécute 1 à 4 composants *32 bits écrits de src0 à dest à l’adresse dans dstAddress et dstByteOffset. Aucune conversion de format.

dest 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 est équivalent au pseudocode suivant qui montre le décalage, l’adresse, le pointeur vers le contenu de la mémoire tampon, la foulée de la source et les données stockées linéairement.

                    BYTE *BufferContents;             // from dest
                    UINT BufferStride;                // from dest
                    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 pseudo-code montre comment fonctionne l’opération, mais les données réelles n’ont pas besoin d’être stockées linéairement. 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.

dest 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 intervalles.

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 un accès hors limites à vous #, tout le contenu de l’UAV devient non défini.

L’adressage hors limites sur g# (les limites de ce g# particulier, par opposition à toute la mémoire partagée) pour un composant 32 bits donné entraîne la non-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 de paramètre 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 les UAV et TGSM.

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

Étant donné que les UAV 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, disponible à partir de Windows 8.

Modèle de nuanceur minimal

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

Rubriques connexes

Shader Model 5 Assembly (DirectX HLSL)