Compatibilité avec WebGPU sur Android
L'équipe Chrome est heureuse d'annoncer que WebGPU est désormais activé par défaut dans Chrome 121 sur les appareils équipés d'Android 12 ou version ultérieure, et équipés de GPU Qualcomm et ARM.
La prise en charge s'étend progressivement à un plus grand nombre d'appareils Android, y compris ceux fonctionnant sous Android 11 dans un avenir proche. Cette expansion dépendra de tests et d'optimisations supplémentaires afin de garantir une expérience fluide sur un plus large éventail de configurations matérielles. Consultez le problème chromium:1497815.
<ph type="x-smartling-placeholder">Utiliser DXC au lieu de FXC pour compiler le nuanceur sous Windows
Chrome exploite désormais la puissance de DXC (DirectX Compiler) pour compiler les nuanceurs sur les ordinateurs Windows D3D12 équipés de matériel graphique SM6+. Auparavant, WebGPU s'appuyait sur FXC (FX Compiler) pour compiler les nuanceurs sous Windows. Bien qu'il fonctionnait, FXC ne proposait pas l'ensemble des fonctionnalités et les optimisations des performances étaient présentes dans DXC.
Les premiers tests montrent une augmentation moyenne de 20% de la vitesse de compilation du nuanceur de calcul avec DXC par rapport à FXC.
Requêtes d'horodatage dans les passes de calcul et de rendu
Les requêtes d'horodatage permettent aux applications WebGPU de mesurer avec précision (à la nanoseconde près) le temps nécessaire à leurs commandes GPU pour exécuter les passes de calcul et de rendu. Ils sont très utilisés pour obtenir des insights sur les performances et le comportement des charges de travail des GPU.
Lorsque la fonctionnalité "timestamp-query"
est disponible dans un GPUAdapter
, vous pouvez désormais effectuer les opérations suivantes:
- Demandez un
GPUDevice
avec la fonctionnalité"timestamp-query"
. - Créez une
GPUQuerySet
de type"timestamp"
. - Utilisez
GPUComputePassDescriptor.timestampWrites
etGPURenderPassDescriptor.timestampWrites
pour définir où écrire les valeurs d'horodatage dansGPUQuerySet
. - Résoudre les valeurs d'horodatage dans un
GPUBuffer
avecresolveQuerySet()
- Relisez les valeurs d'horodatage en copiant les résultats de
GPUBuffer
vers le processeur. - Décodez les valeurs d'horodatage en tant que
BigInt64Array
.
Consultez l'exemple suivant et le problème dawn:1800.
const adapter = await navigator.gpu.requestAdapter();
if (!adapter.features.has("timestamp-query")) {
throw new Error("Timestamp query feature is not available");
}
// Explicitly request timestamp query feature.
const device = await adapter.requestDevice({
requiredFeatures: ["timestamp-query"],
});
const commandEncoder = device.createCommandEncoder();
// Create a GPUQuerySet which holds 2 timestamp query results: one for the
// beginning and one for the end of compute pass execution.
const querySet = device.createQuerySet({ type: "timestamp", count: 2 });
const timestampWrites = {
querySet,
beginningOfPassWriteIndex: 0, // Write timestamp in index 0 when pass begins.
endOfPassWriteIndex: 1, // Write timestamp in index 1 when pass ends.
};
const passEncoder = commandEncoder.beginComputePass({ timestampWrites });
// TODO: Set pipeline, bind group, and dispatch work to be performed.
passEncoder.end();
// Resolve timestamps in nanoseconds as a 64-bit unsigned integer into a GPUBuffer.
const size = 2 * BigInt64Array.BYTES_PER_ELEMENT;
const resolveBuffer = device.createBuffer({
size,
usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
});
commandEncoder.resolveQuerySet(querySet, 0, 2, resolveBuffer, 0);
// Read GPUBuffer memory.
const resultBuffer = device.createBuffer({
size,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
commandEncoder.copyBufferToBuffer(resolveBuffer, 0, resultBuffer, 0, size);
// Submit commands to the GPU.
device.queue.submit([commandEncoder.finish()]);
// Log compute pass duration in nanoseconds.
await resultBuffer.mapAsync(GPUMapMode.READ);
const times = new BigInt64Array(resultBuffer.getMappedRange());
console.log(`Compute pass duration: ${Number(times[1] - times[0])}ns`);
resultBuffer.unmap();
En raison des préoccupations liées aux attaques temporelles, les requêtes de code temporel sont quantifiées avec une résolution de 100 microsecondes, ce qui constitue un bon compromis entre précision et sécurité. Dans le navigateur Chrome, vous pouvez désactiver la quantification de code temporel en activant les fonctionnalités pour les développeurs WebGPU flag à chrome://flags/#enable-webgpu-developer-features
pendant le développement de votre application. Pour en savoir plus, consultez Quantification des requêtes d'horodatage.
Étant donné que les GPU peuvent parfois réinitialiser le compteur d'horodatage, ce qui peut entraîner des valeurs inattendues, comme des deltas négatifs entre les horodatages, je vous recommande de consulter les modifications de git diff qui permettent d'ajouter une prise en charge des requêtes d'horodatage à l'exemple Compute Boids suivant.
<ph type="x-smartling-placeholder">Points d'entrée par défaut des modules de nuanceurs
Pour améliorer l'expérience des développeurs, vous pouvez désormais omettre le entryPoint
de votre module de nuanceur lorsque vous créez un pipeline de calcul ou de rendu. Si aucun point d'entrée unique n'est trouvé dans le code du nuanceur, une erreur GPUValidationError est déclenchée. Consultez l'exemple suivant et le problème dawn:2254.
const code = `
@vertex fn vertexMain(@builtin(vertex_index) i : u32) ->
@builtin(position) vec4f {
const pos = array(vec2f(0, 1), vec2f(-1, -1), vec2f(1, -1));
return vec4f(pos[i], 0, 1);
}
@fragment fn fragmentMain() -> @location(0) vec4f {
return vec4f(1, 0, 0, 1);
}`;
const module = myDevice.createShaderModule({ code });
const format = navigator.gpu.getPreferredCanvasFormat();
const pipeline = await myDevice.createRenderPipelineAsync({
layout: "auto",
vertex: { module, entryPoint: "vertexMain" },
fragment: { module, entryPoint: "fragmentMain", targets: [{ format }] },
vertex: { module },
fragment: { module, targets: [{ format }] },
});
Prise en charge de display-p3 en tant qu'espace colorimétrique GPUExternalTexture
Vous pouvez désormais définir l'espace colorimétrique de destination "display-p3"
lorsque vous importez un élément GPUExternalTexture à partir de vidéos HDR avec importExternalTexture()
. Découvrez comment WebGPU gère les espaces de couleur. Consultez l'exemple suivant et le problème chromium:1330250.
// Create texture from HDR video.
const video = document.querySelector("video");
const texture = myDevice.importExternalTexture({
source: video,
colorSpace: "display-p3",
});
Informations sur les tas de mémoire
Pour vous aider à anticiper les limites de mémoire lors de l'allocation de grandes quantités de mémoire pendant le développement de votre application, requestAdapterInfo()
affiche désormais des informations memoryHeaps
, telles que la taille et le type des tas de mémoire disponibles sur l'adaptateur. Cette fonctionnalité expérimentale n'est accessible que lorsque la section "Fonctionnalités pour les développeurs WebGPU" L'indicateur à chrome://flags/#enable-webgpu-developer-features
est activé. Consultez l'exemple suivant et le problème dawn:2249.
const adapter = await navigator.gpu.requestAdapter();
const adapterInfo = await adapter.requestAdapterInfo();
for (const { size, properties } of adapterInfo.memoryHeaps) {
console.log(size); // memory heap size in bytes
if (properties & GPUHeapProperty.DEVICE_LOCAL) { /* ... */ }
if (properties & GPUHeapProperty.HOST_VISIBLE) { /* ... */ }
if (properties & GPUHeapProperty.HOST_COHERENT) { /* ... */ }
if (properties & GPUHeapProperty.HOST_UNCACHED) { /* ... */ }
if (properties & GPUHeapProperty.HOST_CACHED) { /* ... */ }
}
<ph type="x-smartling-placeholder">
Actualités de l'aube
Les méthodes HasWGSLLanguageFeature
et EnumerateWGSLLanguageFeatures
sur wgpu::Instance
ont été ajoutées pour gérer les fonctionnalités du langage WGSL. Consultez le problème dawn:2260.
La fonctionnalité wgpu::Feature::BufferMapExtendedUsages
non standard vous permet de créer un tampon GPU avec wgpu::BufferUsage::MapRead
ou wgpu::BufferUsage::MapWrite
et tout autre wgpu::BufferUsage
. Consultez l'exemple suivant et le problème dawn:2204.
wgpu::BufferDescriptor descriptor = {
.size = 128,
.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::Uniform
};
wgpu::Buffer uniformBuffer = device.CreateBuffer(&descriptor);
uniformBuffer.MapAsync(wgpu::MapMode::Write, 0, 128,
[](WGPUBufferMapAsyncStatus status, void* userdata)
{
wgpu::Buffer* buffer = static_cast<wgpu::Buffer*>(userdata);
memcpy(buffer->GetMappedRange(), data, sizeof(data));
},
&uniformBuffer);
Les fonctionnalités suivantes ont été documentées: Partage de texture ANGLE, D3D11 multithread Protected, Implicit Device Synchronization, Norm16 Texture formats, Timestamp Query Inside Passes, Stockage local Pixel, Fonctionnalités du nuanceur et Formats multiplanaires.
L'équipe Chrome a créé un dépôt GitHub officiel pour Dawn.
Cette présentation ne porte que sur certains points clés. Consultez la liste exhaustive des commits.
Nouveautés de WebGPU
Liste de tous les sujets abordés dans la série Nouveautés de WebGPU
Chrome 128
- Tester avec des sous-groupes
- Abandon de la définition du biais de profondeur pour les lignes et les points
- Masquer l'avertissement d'erreur non capturée dans les outils de développement si preventDefault
- WGSL interpole d'abord l'échantillonnage, puis
- Informations sur l'aube
Chrome 127
- Compatibilité expérimentale avec OpenGL ES sur Android
- Attribut d'informations GPUAdapter
- Améliorations de l'interopérabilité de WebAssembly
- Amélioration des erreurs liées à l'encodeur de commande
- Informations sur l'aube
Chrome 126
- Augmentation de la limite maxTextureArrayLayers
- Optimisation de l'importation de tampon pour le backend Vulkan
- Amélioration du temps de compilation des nuanceurs
- Les tampons de commande envoyés doivent être uniques
- Informations sur l'aube
Chrome 125
- Sous-groupes (fonctionnalité en cours de développement)
- Effectuer le rendu d'une tranche de texture 3D
- Informations sur l'aube
Chrome 124
- Textures de stockage en lecture seule et en lecture/écriture
- Assistance pour les service workers et les workers partagés
- Nouveaux attributs d'informations sur l'adaptateur
- Corrections de bugs
- Informations sur l'aube
Chrome 123
- Fonctions intégrées DP4a dans WGSL
- Paramètres de pointeur sans restriction dans WGSL
- Syntaxe sucré pour déréférencer les composites dans WGSL
- État de lecture seule distinct pour les aspects de pochoir et de profondeur
- Informations sur l'aube
Chrome 122
- Élargir la couverture avec le mode de compatibilité (fonctionnalité en développement)
- Augmenter la limite maximale de VertexAttributes
- Informations sur l'aube
Chrome 121
- Compatibilité avec WebGPU sur Android
- Utiliser DXC au lieu de FXC pour la compilation du nuanceur sous Windows
- Requêtes d'horodatage dans les passes de calcul et de rendu
- Points d'entrée par défaut des modules de nuanceurs
- Prise en charge de display-p3 en tant qu'espace colorimétrique GPUExternalTexture
- Informations sur les tas de mémoire
- Informations sur l'aube
Chrome 120
- Compatibilité avec les valeurs à virgule flottante 16 bits dans WGSL
- Repoussez les limites
- Modifications apportées à l'état de profondeur au stencil
- Mises à jour des informations sur l'adaptateur
- Quantification des requêtes d'horodatage
- Fonctionnalités de nettoyage de printemps
Chrome 119
- Textures de float 32 bits filtrables
- Format de sommet unorm10-10-10-2
- rgb10a2uint format de texture
- Informations sur l'aube
Chrome 118
- Compatibilité avec HTMLImageElement et ImageData dans
copyExternalImageToTexture()
- Compatibilité expérimentale avec les textures de stockage en lecture/écriture et en lecture seule
- Informations sur l'aube
Chrome 117
- Tampon de sommets non défini
- Désactiver le groupe de liaisons
- Couper le son des erreurs liées à la création d'un pipeline asynchrone en cas de perte de l'appareil
- Modifications apportées à la création du module de nuanceur SPIR-V
- Améliorer l'expérience des développeurs
- Mettre en cache des pipelines avec une mise en page générée automatiquement
- Informations sur l'aube
Chrome 116
- Intégration de WebCodecs
- Appareil perdu renvoyé par GPUAdapter
requestDevice()
- Maintenir la lecture vidéo fluide si
importExternalTexture()
est appelé - Conformité des spécifications
- Améliorer l'expérience des développeurs
- Informations sur l'aube
Chrome 115
- Extensions de langage WGSL compatibles
- Compatibilité expérimentale avec Direct3D 11
- Utiliser un GPU distinct par défaut sur secteur
- Améliorer l'expérience des développeurs
- Informations sur l'aube
Chrome 114
- Optimiser JavaScript
- getCurrentTexture() sur un canevas non configuré génère InvalidStateError
- Informations concernant WGSL
- Informations sur l'aube