dcp-worker 3.3.16 → 3.3.19

package/README.md

@@ -2,19 +2,16 @@
 
 This is the official DCP Worker program for the Distributive Compute Platform.
 
-This package implements a DCP Worker which can be executive interactively, or a system service, using
+This package implements a DCP Worker which can be executed interactively, or a as system service, using
 Node.js to communicate with the scheduler and control the DCP Evaluator.
 
 A companion program, the DCP Evaluator, is required to use this worker. When you install the DCP Worker
 with your system's package manager, the installer will automatically install the DCP Evaluator as
-`dcp-evaluator-v8` or `dcp-evaluator`. The DCP Evaluator is a secure sandboxing tool which uses the V8 JavaScript engine
-and the Dawn WebGPU engine from Google to execute JavaScript, WebAssembly, and WebGPU code.
-
-You can find a complete package for Linux, including Evaluator binaries at https://archive.distributed.computer/releases/,
-and documentation at https://docs.distributed.computer/worker/readme.html.  If you are a developer
-who interested in porting the Evaluator to your own platform, please contact us and we will
-grant you early access to the MIT-licensed source code.  The build is CMake with GN and largely
-based around V8.
+`dcp-evaluator-v8` or `dcp-evaluator`. The DCP Evaluator is a secure sandboxing tool which uses
+Google's V8 JavaScript engine and Google's Dawn WebGPU implementation for secure execution of JavaScript, WebAssembly, and WebGPU code.
+
+You can find a complete package for Linux, including Evaluator binaries at https://gitlab.com/Distributed-Compute-Protocol/dcp-native/-/releases.
+The build is CMake with GN and largely based around V8.
 
 This package is also used for DCP LocalExec, a local debugging tool for developers using DCP Client.
 

package/bin/dcp-task-probe

