Nouveautés de WebGPU (Chrome 123)

François Beaufort
François Beaufort
GitHub

Compatibilité des fonctions intégrées DP4a avec WGSL

DP4a (produit scalaire de quatre éléments et accumulation) 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 entiers de 8 bits pour accélérer le calcul de ces modèles quantifiés en int8. Il permet d'économiser (jusqu'à 75%) de la mémoire et de la bande passante réseau, et d'améliorer les performances de tous les modèles de machine learning en matière d'inférence, par rapport à leur version f32. Par conséquent, elle est désormais largement utilisée dans de nombreux frameworks d'IA populaires.

Lorsque l'extension de langage WGSL "packed_4x8_integer_dot_product" est présente dans navigator.gpu.wgslLanguageFeatures, vous pouvez désormais utiliser des scalaires entiers 32 bits empaquetant des vecteurs à quatre composantes d'entiers 8 bits comme entrées des 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'empaquetage et de désempaquetage avec des vecteurs à quatre composants empaquetés d'entiers 8 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 merci tout particulier à l'équipe Web Graphics d'Intel à Shanghai, qui a mené à bien cette spécification et cette implémentation.

Paramètres de pointeur sans restriction dans WGSL

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

  • Pointeurs de paramètres des espaces d'adressage storage, uniform et workgroup vers les fonctions déclarées par l'utilisateur.

  • Transmettre des pointeurs vers des membres de structure et des éléments de tableau à des fonctions déclarées par l'utilisateur.

Pour en savoir plus, consultez 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 toujours 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 de la spécification WGSL et l'issue 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);
  }`
});

Syntaxe sucré pour déréférencer les composites dans WGSL

Lorsque l'extension de langage WGSL "pointer_composite_access" est présente dans navigator.gpu.wgslLanguageFeatures, votre code de nuanceur WGSL prend désormais en charge l'accès aux composants de types de données complexes utilisant la même syntaxe à point (.), que vous travailliez directement avec les données ou avec un pointeur vers celles-ci. Le principe est le suivant :

  • Si foo est un pointeur: foo.bar est un moyen plus pratique d'écrire (*foo).bar. L'astérisque (*) serait normalement nécessaire pour transformer le pointeur en "référence" pouvant ê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ébut d'un tableau, l'utilisation de pa[i] vous permet d'accéder directement à l'emplacement de mémoire où est stocké le 'ie é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 issue 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 en lecture seule distinct pour les aspects du pochoir et de la profondeur

Auparavant, les pièces jointes de profondeur et de pochoir en lecture seule dans les passes de rendu nécessitaient que les deux aspects (profondeur et pochoir) soient en lecture seule. Cette limitation a été levée. Vous pouvez désormais utiliser l'aspect de profondeur en lecture seule, par exemple pour le traçage de l'ombre de contact, tandis que le tampon du pochoir est écrit pour identifier les pixels à traiter. Voir issue dawn:2146.

Actualités de l'aube

Le rappel d'erreur non capturé 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.

La méthode wgpuSurfaceGetPreferredFormat() de l'API webgpu.h a été implémentée. Consultez le problème dawn:1362.

Il ne s'agit là que de quelques-uns des points clés. Consultez la liste exhaustive des commits.

Nouveautés de WebGPU

Liste de tout ce qui a été abordé dans la série Nouveautés de WebGPU.

Chrome 131

Chrome 130

Chrome 129

Chrome 128

Chrome 127

Chrome 126

Chrome 125

Chrome 124

Chrome 123

Chrome 122

Chrome 121

Chrome 120

Chrome 119

Chrome 118

Chrome 117

Chrome 116

Chrome 115

Chrome 114

Chrome 113