only tick the garbage collector when storing values

Author: dimitropoulos

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

@@ -23,11 +23,12 @@ type blank = Satisfies<ProgramState, {
 }>
 
 type s<
-  Update extends Partial<ProgramState>
+  Source extends ProgramState,
+  Update extends Partial<ProgramState>,
 > = Satisfies<ProgramState,
   evaluate<
     & Omit<
-      blank,
+      Source,
       keyof Update
     >
     & Required<Update>
@@ -36,10 +37,12 @@ type s<
 
 // end-to-end test for garbage collection
 
-type actual1023 = Satisfies<ProgramState, s<{
-  count: 1023;
+type start1 = Satisfies<ProgramState, s<blank, {
+  count: 1;
+  stack: ["10000000000000000000000000000000", "00000000000000000000000000001111"]
   instructions: [
     { kind: 'Nop', ziltoid: 'theOmniscient' },
+    { kind: 'Store', subkind: 'I32Store8' },
     { kind: 'Nop', ziltoid: 'theOmniscient' },
   ];
   L1Cache: {
@@ -59,20 +62,42 @@ type actual1023 = Satisfies<ProgramState, s<{
   garbageCollection: 1023;
 }>>
 
-type actual1025 = executeInstruction<actual1023, true, 1024>
-type expected1025 = Satisfies<ProgramState, s<{
-  count: 1024;
+// no change to the garbage collection counter for regular instructions
+type actual2 = executeInstruction<start1, true, 2>
+type expected2 = Satisfies<ProgramState, s<start1 /* note: using `start1` here, not `blank` like the rest */, {
+  count: 2;
   instructions: [
+    { kind: 'Store', subkind: 'I32Store8' },
     { kind: 'Nop', ziltoid: 'theOmniscient' },
   ];
-  L1Cache: {};
+}>>
+type test2 = Expect<Equal<actual2, expected2>>
+
+type actual3 = executeInstruction<actual2, true, 3>
+type expected3 = Satisfies<ProgramState, s<blank, {
+  count: 3;
+  instructions: [
+    { kind: 'Nop', ziltoid: 'theOmniscient' },
+  ];
+  L1Cache: evaluate<start1['L1Cache'] & {
+    "10000000000000000000000000000000": "00001111"; // from the I32Store8
+  }>;
+  memory: start1['memory'];
+  garbageCollection: 1024;
+}>>
+type test3 = Expect<Equal<actual3, expected3>>
+
+type actual4 = executeInstruction<actual3, true, 4>
+type expected4 = Satisfies<ProgramState, s<blank, {
+  count: 4;
   memory: {
     "00000000000000000000000000000000": "00101110"; // source and update match
   //"00000000000000000000000000000001": "11111111"; // the update cleared this value
     "00000000000000000000000000000100": "01010101"; // newly added by the update
     "00000000000000000000000000000111": "00000010"; // modified by the update
     "11111111111111111111111100000011": "00000001"; // the random other data only present in the source
+    "10000000000000000000000000000000": "00001111"; // from the I32Store8
   }
   garbageCollection: 0;
 }>>
-type test1025 = Expect<Equal<actual1025, expected1025>>
+type test4 = Expect<Equal<actual4, expected4>>

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

@@ -14,13 +14,32 @@ export type IMemoryGrow = {
 export type ILoad = {
   kind: "Load"
   offset?: WasmValue
-  subkind: string
+  subkind:
+    | 'I32Load'
+    | 'I32Load8u'
+    | 'I32Load8s'
+    | 'I32Load16u'
+    | 'I32Load16s'
+    | 'I64Load'
+    | 'I64Load8u'
+    | 'I64Load8s'
+    | 'I64Load16u'
+    | 'I64Load16s'
+    | 'I64Load32u'
+    | 'I64Load32s'
 }
 
 export type IStore = {
   kind: "Store"
   offset?: WasmValue
-  subkind: string
+  subkind:
+    | "I32Store"
+    | "I32Store8"
+    | "I32Store16"
+    | "I64Store"
+    | "I64Store8"
+    | "I64Store16"
+    | "I64Store32"
 }
 
 export type MemoryInstruction =
@@ -301,18 +320,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

@@ -475,13 +475,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 SweepL1Every
+        : state['garbageCollection'] extends SweepL1Every
           ? true
           : false,
     > = Satisfies<ProgramState,
@@ -509,7 +506,7 @@ export namespace State {
           indirect: state['indirect'];
           results: state['results'];
         }
-      : _next
+      : state
     >
   }