GPUSupportedLimits — Schnittstelle · JavaScript-Referenz

Signatur

interface GPUSupportedLimits

Beschreibung

GPUSupportedLimits ist ein schreibgeschütztes Objekt der WebGPU API. Es enthält eine Reihe numerischer Eigenschaften, die angeben, wie weit die GPU-Ressourcen reichen, zum Beispiel maxTextureDimension2D, maxBufferSize, maxBindGroups oder maxComputeWorkgroupSizeX. Ein eigenes Objekt dieser Art legt man nie an. Man bekommt es über GPUAdapter.limits (was die Hardware maximal kann) oder über GPUDevice.limits (was für das erzeugte Gerät tatsächlich gilt).

Wichtig ist der Unterschied zwischen beiden Quellen: Ein GPUDevice erhält standardmäßig nur die Mindestgrenzen der Spezifikation, auch wenn der Adapter mehr kann. So verhalten sich Anwendungen auf allen Geräten gleich. Höhere Grenzen fordert man ausdrücklich über das Feld requiredLimits in GPUAdapter.requestDevice() an. Die Werte dürfen dabei höchstens so groß sein wie die entsprechenden Adapter-Grenzen.

Es gibt zwei Arten von Grenzen:

„max“-Grenzen (z. B. maxStorageBufferBindingSize): Ein höherer Wert ist besser.
„alignment“-Grenzen (z. B. minUniformBufferOffsetAlignment): Ein niedrigerer Wert ist besser. Sie sind immer Zweierpotenzen.

Typische Einsatzfälle sind die Wahl von Texturauflösungen, die Größe von Compute-Workgroups und die Aufteilung großer Datenpuffer abhängig von der Hardware.

Rückgabewert

Typ

GPUSupportedLimits

Beschreibung

Wird von GPUAdapter.limits und GPUDevice.limits geliefert. Alle Eigenschaften sind schreibgeschützte Zahlen (unsigned long bzw. unsigned long long), z. B. maxTextureDimension1D/2D/3D, maxTextureArrayLayers, maxBindGroups, maxBindingsPerBindGroup, maxUniformBufferBindingSize, maxStorageBufferBindingSize, minUniformBufferOffsetAlignment, minStorageBufferOffsetAlignment, maxVertexBuffers, maxVertexAttributes, maxBufferSize, maxColorAttachments, maxComputeWorkgroupStorageSize, maxComputeInvocationsPerWorkgroup, maxComputeWorkgroupSizeX/Y/Z und maxComputeWorkgroupsPerDimension.

Beispiele

Grenzen des Adapters auslesen

const adapter = await navigator.gpu?.requestAdapter();
if (!adapter) throw new Error('WebGPU wird nicht unterstützt');

const { limits } = adapter;
console.log('Max. 2D-Textur:', limits.maxTextureDimension2D);
console.log('Max. Puffergröße:', limits.maxBufferSize);
console.log('Max. Bind Groups:', limits.maxBindGroups);

Max. 2D-Textur: 16384 Max. Puffergröße: 4294967296 Max. Bind Groups: 4

Höhere Grenzen beim Erzeugen des Geräts anfordern

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

// Ohne requiredLimits bekommt das Gerät nur die Standardwerte (z. B. 128 MiB)
const wunsch = 1024 * 1024 * 1024; // 1 GiB
const device = await adapter.requestDevice({
  requiredLimits: {
    maxStorageBufferBindingSize: Math.min(wunsch, adapter.limits.maxStorageBufferBindingSize),
    maxBufferSize: Math.min(wunsch, adapter.limits.maxBufferSize)
  }
});

console.log('Gerät:', device.limits.maxStorageBufferBindingSize);

Gerät: 1073741824

Alle Grenzen als Tabelle ausgeben

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

const tabelle = {};
// Die Eigenschaften sind Getter auf dem Prototyp, daher for...in statt Object.keys
for (const name in adapter.limits) {
  tabelle[name] = { adapter: adapter.limits[name], geraet: device.limits[name] };
}
console.table(tabelle);

(Tabelle mit Adapter- und Gerätewert je Grenze)

Workgroup-Größe an die Hardware anpassen

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

const groesse = Math.min(256, device.limits.maxComputeWorkgroupSizeX,
  device.limits.maxComputeInvocationsPerWorkgroup);

const module = device.createShaderModule({
  code: `@compute @workgroup_size(${groesse})
  fn main(@builtin(global_invocation_id) id: vec3u) {}`
});
console.log('Workgroup-Größe:', groesse);

Workgroup-Größe: 256

// Wichtig · Fallstricke

Adapter und Gerät unterscheiden sich: device.limits enthält nur die Standardwerte, solange man keine requiredLimits übergibt. Wer die Adapter-Werte voraussetzt, ohne sie anzufordern, bekommt Validierungsfehler.
Fordert man in requiredLimits mehr an, als der Adapter kann, wird das Promise von requestDevice() mit einem OperationError abgelehnt. Unbekannte Namen führen ebenfalls zu einem Fehler. Deshalb mit Math.min() gegen adapter.limits begrenzen.
Die Eigenschaften sind Getter auf dem Prototyp. Object.keys() und JSON.stringify() liefern deshalb ein leeres Ergebnis. Zum Aufzählen for...in verwenden.
Datenschutz: Browser können die gemeldeten Werte auf feste Stufen runden, damit sich Nutzer schwerer über ihre Hardware wiedererkennen lassen (Fingerprinting). Man sollte sich also nicht auf exakte Hardwarewerte verlassen.
Kompatibilität: WebGPU gibt es nur in sicheren Kontexten und in modernen Browsern (Chromium 113+, Safari 26, Firefox 141 unter Windows). Vorher navigator.gpu prüfen. Neue Grenzen können dazukommen, zum Beispiel maxInterStageShaderVariables.

Siehe auch

GPUAdapter GPUDevice GPUAdapter.limits GPUDevice.limits GPUAdapter.requestDevice() GPUSupportedFeatures GPU.requestAdapter()