Share via

store_raw (sm5 - asm)

  • Article

Écriture en accès aléatoire de 1 à 4 composants 32 bits dans la mémoire sans type.

store_raw dest[.write_mask], dstByteOffset[.select_component], src0[.swizzle]
Élément Description
Dest
 [in] Adresse mémoire.
dstByteOffset
 [in] Décalage.
src0
 [in] Composants à écrire.

Remarques

Cette instruction exécute des composants *32 bits 1 à 4 écrits de src0 à dest au décalage dans dstByteOffset. Il n’existe aucune conversion de format.

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

dstByteOffset spécifie la valeur de base 32 bits en mémoire pour une fenêtre de 4 valeurs séquentielles 32 bits dans lesquelles les données peuvent être écrites, en fonction du swizzle et du masque sur d’autres paramètres.

L’emplacement des données écrites est équivalent au pseudocode suivant qui montre l’adresse, le pointeur vers le contenu de la mémoire tampon et les données stockées linéairement.

                    BYTE *BufferContents;          // from src0
                    UINT dstByteOffset;            // source register
                    BYTE *WriteLocation;           // value to calculate

                    // calculate writing location
                    WriteLocation = BufferContents 
                                + 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(UINT32));

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. 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# signifie que rien n’est écrit dans la mémoire hors limites ; toute partie qui se trouve dans des limites est écrite correctement.

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.

cs_4_0 et cs_4_1 prennent en charge cette instruction pour l’UAV.

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

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

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

Sommet Coque Domain Géométrie Pixel Compute
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 Pris 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
Shader Model 2 (DirectX HLSL) Non
Modèle de nuanceur 1 (DirectX HLSL) Non

Shader Model 5 Assembly (DirectX HLSL)