dcp-client 4.4.10-0 → 4.4.11-0

package/libexec/sandbox/lift-webgpu.js

@@ -63,218 +63,253 @@
  *  @date       May 2023
  */
 self.wrapScriptLoading({ scriptName: 'lift-webgpu' }, function liftWebGPU$$fn(protectedStorage, ring0PostMessage) {
-  if ((typeof navigator === 'undefined') || !('gpu' in navigator))
-    return;
-
-  const TimeInterval = protectedStorage.TimeInterval;
-  const globalTrackers = protectedStorage.bigBrother.globalTrackers;
-  const webGPUTimer = globalTrackers.webGPUIntervals;
-
-  /**
-   * Factories to create wrappers for all webGPU function (except submit & onSubmittedWorkDone) to time them when they
-   * are run, recording the duration of the function calls on the webGPU timer.
-   */
-  function webGPUAsyncTimingFactory(fn)
+  protectedStorage.webGPUInitialization = async function webGPUInitialization()
   {
-    return function promiseWebGPUWrapper(...args)
+    // dcp-native lazy-loading for webgpu.
+    if (typeof initWebGPU === 'function')
     {
-      const duration = new TimeInterval();
-      const original = fn.apply(this, args);
-      original.finally(() => webGPUTimer.push(duration.stop()));
-      return original;
+      const webgpuReady = await initWebGPU();
+      if (!webgpuReady)
+        return;
     }
-  }
 
-  function webGPUSyncTimingFactory(fn)
-  {
-    return function syncWebGPUWrapper(...args)
+    if ((typeof navigator === 'undefined') || !('gpu' in navigator))
+      return;
+
+
+    const submitDescriptor    = Object.getOwnPropertyDescriptor(GPUQueue.prototype, 'submit');
+    const navigatorDescriptor = Object.getOwnPropertyDescriptor(globalThis,         'navigator');
+    const GPUDescriptor       = Object.getOwnPropertyDescriptor(globalThis,         'GPU');
+
+    // Fatal: globalThis.navigator OR globalThis.GPU are non-writable/configurable. This would prevent these scripts from being able
+    // to block access to webgpu for jobs that do not explicitly require it - allowing jobs to bypass scheduling decisions based
+    // on gpu availability must crash the sandbox, may want to stop the worker as well
+    if (!((GPUDescriptor.writable || GPUDescriptor.configurable )
+         && (navigatorDescriptor.writable || navigatorDescriptor.configurable)))
     {
-      const duration = new TimeInterval();
-      const ret = fn.apply(this, args);
-      webGPUTimer.push(duration.stop());
-      return ret;
+      postMessage({ request: 'unrecoverable-evaluator', message: 'webgpu exists but is not wrapable' });
+      close();
     }
-  }
 
-  /**
-   * Wrap various webGPU functions such that their usage will be tracked
-   *
-   */
-  function liftWebGPUPrototype(GPUClass)
-  {
-    // the standard dictates these functions will return promises
-    const promiseReturningFunctions = new Set([
-      'requestDevice',
-      'requestAdapterInfo',
-      'createComputePipelineAsync',
-      'createRenderPipelineAsync',
-      'mapAsync', // this would overestimate in some cases, a potential discussion
-      'getCompilationInfo',
-      'onSubmittedWorkDone',
-      'popErrorScope',
-      'requestAdapter',
-    ]);
-
-    // TODO: consider what to do with 'destroy'
-    // while they appear to be blocking, the meat of the work happens on the gpu driver thread
-    const blockingFunctions = new Set([
-      // GPU
-      'getPreferedCanvasFormat',
-
-      // GPUDevice
-      'createBuffer',
-      'createTexture',
-      'createSampler',
-      'importExternalTexture',
-      'createBindGroupLayout',
-      'createPipelineLayout',
-      'createBindGroup',
-      'createShaderModule',
-      'createComputePipeline',
-      'createRenderPipeline',
-      'createCommandEncoder',
-      'createRenderBundleEncoder',
-      'createQuerySet',
-
-      // GPUBuffer 
-      'getMappedRange',
-      'unmap',
-
-      // GPUTexture
-      'createView',
-
-      // GPUPipelineBase 
-      'getBindGroupLayout',
-
-      // GPUDebugCommandsMixin 
-      'pushDebugGroup',
-      'popDebugGroup',
-      'insertDebugWorker',
-
-      // GPUCommandEncoder
-      'beginRenderPass',
-      'beginComputePass',
-      'copyBufferToBuffer',
-      'copyBufferToTexture',
-      'copyTextureToBuffer',
-      'copyTextureToTexture',
-      'clearBuffer',
-      'writeTimestamp',
-      'resolveQuerySet',
-      'finish',
-
-      // GPUBindingsCommandMixin
-      'setBindGroup',
-
-      // GPUComputePassEncoder
-      'setPipeline',
-      'dispatchWorkgroups',
-      'dispatchWorkgroupsIndirect',
-      'end',
-
-      // GPURenderPassEncoder
-      'setViewPort',
-      'setScissorRect',
-      'setBlendConstant',
-      'setStencilReference',
-      'beginOcclusionQuery',
-      'endOcclusionQuery',
-      'executeBundles',
-      'end',
-
-      // GPURenderCommandsMixin
-      'setPipeline',
-      'setIndexBuffer',
-      'draw',
-      'drawIndexed',
-      'drawIndirect',
-      'drawIndexedIndirect',
-
-      // GPURenderBundleEncoder
-      'finish',
-
-      // GPUCanvasContext
-      'configure',
-      'unconfigure',
-
-      // GPUQueue
-      'writeBuffer',
-      'writeTexture',
-      'copyExternalImageToTexture',
-
-      'pushErrorScope',
-    ]);
-
-    // Iterating through all things 'GPU' on global object, some may not be classes. Skip those without a prototype.
-    if (!self[GPUClass].prototype)
+    // Non-fatal: GPUQueue.prototype.submit is non-writable/configurable. This would prevent our gpu timing code from functioning
+    // properly, so we cannot use webGPU for this sandbox, however by writing over the navigator.gpu and globalThis.GPU symbols,
+    // we can fully block webGPU access, allowing the sandbox to live for CPU-compute purposes.
+    if (!(submitDescriptor.writable || submitDescriptor.configurable))
+    {
+      protectedStorage.forceDisableWebGPU = true;
       return;
+    }
+
+    const TimeInterval = protectedStorage.TimeInterval;
+    const globalTrackers = protectedStorage.bigBrother.globalTrackers;
+    const webGPUTimer = globalTrackers.webGPUIntervals;
 
-    for (let prop of Object.keys(self[GPUClass].prototype))
+    /**
+     * Factories to create wrappers for all webGPU function (except submit & onSubmittedWorkDone) to time them when they
+     * are run, recording the duration of the function calls on the webGPU timer.
+     */
+    function webGPUAsyncTimingFactory(fn)
     {
-      if (promiseReturningFunctions.has(prop))
+      return function promiseWebGPUWrapper(...args)
       {
-        const fn = self[GPUClass].prototype[prop];
-        self[GPUClass].prototype[prop] = webGPUAsyncTimingFactory(fn);
+        const duration = new TimeInterval();
+        const original = fn.apply(this, args);
+        original.finally(() => webGPUTimer.push(duration.stop()));
+        return original;
       }
-      else if (blockingFunctions.has(prop))
+    }
+
+    function webGPUSyncTimingFactory(fn)
+    {
+      return function syncWebGPUWrapper(...args)
       {
-        const fn = self[GPUClass].prototype[prop];
-        self[GPUClass].prototype[prop] = webGPUSyncTimingFactory(fn);
+        const duration = new TimeInterval();
+        const ret = fn.apply(this, args);
+        webGPUTimer.push(duration.stop());
+        return ret;
       }
     }
-  }
 
-  // Want to use the submit/onSubmittedWorkDone original functions for timing.
-  const underlyingOnSubmittedWorkDone = GPUQueue.prototype.onSubmittedWorkDone;
-  const underlyingSubmit = GPUQueue.prototype.submit;
-
-  // some of them will get re-wrapped, that's fine, we always refer to the original function
-  const requiredWrappingGPUClasses = [
-    'GPU',
-    'GPUAdapter',
-    'GPUDevice',
-    'GPUBuffer',
-    'GPUTexture',
-    'GPUShaderModule',
-    'GPUComputePipeline',
-    'GPURenderPipeline',
-    'GPUCommandEncoder',
-    'GPUComputePassEncoder',
-    'GPURenderPassEncoder',
-    'GPURenderBundleEncoder',
-    'GPUQueue',
-    'GPUQuerySet',
-    'GPUCanvasContext',
-  ];
-
-  requiredWrappingGPUClasses.forEach(liftWebGPUPrototype);
-
-  let locked = false;
-  const submittedDonePromises = [];
-  protectedStorage.webGPU = {
-    lock: () => { locked = true; },
-    unlock: () => { locked = false; },
-    waitAllCommandToFinish: () => { return Promise.allSettled(submittedDonePromises); },
-  };
-
-  // our submit keeps a global tracker of all submissions, so we can track the time of each submission 
-  GPUQueue.prototype.submit = function submit(commandBuffers)
-  {
-    if (locked)
-      throw new Error('Attempted to submit webGPU queue after work function resolved');
-    underlyingSubmit.call(this, commandBuffers);
-
-    const submitTime = performance.now();
-    const submitDonePromise = underlyingOnSubmittedWorkDone.call(this).then(() => {
-      const idx = submittedDonePromises.indexOf(submitDonePromise);
-      submittedDonePromises.splice(idx);
-
-      const completedAt = performance.now();
-      const duration = new TimeInterval();
-      duration.overrideInterval(submitTime, completedAt);
-      webGPUTimer.push(duration);
-    });
-    submittedDonePromises.push(submitDonePromise);
-  }
+    /**
+     * Wrap various webGPU functions such that their usage will be tracked
+     *
+     */
+    function liftWebGPUPrototype(GPUClass)
+    {
+      // the standard dictates these functions will return promises
+      const promiseReturningFunctions = new Set([
+        'requestDevice',
+        'requestAdapterInfo',
+        'createComputePipelineAsync',
+        'createRenderPipelineAsync',
+        'mapAsync', // this would overestimate in some cases, a potential discussion
+        'getCompilationInfo',
+        'onSubmittedWorkDone',
+        'popErrorScope',
+        'requestAdapter',
+      ]);
+
+      // TODO: consider what to do with 'destroy'
+      // while they appear to be blocking, the meat of the work happens on the gpu driver thread
+      const blockingFunctions = new Set([
+        // GPU
+        'getPreferedCanvasFormat',
+
+        // GPUDevice
+        'createBuffer',
+        'createTexture',
+        'createSampler',
+        'importExternalTexture',
+        'createBindGroupLayout',
+        'createPipelineLayout',
+        'createBindGroup',
+        'createShaderModule',
+        'createComputePipeline',
+        'createRenderPipeline',
+        'createCommandEncoder',
+        'createRenderBundleEncoder',
+        'createQuerySet',
+
+        // GPUBuffer 
+        'getMappedRange',
+        'unmap',
+
+        // GPUTexture
+        'createView',
+
+        // GPUPipelineBase 
+        'getBindGroupLayout',
+
+        // GPUDebugCommandsMixin 
+        'pushDebugGroup',
+        'popDebugGroup',
+        'insertDebugWorker',
 
+        // GPUCommandEncoder
+        'beginRenderPass',
+        'beginComputePass',
+        'copyBufferToBuffer',
+        'copyBufferToTexture',
+        'copyTextureToBuffer',
+        'copyTextureToTexture',
+        'clearBuffer',
+        'writeTimestamp',
+        'resolveQuerySet',
+        'finish',
+
+        // GPUBindingsCommandMixin
+        'setBindGroup',
+
+        // GPUComputePassEncoder
+        'setPipeline',
+        'dispatchWorkgroups',
+        'dispatchWorkgroupsIndirect',
+        'end',
+
+        // GPURenderPassEncoder
+        'setViewPort',
+        'setScissorRect',
+        'setBlendConstant',
+        'setStencilReference',
+        'beginOcclusionQuery',
+        'endOcclusionQuery',
+        'executeBundles',
+        'end',
+
+        // GPURenderCommandsMixin
+        'setPipeline',
+        'setIndexBuffer',
+        'draw',
+        'drawIndexed',
+        'drawIndirect',
+        'drawIndexedIndirect',
+
+        // GPURenderBundleEncoder
+        'finish',
+
+        // GPUCanvasContext
+        'configure',
+        'unconfigure',
+
+        // GPUQueue
+        'writeBuffer',
+        'writeTexture',
+        'copyExternalImageToTexture',
+
+        'pushErrorScope',
+      ]);
+
+      // Iterating through all things 'GPU' on global object, some may not be classes. Skip those without a prototype.
+      if (!self[GPUClass].prototype)
+        return;
+
+      for (let prop of Object.keys(self[GPUClass].prototype))
+      {
+        if (promiseReturningFunctions.has(prop))
+        {
+          const fn = self[GPUClass].prototype[prop];
+          self[GPUClass].prototype[prop] = webGPUAsyncTimingFactory(fn);
+        }
+        else if (blockingFunctions.has(prop))
+        {
+          const fn = self[GPUClass].prototype[prop];
+          self[GPUClass].prototype[prop] = webGPUSyncTimingFactory(fn);
+        }
+      }
+    }
+
+    // Want to use the submit/onSubmittedWorkDone original functions for timing.
+    const underlyingOnSubmittedWorkDone = GPUQueue.prototype.onSubmittedWorkDone;
+    const underlyingSubmit = GPUQueue.prototype.submit;
+
+    // some of them will get re-wrapped, that's fine, we always refer to the original function
+    const requiredWrappingGPUClasses = [
+      'GPU',
+      'GPUAdapter',
+      'GPUDevice',
+      'GPUBuffer',
+      'GPUTexture',
+      'GPUShaderModule',
+      'GPUComputePipeline',
+      'GPURenderPipeline',
+      'GPUCommandEncoder',
+      'GPUComputePassEncoder',
+      'GPURenderPassEncoder',
+      'GPURenderBundleEncoder',
+      'GPUQueue',
+      'GPUQuerySet',
+      'GPUCanvasContext',
+    ];
+
+    requiredWrappingGPUClasses.forEach(liftWebGPUPrototype);
+
+    let locked = false;
+    const submittedDonePromises = [];
+    protectedStorage.webGPU = {
+      lock: () => { locked = true; },
+      unlock: () => { locked = false; },
+      waitAllCommandToFinish: () => { return Promise.allSettled(submittedDonePromises); },
+    };
+
+    // our submit keeps a global tracker of all submissions, so we can track the time of each submission 
+    GPUQueue.prototype.submit = function submit(commandBuffers)
+    {
+      if (locked)
+        throw new Error('Attempted to submit webGPU queue after work function resolved');
+      underlyingSubmit.call(this, commandBuffers);
+
+      const submitTime = performance.now();
+      const submitDonePromise = underlyingOnSubmittedWorkDone.call(this).then(() => {
+        const idx = submittedDonePromises.indexOf(submitDonePromise);
+        submittedDonePromises.splice(idx);
+
+        const completedAt = performance.now();
+        const duration = new TimeInterval();
+        duration.overrideInterval(submitTime, completedAt);
+        webGPUTimer.push(duration);
+      });
+      submittedDonePromises.push(submitDonePromise);
+    }
+
+  }
 });

