optimize the garbage collector (only inc when storing, and skip earlier)

Author: dimitropoulos

package.json

@@ -17,7 +17,7 @@
     "test:create-new": "pnpm --filter conformance-tests run test:create-new",
     "test:rust": "cargo test",
     "test": "pnpm run test:rust && CI=true pnpm run test:math && CI=true pnpm run test:conformance && pnpm run build",
-    "build": "node --stack-size=8100 --max-old-space-size=4096 --max-semi-space-size=4096  ./node_modules/typescript/lib/tsc",
+    "build": "node --stack-size=16384 --max-old-space-size=8192 --max-semi-space-size=8192 ./node_modules/typescript/lib/tsc",
     "build:trace": "pnpm run build --generateTrace trace",
     "build:force": "MICHIGAN_TYPESCRIPT=true time tsc --incremental false --tsBuildInfoFile null --generateCpuProfile tsc-output.cpuprofile"
   },

packages/playground/package.json

@@ -9,7 +9,7 @@
     "c-to-wat": "pnpm run compile:c-to-wasm && pnpm run compile:wasm-to-wat",
     "wat-to-wasm": "wat2wasm code.wat --output code.wasm",
     "test": "vitest",
-    "eval": "node --stack-size=8100 --max-old-space-size=4096 --max-semi-space-size=4096 --import tsx/esm ./evaluate/run.ts"
+    "eval": "node --stack-size=16384 --max-old-space-size=8192 --max-semi-space-size=8192 --import tsx/esm ./evaluate/run.ts"
   },
   "devDependencies": {
     "http-server": "^14.1.1"

packages/ts-type-math/store.ts

@@ -90,16 +90,6 @@ export type BytePatch<
       : never // unreachable
 }>, MemoryByAddress>>;
 
-export type GarbageCollect<
-  Memory extends MemoryByAddress
-> = Satisfies<MemoryByAddress, {
-  [k in keyof Memory as
-    Memory[k] extends Wasm.I8False
-    ? never
-    : k
-  ]: Memory[k]
-}>
-
 export namespace Store {
   export type I32<
     a extends WasmValue

packages/wasm-to-typescript-types/state.test.ts renamed to packages/wasm-to-typescript-types/garbageCollection.test.ts

@@ -1,22 +1,16 @@
 import { Equal, Expect } from "type-testing"
 import { ProgramState } from "./types"
-import { State } from './state'
 import type { Satisfies } from 'ts-type-math'
 import { executeInstruction } from "./program"
 
-
 // end-to-end test for garbage collection
 
 type actual1022 = Satisfies<ProgramState, {
   count: 1022;
   results: [];
   stack: ["00000000000000000000010000000001", "00000000000000000000000000000000"];
   instructions: [
-    {
-      kind: "Store";
-      subkind: "I32Store8";
-      offset: "00000000000000000000000000000000";
-    },
+    { kind: "Store"; subkind: "I32Store8" },
     { kind: 'Const'; value: '10000000000000000000000000000000' },
     { kind: 'Nop', ziltoid: 'theOmniscient' },
   ];
@@ -29,7 +23,7 @@ type actual1022 = Satisfies<ProgramState, {
     "00000000000000000000010000000000": "01000001";
   };
   memory: {};
-  garbageCollection: 1022;
+  garbageCollection: 1023;
   indirect: {};
   memorySize: "";
   executionContexts: [];
@@ -52,10 +46,9 @@ type expected1023 = Satisfies<ProgramState, {
   globals: {};
   L1Cache: {
     "00000000000000000000010000000000": "01000001";
-    "00000000000000000000010000000001": "00000000";
   };
   memory: {};
-  garbageCollection: 1023;
+  garbageCollection: 1024;
   indirect: {};
   memorySize: "";
   executionContexts: [];

packages/wasm-to-typescript-types/instructions/memory.ts

@@ -301,18 +301,20 @@ export type Store<
     infer address extends MemoryAddress,
     infer value extends WasmValue,
   ]
-  ? State.Stack.set<
-      remaining,
-
-      instruction['subkind'] extends 'I32Store'   ? StoreAll<address, value, instruction, state> :
-      instruction['subkind'] extends 'I32Store8'  ? Store8<address, value, instruction, state> :
-      instruction['subkind'] extends 'I32Store16' ? Store16<address, value, instruction, state> :
-
-      instruction['subkind'] extends 'I64Store'   ? StoreAll<address, value, instruction, state> :
-      instruction['subkind'] extends 'I64Store8'  ? Store8<address, value, instruction, state> :
-      instruction['subkind'] extends 'I64Store16' ? Store16<address, value, instruction, state> :
-      instruction['subkind'] extends 'I64Store32' ? Store32<address, value, instruction, state> :
-      never
+  ? State.GarbageCollection.increment<
+      State.Stack.set<
+        remaining,
+
+        instruction['subkind'] extends 'I32Store'   ? StoreAll<address, value, instruction, state> :
+        instruction['subkind'] extends 'I32Store8'  ? Store8<address, value, instruction, state> :
+        instruction['subkind'] extends 'I32Store16' ? Store16<address, value, instruction, state> :
+
+        instruction['subkind'] extends 'I64Store'   ? StoreAll<address, value, instruction, state> :
+        instruction['subkind'] extends 'I64Store8'  ? Store8<address, value, instruction, state> :
+        instruction['subkind'] extends 'I64Store16' ? Store16<address, value, instruction, state> :
+        instruction['subkind'] extends 'I64Store32' ? Store32<address, value, instruction, state> :
+        never
+      >
     >
   : State.error<"stack exhausted", instruction, state>
 >

packages/wasm-to-typescript-types/state.ts

@@ -407,10 +407,13 @@ export namespace State {
       ? CollectBytes<
           I32AddBinary<address, Wasm.I32True>,
           tail,
-          // POTENTIAL OPTIMIZATION: if we are setting head for the first time we can just skip it entirely
           _Acc & { [k in address]: head } // note: this doesn't need Patch because we are building it up from scratch
         >
-      : _Acc
+      : { [
+            k in keyof _Acc as _Acc[k] extends Wasm.I8False
+            ? never
+            : k
+          ]: _Acc[k] }
     >
 
     export type insert<
@@ -424,7 +427,7 @@ export namespace State {
           bytes
         >
     > = Satisfies<ProgramState,
-      // State.debug<[_update], {
+      // State.debug<[_update],
       {
         count: state['count']; 
         stack: state['stack'];
@@ -475,13 +478,10 @@ export namespace State {
       state extends ProgramState,
       force extends 'force' | 'schedule' = 'schedule',
 
-      // increment first, then check for collection
-      _next extends ProgramState = increment<state>,
-
       _shoudlCollect extends boolean =
         force extends 'force'
         ? true
-        : _next['garbageCollection'] extends CollectAt
+        : state['garbageCollection'] extends CollectAt
           ? true
           : false,
     > = Satisfies<ProgramState,
@@ -495,10 +495,7 @@ export namespace State {
           instructions: state['instructions'];
           activeBranches: state['activeBranches'];
           L1Cache: {}; // clear the L1Cache
-          memory: Patch<
-            state['memory'],
-            TypeMath.GarbageCollect<state['L1Cache']>
-          >; // update the memory with the L1Cache
+          memory: Patch<state['memory'], state['L1Cache']>; // update the memory with the L1Cache
           executionContexts: state['executionContexts'];
           funcs: state['funcs'];
           garbageCollection: 0; // reset
@@ -507,7 +504,7 @@ export namespace State {
           indirect: state['indirect'];
           results: state['results'];
         }
-      : _next
+      : state
     >
   }