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

This reverts commit 7cb0761.

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=16384 --max-old-space-size=8192 --max-semi-space-size=8192 ./node_modules/typescript/lib/tsc",
+    "build": "node --stack-size=8100 --max-old-space-size=4096 --max-semi-space-size=4096  ./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=16384 --max-old-space-size=8192 --max-semi-space-size=8192 --import tsx/esm ./evaluate/run.ts"
+    "eval": "node --stack-size=8100 --max-old-space-size=4096 --max-semi-space-size=4096 --import tsx/esm ./evaluate/run.ts"
   },
   "devDependencies": {
     "http-server": "^14.1.1"

packages/ts-type-math/store.ts

@@ -90,6 +90,16 @@ 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/instructions/memory.ts

@@ -301,20 +301,18 @@ export type Store<
     infer address extends MemoryAddress,
     infer value extends WasmValue,
   ]
-  ? 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.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>
 >

…pescript-types/garbageCollection.test.ts …s/wasm-to-typescript-types/state.test.tspackages/wasm-to-typescript-types/garbageCollection.test.ts renamed to packages/wasm-to-typescript-types/state.test.ts packages/wasm-to-typescript-types/garbageCollection.test.ts renamed to packages/wasm-to-typescript-types/state.test.ts

@@ -1,16 +1,22 @@
 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" },
+    {
+      kind: "Store";
+      subkind: "I32Store8";
+      offset: "00000000000000000000000000000000";
+    },
     { kind: 'Const'; value: '10000000000000000000000000000000' },
     { kind: 'Nop', ziltoid: 'theOmniscient' },
   ];
@@ -23,7 +29,7 @@ type actual1022 = Satisfies<ProgramState, {
     "00000000000000000000010000000000": "01000001";
   };
   memory: {};
-  garbageCollection: 1023;
+  garbageCollection: 1022;
   indirect: {};
   memorySize: "";
   executionContexts: [];
@@ -46,9 +52,10 @@ type expected1023 = Satisfies<ProgramState, {
   globals: {};
   L1Cache: {
     "00000000000000000000010000000000": "01000001";
+    "00000000000000000000010000000001": "00000000";
   };
   memory: {};
-  garbageCollection: 1024;
+  garbageCollection: 1023;
   indirect: {};
   memorySize: "";
   executionContexts: [];

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

@@ -407,13 +407,10 @@ 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
         >
-      : { [
-            k in keyof _Acc as _Acc[k] extends Wasm.I8False
-            ? never
-            : k
-          ]: _Acc[k] }
+      : _Acc
     >
 
     export type insert<
@@ -427,7 +424,7 @@ export namespace State {
           bytes
         >
     > = Satisfies<ProgramState,
-      // State.debug<[_update],
+      // State.debug<[_update], {
       {
         count: state['count']; 
         stack: state['stack'];
@@ -478,10 +475,13 @@ 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
-        : state['garbageCollection'] extends CollectAt
+        : _next['garbageCollection'] extends CollectAt
           ? true
           : false,
     > = Satisfies<ProgramState,
@@ -495,7 +495,10 @@ export namespace State {
           instructions: state['instructions'];
           activeBranches: state['activeBranches'];
           L1Cache: {}; // clear the L1Cache
-          memory: Patch<state['memory'], state['L1Cache']>; // update the memory with the L1Cache
+          memory: Patch<
+            state['memory'],
+            TypeMath.GarbageCollect<state['L1Cache']>
+          >; // update the memory with the L1Cache
           executionContexts: state['executionContexts'];
           funcs: state['funcs'];
           garbageCollection: 0; // reset
@@ -504,7 +507,7 @@ export namespace State {
           indirect: state['indirect'];
           results: state['results'];
         }
-      : state
+      : _next
     >
   }