Cette page a été traduite par l'API Cloud Translation.

Nouveautés de WebGPU (Chrome 123)

François Beaufort

Prise en charge des fonctions intégrées DP4a dans WGSL

DP4a (Dot Product of 4 Elements and Accumulate) fait référence à un ensemble d'instructions GPU couramment utilisées dans l'inférence de deep learning pour la quantification. Il effectue efficacement des produits scalaires d'entiers de 8 bits pour accélérer le calcul de ces modèles quantifiés int8. Il peut économiser jusqu'à 75 % de mémoire et de bande passante réseau, et améliorer les performances de tous les modèles de machine learning lors de l'inférence par rapport à leur version f32. Par conséquent, il est désormais largement utilisé dans de nombreux frameworks d'IA populaires.

Lorsque l'extension de langage "packed_4x8_integer_dot_product" WGSL est présente dans navigator.gpu.wgslLanguageFeatures, vous pouvez désormais utiliser des scalaires entiers 32 bits qui regroupent des vecteurs à quatre composants d'entiers 8 bits comme entrées pour les instructions de produit scalaire dans votre code de nuanceur WGSL avec les fonctions intégrées dot4U8Packed et dot4I8Packed. Vous pouvez également utiliser des instructions d'emballage et de déballage avec des vecteurs de quatre composants d'entiers de huit bits avec les fonctions intégrées WGSL pack4xI8, pack4xU8, pack4xI8Clamp, pack4xU8Clamp, unpack4xI8 et unpack4xU8.

Il est recommandé d'utiliser une directive "requires" pour signaler le risque de non-portabilité avec requires packed_4x8_integer_dot_product; en haut de votre code de nuanceur WGSL. Consultez l'exemple suivant et issue tint:1497.

if (!navigator.gpu.wgslLanguageFeatures.has("packed_4x8_integer_dot_product")) {
  throw new Error(`DP4a built-in functions are not available`);
}

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const shaderModule = device.createShaderModule({ code: `
  requires packed_4x8_integer_dot_product;

  fn main() {
    const result: u32 = dot4U8Packed(0x01020304u, 0x02040405u); // 42
  }`,
});

Un grand merci à l'équipe Web Graphics d'Intel à Shanghai pour avoir mené à bien cette spécification et son implémentation !

Paramètres de pointeur non restreints dans WGSL

L'extension de langage "unrestricted_pointer_parameters" WGSL assouplit les restrictions sur les pointeurs pouvant être transmis aux fonctions WGSL :

Les pointeurs de paramètres des espaces d'adressage storage, uniform et workgroup aux fonctions déclarées par l'utilisateur.
Transmettre des pointeurs aux membres de la structure et aux éléments du tableau aux fonctions déclarées par l'utilisateur.

Pour en savoir plus, consultez Pointers As Function Parameters | Tour of WGSL (Pointeurs en tant que paramètres de fonction | Visite guidée de WGSL).

Cette fonctionnalité peut être détectée à l'aide de navigator.gpu.wgslLanguageFeatures. Il est recommandé d'utiliser systématiquement une directive requires pour signaler le risque de non-portabilité avec requires unrestricted_pointer_parameters; en haut de votre code de nuanceur WGSL. Consultez l'exemple suivant, les modifications apportées à la spécification WGSL et le problème tint:2053.

if (!navigator.gpu.wgslLanguageFeatures.has("unrestricted_pointer_parameters")) {
  throw new Error(`Unrestricted pointer parameters are not available`);
}

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const shaderModule = device.createShaderModule({ code: `
  requires unrestricted_pointer_parameters;

  @group(0) @binding(0) var<storage, read_write> S : i32;

  fn func(pointer : ptr<storage, i32, read_write>) {
    *pointer = 42;
  }

  @compute @workgroup_size(1)
  fn main() {
    func(&S);
  }`
});

Sucre syntaxique pour la déréférence des composites dans WGSL

Lorsque l'extension de langage "pointer_composite_access" WGSL est présente dans navigator.gpu.wgslLanguageFeatures, votre code de nuanceur WGSL permet désormais d'accéder aux composants de types de données complexes à l'aide de la même syntaxe de point (.), que vous travailliez directement avec les données ou avec un pointeur vers celles-ci. Voici comment cela fonctionne :

Si foo est un pointeur, foo.bar est une façon plus pratique d'écrire (*foo).bar. L'astérisque (*) était normalement nécessaire pour transformer le pointeur en "référence" qui peut être déréférencée, mais maintenant, les pointeurs et les références sont beaucoup plus similaires et presque interchangeables.
Si foo n'est pas un pointeur : l'opérateur point (.) fonctionne exactement comme vous en avez l'habitude pour accéder directement aux membres.

De même, si pa est un pointeur qui stocke l'adresse de départ d'un tableau, l'utilisation de pa[i] vous donne un accès direct à l'emplacement de mémoire où est stocké le 'i-ième élément de ce tableau.

Il est recommandé d'utiliser une directive "requires" pour signaler le risque de non-portabilité avec requires pointer_composite_access; en haut de votre code de nuanceur WGSL. Consultez l'exemple suivant et le problème tint:2113.

if (!navigator.gpu.wgslLanguageFeatures.has("pointer_composite_access")) {
  throw new Error(`Pointer composite access is not available`);
}

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const shaderModule = device.createShaderModule({ code: `
  requires pointer_composite_access;

  fn main() {
    var a = vec3f();
    let p : ptr<function, vec3f> = &a;
    let r1 = (*p).x; // always valid.
    let r2 = p.x; // requires pointer composite access.
  }`
});

État de lecture seule distinct pour les aspects de pochoir et de profondeur

Auparavant, les pièces jointes profondeur/stencil en lecture seule dans les passes de rendu nécessitaient que les deux aspects (profondeur et stencil) soient en lecture seule. Cette limite a été levée. Vous pouvez désormais utiliser l'aspect de profondeur en lecture seule, par exemple pour le traçage des ombres de contact, tandis que le tampon de stencil est écrit pour identifier les pixels à traiter ultérieurement. Consultez le problème dawn:2146.

Mises à jour de l'Aube

Le rappel d'erreur non capturée défini avec wgpuDeviceSetUncapturedErrorCallback() est désormais appelé immédiatement lorsque l'erreur se produit. C'est ce que les développeurs attendent et souhaitent systématiquement pour le débogage. Voir change dawn:173620.