@agoric/swingset-vat 0.33.0-u19.2 → 0.33.0-u21.0

package/src/controller/startNodeSubprocess.js

@@ -13,6 +13,12 @@ export function makeStartSubprocessWorkerNode(
     ).pathname;
     const args = nodeOptions ? [...nodeOptions] : [];
     if (profileVats.includes(vatID)) {
+      // Enable profiling with a 1 microsecond sampling interval,
+      // saving results to a file in the working directory
+      // with a portable name derived from the vat name
+      // and in particular replacing any colons with dashes.
+      // cf. ../kernel/vat-loader/manager-subprocess-node.js
+      // https://github.com/Agoric/agoric-sdk/blob/18d561f1b95755e58ca691b26938fc249618018d/packages/SwingSet/src/kernel/vat-loader/manager-subprocess-node.js#L32-L34
       args.push('--cpu-prof');
       args.push('--cpu-prof-interval');
       args.push('1');

package/src/controller/upgradeSwingset.js

@@ -285,11 +285,9 @@ export const upgradeSwingset = kernelStorage => {
 
     const buggyKPIDs = []; // [kpid, vatID]
     for (const vatID of allVatIDs) {
-      const prefix = `${vatID}.c.`;
-      const len = prefix.length;
       const ckpPrefix = `${vatID}.c.kp`;
-      for (const key of enumeratePrefixedKeys(kvStore, ckpPrefix)) {
-        const kpid = key.slice(len);
+      for (const { suffix } of enumeratePrefixedKeys(kvStore, ckpPrefix)) {
+        const kpid = `kp${suffix}`;
         if (isSettled(kpid)) {
           const n = notifies.get(kpid);
           if (!n || !n.includes(vatID)) {

package/src/devices/bridge/device-bridge.js

@@ -62,3 +62,5 @@ export function buildRootDeviceNode(tools) {
     },
   });
 }
+
+/** @typedef {import('../../types-external.js').Device<ReturnType<typeof buildRootDeviceNode>>} BridgeDevice */

package/src/devices/timer/device-timer.js

@@ -86,6 +86,7 @@ function makeTimerMap(state = undefined) {
     return copyState(schedule);
   }
 
+  /** @param {bigint} time */
   function eventsFor(time) {
     assert.typeof(time, 'bigint');
     for (let i = 0; i < schedule.length && schedule[i].time <= time; i += 1) {
@@ -101,17 +102,29 @@ function makeTimerMap(state = undefined) {
   // There's some question as to whether it's important to invoke the handlers
   // in the order of their deadlines. If so, we should probably ensure that the
   // recorded deadlines don't have finer granularity than the turns.
-  function add(time, handler, repeater = undefined) {
+  /**
+   *
+   * @param {bigint} time
+   * @param {Waker} handler
+   * @param {number} [index]
+   * @returns {bigint}
+   */
+  function add(time, handler, index = undefined) {
     assert.typeof(time, 'bigint');
+    /** @type {IndexedHandler} */
     const handlerRecord =
-      typeof repeater === 'number' ? { handler, index: repeater } : { handler };
+      typeof index === 'number' ? { handler, index } : { handler };
     const { handlers: records } = eventsFor(time);
     records.push(handlerRecord);
     schedule.sort((a, b) => Number(a.time - b.time));
     return time;
   }
 
-  // Remove and return all pairs indexed by numbers up to target
+  /**
+   * Remove and return all pairs indexed by numbers up to target
+   *
+   * @param {bigint} target
+   */
   function removeEventsThrough(target) {
     assert.typeof(target, 'bigint');
     const returnValues = [];
@@ -132,33 +145,29 @@ function makeTimerMap(state = undefined) {
   }
 
   // We don't expect this to be called often, so we don't optimize for it.
+  /**
+   *
+   * @param {Waker} targetHandler
+   * @returns {bigint[]} times that have been removed (may contain duplicates)
+   */
   function remove(targetHandler) {
+    /** @type {bigint[]} */
     const droppedTimes = [];
     let i = 0;
     while (i < schedule.length) {
       const { time, handlers } = schedule[i];
-      if (handlers.length === 1) {
-        if (handlers[0].handler === targetHandler) {
-          schedule.splice(i, 1);
+      // Nothing prevents a particular handler from appearing more than once
+      for (let j = handlers.length - 1; j >= 0; j -= 1) {
+        if (handlers[j].handler === targetHandler) {
+          handlers.splice(j, 1);
           droppedTimes.push(time);
-        } else {
-          i += 1;
         }
+      }
+      if (handlers.length === 0) {
+        // Splice out this element, preserving `i` so we visit any successor.
+        schedule.splice(i, 1);
       } else {
-        // Nothing prevents a particular handler from appearing more than once
-        for (const { handler } of handlers) {
-          // @ts-expect-error xxx Waker vs IndexedHandler
-          if (handler === targetHandler && handlers.indexOf(handler) !== -1) {
-            // @ts-expect-error xxx Waker vs IndexedHandler
-            handlers.splice(handlers.indexOf(handler), 1);
-            droppedTimes.push(time);
-          }
-        }
-        if (handlers.length === 0) {
-          schedule.splice(i, 1);
-        } else {
-          i += 1;
-        }
+        i += 1;
       }
     }
     return droppedTimes;
@@ -223,6 +232,7 @@ export function buildRootDeviceNode(tools) {
   // The latest time poll() was called. This might be a block height or it
   // might be a time from Date.now(). The current time is not reflected back
   // to the user.
+  /** @type {bigint} */
   let lastPolled = restart ? restart.lastPolled : 0n;
   let nextRepeater = restart ? restart.nextRepeater : 0;
 
@@ -276,6 +286,10 @@ export function buildRootDeviceNode(tools) {
       saveState();
       return baseTime;
     },
+    /**
+     * @param {Waker} handler
+     * @returns {bigint[]} times that have been removed (may contain duplicates)
+     */
     removeWakeup(handler) {
       const times = deadlines.remove(handler);
       saveState();
@@ -303,6 +317,10 @@ export function buildRootDeviceNode(tools) {
       saveState();
       return index;
     },
+    /**
+     * @param {number} index
+     * @param {Waker} handler
+     */
     schedule(index, handler) {
       const nextTime = nextScheduleTime(index, repeaters, lastPolled);
       deadlines.add(nextTime, handler, index);
@@ -311,6 +329,7 @@ export function buildRootDeviceNode(tools) {
     },
   });
 }
+/** @typedef {import('../../types-external.js').Device<ReturnType<typeof buildRootDeviceNode>>} TimerDevice */
 
 // exported for testing. Only buildRootDeviceNode is intended for production
 // use.

package/src/kernel/kernel.js

@@ -99,6 +99,7 @@ export default function buildKernel(
     startSubprocessWorkerNode,
     startXSnap,
     writeSlogObject,
+    slogDuration,
     WeakRef,
     FinalizationRegistry,
     gcAndFinalize,
@@ -111,11 +112,12 @@ export default function buildKernel(
     overrideVatManagerOptions = {},
   } = kernelRuntimeOptions;
   const logStartup = verbose ? console.debug : () => {};
+  if (verbose) kdebugEnable(true);
 
   const vatAdminRootKref = kernelStorage.kvStore.get('vatAdminRootKref');
 
   const kernelSlog = writeSlogObject
-    ? makeSlogger(slogCallbacks, writeSlogObject)
+    ? makeSlogger(slogCallbacks, writeSlogObject, slogDuration)
     : makeDummySlogger(slogCallbacks, makeConsole('disabled slogger'));
 
   const kernelKeeper = makeKernelKeeper(
@@ -559,6 +561,10 @@ export default function buildKernel(
    */
   async function processSend(vatID, target, msg) {
     insistMessage(msg);
+    // DEPRECATED: These counts are available as "crank-start"/"crank-finish"
+    // slog entries with crankType "delivery" (the latter count filtered on
+    // messageType "send") and "deliver"/"deliver-result" slog entries (the
+    // latter count filtered on dispatch "message").
     kernelKeeper.incStat('dispatches');
     kernelKeeper.incStat('dispatchDeliver');
 
@@ -589,6 +595,8 @@ export default function buildKernel(
     const { vatID, kpid } = message;
     insistVatID(vatID);
     insistKernelType('promise', kpid);
+    // DEPRECATED: This count is available as "crank-start"/"crank-finish"
+    // slog entries with crankType "delivery".
     kernelKeeper.incStat('dispatches');
     const vatInfo = vatWarehouse.lookup(vatID);
     if (!vatInfo) {
@@ -598,6 +606,8 @@ export default function buildKernel(
     const { meterID } = vatInfo;
 
     const p = kernelKeeper.getKernelPromise(kpid);
+    // DEPRECATED: This count is available as "deliver"/"deliver-result" slog
+    // entries with dispatch "notify".
     kernelKeeper.incStat('dispatchNotify');
     const vatKeeper = kernelKeeper.provideVatKeeper(vatID);
     if (p.state === 'unresolved') {
@@ -1342,14 +1352,15 @@ export default function buildKernel(
    * @returns {Promise<PolicyInput>}
    */
   async function processDeliveryMessage(message) {
+    const messageType = message.type;
     kdebug('');
     // prettier-ignore
     kdebug(`processQ crank ${kernelKeeper.getCrankNumber()} ${JSON.stringify(message)}`);
     kdebug(legibilizeMessage(message));
-    kernelSlog.write({
-      type: 'crank-start',
+    const finish = kernelSlog.startDuration(['crank-start', 'crank-finish'], {
       crankType: 'delivery',
       crankNum: kernelKeeper.getCrankNumber(),
+      messageType,
       message,
     });
     /** @type { PolicyInput } */
@@ -1451,12 +1462,8 @@ export default function buildKernel(
     const crankNum = kernelKeeper.getCrankNumber();
     kernelKeeper.incrementCrankNumber();
     const { crankhash, activityhash } = kernelKeeper.emitCrankHashes();
-    // kernelSlog.write({
-    //   type: 'kernel-stats',
-    //   stats: kernelKeeper.getStats(),
-    // });
-    kernelSlog.write({
-      type: 'crank-finish',
+    finish({
+      message: undefined,
       crankNum,
       crankhash,
       activityhash,
@@ -1494,14 +1501,15 @@ export default function buildKernel(
    * @returns {Promise<PolicyInput>}
    */
   async function processAcceptanceMessage(message) {
+    const messageType = message.type;
     kdebug('');
     // prettier-ignore
-    kdebug(`processAcceptanceQ crank ${kernelKeeper.getCrankNumber()} ${message.type}`);
+    kdebug(`processAcceptanceQ crank ${kernelKeeper.getCrankNumber()} ${messageType}`);
     // kdebug(legibilizeMessage(message));
-    kernelSlog.write({
-      type: 'crank-start',
+    const finish = kernelSlog.startDuration(['crank-start', 'crank-finish'], {
       crankType: 'routing',
       crankNum: kernelKeeper.getCrankNumber(),
+      messageType,
       message,
     });
     /** @type { PolicyInput } */
@@ -1538,8 +1546,8 @@ export default function buildKernel(
     const crankNum = kernelKeeper.getCrankNumber();
     kernelKeeper.incrementCrankNumber();
     const { crankhash, activityhash } = kernelKeeper.emitCrankHashes();
-    kernelSlog.write({
-      type: 'crank-finish',
+    finish({
+      message: undefined,
       crankNum,
       crankhash,
       activityhash,
@@ -1938,15 +1946,63 @@ export default function buildKernel(
     }
   }
 
-  function reapAllVats() {
+  /** @returns {Generator<VatID>} */
+  function* getAllVatIds() {
     for (const [_, vatID] of kernelKeeper.getStaticVats()) {
-      kernelKeeper.scheduleReap(vatID);
+      yield vatID;
     }
     for (const vatID of kernelKeeper.getDynamicVats()) {
-      kernelKeeper.scheduleReap(vatID);
+      yield vatID;
     }
   }
 
+  function* getAllVatPosEntries() {
+    for (const vatID of getAllVatIds()) {
+      const vatKeeper = kernelKeeper.provideVatKeeper(vatID);
+      yield /** @type {const} */ ([
+        vatID,
+        vatKeeper.getTranscriptEndPosition(),
+      ]);
+    }
+  }
+
+  function reapAllVats(previousVatPos = {}) {
+    /** @type {Record<string, number>} */
+    const currentVatPos = {};
+
+    for (const [vatID, endPos] of getAllVatPosEntries()) {
+      const vatUsesTranscript = endPos !== 0;
+      if (!vatUsesTranscript) {
+        // The comms vat is a little special. It doesn't use a transcript,
+        // doesn't implement BOYD, and is created with a never reap threshold.
+        //
+        // Here we conflate a vat that doesn't use a transcript with a vat
+        // that cannot reap. We do not bother checking the vat options because
+        // in tests we would actually like to force reap normal vats that may
+        // have been configured with a never threshold.
+        continue;
+      } else if ((previousVatPos[vatID] ?? 0) < endPos) {
+        kernelKeeper.scheduleReap(vatID);
+        // We just added one delivery
+        currentVatPos[vatID] = endPos + 1;
+      } else {
+        currentVatPos[vatID] = endPos;
+      }
+    }
+
+    return harden(currentVatPos);
+  }
+
+  async function snapshotAllVats() {
+    const snapshottedVats = [];
+    await null;
+    for (const vatID of getAllVatIds()) {
+      const snapshotted = await vatWarehouse.maybeSaveSnapshot(vatID, 2);
+      if (snapshotted) snapshottedVats.push(vatID);
+    }
+    return harden(snapshottedVats);
+  }
+
   async function step() {
     if (kernelPanic) {
       throw kernelPanic;
@@ -2151,6 +2207,7 @@ export default function buildKernel(
     run,
     shutdown,
     reapAllVats,
+    snapshotAllVats,
     changeKernelOptions,
 
     // the rest are for testing and debugging
@@ -2161,6 +2218,11 @@ export default function buildKernel(
       ephemeral.log.push(`${str}`);
     },
 
+    /**
+     * Return a fresh stats snapshot.
+     *
+     * @returns {Record<string, number>}
+     */
     getStats() {
       return kernelKeeper.getStats();
     },

package/src/kernel/slogger.js

@@ -1,9 +1,12 @@
-import { q } from '@endo/errors';
+import { q, Fail } from '@endo/errors';
+import { makePromiseKit } from '@endo/promise-kit';
 import { objectMap } from '@agoric/internal';
+import { defineName } from '@agoric/internal/src/js-utils.js';
 import { makeLimitedConsole } from '@agoric/internal/src/ses-utils.js';
 
 /** @import {Callable} from '@agoric/internal'; */
 /** @import {LimitedConsole} from '@agoric/internal/src/js-utils.js'; */
+/** @import {SlogProps, SlogDurationProps, SwingsetController} from '../controller/controller.js'; */
 
 const IDLE = 'idle';
 const STARTUP = 'startup';
@@ -12,7 +15,7 @@ const DELIVERY = 'delivery';
 const noopFinisher = harden(() => {});
 
 /** @typedef {(...finishArgs: unknown[]) => unknown} AnyFinisher */
-/** @typedef {Partial<Record<Exclude<keyof KernelSlog, 'write'>, (methodName: string, args: unknown[], finisher: AnyFinisher) => unknown>>} SlogWrappers */
+/** @typedef {Partial<Record<Exclude<keyof KernelSlog, 'write' | 'startDuration'>, (methodName: string, args: unknown[], finisher: AnyFinisher) => unknown>>} SlogWrappers */
 
 /**
  * Support asynchronous slog callbacks that are invoked at the start
@@ -96,24 +99,81 @@ export function makeDummySlogger(slogCallbacks, dummyConsole = badConsole) {
     changeCList: () => noopFinisher,
     terminateVat: () => noopFinisher,
   });
-  return harden({ ...wrappedMethods, write: noopFinisher });
+  return harden({
+    ...wrappedMethods,
+    write: noopFinisher,
+    startDuration: () => noopFinisher,
+  });
 }
 
+/**
+ * @callback StartDuration
+ * Capture an extended process, writing an entry with `type` $startLabel and
+ * then later (when the returned finish function is called) another entry with
+ * `type` $endLabel and `seconds` reporting the intervening duration.
+ *
+ * @param {readonly [startLabel: string, endLabel: string]} labels
+ * @param {SlogDurationProps} startProps
+ * @returns {import('../types-external').FinishSlogDuration}
+ */
+
 /**
  * @param {SlogWrappers} slogCallbacks
- * @param {(obj: object) => void} [writeObj]
+ * @param {SwingsetController['writeSlogObject']} [writeSlogObject]
+ * @param {SwingsetController['slogDuration']} [slogDuration] required when writeSlogObject is provided
  * @returns {KernelSlog}
  */
-export function makeSlogger(slogCallbacks, writeObj) {
-  const safeWrite = writeObj
-    ? obj => {
-        try {
-          writeObj(obj);
-        } catch (err) {
-          console.error('WARNING: slogger write error', err);
+export function makeSlogger(slogCallbacks, writeSlogObject, slogDuration) {
+  if (writeSlogObject && !slogDuration) {
+    throw Fail`slogDuration is required with writeSlogObject`;
+  }
+  const { safeWrite, startDuration } = (() => {
+    if (!writeSlogObject) {
+      const dummySafeWrite = () => {};
+      /** @type {StartDuration} */
+      const dummyStartDuration = () => defineName('dummyFinish', () => {});
+      return { safeWrite: dummySafeWrite, startDuration: dummyStartDuration };
+    }
+    /** @type {(obj: SlogProps) => void} */
+    // eslint-disable-next-line no-shadow
+    const safeWrite = obj => {
+      try {
+        writeSlogObject(obj);
+      } catch (err) {
+        console.error('WARNING: slogger write error', err);
+      }
+    };
+    /** @type {StartDuration} */
+    // eslint-disable-next-line no-shadow
+    const startDuration = (labels, startProps) => {
+      try {
+        /** @type {(extraProps?: SlogDurationProps) => void} */
+        let closeSpan;
+        // @ts-expect-error TS2722 slogDuration is not undefined here
+        void slogDuration(labels, startProps, async finish => {
+          const doneKit = makePromiseKit();
+          closeSpan = props => {
+            try {
+              finish(props);
+            } finally {
+              doneKit.resolve(undefined);
+            }
+          };
+          // Hold the span open until `finish` is called.
+          await doneKit.promise;
+        });
+        // @ts-expect-error TS2454 closeSpan must have been assigned above
+        if (typeof closeSpan !== 'function') {
+          throw Fail`slogDuration did not synchronously provide a finisher`;
         }
+        return closeSpan;
+      } catch (err) {
+        console.error('WARNING: slogger write error', err);
+        return defineName('dummyFinish', () => {});
       }
-    : () => {};
+    };
+    return { safeWrite, startDuration };
+  })();
 
   const vatSlogs = new Map(); // vatID -> vatSlog
 
@@ -149,15 +209,17 @@ export function makeSlogger(slogCallbacks, writeObj) {
 
     function startup() {
       // provide a context for console calls during startup
-      checkOldState(IDLE, 'did startup get called twice?');
+      checkOldState(IDLE, 'vat-startup called twice?');
       state = STARTUP;
-      safeWrite({ type: 'vat-startup-start', vatID });
-      function finish() {
-        checkOldState(STARTUP, 'startup-finish called twice?');
+      const finish = startDuration(
+        ['vat-startup-start', 'vat-startup-finish'],
+        { vatID },
+      );
+      return harden(() => {
+        checkOldState(STARTUP, 'vat-startup-finish called twice?');
         state = IDLE;
-        safeWrite({ type: 'vat-startup-finish', vatID });
-      }
-      return harden(finish);
+        finish();
+      });
     }
 
     // kd: kernelDelivery, vd: vatDelivery
@@ -167,32 +229,44 @@ export function makeSlogger(slogCallbacks, writeObj) {
       crankNum = newCrankNum;
       deliveryNum = newDeliveryNum;
       replay = inReplay;
-      const when = { crankNum, vatID, deliveryNum, replay };
-      safeWrite({ type: 'deliver', ...when, kd, vd });
       syscallNum = 0;
-
+      const dispatch = vd?.[0]; // using vd because kd is undefined in replay
+      const finish = startDuration(['deliver', 'deliver-result'], {
+        crankNum,
+        vatID,
+        deliveryNum,
+        replay,
+        dispatch,
+        kd,
+        vd,
+      });
       // dr: deliveryResult
-      function finish(dr) {
-        checkOldState(DELIVERY, 'delivery-finish called twice?');
-        safeWrite({ type: 'deliver-result', ...when, dr });
+      return harden(dr => {
+        checkOldState(DELIVERY, 'deliver-result called twice?');
         state = IDLE;
-      }
-      return harden(finish);
+        finish({ kd: undefined, vd: undefined, dr });
+      });
     }
 
     // ksc: kernelSyscallObject, vsc: vatSyscallObject
     function syscall(ksc, vsc) {
       checkOldState(DELIVERY, 'syscall invoked outside of delivery');
-      const when = { crankNum, vatID, deliveryNum, syscallNum, replay };
-      safeWrite({ type: 'syscall', ...when, ksc, vsc });
+      const finish = startDuration(['syscall', 'syscall-result'], {
+        crankNum,
+        vatID,
+        deliveryNum,
+        syscallNum,
+        replay,
+        syscall: vsc?.[0],
+        ksc,
+        vsc,
+      });
       syscallNum += 1;
-
       // ksr: kernelSyscallResult, vsr: vatSyscallResult
-      function finish(ksr, vsr) {
+      return harden((ksr, vsr) => {
         checkOldState(DELIVERY, 'syscall finished after delivery?');
-        safeWrite({ type: 'syscall-result', ...when, ksr, vsr });
-      }
-      return harden(finish);
+        finish({ ksc: undefined, vsc: undefined, ksr, vsr });
+      });
     }
 
     // mode: 'import' | 'export' | 'drop'
@@ -258,5 +332,5 @@ export function makeSlogger(slogCallbacks, writeObj) {
     terminateVat: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.terminateVat(...args),
   });
-  return harden({ ...wrappedMethods, write: safeWrite });
+  return harden({ ...wrappedMethods, write: safeWrite, startDuration });
 }

package/src/kernel/state/deviceKeeper.js

@@ -189,11 +189,12 @@ export function makeDeviceKeeper(kvStore, deviceID, tools) {
     /** @type {Array<[string, string, string]>} */
     const res = [];
     const prefix = `${deviceID}.c.`;
-    for (const k of enumeratePrefixedKeys(kvStore, prefix)) {
-      const slot = k.slice(prefix.length);
+    const prefixedKeys = enumeratePrefixedKeys(kvStore, prefix);
+
+    for (const { key, suffix: slot } of prefixedKeys) {
       if (!slot.startsWith('k')) {
         const devSlot = slot;
-        const kernelSlot = kvStore.get(k);
+        const kernelSlot = kvStore.get(key);
         res.push([kernelSlot, deviceID, devSlot]);
       }
     }