@@ -0,0 +1,696 @@
+#! /usr/bin/env node
+/**
+ * @file        dcp-task-probe
+ *              Tool to discover work available on the scheduler by requesting and
+ *              then returning slices.
+ *
+ * task request response payload currently (dec 2024) has
+ * - owner: scheduler's address
+ * - signature: ethereum signature object
+ * - auth:
+ *   - workerId: our worker id
+ *   - authSlices: job address props -> array of number
+ *   - schedulerId: { address: scheduler's address }
+ * - jobCommissions: job address props
+ *   - rate: number
+ *   - bank account
+ * - body:
+ *   - newJobs: job address props
+ *     - address: job address
+ *     - metrics:
+ *       - sliceCPUTime
+ *       - sliceGPUTime
+ *       - sliceCPUDensity
+ *       - sliceGPUDensity
+ *       - lastSliceNumber
+ *       - measuredSlices
+ *       - alpha
+ *       - running: true
+ *     - requirements: object
+ *     - public:
+ *       - computeGroups array
+ *       - name
+ *       - description
+ *       - link
+ *     - uuid
+ *     - codeLocation: uri
+ *     - argumentsLocation: array
+ *     - MROLocation: uri
+ *     - requirePath: array
+ *     - modulePath: array
+ *     - dependencies: array of module identifiers
+ *     - urlParameters:
+ *       - job: job address
+ *       - jobId: uuid
+ *     - workerConsole: 0
+ *     - worktime:
+ *       - name
+ *       - version
+ *   - task: job address props -> array
+ *     - jobAddress: address
+ *     - uuid: uuid
+ *     - worker: worker opaque id
+ *     - sliceNumber
+ *     - cotaskCount
+ *     - isEstimationSlice: boolean
+ *     - isLongSlice: boolean
+ *     - timestamp: ms
+ *     - resultStorageType: values|??
+ *     - resultStorageDetails
+ *     - resultStorageParams
+ *   - computeGroupJobs: opaqueId props
+ *     - array of jobId
+ * - computeGroups: opaque id -> array
+ * - computeGroupOrigins: {}
+ * - schedulerConfig:
+ *   - shared:
+ *     - frequencyMs
+ *     - debuggingFactor
+ *     - useLifetimeAnalysis
+ *     - lifetimeFactor
+ *     - slice
+ *       - maxCotasking
+ *       - multiplier
+ *       - sigmas
+ *       - factor
+ *       - biasMs
+ *   - targetTaskDuration: number in seconds
+ *
+ * @author      Wes Garland, wes@distributive.network
+ * @date        Dec 2024
+ */
+'use strict';
+
+const fs      = require('fs');
+const path    = require('path');
+const debug   = require('debug');
+const getopt  = require('posix-getopt');
+const util    = require('util');
+
+function usage()
+{
+  console.log(
+`
+DCP Task Probe - Copyright (c) 2024 Distributive Corp.
+Released under the terms of the MIT License.
+
+Usage: ${process.argv[0]} [option...]
+Examples (bash syntax):
+  - # dcp-task-probe --set cores.cpu=13 --set sandbox.progressTimeoutMs=2000
+  - # dcp-task-probe --merge allowOrigins.fetchData=https://google.com -c
+  - # bin/dcp-task-probe --set minimumWage.CPU=1 --set minimumWage.GPU=3 -c
+  - # dcp-task-probe --merge "minimumWage=({CPU:1, GPU:3})" -c
+  - # dcp-task-probe --merge 'minimumWage={"CPU":1,"GPU":3}' -c
+Options:
+  -h | --help                    show this help and exit
+  -C | --dumpConfig              dump worker configuration instead of requesting a task
+  -v | --version                 increase verbosity (show job info)
+  -H | --hostname=               set evaluator hostname (for capability probing)
+  -p | --port=                   set evaluator port number (for capability probing)
+  -S | --set property.name=      sets a node in dcpConfig.worker to the given value
+  -M | --merge property.name=    merge a given value to with a node in dcpConfig.worker
+  -a | --allowedOrigins=         add url to dcpConfig.worker.allowedOrigins.any
+  -c | --cores=                  set the number of cpu,gpu cores
+  -u | --utilization=            set the cpu,gpu utilization target
+  -m | --maxSandboxes=           Maximum number of sandboxes
+  -g | --joinComputeGroup=       joinKey,joinSecret or joinKey,joinHash of compute group to join
+  -j | --jobId=                  id of job to work
+  -r | --replay                  replay request from worker's last requestSnapshot
+  -l | --load                    load config from worker's last requestSnapshot
+  -i | --input=                  render the input file instead of requesting a new task
+  -o | --output=                 save the task to disk
+Syntax:
+  The --merge and --set options have a variety of parsing options, to allow values in
+  dcpConfig.worker to have the correct types. The parsing method is controlled by the
+  first character of the value:
+    @ - the value is a filename; the file is read in and its contents are used in place
+        of the value specified on the command-line
+    ( - the value is parsed as a JavaScript expression
+    { - the value is parsed as a JSON object
+    # - the rest of the value is parsed as JSON
+    [ - the value is parsed as a JSON array
+    \` - the value is parsed as a JavaScript template string
+    ' - the value is parsed as a string
+    " - the value is parsed as a string
+    other - the value is parsed as a string, unless it can be parsed as a number
+Note:
+  Beyond the usual dcpConfig.worker values, this program adds dcpConfig.worker.capabilities and
+  dcpConfig.worker.worktimes. If they are not present in the loaded config, they are automtically
+  populated by querying the local evaluator. If they are both specified in the config, then it
+  is not necessary to have a working evaluator to run this program.
+Environment:
+  DEBUG      - enables debugging, eg DEBUG='dcp-task-probe*,-dcp-task-probe:evaluator'
+  DCP_CONFIG - sets location of dcp-worker-config file
+`);
+
+  process.exit(0);
+}
+
+function panic()
+{
+  console.error.apply(console, arguments);
+  process.exit(1);
+}
+
+function detailedView(object)
+{
+  return util.inspect(object, { depth: null, colors: process.env.FORCE_COLOR || true });
+}
+
+/**
+ * Determine if an string is a hash; used to differentiate between compute group join keys and hashes.
+ */
+function isHash(b)
+{
+  return b && b.length === 68 && b.startsWith('eh1-');
+}
+
+/**
+ * Evaluate a JavaScript expression within a given namespace. This function creates an IIFE and injects
+ * the properties of the namespace object into the IIFE's function block scope.
+ *
+ * @param {string}   expression    the JS expression to evaluatte
+ * @param {object}   namespace     the namespace object; each property becomes a symbol that can be used
+ *                                 by the expression
+ */
+function nsEval(expression, namespace)
+{
+  const indirectEval = eval; // eslint-disable-line no-eval
+  const symbolNames = Object.keys(namespace);
+  const symbolValues = Object.values(namespace);
+  return indirectEval(`(${symbolNames}) => ${expression}`)(symbolValues);
+}
+
+/**
+ * Parse a value within a given namespace. See the usage function for the syntax supported by this
+ * function. If the value is not a string, it is not parsed and simply returned.
+ *
+ * @param   {any}     value      the value to parse
+ * @param   {object}  namespace  a namespacing object used when evaluating JS expresssions; see nsEval
+ * @returns {any}  value or a JS value derived by parsing value
+ */
+function parseValue(value, namespace)
+{
+  if (typeof value !== 'string')
+    return;
+
+  if (value[0] === '@')
+    value = fs.readFileSync(value[0], 'utf-8');
+  switch(value[0])
+  {
+    case '#':
+      value = JSON.parse(value.slice(1));
+      break;
+    case '[':
+    case '{':
+      value = JSON.parse(value);
+      break;
+    case '`': /* fallthrough */
+    case '(':
+      value = nsEval(value, namespace);
+      break;
+    case "'":
+      if (/^'([^']*)'/.test(value))
+        value = value.match(/^'([^.]*)'/)[1];
+      break;
+    case '"':
+      if (/^"([^"]*)"/.test(value))
+        value = value.match(/^"([^"]*)"/)[1];
+      break;
+    default:
+      if (!isNaN(Number(value)))
+        value = Number(value);
+    break;
+  }
+  return value;
+}
+
+/**
+ * Traverse a graph by walking a dot path (eg a.b.c); ie. the path names each edge of the graph of the
+ * graph to traverse. The value returned is the node which is the parent of the final edge in the path,
+ * and the final edge the path. This is so that the calling code can replace the edge and is effectively
+ * a pointer to the node described by the dot path.
+ *
+ * @example:
+ *  walkDotPath(dcpConfig.worker, 'minimumWage.CPU')
+ *  returns [ dcpConfig.worker.minimumWage, 'CPU' ]
+ *
+ * @param {object}   startNode   the name of the first node in the graph
+ * @param {string}   dotPath     the names of the edges to traverse, separated by dots
+ * @return { Array } whose first element is the node containing parent node of the final edge and
+ *                   whose second element is the name of the final edge
+ */
+function walkDotPath(startNode, dotPath)
+{
+  var node = startNode;
+  var seen = [ 'worker' ];
+
+  dotPath = dotPath.split('.');
+  while(dotPath.length > 1)
+  {
+    const prop = dotPath.shift();
+    if (!node[prop])
+      panic(`invalid property ${prop} in dcpConfig.${seen.join('.')}`)
+    node = node[prop];
+    seen.push(prop);
+  }
+
+  return [ node, dotPath[0] ];
+}
+
+/** Parse a string of the form a,b into { cpu: a, gpu: b } */
+function cpuCommaGpu(str)
+{
+  const [cpu,gpu] = str.split(/[ ,]/);
+  const obj = {};
+  if (typeof cpu !== 'undefined' && cpu !== '')
+    obj.cpu = Number(cpu);
+  if (typeof gpu !== 'undefined')
+    obj.gpu = Number(gpu);
+  return obj;
+}
+
+/**
+ * Parse and process command-line options. Most options result in changes to the running dcpConfig;
+ * other options are reflected in the returned object:
+ *  - dumpConfig
+ *  - workerId
+ */
+async function processOptions()
+{
+  const opts = { verbose: 0 };
+  const parser = new getopt.BasicParser('h(help)C(dumpConfig)S:(set)M:(merge)a:(allowedOrigins)'
+                                        + 'c:(cores)u:(utilization)m:(maxSandboxes)w:(workerId)'
+                                        + 'J:(jobAddress)j:(job)g:(computeGroup)G(leaveGlobalGroup)'
+                                        + 'H:(hostname)p:(port)r(replay)l(load)i(input)o(output)'
+                                        + 'v(verbose)',
+                                        process.argv);
+  var opthnd;
+
+  while ((opthnd = parser.getopt()) !== undefined)
+  {
+    switch (opthnd.option)
+    {
+      case 'h':
+        usage();
+        break;
+
+      default:
+        throw new Error(`defined but unspecified option: -${opthnd.option}` + (opthnd.optarg ? `=${opthnd.optarg}` : ''));
+
+      case '?':
+        process.exit(1);
+        break;
+
+      case 'C':
+        opts.dumpConfig = true;
+        break;
+
+      case 'v':
+        opts.verbose += 1;
+        break;
+
+      case 'w':
+        opts.workerId = opthnd.optarg;
+        break;
+
+      case 'r':
+        opts.replay = true;
+        break;
+
+      case 'a':
+        dcpConfig.worker.allowedOrigins.any.push(opthnd.optarg);
+        break;
+
+      case 'c':
+        Object.assign(dcpConfig.worker.cores, cpuCommaGpu(opthnd.optarg));
+        break;
+
+      case 'u':
+        Object.assign(dcpConfig.worker.utilization, cpuCommaGpu(opthnd.optarg));
+        break;
+
+      case 'm':
+        dcpConfig.worker.maxSandboxes = Number(opthnd.optarg);
+        break;
+
+      case 'J':
+        dcpConfig.worker.jobAddresses = (dcpConfig.worker.jobAddresses || []).concat(opthnd.optarg);
+        break;
+
+      case 'j': /** @todo integrate with upcoming scheduler changes to opaqueId /wg dec 2024 */
+        dcpConfig.worker.jobs = (dcpConfig.worker.jobs || []).concat(opthnd.optarg);
+        break;
+
+      case 'G':
+        dcpConfig.worker.leavePublicGroup = true;
+        break;
+
+      case 'H':
+        dcpConfig.evaluator.location.hostname = opthnd.ortarg;
+        break;
+
+      case 'p':
+        dcpConfig.evaluator.location.port = opthnd.ortarg;
+        break;
+
+      case 'g':
+      {
+        const [ joinKey, joinSecret ] = opthnd.optarg.split(',');
+        const joinHash = joinSecret;
+
+        if (isHash(joinHash))
+          dcpConfig.worker.computeGroups.push({ joinKey, joinHash });
+        else
+          dcpConfig.worker.computeGroups.push({ joinKey, joinSecret });
+        break;
+      }
+
+      case 'M': /* fallthrough */
+      case 'S':
+      {
+        const eqIdx = opthnd.optarg.indexOf('=');
+        const idx = eqIdx !== -1 ? eqIdx : opthnd.optarg.length;
+        const value = parseValue(opthnd.optarg.slice(idx + 1), dcpConfig.worker);
+        const [ confNode, prop ] = walkDotPath(dcpConfig.worker, opthnd.optarg.slice(0, idx));
+
+        if (opthnd.option === 's')
+          confNode[prop] = value;
+        else
+        {
+          /* merge mode: objects are merged at the property level, except for arrays, which are concatenated */
+          if (confNode === dcpConfig.worker && (prop === 'worktimes' || prop === 'capabilities'))
+            await probeEvaluator(); /* ensure we have something to merge into */
+          switch(typeof confNode[prop])
+          {
+            case 'object':
+            {
+              if (!Array.isArray(confNode[prop]))
+                Object.assign(confNode[prop], value);
+              else
+              {
+                if (Array.isArray(value))
+                  Array.push.apply(confNode, value);
+                else
+                  confNode[prop].push(value);
+              }
+              break;
+            }
+            default:
+              confNode[prop] = value;
+              break;
+          }
+        }
+        break;
+      }
+
+      case 'l':
+      {
+        const wallet = require('dcp/wallet');
+        const snapshot = readWorkerSnapshot();
+        dcpConfig.worker = snapshot.workerConfig;
+        dcpConfig.worker.paymentAddress = new wallet.Address(dcpConfig.worker.paymentAddress);
+      }
+    }
+  }
+
+  return opts;
+}
+
+/**
+ * Probe the evaluator to determine its capabilities and supported worktimes. This function is delayed
+ * as late as possible during the configuration phase so that the user has the option to specify these
+ * completely on a system with no evaluator.
+ */
+async function probeEvaluator()
+{
+  if (probeEvaluator.probed)
+    return;
+  probeEvaluator.probed = true;
+  const probeTimer = setTimeout(() => panic('unable to probe evaluator'), 66610e3); /* Need to keep main from exiting */
+
+  if (!dcpConfig.worker.capabilities || !dcpConfig.worker.worktimes)
+  {
+    const { workerFactory } = require('dcp-client/lib/standaloneWorker');
+    debug('dcp-task-probe:evaluator')('Probing evaluator at', dcpConfig.evaluator.location);
+    const evaluatorInfo = await require('dcp/worker').probeEvaluator(workerFactory(dcpConfig.evaluator.location));
+    dcpConfig.worker.capabilities ||= evaluatorInfo.capabilities;
+    dcpConfig.worker.worktimes    ||= evaluatorInfo.worktimes;
+  }
+
+  clearTimeout(probeTimer);
+}
+
+/**
+ * Returns the most recent snapshot left behind by the worker. The location of the snapshot is given by
+ * dcpConfig.worker.requestSnapshot. Multiple calls to this function always return the same snapshot.
+ * This function understands that the worker might write kvin-encoded snapshots, identitfied by their
+ * extension. The snapshots are written automatically by the worker during task request when the
+ * dcpConfig.worker.requestSnapshot is set.
+ */
+function readWorkerSnapshot()
+{
+  if (!dcpConfig.worker.requestSnapshot)
+    panic('no snapshot specified in dcpConfig.worker.requestSnapshot');
+
+  if (!readWorkerSnapshot.cache)
+  {
+    const serializer = dcpConfig.worker.requestSnapshot.endsWith('kvin') ? require('kvin').KVIN : JSON;
+    debug('dcp-task-probe')('loading snapshot', detailedView(dcpConfig.worker.requestSnapshot));
+    readWorkerSnapshot.cache = serializer.parse(fs.readFileSync(dcpConfig.worker.requestSnapshot));
+  }
+  return readWorkerSnapshot.cache;
+}
+
+/**
+ * Generate non-global compute group secrets, hashed with the current task distributor connection's
+ * dcpsid. Add in the public group if necessary.
+ *
+ * @todo unify with supervisor /wg dec2024
+ */
+function makeComputeGroupsRequest(tdConn, dummyWorker)
+{
+  const computeGroups = structuredClone(dcpConfig.worker.computeGroups); /* supervisor code sadly mutates this /wg dec 2024 */
+  const options = Object.assign({}, dcpConfig.worker, { computeGroups });
+  const taskDistributor = { connection: tdConn };
+
+  dummyWorker.badSupervisorBackdoor.dcp4.generateWorkerComputeGroups.apply({ taskDistributor, options });
+  if (!dcpConfig.worker.leavePublicGroup && !dcpConfig.worker.leaveGlobalGroup)
+    options.computeGroups.unshift({ joinKey: 'public' });
+  return options.computeGroups;
+}
+
+
+/**
+ * Request a task from the task distributor
+ *
+ * @todo unify with supervisor /wg dec 2024
+ * @param {Keystore} identity   identity of the requesting entity
+ * @param {Object}   opts       command-line options to dcp-task-probe
+ *                    .replay     truey to use request from worker snapshot instead of a generated request
+ *                    .workerId   workerId for request
+ */
+async function requestTask(identity, opts)
+{
+  const protocol = require('dcp/protocol');
+  const worker = require('dcp/worker');
+  const tdConn = new protocol.Connection(dcpConfig.scheduler.services.taskDistributor);
+  const dummyWorker = new worker.Worker(identity, dcpConfig.worker); /* side effect: initializes dcpConfig.worker */
+  var request;
+
+  if (opts.replay)
+    request = readWorkerSnapshot().request;
+  else
+    request = {
+      supervisor: dummyWorker.supervisorVersion,
+      targetLoad: {
+        cpu: Math.min(dcpConfig.worker.maxSandboxes, dcpConfig.worker.cores.cpu * dcpConfig.worker.utilization.cpu) /* cpuCoreSpace */,
+        gpu: Math.min(dcpConfig.worker.maxSandboxes, dcpConfig.worker.cores.gpu * dcpConfig.worker.utilization.gpu) /* this.maxWorkingGPUs */,
+        longSlices: dcpConfig.worker.maxSandboxes /* Math.floor(cpuCoreSpace) */,
+      },
+      coreStats: { /** @todo why are we specifying these? /wg dec 2024 */
+        worker: dummyWorker.workerId,
+        lCores: require('os').cpus().length,
+        pCores: require('physical-cpu-count'),
+        sandbox: dcpConfig.worker.maxSandboxes,
+      },
+      jobQuanta:            [ 1 ]/* this.quanta.calculateJobQuanta() */,
+      capabilities:         dcpConfig.worker.capabilities,
+      paymentAddress:       dcpConfig.worker.paymentAddress,
+      jobAddresses:         dcpConfig.worker.jobAddresses || [],
+      workerComputeGroups:  makeComputeGroupsRequest(tdConn, dummyWorker),
+      minimumWage:          dcpConfig.worker.minimumWage,
+      soteriaJobs:          [],
+      overdueSlices:        [],
+      previouslyWorkedJobs: [], /* discrete jobs */
+      rejectedJobs:         [],
+      unresolvedJobs:       [],
+      fetchState:           1, /* normal fetch */
+      worktimes:            dcpConfig.worker.worktimes,
+    };
+
+  debug('dcp-task-probe:connect')('Connecting to task distributor at', tdConn.targetDescriptor.location.href);
+  await tdConn.keepalive();
+  debug('dcp-task-probe:request')('Task Request:', request);
+
+  const rtStart = Date.now();
+  const response = await tdConn.request('requestTask', request);
+  const rtElapsed = Date.now() - rtStart;
+  console.log('Task Request Time:   ', fmtMs(rtElapsed));
+
+  debug('dcp-task-probe:request')('Task Response:', detailedView(response));
+  if (!response.success)
+    panic('request failed:', response.payload);
+
+  return { response, workerId: request.coreStats?.worker };
+}
+
+async function returnTask(taskResponsePayload)
+{
+  const protocol = require('dcp/protocol');
+  const { body,  ...authorizationMessage } = taskResponsePayload;
+  const { auth } = taskResponsePayload;
+  const returnRequest = {
+    worker: auth.workerId,
+    slices: [],
+  };
+
+  for (const job in auth.authSlices)
+  {
+    for (const sliceNumber of auth.authSlices[job])
+    {
+      const slices = body.task[job];
+      returnRequest.slices.push({
+        sliceNumber,
+        job,
+        authorizationMessage,
+        isEstimationSlice: slices.filter(slice => slice.sliceNumber === sliceNumber)[0].isEstimationSlice,
+        status: 'return',
+        reason: 'task-probe',
+      });
+    }
+  }
+
+  debug('dcp-task-probe:request')('Return Request:', detailedView(returnRequest));
+  const rsConn = new protocol.Connection(dcpConfig.scheduler.services.resultSubmitter);
+  const response = await rsConn.request('status', returnRequest);
+
+  if (!response.success)
+    panic('request failed:', response.payload);
+
+  debug('dcp-task-probe:response')('Return Response:', detailedView(response));
+  if (!response.payload?.length)
+    panic('did not return task');
+}
+
+function unique(e, i, self)
+{
+  return i === self. indexOf(e);
+}
+
+function fmtMs(ms)
+{
+  return (ms / 1e3).toFixed(3) + 's';
+}
+
+/** Main program entry point */
+async function main()
+{
+  const wallet   = require('dcp/wallet');
+  const identity = await wallet.getId();
+  const opts = await processOptions();
+
+  if (!dcpConfig.worker.paymentAddress)
+    dcpConfig.worker.paymentAddress = (await wallet.get()).address;
+
+  if (!opts.replay)
+    await probeEvaluator();
+
+  if (opts.dumpConfig)
+  {
+    /* work around the cores getter/setter that is added by the worker */
+    const dump = Object.assign({}, dcpConfig.worker);
+    dump.cores = { cpu: dcpConfig.worker.cores.cpu, gpu: dcpConfig.worker.cores.gpu };
+    console.log(dump);
+    process.exit(0);
+  }
+
+  const { workerId, response } = await requestTask(identity, opts);
+  const task = response.payload?.body?.task;
+  if (task)
+    await returnTask(response.payload);
+
+  console.log('Task Distributor:    ', dcpConfig.scheduler.services.taskDistributor.location.href);
+  console.log('Result Submitter:    ', dcpConfig.scheduler.services.resultSubmitter.location.href);
+  console.log('Worker Id:           ', workerId);
+  console.log('DCP Address:         ', String(identity.address));
+
+  if (!task)
+  {
+    console.error('no work');
+    process.exit(22);
+  }
+
+  const { newJobs, computeGroupJobs, computeGroupOrigins, schedulerConfig } = response.payload.body;
+  const cgs = {}
+  for (const cgId in computeGroupJobs)
+    cgs[cgId] = { jobCount: computeGroupJobs[cgId].length };
+  for (const jobId in newJobs)
+  {
+    for (const cg of newJobs[jobId].public.computeGroups)
+      Object.assign(cgs[cg.opaqueId], { name: cg.name, description: cg.description });
+  }
+
+  console.log('Total Jobs:          ', Object.keys(task).length);
+  console.log('Total Slices:        ', Object.keys(task).map(jobId => task[jobId].length).reduce((a, b) => a+b, 0));
+  console.log('Total CPU,GPU Time:  ',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0)) + ',',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0)));
+  console.log('CPU,GPU Time/core:   ',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0) / dcpConfig.worker.cores.cpu) + ',',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0) / dcpConfig.worker.cores.gpu));
+  console.log('Task Duration:       ', schedulerConfig.targetTaskDuration + 's');
+  console.log('Compute Groups:      ', Object.keys(computeGroupJobs).length);
+
+  if (opts.verbose)
+  {
+    for (const cgId in cgs)
+    {
+      console.log(' -', cgId, cgs[cgId].name);
+      if (computeGroupOrigins[cgId])
+        console.log('   allow origins:', computeGroupOrigins[cgId]);
+    }
+  }
+
+  if (opts.verbose)
+  {
+    for (const jobId of Object.keys(task))
+    {
+      console.log(`\n-- Job ${jobId} ------------------------------`);
+      console.log('Public Info:       ', newJobs[jobId].public.name, newJobs[jobId].public.description, newJobs[jobId].public.link || '');
+      console.log('Compute Groups:    ', newJobs[jobId].public.computeGroups.map(cg=>cg.opaqueId).filter(unique));
+      console.log('Slices:            ', Object.keys(task[jobId]).length);
+      console.log('Avg Slice Time:    ',
+                  `cpu=${fmtMs(newJobs[jobId].metrics.sliceCPUTime)}`,
+                  `gpu=${fmtMs(newJobs[jobId].metrics.sliceGPUTime)}`);
+      console.log('Avg Slice Density: ',
+                  `cpu=${(newJobs[jobId].metrics.sliceCPUDensity * 100).toFixed(1)}%`,
+                  `gpu=${(newJobs[jobId].metrics.sliceGPUDensity * 100).toFixed(1)}%`);
+      console.log('Worktime:          ', `${newJobs[jobId].worktime.name}@${newJobs[jobId].worktime.version}`);
+      if (newJobs[jobId].codeLocation.startsWith('data:'))
+        console.log('Work Function:     ', newJobs[jobId].codeLocation.length, 'bytes, inline');
+      else
+        console.log('Work Function:     ', newJobs[jobId].codeLocation);
+
+      console.log('Result Storage:    ', task[jobId][0].resultStorageType, task[jobId][0].resultStorageDetails);
+      console.log('Dependencies:      ', newJobs[jobId].dependencies.map(a => path.basename(a)).join(' '));
+    }
+  }
+}
+
+/* Initialize dcp-client to use only local resources before launching the main function */
+require('dcp-client').init({
+  progName: 'dcp-worker',
+  parseArgv: false,
+  configName: process.env.DCP_CONFIG || '../etc/dcp-worker-config', /* => .js or .json */
+}).then(main);

