@daugasauron/dolly-host-gpu 0.1.4 → 0.1.5-rc.0

package/abi.mjs

@@ -47,4 +47,4 @@ export const DOLLY_GPU_END_RENDER_PASS = 24;
 export const DOLLY_GPU_DRAW_MESH = 25;
 export const DOLLY_GPU_VIEWPORT = 26;
 export const DOLLY_ERRNO = Object.freeze({ E2BIG: 1, EACCES: 2, EADDRINUSE: 3, EADDRNOTAVAIL: 4, EAFNOSUPPORT: 5, EAGAIN: 6, EALREADY: 7, EBADF: 8, EBADMSG: 9, EBUSY: 10, ECANCELED: 11, ECHILD: 12, ECONNABORTED: 13, ECONNREFUSED: 14, ECONNRESET: 15, EDEADLK: 16, EDESTADDRREQ: 17, EDOM: 18, EDQUOT: 19, EEXIST: 20, EFAULT: 21, EFBIG: 22, EHOSTUNREACH: 23, EIDRM: 24, EILSEQ: 25, EINPROGRESS: 26, EINTR: 27, EINVAL: 28, EIO: 29, EISCONN: 30, EISDIR: 31, ELOOP: 32, EMFILE: 33, EMLINK: 34, EMSGSIZE: 35, EMULTIHOP: 36, ENAMETOOLONG: 37, ENETDOWN: 38, ENETRESET: 39, ENETUNREACH: 40, ENFILE: 41, ENOBUFS: 42, ENODEV: 43, ENOENT: 44, ENOEXEC: 45, ENOLCK: 46, ENOLINK: 47, ENOMEM: 48, ENOMSG: 49, ENOPROTOOPT: 50, ENOSPC: 51, ENOSYS: 52, ENOTCONN: 53, ENOTDIR: 54, ENOTEMPTY: 55, ENOTRECOVERABLE: 56, ENOTSOCK: 57, ENOTTY: 59, ENXIO: 60, EOVERFLOW: 61, EOWNERDEAD: 62, EPERM: 63, EPIPE: 64, EPROTO: 65, EPROTONOSUPPORT: 66, EPROTOTYPE: 67, ERANGE: 68, EROFS: 69, ESPIPE: 70, ESRCH: 71, ESTALE: 72, ETIMEDOUT: 73, ETXTBSY: 74, EXDEV: 75, ENODATA: 116, ENOTSUP: 138 });
-export const DOLLY_GPU_ABI_DIGEST = "c947036666d5532b78179512c852d1fd58a143e067ca8c947055072ac7fc104a";
+export const DOLLY_GPU_ABI_DIGEST = "f2798b5850f46ad4287cdfd82fe36970af78c5184acd6cbefdded38f49444259";

package/gpu.mjs

