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.
L'assistenza verrà estesa gradualmente a una gamma più ampia di dispositivi Android, inclusi quelli con Android 11. Questa espansione dipenderà da ulteriori test e ottimizzazioni per garantire un'esperienza senza interruzioni su una gamma più ampia di configurazioni hardware. Vedi issue chromium:1497815.
Usa DXC invece di FXC per la compilazione dello Shadr su Windows
Chrome ora sfrutta la potenza di DXC (compilatore DirectX) per compilare i Shader su computer Windows D3D12 dotati di hardware grafico SM6+. In precedenza, WebGPU si affidava a FXC (FX Compiler) per la compilazione shabbyr su Windows. Sebbene fosse funzionale, FXC non disponeva del set di funzionalità e delle ottimizzazioni delle prestazioni presenti in DXC.
I test iniziali mostrano un aumento medio del 20% della velocità di compilazione dello Shadr di calcolo con DXC rispetto a FXC.
Query di timestamp nelle tessere di computing e rendering
Le query con timestamp consentono alle applicazioni WebGPU di misurare con precisione (fino al nanosecondo) il tempo impiegato dai comandi della GPU per eseguire le operazioni di calcolo e rendering. Sono molto utilizzati per ottenere insight sulle prestazioni e sul comportamento dei carichi di lavoro della GPU.
Quando la funzionalità "timestamp-query"
è disponibile in GPUAdapter
, ora puoi fare quanto segue:
- 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 dei timestamp inGPUQuerySet
. - Risolvi i valori del timestamp in un
GPUBuffer
conresolveQuerySet()
. - Per rileggere i valori timestamp, copia i risultati da
GPUBuffer
alla CPU. - Decodifica i valori del timestamp come
BigInt64Array
.
Vedi l'esempio seguente e pubblica il problema 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();
A causa di problemi di attacco a tempo, le query dei timestamp sono quantificate con una risoluzione di 100 microsecondi, il che offre un buon compromesso tra precisione e sicurezza. Nel browser Chrome puoi disattivare la quantizzazione del 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 la sezione Quantizzazione delle query timestamp.
Poiché di tanto in tanto le GPU possono reimpostare il contatore di timestamp, il che può generare valori imprevisti, come delta negativi tra i timestamp, ti consiglio di controllare le modifiche alle differenze git che aggiungono il supporto delle query dei timestamp al seguente esempio di Compute Boids.
Punti di ingresso predefiniti ai moduli Shadr
Per migliorare l'esperienza degli sviluppatori, ora puoi omettere il campo entryPoint
del moduloshar durante la creazione di una pipeline di computing o rendering. Se nel codice dello smoother non viene trovato alcun punto di ingresso univoco per la fase dello Shadr, verrà attivato un errore 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 una GPUExternalTexture da video HDR con importExternalTexture()
. Scopri in che modo WebGPU gestisce gli spazi colore. Vedi l'esempio che segue e riporta il problema 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 i limiti di memoria quando assegni grandi quantità durante lo sviluppo dell'app, requestAdapterInfo()
ora espone le informazioni memoryHeaps
, ad esempio le dimensioni e il tipo di heap di memoria disponibili sull'adattatore. Questa funzionalità sperimentale è accessibile solo quando è attivo il flag "Funzionalità per sviluppatori WebGPU" all'indirizzo chrome://flags/#enable-webgpu-developer-features
. 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 da Dawn
I metodi HasWGSLLanguageFeature
e EnumerateWGSLLanguageFeatures
su wgpu::Instance
sono stati aggiunti per gestire le funzionalità in lingua WGSL. Vedi il problema dawn:2260.
La funzionalità wgpu::Feature::BufferMapExtendedUsages
non standard consente di creare un buffer GPU con wgpu::BufferUsage::MapRead
o wgpu::BufferUsage::MapWrite
e qualsiasi altro wgpu::BufferUsage
. Vedi l'esempio seguente e pubblica 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);
Le seguenti funzionalità sono state documentate: Condivisione della trama ANGLE, Protezione multi-thread D3D11, Sincronizzazione implicita dei dispositivi, Formati di texture Norm16, Timestamp Query Inside Pass, Spazio di archiviazione locale di Pixel, Funzionalità Shader e Formati multiplanari.
Il team di Chrome ha creato un repository GitHub ufficiale per Dawn.
Vengono trattati solo alcuni dei punti salienti. Consulta l'elenco completo dei commit.
Novità di WebGPU
Un elenco di tutti gli argomenti trattati nella serie Novità di WebGPU.
Chrome 125
- Sottogruppi (funzionalità in fase di sviluppo)
- Eseguire il rendering su una fetta di texture 3D
- Aggiornamenti dell'alba
Chrome 124
- Texture di archiviazione di sola lettura e lettura/scrittura
- Assistenza per i Service worker e i worker condivisi
- Nuovi attributi delle informazioni sull'adattatore
- Correzioni di bug
- Aggiornamenti dell'alba
Chrome 123
- Supporto delle funzioni integrate DP4a in WGSL
- Parametri puntatore senza limitazioni in WGSL
- zucchero della sintassi per dereferenziare i compositi in WGSL
- Stato di sola lettura separato per aspetti stencil e di profondità
- Aggiornamenti dell'alba
Chrome 122
- Espandi la copertura con la modalità di compatibilità (funzionalità in fase di sviluppo)
- Aumenta il limite maxVertexAttributes
- Aggiornamenti dell'alba
Guida introduttiva di Chrome
- Supporto di WebGPU su Android
- Usare DXC anziché FXC per la compilazione dello Shader su Windows
- Query di timestamp nelle tessere di calcolo e rendering
- Punti di contatto predefiniti per i moduli Shadr
- Supporto display-p3 come spazio colore GPUExternalTexture
- Informazioni sui heap di memoria
- Aggiornamenti dell'alba
Chrome 120
- Supporto per valori in virgola mobile a 16 bit in WGSL
- Supera i limiti
- Modifiche allo stato dello stencil di profondità
- Aggiornamenti alle informazioni sull'alimentatore
- Quantizzazione delle query dei timestamp
- Funzionalità per le pulizie di primavera
Chrome 119
- Trame fluttuanti a 32 bit filtrabili
- formato unorm10-10-10-2 vertex
- Formato trama Memcache10a2uint
- Aggiornamenti dell'alba
Chrome 118
- Supporto di HTMLImageElement e ImageData in
copyExternalImageToTexture()
- Supporto sperimentale per la texture di archiviazione in lettura/scrittura e in sola lettura
- Aggiornamenti dell'alba
Chrome 117
- Impostazione del buffer del vertex non impostata
- Annulla impostazione gruppo di associazione
- Silenziare gli errori della creazione di pipeline asincrone in caso di perdita del dispositivo
- Aggiornamenti alla creazione del modulo shabby di SPIR-V
- Migliorare l'esperienza degli sviluppatori
- Memorizzazione nella cache delle pipeline con il layout generato automaticamente
- Aggiornamenti dell'alba
Chrome 116
- Integrazione di WebCodecs
- Dispositivo smarrito restituito da GPUAdapter
requestDevice()
- Mantieni la riproduzione video fluida se viene chiamato
importExternalTexture()
- Conformità alle specifiche
- Migliorare l'esperienza degli sviluppatori
- Aggiornamenti dell'alba
Versione 115 di Chrome
- Estensioni in lingua WGSL supportate
- Supporto sperimentale per Direct3D 11
- Ricevi una GPU discreta per impostazione predefinita tramite alimentazione CA
- Migliorare l'esperienza degli sviluppatori
- Aggiornamenti dell'alba
Chrome 114
- Ottimizzare JavaScript
- getCurrentTexture() su canvas non configurati genera InvalidStateError
- Aggiornamenti di WGSL
- Aggiornamenti dell'alba