package/bin/dcp-worker

@@ -130,14 +130,7 @@ function parseCliArgs()
         alias: 'p',
         describe: 'Evaluator port',
         type: 'number',
-        default: Number(dcpConfig.evaluator.listen.port),
-      },
-      priorityOnly: {
-        alias: 'P',
-        hidden: true,
-        describe: 'Set the priority mode [deprecated]',
-        type: 'boolean',
-        default: false
+        default: Number(dcpConfig.evaluator.location.port),
       },
       'job-id': {
         alias: 'j',
@@ -403,7 +396,6 @@ z   */
     if (dcpWorkerOptions.jobAddresses === false || dcpWorkerOptions.jobAddresses === undefined)
       dcpWorkerOptions.jobAddresses = [];
     dcpWorkerOptions.jobAddresses.push(...cliArgs.jobId);
-    dcpWorkerOptions.priorityOnly = true;
   }
 
   if (cliArgs.allowedOrigins)
@@ -462,10 +454,12 @@ z   */
     else
     {
       const errorCode = error.code ?? error.errorCode;
+      const location = error.stack.split('\n')[1].replace(/^\s*/,'');
+      let message = error.message;
+
       if (errorCode)
-        console.error(`Error: ${error.message}: error.code ${errorCode}`);
-      else
-        console.error(`Error: ${error.message}`);
+        message += ` (${error.code})`;
+      console.error(`Error: ${error.message} ${location}`);
     }
   });
   require('../lib/default-ui-events').hook(nascentWorker, cliArgs);