@@ -37,11 +37,12 @@ function announce({ indicators }, element, state, borderColor) {
 function indicate(page, info, unavailable) {
   let element = document.querySelector("#gpu-status");
   if (!element) {
-    element = document.body.appendChild(document.createElement("div"));
+    // In Dolly's element; a display-less embedding has none, and the indicator shows nowhere.
+    element = (page.mount ?? document.createElement("div")).appendChild(document.createElement("div"));
     element.id = "gpu-status";
     element.className = "page-indicator";
     element.setAttribute("role", "status");
-    element.style.cssText = "position:fixed;right:0.5rem;bottom:2rem;z-index:8;max-width:calc(100vw - 1rem);" +
+    element.style.cssText = "position:absolute;right:0.5rem;bottom:2rem;z-index:8;max-width:calc(100% - 1rem);" +
       "padding:0.15rem 0.45rem;background:#262626;border:1px solid;font-size:13px;pointer-events:none";
   }
   if (unavailable) {
@@ -78,7 +79,6 @@ export function browser(page) {
   let status = {};
   return {
     configuration: { canvas: surface }, transfers: surface ? [surface] : [],
-    get status() { return status; },
     page: { get gpu() { return status; } },
     get surfaceSize() { return status.active ? { width: status.width, height: status.height } : undefined; },
     // The provider reports the adapter of each device it creates, or why it has none.

package/package.json

@@ -1,10 +1,10 @@
 {
-  "version": "0.1.4",
+  "version": "0.1.5-rc.0",
   "type": "module",
   "name": "@daugasauron/dolly-host-gpu",
   "license": "MIT",
   "dependencies": {
-    "@daugasauron/dolly": "0.1.4"
+    "@daugasauron/dolly": "0.1.5-rc.0"
   },
   "description": "Dolly's gpu@0 host module: WebGPU on the browser's adapter, over the display.",
   "repository": {

package/worker.mjs

@@ -21,6 +21,28 @@ const maxBytes = 4 * 1024 ** 3, bufferCeiling = 1024 ** 3, maxObjects = 4096;
 const queueFull = scope => scope.surface && scope.frames.length >= 3 ? scope.frames[0]
   : scope.submissions.length >= 64 ? scope.submissions[0] : null;
 const timestampQueries = A.DOLLY_GPU_MAX_COMMANDS * 2;
+// A batch record's byte length: exact for one of fixed layout, the least for
+// one with a variable tail, which records() checks.
+const fixedRecordBytes = new Map([[A.DOLLY_GPU_CREATE_BUFFER, 32], [A.DOLLY_GPU_RENDER, 64],
+  [A.DOLLY_GPU_COMPUTE, 40], [A.DOLLY_GPU_COPY_BUFFER, 48], [A.DOLLY_GPU_MAP_READ, 32], [A.DOLLY_GPU_UNMAP, 16],
+  [A.DOLLY_GPU_RELEASE, 16], [A.DOLLY_GPU_SUBMIT, 8], [A.DOLLY_GPU_RENDER_VERTEX, 88],
+  [A.DOLLY_GPU_CAPTURE_FRAME, 32], [A.DOLLY_GPU_CREATE_TEXTURE, 48], [A.DOLLY_GPU_CREATE_SAMPLER, 48],
+  [A.DOLLY_GPU_BEGIN_RENDER_PASS, 64], [A.DOLLY_GPU_END_RENDER_PASS, 8], [A.DOLLY_GPU_VIEWPORT, 48]]);
+const leastRecordBytes = new Map([[A.DOLLY_GPU_WRITE_BUFFER, 32], [A.DOLLY_GPU_CREATE_SHADER, 24],
+  [A.DOLLY_GPU_RENDER_PIPELINE, 40], [A.DOLLY_GPU_COMPUTE_PIPELINE, 32], [A.DOLLY_GPU_BIND_GROUP, 32],
+  [A.DOLLY_GPU_VERTEX_PIPELINE, 48], [A.DOLLY_GPU_COMPUTE_CONSTANTS, 32], [A.DOLLY_GPU_WRITE_TEXTURE, 48],
+  [A.DOLLY_GPU_GRAPHICS_PIPELINE, 112], [A.DOLLY_GPU_RESOURCE_GROUP, 32], [A.DOLLY_GPU_DRAW_MESH, 80]]);
+// The records a render pass may hold, between BEGIN_RENDER_PASS and END_RENDER_PASS.
+const renderPassRecords = new Set([A.DOLLY_GPU_CREATE_BUFFER, A.DOLLY_GPU_WRITE_BUFFER, A.DOLLY_GPU_CREATE_SHADER,
+  A.DOLLY_GPU_CREATE_TEXTURE, A.DOLLY_GPU_CREATE_SAMPLER, A.DOLLY_GPU_GRAPHICS_PIPELINE, A.DOLLY_GPU_RESOURCE_GROUP,
+  A.DOLLY_GPU_END_RENDER_PASS, A.DOLLY_GPU_DRAW_MESH, A.DOLLY_GPU_VIEWPORT]);
+// The records that create an object, charged to the scope's object quota before they run.
+const creatingRecords = new Set([A.DOLLY_GPU_CREATE_BUFFER, A.DOLLY_GPU_CREATE_SHADER, A.DOLLY_GPU_RENDER_PIPELINE,
+  A.DOLLY_GPU_COMPUTE_PIPELINE, A.DOLLY_GPU_BIND_GROUP, A.DOLLY_GPU_VERTEX_PIPELINE, A.DOLLY_GPU_COMPUTE_CONSTANTS,
+  A.DOLLY_GPU_CREATE_TEXTURE, A.DOLLY_GPU_CREATE_SAMPLER, A.DOLLY_GPU_GRAPHICS_PIPELINE, A.DOLLY_GPU_RESOURCE_GROUP]);
+// A request's byte length, header included; BATCH's is its records'.
+const requestBytes = new Map([[A.DOLLY_GPU_OPEN, 40], [A.DOLLY_GPU_WAIT, 32], [A.DOLLY_GPU_READ, 56],
+  [A.DOLLY_GPU_CLOSE, 32], [A.DOLLY_GPU_INFO, 32], [A.DOLLY_GPU_CAPABILITIES, 32]]);
 let maxBuffer = bufferCeiling, capabilities;
 const slots = Array(A.DOLLY_GPU_SLOTS).fill(null), generations = slots.map(() => 0);
 let heap, memory, mailbox, control, canvas, context, device, format;
@@ -95,7 +117,7 @@ function header(bytes) {
   ensure(bytes.length >= 32, "Short GPU packet");
   const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const scope = integer(v, 8), sequence = integer(v, 16);
-  ensure(v.getUint32(0, true) === 0 && v.getUint32(28, true) === 0 &&
+  ensure(v.getUint32(0, true) === A.DOLLY_GPU_VERSION && v.getUint32(28, true) === 0 &&
     v.getUint32(24, true) === bytes.length - 32 && scope > 0 && scope <= 0xffffffff &&
     sequence > 0 && sequence <= 0xffffffff, "Invalid GPU header");
   return { op: v.getUint32(4, true), scope, sequence, index: (scope - 1) % slots.length, bytes, v };
@@ -117,24 +139,20 @@ function records(request) {
     const opcode = v.getUint32(offset, true), size = v.getUint32(offset + 4, true);
     ensure(size >= 8 && size % 8 === 0 && size <= bytes.length - offset, "Invalid GPU command length");
     const b = bytes.subarray(offset, offset + size), w = new DataView(b.buffer, b.byteOffset, b.byteLength);
-    const fixed = { 1: 32, 7: 64, 8: 40, 9: 48, 10: 32, 11: 16, 12: 16, 13: 8, 15: 88, 17: 32, 18: 48, 20: 48, 23: 64, 24: 8, 26: 48 }[opcode];
-    if (fixed) ensure(size === fixed, "Wrong GPU command layout");
-    else {
-      const minimum = { 2: 32, 3: 24, 4: 40, 5: 32, 6: 32, 14: 48, 16: 32, 19: 48, 21: 112, 22: 32, 25: 80 }[opcode];
-      ensure(minimum && size >= minimum, "Unsupported GPU command", E.ENOTSUP);
-    }
+    if (fixedRecordBytes.has(opcode)) ensure(size === fixedRecordBytes.get(opcode), "Wrong GPU command layout");
+    else ensure(leastRecordBytes.has(opcode) && size >= leastRecordBytes.get(opcode), "Unsupported GPU command", E.ENOTSUP);
     // Validate every variable-length span before any command has side effects.
-    if (opcode === 2) {
+    if (opcode === A.DOLLY_GPU_WRITE_BUFFER) {
       const at = w.getUint32(24, true), n = w.getUint32(28, true);
       ensure(at >= 32 && at <= size - n && n % 4 === 0, "Invalid GPU upload span");
-    } else if (opcode === 3) {
+    } else if (opcode === A.DOLLY_GPU_CREATE_SHADER) {
       ensure(w.getUint32(20, true) === 0, "Shader reserved field");
       text(b, 24, w.getUint32(16, true));
-    } else if (opcode === 4 || opcode === 14) {
+    } else if (opcode === A.DOLLY_GPU_RENDER_PIPELINE || opcode === A.DOLLY_GPU_VERTEX_PIPELINE) {
       const vs = w.getUint32(32, true), fs = w.getUint32(36, true);
       ensure(vs <= 64 && fs <= 64, "GPU entry name too long");
       let at = 40;
-      if (opcode === 14) {
+      if (opcode === A.DOLLY_GPU_VERTEX_PIPELINE) {
         const count = w.getUint32(44, true), stride = w.getUint32(40, true);
         ensure(count > 0 && count <= 8 && stride > 0 && stride <= 2048 && stride % 4 === 0 && size >= 48 + count * 16, "Vertex layout");
         const locations = new Set();
@@ -146,10 +164,10 @@ function records(request) {
         at = 48 + count * 16;
       }
       text(b, at, vs); text(b, at + vs, fs);
-    } else if (opcode === 5) {
+    } else if (opcode === A.DOLLY_GPU_COMPUTE_PIPELINE) {
       ensure(w.getUint32(28, true) === 0 && w.getUint32(24, true) <= 64, "Compute entry name");
       text(b, 32, w.getUint32(24, true));
-    } else if (opcode === 16) {
+    } else if (opcode === A.DOLLY_GPU_COMPUTE_CONSTANTS) {
       const entryBytes = w.getUint32(24,true), count = w.getUint32(28,true);
       ensure(entryBytes <= 64 && count <= 16, "Compute constants layout");
       text(b,32,entryBytes);
@@ -164,7 +182,7 @@ function records(request) {
         at=(at+16+n+7)&~7;
       }
       ensure(at===size,"Trailing compute constant bytes");
-    } else if (opcode === 6) {
+    } else if (opcode === A.DOLLY_GPU_BIND_GROUP) {
       const n = w.getUint32(24, true);
       ensure(n <= A.DOLLY_GPU_MAX_BINDINGS && size === 32 + n * 24 && w.getUint32(28, true) === 0, "Bind group layout");
     }
@@ -288,13 +306,12 @@ async function batch(scope, commands) {
     for (const { opcode: op, b, w } of commands) {
       const id = b.length >= 16 && op !== A.DOLLY_GPU_VIEWPORT ? integer(w, 8) : 0;
       if (op !== A.DOLLY_GPU_COMPUTE) endCompute();
-      if (renderPass) ensure([1,2,3,18,20,21,22,24,25,26].includes(op), "Command is invalid inside a render pass");
-      if ([1,3,4,5,6,14,16,18,20,21,22].includes(op)) ensure(id > scope.high && id <= 0xffffffff && scope.objects.size + scope.retired.size < maxObjects, "GPU object quota", E.ENOSPC);
+      if (renderPass) ensure(renderPassRecords.has(op), "Command is invalid inside a render pass");
+      if (creatingRecords.has(op)) ensure(id > scope.high && id <= 0xffffffff && scope.objects.size + scope.retired.size < maxObjects, "GPU object quota", E.ENOSPC);
       if (op === A.DOLLY_GPU_CREATE_BUFFER) {
         const size = integer(w, 16), usage = w.getUint32(24, true);
         ensure(size > 0 && size <= maxBuffer && size <= maxBytes - usedBytes, "GPU allocation quota", E.ENOMEM);
         ensure(w.getUint32(28, true) === 0 && usage > 0 && (usage & ~1023) === 0, "Buffer usage");
-        ensure(id > scope.high && scope.objects.size + scope.retired.size < maxObjects, "GPU resource quota", E.ENOSPC);
         const buffer = device.createBuffer({ size, usage });
         insert(scope, id, "buffer", buffer, size); usedBytes += size;
       } else if (op === A.DOLLY_GPU_WRITE_BUFFER) {
@@ -686,11 +703,11 @@ self.onmessage = event => {
     } else {
       ensure(Number.isSafeInteger(address)&&Number.isSafeInteger(size)&&address>0&&size>=32&&size<=A.DOLLY_GPU_PACKET_BYTES&&address<=memory.byteLength-size,"Invalid GPU request span",E.EFAULT);
       const request=header(new Uint8Array(memory,address,size).slice());
-      ensure(request.op>=1&&request.op<=7,"Unknown GPU operation",E.ENOTSUP);
-      ensure((request.op!==1||size===40)&&(![3,5,6,7].includes(request.op)||size===32)&&(request.op!==4||size===56),"GPU operation layout");
-      const parsed=request.op===2?records(request):null;
+      ensure(request.op>=A.DOLLY_GPU_OPEN&&request.op<=A.DOLLY_GPU_CAPABILITIES,"Unknown GPU operation",E.ENOTSUP);
+      ensure(!requestBytes.has(request.op)||requestBytes.get(request.op)===size,"GPU operation layout");
+      const parsed=request.op===A.DOLLY_GPU_BATCH?records(request):null;
       let scope=slots[request.index];
-      if(request.op===1) {
+      if(request.op===A.DOLLY_GPU_OPEN) {
         ensure(!scope&&request.scope>generations[request.index],"GPU scope slot is busy",E.EBUSY);
         scope={id:request.scope,index:request.index,sequence:0,objects:new Map(),retired:new Map(),high:0,submissions:[],frames:[],lost:false,surface:false};
         generations[request.index]=scope.id;slots[request.index]=scope;