package/libexec/sandbox/native-event-loop.js

@@ -52,7 +52,7 @@ self.wrapScriptLoading({ scriptName: 'native-event-loop' }, function nativeEvent
     {
       sortTimers();
       let timer = timers.shift();
-      let now = performance.now();
+      let now = Date.now();
       if (!timer)
         throw new Error('Logic error: trying to run timer when no timer exists') /* should be impossible */
       if (timer.when > now)  /* should be impossible, but at least we can handle this */
@@ -65,7 +65,7 @@ self.wrapScriptLoading({ scriptName: 'native-event-loop' }, function nativeEvent
 
       if (timer.recur)
       {
-        timer.when = performance.now() + timer.recur;
+        timer.when = Date.now() + timer.recur;
         timers.push(timer);
       }
 
@@ -101,7 +101,7 @@ self.wrapScriptLoading({ scriptName: 'native-event-loop' }, function nativeEvent
       timers.serial = +timers.serial + 1;
       timer = {
         fn: callback,
-        when: performance.now() + (+timeout || 0),
+        when: Date.now() + (+timeout || 0),
         serial: timers.serial,
         valueOf: function () { return this.serial; }
       }

package/libexec/sandbox/sa-ww-simulation.js

@@ -69,6 +69,12 @@ try {
       send({type: 'workerMessage', message });
     }
 
+    self.close = function close()
+    {
+      writeln('DIE: worker close called');
+      die();
+    }
+
     self.addEventListener = function workerControl$$Worker$addEventListener (type, listener) {
       if (typeof eventListeners[type] === 'undefined') { eventListeners[type] = [] }
       eventListeners[type].push(listener)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-client",
-  "version": "4.4.10-0",
+  "version": "4.4.11-0",
   "description": "Core libraries for accessing DCP network",
   "keywords": [
     "dcp"
@@ -43,8 +43,8 @@
     "polyfill-crypto.getrandomvalues": "^1.0.0",
     "regedit": "^3.0.3",
     "semver": "^7.3.5",
-    "webpack": "5.92.0",
     "source-map-support": "0.5.21",
+    "webpack": "5.92.0",
     "webpack-cli": "^4.7.2",
     "yargs": "16.2.0"
   },
@@ -52,7 +52,7 @@
     "@kingsds/eslint-config": "1.0.1",
     "eslint": "7.30.0",
     "express": "^4.18.2",
-    "peter": "2.4.5"
+    "peter": "2.4.7"
   },
   "engines": {
     "node": ">=18",