@@ -533,29 +527,26 @@ z   */
   if (telnetd.hasOwnProperty('port'))
     bannerLog(` ! telnetd listening on port ${telnetd.port}`);
 
-  const { worktimes } = require('dcp-client/libexec/sandbox/worktimes');
-  if (Object.keys(worktimes).length > 0)
-  {
-    bannerLog(' . Worktimes Available:');
-    for (const wt of worktimes)
-      bannerLog(`    -\t${wt.name}@${wt.versions.join(';')}`);
-  }
-
-  let webgpuInfo;
+  let workerInfo;
   console.throb('log', ' ! Waiting for dcp-evaluator to start...');
-  for (let i=0; !webgpuInfo; i++)
+  for (let i=0; !workerInfo; i++)
   {
-    webgpuInfo = await require('../lib/webgpu-info').checkWebGPU(sawOptions);
-    if (webgpuInfo)
+    workerInfo = await require('../lib/worker-info').getEvaluatorInformation(sawOptions);
+    if (workerInfo)
       break;
     console.throb();
     await a$sleep(Math.max(i + 1, 10) / 4);
     console.throb();
   }
 
-  if (!webgpuInfo)
-    bannerLog(' . WebGPU detection failed');
-  else if (!webgpuInfo.enabled)
+  if (Object.keys(workerInfo.worktimes).length > 0)
+  {
+    bannerLog(' . Worktimes Available:');
+    for (const wt of workerInfo.worktimes)
+      bannerLog(`    -\t${wt.name}@${wt.versions.join(';')}`);
+  }
+
+  if (!workerInfo.webgpu.enabled)
   {
     bannerLog(' . WebGPU not enabled');
     systemStateInfo.gpu = false;
@@ -563,13 +554,13 @@ z   */
   else
   {
     bannerLog(' . WebGPU available. GPU info:');
-    for (let descriptor in webgpuInfo.info)
-      bannerLog(`    -\t${descriptor}: ${webgpuInfo.info[descriptor]}`);
-    systemStateInfo.gpu = Object.assign({}, webgpuInfo.info);
+    for (let descriptor in workerInfo.webgpu.info)
+      bannerLog(`    -\t${descriptor}: ${workerInfo.webgpu.info[descriptor]}`);
+    systemStateInfo.gpu = Object.assign({}, workerInfo.webgpu.info);
     systemStateInfo.gpu.device
     for (let descriptor in bannedGPUs)
     {
-      if (bannedGPUs[descriptor].test(webgpuInfo.info[descriptor]))
+      if (bannedGPUs[descriptor].test(workerInfo.webgpu.info[descriptor]))
       {
         console.error(' * This GPU is not supported; disabling');
         dcpWorkerOptions.cores = { cpu: dcpWorkerOptions.cores.cpu, gpu: 0 };
@@ -834,6 +825,7 @@ function handleSigDeath(signalName, signal)
   if (handleSigDeath.count === 3)
     die();
 }
+globalThis.die = () => handleSigDeath('QUIT', 15);
 
 /**
  * Returns the duration of the cleanup timeout in milliseconds. It is possible to specify zero.

package/lib/dashboard-tui.js

@@ -44,11 +44,12 @@ exports.init = function dashboard$$init(worker, options, bannerLogCumulative)
   var screen = blessed.screen(screenConf);
 
   worker.on('end', () =>  {
-    screen.destroy();
-    screen = false;
+    if (screen?.destroy)
+      screen.destroy();
+    screen.destroy = false;
   });
   process.on('exit', () => {
-    if (screen)
+    if (screen?.destroy)
       screen.destroy();
   });
 

package/lib/{webgpu-info.js → worker-info.js}

@@ -1,7 +1,9 @@
 /**
- *  @file       webgpu-capabilities.js
- *              Check evaluator to determine if webgpu is enabled, and what capabilities it has.
- *
+ *  @file       worker-reporting.js
+ *              Check evaluator to determine if certain information including:
+ *                - if webgpu is enabled, and what capabilities it has.
+ *                - supported worktimes for the evaluator
+ * 
  *  @author     Ryan Saweczko, ryansaweczko@distributive.network
  *
  *  @date       Sept 2024
@@ -9,19 +11,20 @@
 'use strict';
 
 const kvin = require('kvin');
-const evaluatorId = 'webgpuCheck';
+const evaluatorId = 'reportingCheck';
 
-async function eval$$webgpu()
+async function eval$$getInfo()
 {
+  const info = {};
   if (typeof initWebGPU === 'function')
     await initWebGPU();
 
   if (!(typeof globalThis.navigator?.gpu === 'object'))
-    return { enabled: false };
+    info.webgpu = { enabled: false };
 
   try
   {
-    const info = {};
+    const webgpuInfo = {};
     const adapter = await navigator.gpu.requestAdapter();
     /*
      * Newer versions of dcp-evaluator use different methods to access the adapter info as the api changes/bugs are fixed.
@@ -35,29 +38,34 @@ async function eval$$webgpu()
     if (adapter.info)
     {
       for (let key in adapter.info)
-        info[key] = adapter.info[key];
-      return { enabled: true, info: info };
+        webgpuInfo[key] = adapter.info[key];
+      info.webgpu = { enabled: true, info: webgpuInfo };
+    }
+    else
+    {
+      const properties = ['vendor', 'architecture', 'device', 'description'];
+      const adapterInfo = await adapter.requestAdapterInfo();
+      for (let key of properties)
+        webgpuInfo[key] = adapterInfo[key];
+      info.webgpu = { enabled: true, info: webgpuInfo };  
     }
-    const properties = ['vendor', 'architecture', 'device', 'description'];
-    const adapterInfo = await adapter.requestAdapterInfo();
-    for (let key of properties)
-      info[key] = adapterInfo[key];
-    return { enabled: true, info: info };
   }
   catch (err)
   {
-    return { enabled: false };
+    info.webgpu = { enabled: false };
   }
+
+  info.worktimes = globalThis.worktimes;
+
+  return info;
 }
 
 /**
- * Connect to an evaluator instance and return back if webGPU is enabled, and if it is some information on the 
- * GPU device.
+ * Connect to an evaluator instance and return back information on the evaluator
  * @param {object} evaluatorConfig - Object containing the hostname and port to connect to the evaluator instance on
- * @returns {Promise} which resolves with undefined detection failed (ie couldn't connect to evaluator), 
- *                    or the object {enabled, info} with info on if webgpu exists, and if so what the gpu is.
+ * @returns {Promise} which resolves with undefined detection failed (ie couldn't connect to evaluator), or the information object
  */
-function checkEvaluatorWebGPU(evaluatorConfig)
+function getEvaluatorInformation(evaluatorConfig)
 {
   const StandaloneWorker = require('dcp-client/lib/standaloneWorker').workerFactory(evaluatorConfig);
   const { a$sleep } = require('dcp/utils');
@@ -65,7 +73,7 @@ function checkEvaluatorWebGPU(evaluatorConfig)
   const evaluatorHandle = new StandaloneWorker({ name: 'DCP Sandbox #1', });
 
   var noResponse, resolve;
-  const p$webgpuInfo = new Promise((res, rej) => { resolve = res; }).finally(() => {
+  const p$workerInfo = new Promise((res, rej) => { resolve = res; }).finally(() => {
     evaluatorHandle.terminate();
     noResponse.intr();
   });
@@ -84,11 +92,11 @@ function checkEvaluatorWebGPU(evaluatorConfig)
 
   const message = {
     request: 'eval',
-    data: '(' + eval$$webgpu.toString() + ')()',
+    data: '(' + eval$$getInfo.toString() + ')()',
     msgId: evaluatorId,
   }
   evaluatorHandle.postMessage(kvin.marshal(message));
-  return p$webgpuInfo;
+  return p$workerInfo;
 }
 
-exports.checkWebGPU = checkEvaluatorWebGPU;
+exports.getEvaluatorInformation = getEvaluatorInformation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.3.16",
+  "version": "3.3.19",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -40,7 +40,7 @@
     "blessed": "^0.1.81",
     "blessed-contrib": "4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "^4.4.21",
+    "dcp-client": "^4.4.24",
     "kvin": "^1.2.7",
     "posix-getopt": "^1.2.1",
     "semver": "^7.3.8",