Prune resolved promises (recipient side)

packages/SwingSet/.eslintrc.js

@@ -10,6 +10,7 @@ module.exports = {
     'function-paren-newline': 'off',
     'arrow-parens': 'off',
     strict: 'off',
+    'prefer-destructuring': 'off',
     'no-else-return': 'off',
     'no-console': 'off',
     'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],

packages/SwingSet/src/kernel/deviceManager.js

@@ -4,7 +4,7 @@ import { insistKernelType } from './parseKernelSlots';
 import { insistVatType, parseVatSlot } from '../parseVatSlots';
 import { insistCapData } from '../capdata';
 import { insistMessage } from '../message';
-import kdebug from './kdebug';
+import { kdebug } from './kdebug';
 
 /**
  * Produce an object that will serve as the kernel's handle onto a device.

packages/SwingSet/src/kernel/kdebug.js

@@ -1,7 +1,58 @@
 const enableKDebug = false;
 
-export default function kdebug(...args) {
+export function kdebug(...args) {
   if (enableKDebug) {
     console.log(...args);
   }
 }
+
+function legibilizeValue(val, slots) {
+  if (Array.isArray(val)) {
+    let result = '[';
+    for (const elem of val) {
+      if (result.length !== 1) {
+        result += ', ';
+      }
+      result += legibilizeValue(elem, slots);
+    }
+    result += ']';
+    return result;
+  } else if (val && typeof val === 'object' && val.constructor === Object) {
+    const qClass = val['@qclass'];
+    if (qClass) {
+      switch (qClass) {
+        case 'undefined':
+        case 'NaN':
+        case 'Infinity':
+        case '-Infinity':
+          return qClass;
+        case 'bigint':
+          return val.digits;
+        case 'slot':
+          return `@${slots[val.index]}`;
+        case 'error':
+          return `new ${val.name}('${val.message}')`;
+        case 'ibid':
+          return `ibid(${val.index})`;
+        default:
+          throw new Error(`unknown qClass ${qClass} in legibilizeValue`);
+      }
+    } else {
+      let result = '{';
+      for (const prop of Object.getOwnPropertyNames(val)) {
+        if (result.length !== 1) {
+          result += ', ';
+        }
+        result += `${prop}: ${legibilizeValue(val[prop], slots)}`;
+      }
+      result += '}';
+      return result;
+    }
+  } else {
+    return JSON.stringify(val);
+  }
+}
+
+export function legibilizeMessageArgs(args) {
+  return JSON.parse(args.body).map(arg => legibilizeValue(arg, args.slots));
+}

packages/SwingSet/src/kernel/kernel.js

@@ -10,7 +10,7 @@ import { makeDeviceSlots } from './deviceSlots';
 import makeDeviceManager from './deviceManager';
 import { wrapStorage } from './state/storageWrapper';
 import makeKernelKeeper from './state/kernelKeeper';
-import kdebug from './kdebug';
+import { kdebug, legibilizeMessageArgs } from './kdebug';
 import { insistKernelType, parseKernelSlot } from './parseKernelSlots';
 import { makeVatSlot, parseVatSlot } from '../parseVatSlots';
 import { insistStorageAPI } from '../storageAPI';
@@ -364,9 +364,23 @@ export default function buildKernel(kernelEndowments) {
     }
   }
 
+  function legibilizeMessage(message) {
+    if (message.type === 'send') {
+      const msg = message.msg;
+      const argList = legibilizeMessageArgs(msg.args).join(', ');
+      const result = msg.result ? msg.result : 'null';
+      return `@${message.target} <- ${msg.method}(${argList}) : @${result}`;
+    } else if (message.type === 'notify') {
+      return `notify(vatID: ${message.vatID}, kpid: @${message.kpid})`;
+    } else {
+      return `unknown message type ${message.type}`;
+    }
+  }
+
   let processQueueRunning;
   async function processQueueMessage(message) {
     kdebug(`processQ ${JSON.stringify(message)}`);
+    kdebug(legibilizeMessage(message));
     if (processQueueRunning) {
       console.error(`We're currently already running at`, processQueueRunning);
       throw Error(`Kernel reentrancy is forbidden`);
@@ -688,6 +702,7 @@ export default function buildKernel(kernelEndowments) {
       const bootstrapVatID = vatNameToID(bootstrapVatName);
       console.log(`=> queueing bootstrap()`);
       callBootstrap(bootstrapVatID, argvString);
+      commitCrank();
     }
 
     // if it *was* initialized, replay the transcripts

packages/SwingSet/src/kernel/liveSlots.js

@@ -331,6 +331,13 @@ function build(syscall, _state, makeRoot, forVatID) {
     };
   }
 
+  function retirePromiseID(promiseID) {
+    importedPromisesByPromiseID.delete(promiseID);
+    const p = slotToVal.get(promiseID);
+    valToSlot.delete(p);
+    slotToVal.delete(promiseID);
+  }
+
   function notifyFulfillToData(promiseID, data) {
     insistCapData(data);
     lsdebug(
@@ -342,6 +349,7 @@ function build(syscall, _state, makeRoot, forVatID) {
     }
     const val = m.unserialize(data);
     importedPromisesByPromiseID.get(promiseID).res(val);
+    retirePromiseID(promiseID);
   }
 
   function notifyFulfillToPresence(promiseID, slot) {
@@ -352,6 +360,7 @@ function build(syscall, _state, makeRoot, forVatID) {
     }
     const val = convertSlotToVal(slot);
     importedPromisesByPromiseID.get(promiseID).res(val);
+    retirePromiseID(promiseID);
   }
 
   function notifyReject(promiseID, data) {
@@ -365,6 +374,7 @@ function build(syscall, _state, makeRoot, forVatID) {
     }
     const val = m.unserialize(data);
     importedPromisesByPromiseID.get(promiseID).rej(val);
+    retirePromiseID(promiseID);
   }
 
   // here we finally invoke the vat code, and get back the root object

packages/SwingSet/src/kernel/state/kernelKeeper.js

@@ -11,7 +11,7 @@ import {
 } from '../parseKernelSlots';
 import { insistCapData } from '../../capdata';
 import { insistDeviceID, insistVatID, makeDeviceID, makeVatID } from '../id';
-import kdebug from '../kdebug';
+import { kdebug } from '../kdebug';
 
 // This holds all the kernel state, including that of each Vat and Device, in
 // a single JSON-serializable object. At any moment (well, really only
@@ -126,7 +126,7 @@ export default function makeKernelKeeper(storage) {
   function addKernelObject(ownerID) {
     insistVatID(ownerID);
     const id = Nat(Number(getRequired('ko.nextID')));
-    kdebug(`Adding kernel object ${id} for ${ownerID}`);
+    kdebug(`Adding kernel object ko${id} for ${ownerID}`);
     storage.set('ko.nextID', `${id + 1}`);
     const s = makeKernelSlot('object', id);
     storage.set(`${s}.owner`, ownerID);
@@ -143,6 +143,7 @@ export default function makeKernelKeeper(storage) {
   function addKernelDeviceNode(deviceID) {
     insistDeviceID(deviceID);
     const id = Nat(Number(getRequired('kd.nextID')));
+    kdebug(`Adding kernel device kd${id} for ${deviceID}`);
     storage.set('kd.nextID', `${id + 1}`);
     const s = makeKernelSlot('device', id);
     storage.set(`${s}.owner`, deviceID);
@@ -159,6 +160,7 @@ export default function makeKernelKeeper(storage) {
   function addKernelPromise(deciderVatID) {
     insistVatID(deciderVatID);
     const kpid = Nat(Number(getRequired('kp.nextID')));
+    kdebug(`Adding kernel promise kp${kpid} for ${deciderVatID}`);
     storage.set('kp.nextID', `${kpid + 1}`);
     const s = makeKernelSlot('promise', kpid);
     storage.set(`${s}.state`, 'unresolved');

packages/SwingSet/src/kernel/state/vatKeeper.js

@@ -8,7 +8,7 @@ import { assert, details } from '@agoric/assert';
 import { parseKernelSlot } from '../parseKernelSlots';
 import { makeVatSlot, parseVatSlot } from '../../parseVatSlots';
 import { insistVatID } from '../id';
-import kdebug from '../kdebug';
+import { kdebug } from '../kdebug';
 
 // makeVatKeeper is a pure function: all state is kept in the argument object
 
@@ -84,7 +84,7 @@ export function makeVatKeeper(
         const kernelKey = `${vatID}.c.${kernelSlot}`;
         storage.set(kernelKey, vatSlot);
         storage.set(vatKey, kernelSlot);
-        kdebug(`Mapping ${kernelKey}<=>${vatKey}`);
+        kdebug(`Add mapping v->k ${kernelKey}<=>${vatKey}`);
       } else {
         // the vat didn't allocate it, and the kernel didn't allocate it
         // (else it would have been in the c-list), so it must be bogus
@@ -130,11 +130,26 @@ export function makeVatKeeper(
       const vatKey = `${vatID}.c.${vatSlot}`;
       storage.set(vatKey, kernelSlot);
       storage.set(kernelKey, vatSlot);
+      kdebug(`Add mapping k->v ${kernelKey}<=>${vatKey}`);
     }
 
     return storage.get(kernelKey);
   }
 
+  /**
+   * Remove an entry from the vat's c-list.
+   *
+   * @param kernelSlot  The kernel slot being removed
+   * @param vatSlot  The vat slot being removed
+   */
+  function deleteCListEntry(kernelSlot, vatSlot) {
+    const kernelKey = `${vatID}.c.${kernelSlot}`;
+    const vatKey = `${vatID}.c.${vatSlot}`;
+    kdebug(`Delete mapping ${kernelKey}<=>${vatKey}`);
+    storage.delete(kernelKey);
+    storage.delete(vatKey);
+  }
+
   /**
    * Generator function to return the vat's transcript, one entry at a time.
    */
@@ -197,6 +212,7 @@ export function makeVatKeeper(
   return harden({
     mapVatSlotToKernelSlot,
     mapKernelSlotToVatSlot,
+    deleteCListEntry,
     getTranscript,
     addToTranscript,
     vatStats,

packages/SwingSet/src/kernel/vatManager.js

@@ -5,7 +5,7 @@ import { insistKernelType, parseKernelSlot } from './parseKernelSlots';
 import { insistVatType, parseVatSlot } from '../parseVatSlots';
 import { insistCapData } from '../capdata';
 import { insistMessage } from '../message';
-import kdebug from './kdebug';
+import { kdebug, legibilizeMessageArgs } from './kdebug';
 
 export default function makeVatManager(
   vatID,
@@ -82,11 +82,6 @@ export default function makeVatManager(
   function mapKernelSlotToVatSlot(kernelSlot) {
     assert(`${kernelSlot}` === kernelSlot, 'non-string kernelSlot');
     const vatSlot = vatKeeper.mapKernelSlotToVatSlot(kernelSlot);
-    kdebug(
-      `mapKernelSlotToVatSlot for ${vatID} of ${JSON.stringify(
-        kernelSlot,
-      )} to ${vatSlot}`,
-    );
     return vatSlot;
   }
 
@@ -116,7 +111,9 @@ export default function makeVatManager(
     insistCapData(args);
     // TODO: disable send-to-self for now, qv issue #43
     const target = mapVatSlotToKernelSlot(targetSlot);
-    kdebug(`syscall[${vatID}].send(vat:${targetSlot}=ker:${target}).${method}`);
+    const argList = legibilizeMessageArgs(args).join(', ');
+    // prettier-ignore
+    kdebug(`syscall[${vatID}].send(vat:${targetSlot}=ker:${target}).${method}(${argList})`);
     const kernelSlots = args.slots.map(slot => mapVatSlotToKernelSlot(slot));
     const kernelArgs = harden({ ...args, slots: kernelSlots });
     let result = null;
@@ -206,7 +203,8 @@ export default function makeVatManager(
     }
     const kernelSlots = args.slots.map(slot => mapVatSlotToKernelSlot(slot));
     const kernelData = harden({ ...args, slots: kernelSlots });
-    kdebug(`syscall[${vatID}].callNow(${target}/${dev}).${method}`);
+    // prettier-ignore
+    kdebug(`syscall[${vatID}].callNow(${target}/${dev}).${method}(${JSON.stringify(args)})`);
     const ret = syscallManager.invoke(dev, method, kernelData);
     const retSlots = ret.slots.map(slot => mapKernelSlotToVatSlot(slot));
     return harden({ ...ret, slots: retSlots });
@@ -347,6 +345,7 @@ export default function makeVatManager(
         ['notifyFulfillToPresence', vpid, slot],
         `vat[${vatID}].promise[${vpid}] fulfillToPresence failed`,
       );
+      vatKeeper.deleteCListEntry(kpid, vpid);
     } else if (kp.state === 'redirected') {
       throw new Error('not implemented yet');
     } else if (kp.state === 'fulfilledToData') {
@@ -359,6 +358,7 @@ export default function makeVatManager(
         ['notifyFulfillToData', vpid, vatData],
         `vat[${vatID}].promise[${vpid}] fulfillToData failed`,
       );
+      vatKeeper.deleteCListEntry(kpid, vpid);
     } else if (kp.state === 'rejected') {
       const vpid = mapKernelSlotToVatSlot(kpid);
       const vatData = harden({
@@ -369,6 +369,7 @@ export default function makeVatManager(
         ['notifyReject', vpid, vatData],
         `vat[${vatID}].promise[${vpid}] reject failed`,
       );
+      vatKeeper.deleteCListEntry(kpid, vpid);
     } else {
       throw new Error(`unknown kernelPromise state '${kp.state}'`);
     }

packages/swingset-runner/bin/runner

@@ -1,5 +1,7 @@
 #!/usr/bin/env -S node --expose-gc -r esm
 
+// #!/usr/bin/env -S node --inspect-brk --expose-gc -r esm
+
 /**
  * Simple boilerplate program providing linkage to launch an application written using modules within the
  * as yet not-entirely-ESM-supporting version of NodeJS.

packages/swingset-runner/demo/justReply/bootstrap.js

@@ -0,0 +1,28 @@
+import harden from '@agoric/harden';
+
+console.log(`=> loading bootstrap.js`);
+
+export default function setup(syscall, state, helpers) {
+  function log(what) {
+    helpers.log(what);
+    console.log(what);
+  }
+  log(`=> setup called`);
+  return helpers.makeLiveSlots(
+    syscall,
+    state,
+    E =>
+      harden({
+        bootstrap(argv, vats) {
+          console.log('=> bootstrap() called');
+          E(vats.alice)
+            .sayHelloTo(vats.bob)
+            .then(
+              r => log(`=> alice.hello(bob) resolved to '${r}'`),
+              e => log(`=> alice.hello(bob) rejected as '${e}'`),
+            );
+        },
+      }),
+    helpers.vatID,
+  );
+}

packages/swingset-runner/demo/justReply/vat-alice.js

@@ -0,0 +1,28 @@
+import harden from '@agoric/harden';
+
+function build(E, log) {
+  return harden({
+    sayHelloTo(other) {
+      log(`=> Alice.sayHelloTo`);
+      const answer = E(other).hello();
+      answer.then(
+        r => log(`=> alice.hello() answer resolved to '${r}'`),
+        e => log(`=> alice.hello() answer rejected as '${e}'`),
+      );
+      return `Alice started\n`;
+    },
+  });
+}
+
+export default function setup(syscall, state, helpers) {
+  function log(what) {
+    helpers.log(what);
+    console.log(what);
+  }
+  return helpers.makeLiveSlots(
+    syscall,
+    state,
+    E => build(E, log),
+    helpers.vatID,
+  );
+}

packages/swingset-runner/demo/justReply/vat-bob.js

@@ -0,0 +1,23 @@
+import harden from '@agoric/harden';
+
+function build(_E, log) {
+  return harden({
+    hello() {
+      log(`=> Somebody said hello to Bob`);
+      return 'hi there!';
+    },
+  });
+}
+
+export default function setup(syscall, state, helpers) {
+  function log(what) {
+    helpers.log(what);
+    console.log(what);
+  }
+  return helpers.makeLiveSlots(
+    syscall,
+    state,
+    E => build(E, log),
+    helpers.vatID,
+  );
+}