Supporto di WebGPU su Android
Il team di Chrome è lieto di annunciare che WebGPU è ora abilitata per impostazione predefinita in Chrome 121 sui dispositivi con Android 12 e versioni successive con GPU Qualcomm e ARM.
Il supporto verrà esteso gradualmente a una gamma più ampia di dispositivi Android, inclusi quelli con Android 11 nel prossimo futuro. Questo ampliamento dipenderà da ulteriori test e ottimizzazioni per garantire un'esperienza uniforme in una gamma più ampia di configurazioni hardware. Vedi issue chromium:1497815.
Utilizzare DXC anziché FXC per la compilazione degli shader su Windows
Ora Chrome utilizza la potenza di DXC (DirectX Compiler) per compilare gli shader su macchine Windows D3D12 dotate di hardware grafico SM6+. In precedenza, WebGPU si basava su FXC (FX Compiler) per la compilazione degli shader su Windows. Sebbene fosse funzionale, FXC non disponeva del set di funzionalità e delle ottimizzazioni del rendimento presenti in DXC.
I test iniziali mostrano un aumento medio del 20% della velocità di compilazione degli shader di calcolo quando si utilizza DXC rispetto a FXC.
Query sui timestamp nei passaggi di calcolo e di rendering
Le query timestamp consentono alle applicazioni WebGPU di misurare con precisione (fino al nanosecondo) il tempo necessario ai comandi GPU per eseguire i passaggi di calcolo e rendering. Vengono ampiamente utilizzati per ottenere informazioni sul rendimento e sul comportamento dei carichi di lavoro GPU.
Quando la funzionalità "timestamp-query"
è disponibile in un GPUAdapter
, ora puoi eseguire le seguenti operazioni:
- Richiedi un
GPUDevice
con la funzionalità"timestamp-query"
. - Crea un
GPUQuerySet
di tipo"timestamp"
. - Utilizza
GPUComputePassDescriptor.timestampWrites
eGPURenderPassDescriptor.timestampWrites
per definire dove scrivere i valori timestamp inGPUQuerySet
. - Risolvi i valori timestamp in un
GPUBuffer
conresolveQuerySet()
. - Leggi i valori del timestamp copiando i risultati da
GPUBuffer
alla CPU. - Decodifica i valori del timestamp come
BigInt64Array
.
Vedi l'esempio seguente e il problema alba: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();
A causa di problemi di attacchi di temporizzazione, le query sui timestamp vengono quantizzate con una risoluzione di 100 microsecondi, il che offre un buon compromesso tra precisione e sicurezza. Nel browser Chrome, puoi disattivare la quantizzazione dei timestamp attivando il flag "Funzionalità per sviluppatori WebGPU" all'indirizzo chrome://flags/#enable-webgpu-developer-features
durante lo sviluppo dell'app. Per scoprire di più, consulta Quantizzazione delle query con timestamp.
Poiché di tanto in tanto le GPU possono reimpostare il contatore dei timestamp, il che può generare valori imprevisti, come delta negativi tra i timestamp, ti consiglio di controllare le modifiche delle differenze git che aggiungono il supporto delle query timestamp al seguente esempio di boid Compute.
Punti di ingresso predefiniti ai moduli Shar
Per migliorare l'esperienza dello sviluppatore, ora puoi omettere entryPoint
del modulo shader quando crei una pipeline di calcolo o di rendering. Se nel codice shader non viene trovato un punto di ingresso univoco per la fase dello shader, verrà attivato un GPUValidationError. Vedi l'esempio seguente e issue 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 }] },
});
Supporta display-p3 come spazio colore GPUExternalTexture
Ora puoi impostare lo spazio colore di destinazione "display-p3"
quando importi un GPUExternalTexture da video HDR con importExternalTexture()
. Scopri in che modo WebGPU gestisce gli spazi colore. Guarda l'esempio che segue e verifica il problema con chromium:1330250.
// Create texture from HDR video.
const video = document.querySelector("video");
const texture = myDevice.importExternalTexture({
source: video,
colorSpace: "display-p3",
});
Informazioni sugli heap di memoria
Per aiutarti ad anticipare le limitazioni di memoria durante l'allocazione di grandi quantità durante lo sviluppo dell'app, requestAdapterInfo()
ora espone informazioni memoryHeaps
come le dimensioni e il tipo di heap di memoria disponibili sull'adattatore. Questa funzionalità sperimentale è accessibile solo se il flag "Funzionalità per sviluppatori WebGPU" in chrome://flags/#enable-webgpu-developer-features
è attivato. Vedi l'esempio seguente e issue 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) { /* ... */ }
}
Aggiornamenti di Dawn
I metodi HasWGSLLanguageFeature
e EnumerateWGSLLanguageFeatures
in wgpu::Instance
sono stati aggiunti per gestire le funzionalità linguistiche WGSL. Vedi il problema dawn:2260.
La funzionalità non standard wgpu::Feature::BufferMapExtendedUsages
ti consente di creare un buffer della GPU con wgpu::BufferUsage::MapRead
o wgpu::BufferUsage::MapWrite
e qualsiasi altro wgpu::BufferUsage
. Vedi l'esempio seguente e riscontri il problema 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);
Sono state documentate le seguenti funzionalità: Condivisione delle texture ANGLE, D3D11 multithread protetto, Sincronizzazione implicita del dispositivo, Formati delle texture Norm16, Query timestamp all'interno dei passaggi, Memoria locale di Pixel, Funzionalità shader e Formati multiplanari.
Il team di Chrome ha creato un repository GitHub ufficiale per Dawn.
Sono riportati solo alcuni punti salienti. Consulta l'elenco completo dei commit.
Novità di WebGPU
Un elenco di tutto ciò che è stato trattato nella serie Novità di WebGPU.
Chrome 130
- Combinazione di due sorgenti
- Miglioramenti ai tempi di compilazione degli shader su Metal
- Ritiro di GPUAdapter requestAdapterInfo()
- Aggiornamenti di Dawn
Chrome 129
- Supporto HDR con la modalità di mappatura dei toni della tela
- Supporto dei sottogruppi ampliato
- Aggiornamenti di Dawn
Chrome 128
- Esperimenti con i sottogruppi
- Ritiro dell'impostazione della bias di profondità per linee e punti
- Nascondere l'avviso DevTools relativo a un errore non rilevato se preventDefault
- WGSL esegue prima l'interpolazione del campionamento e poi
- Aggiornamenti sull'alba
Chrome 127
- Supporto sperimentale per OpenGL ES su Android
- Attributo info di GPUAdapter
- Miglioramenti all'interoperabilità di WebAssembly
- Miglioramento degli errori del codificatore di comandi
- Aggiornamenti sull'alba
Chrome 126
- Aumentare il limite di maxTextureArrayLayers
- Ottimizzazione del caricamento del buffer per il backend Vulkan
- Miglioramenti ai tempi di compilazione degli shader
- Gli spazi dei comandi inviati devono essere univoci
- Aggiornamenti di Dawn
Chrome 125
- Sottogruppi (funzionalità in fase di sviluppo)
- Esegui il rendering su una porzione della texture 3D
- Aggiornamenti sull'alba
Chrome 124
- Texture di archiviazione di sola lettura e di lettura e scrittura
- Supporto di worker di servizio e worker condivisi
- Nuovi attributi relativi alle informazioni sull'adattatore
- Correzioni di bug
- Aggiornamenti sull'alba
Chrome 123
- Supporto delle funzioni integrate DP4a in WGSL
- Parametri del cursore non soggetti a limitazioni in WGSL
- Sintassi alternativa per il dereferenziamento dei compositi in WGSL
- Stato di sola lettura separato per gli aspetti di stencil e profondità
- Aggiornamenti di Dawn
Chrome 122
- Ampliare la copertura con la modalità di compatibilità (funzionalità in fase di sviluppo)
- Aumentare il limite di maxVertexAttributes
- Aggiornamenti sull'alba
Chrome 121
- Supporto di WebGPU su Android
- Usa DXC al posto di FXC per la compilazione dello shaker su Windows
- Query sui timestamp nei passaggi di calcolo e rendering
- Punti di contatto predefiniti per i moduli shader
- Supporto di display-p3 come spazio colore GPUExternalTexture
- Informazioni sugli heap di memoria
- Aggiornamenti di Dawn
Chrome 120
- Supporto dei valori in virgola mobile a 16 bit in WGSL
- Spingere i limiti al massimo
- Modifiche allo stato della maschera di profondità
- Aggiornamenti delle informazioni sull'adattatore
- Quantizzazione delle query con timestamp
- Funzionalità per le pulizie di primavera
Chrome 119
- Texture con formato a virgola mobile 32 bit filtrabili
- Formato vertice unorm10-10-10-2
- Formato texture rgb10a2uint
- Aggiornamenti di Dawn
Chrome 118
- Supporto di HTMLImageElement e ImageData in
copyExternalImageToTexture()
- Supporto sperimentale per la texture di archiviazione in lettura/scrittura e sola lettura
- Aggiornamenti di Dawn
Chrome 117
- Buffer di vertici non impostato
- Reimpostare il gruppo di associazione
- Ignorare gli errori della creazione della pipeline asincrona quando il dispositivo viene smarrito
- Aggiornamenti sulla creazione di moduli shader SPIR-V
- Miglioramento dell'esperienza degli sviluppatori
- Pipeline di memorizzazione nella cache con layout generato automaticamente
- Aggiornamenti sull'alba
Chrome 116
- Integrazione di WebCodec
- Dispositivo smarrito restituito da GPUAdapter
requestDevice()
- Mantenere la riproduzione video fluida se viene chiamato
importExternalTexture()
- Conformità alle specifiche
- Miglioramento dell'esperienza degli sviluppatori
- Aggiornamenti sull'alba
Chrome 115
- Estensioni di lingua WGSL supportate
- Supporto sperimentale per Direct3D 11
- Ottenere una GPU discreta per impostazione predefinita con alimentazione CA
- Miglioramento dell'esperienza degli sviluppatori
- Aggiornamenti di Dawn
Chrome 114
- Ottimizzare JavaScript
- getCurrentTexture() su canvas non configurato genera un errore InvalidStateError
- Aggiornamenti WGSL
- Aggiornamenti di Dawn