Add realloc support to rtrace (#1062)

Author: dcodeIO

lib/rtrace/index.d.ts

@@ -1,82 +1,63 @@
-/**
- * This method returns an `RTrace` object used for reference count tracing.
- *
- * @param {TraceEventCallback?} onerror - A method that is called when a trace error event occurs.
- * @param {TraceEventCallback?} oninfo - A method that is called when a trace info event occurs.
- */
-declare function rtrace(onerror?: rtrace.TraceEventCallback, oninfo?: rtrace.TraceEventCallback): rtrace.RTrace;
+/** Creates a new `RTrace` instance, tracking allocations, frees and reference counts. */
+declare function rtrace(
+  /** Function being called when a problem is detected. */
+  onerror?: (error: Error) => void,
+  /** Function being called with information messages. */
+  oninfo?: (info: string) => void
+): rtrace.RTrace;
 
 declare namespace rtrace {
-  /**
-   * The RTrace interface represents a collection of properties that help develoeprs describe the
-   * reference counts and state of the Web Assembly module.
-   */
+  /** The rtrace instance used as the `rtrace` import to the Wasm module. */
   export interface RTrace {
-
-    /**
-     * The current allocation count.
-     */
+    /** Number of allocations so far. */
     allocCount: number;
-
-    /**
-     * The current free count.
-     */
+    /** Number of reallocations so far. */
+    reallocCount: number;
+    /** Number of frees so far. */
     freeCount: number;
-
-    /**
-     * The current increment count.
-     */
+    /** Number of RC increments (retains) so far. */
     incrementCount: number;
-
-    /**
-     * The current decrement count.
-     */
+    /** Number of RC decrements (releases) so far. */
     decrementCount: number;
 
-    /**
-     * This method is called when an allocation occurs.
-     *
-     * @param {number} block - The `ptr - 16` value indicating the start of the block.
-     */
-    onalloc(block: number): void;
-
-    /**
-     * This method is called when a block is freed.
-     *
-     * @param {number} block - The `ptr - 16` value indicating the start of the block.
-     */
-    onfree(block: number): void;
-
-    /**
-     * This method is called when a reference count is incrememnted
-     *
-     * @param {number} block - The `ptr - 16` value indicating the start of the block.
-     */
-    onincrement(block: number): void;
-
-    /**
-     * This method is called when a reference count is decremented.
-     *
-     * @param {number} block - The `ptr - 16` value indicating the start of the block.
-     */
-    ondecrement(block: number): void;
-
-    /**
-     * This property indicates if rtrace is active.
-     */
+    /** Called when a new block is allocated. */
+    onalloc(
+      /** New block being allocated. */
+      block: number
+    ): void;
+
+    /** Called when a block is reallocated and must be moved. */
+    onrealloc(
+      /** Block being moved. */
+      oldBlock: number,
+      /** New block used from now on. */
+      newBlock: number
+    ): void;
+
+    /** Called when a block is freed, implicitly or explicitly. */
+    onfree(
+      /** Block being freed. */
+      block: number
+    ): void;
+
+    /** Called when a reference to a block is retained (RC incremented by one). */
+    onincrement(
+      /** Block a reference to is being retained. */
+      block: number
+    ): void;
+
+    /** Called when a reference to a block is released (RC decremented by one). */
+    ondecrement(
+      /** Block a reference to is being released. */
+      block: number
+    ): void;
+
+    /** Checks if rtrace is active, i.e. at least one event has occurred. */
     readonly active: boolean;
 
-    /**
-     * This method returns the current number of allocated blocks.
-     */
+    /** Checks if there are any leaks and emits them via `oninfo`. Returns the number of live blocks. */
     check(): number;
-
   }
-
-  /**
-   * This is a trace event callback. It accepts a string containing a message about the event.
-   */
-  export type TraceEventCallback = (info: string) => void;
 }
 
 export = rtrace;

lib/rtrace/index.js

@@ -5,6 +5,7 @@ function rtrace(onerror, oninfo) {
   var rtrace = {
 
     allocCount: 0,
+    reallocCount: 0,
     freeCount: 0,
     incrementCount: 0,
     decrementCount: 0,
@@ -19,6 +20,26 @@ function rtrace(onerror, oninfo) {
       }
     },
 
+    onrealloc: function(oldBlock, newBlock) {
+      ++rtrace.reallocCount;
+      if (!blocks.has(oldBlock)) {
+        onerror(Error("orphaned realloc (old): " + oldBlock));
+      } else {
+        if (!blocks.has(newBlock)) {
+          onerror(Error("orphaned realloc (new): " + newBlock));
+        } else {
+          let newRc = blocks.get(newBlock);
+          if (newRc != 0) {
+            onerror(Error("invalid realloc: " + oldBlock + " -> " + newBlock + " @ " + newRc));
+          } else {
+            let oldRc = blocks.get(oldBlock);
+            oninfo("REALLOC " + oldBlock + " @ " + oldRc + " -> " + newBlock);
+            blocks.set(newBlock, oldRc);
+          }
+        }
+      }
+    },
+
     onfree: function(block) {
       ++rtrace.freeCount;
       if (!blocks.has(block)) {
@@ -47,7 +68,7 @@ function rtrace(onerror, oninfo) {
       } else {
         let rc = blocks.get(block);
         if (rc < 1) {
-          onerror(Error("invalid decrement: " + block));
+          onerror(Error("invalid decrement: " + block + " @ " + rc));
         } else {
           oninfo("-- " + block + " @ " + rc + "->" + (rc - 1));
           blocks.set(block, rc - 1);
@@ -56,7 +77,7 @@ function rtrace(onerror, oninfo) {
     },
 
     get active() {
-      return Boolean(rtrace.allocCount || rtrace.freeCount || rtrace.incrementCount || rtrace.decrementCount);
+      return Boolean(rtrace.allocCount || rtrace.reallocCount || rtrace.freeCount || rtrace.incrementCount || rtrace.decrementCount);
     },
 
     check() {

std/assembly/rt/rtrace.ts

@@ -1,6 +1,7 @@
 import { BLOCK } from "./common";
 
 export declare function onalloc(s: BLOCK): void;
+export declare function onrealloc(sOld: BLOCK, sNew: BLOCK): void;
 export declare function onincrement(s: BLOCK): void;
 export declare function ondecrement(s: BLOCK): void;
 export declare function onfree(s: BLOCK): void;

std/assembly/rt/tlsf.ts

@@ -1,5 +1,5 @@
 import { AL_BITS, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from "rt/common";
-import { onfree, onalloc } from "./rtrace";
+import { onfree, onalloc, onrealloc } from "./rtrace";
 import { REFCOUNT_MASK } from "./pure";
 
 /////////////////////// The TLSF (Two-Level Segregate Fit) memory allocator ///////////////////////
@@ -549,7 +549,10 @@ export function reallocateBlock(root: Root, block: Block, size: usize): Block {
   var newBlock = allocateBlock(root, size, block.rtId); // may invalidate cached blockInfo
   newBlock.gcInfo = block.gcInfo; // keep RC
   memory.copy(changetype<usize>(newBlock) + BLOCK_OVERHEAD, changetype<usize>(block) + BLOCK_OVERHEAD, size);
-  if (changetype<usize>(block) >= __heap_base) freeBlock(root, block);
+  if (changetype<usize>(block) >= __heap_base) {
+    if (isDefined(ASC_RTRACE)) onrealloc(block, newBlock);
+    freeBlock(root, block);
+  }
   return newBlock;
 }
 

tests/compiler/do.optimized.wat

@@ -1835,7 +1835,7 @@
   if
    i32.const 0
    i32.const 64
-   i32.const 567
+   i32.const 570
    i32.const 2
    call $~lib/builtins/abort
    unreachable

tests/compiler/do.untouched.wat

@@ -3445,7 +3445,7 @@
   if
    i32.const 0
    i32.const 64
-   i32.const 567
+   i32.const 570
    i32.const 2
    call $~lib/builtins/abort
    unreachable

tests/compiler/extends-baseaggregate.optimized.wat

@@ -1405,7 +1405,7 @@
   if
    i32.const 0
    i32.const 128
-   i32.const 567
+   i32.const 570
    i32.const 2
    call $~lib/builtins/abort
    unreachable

tests/compiler/extends-baseaggregate.untouched.wat

@@ -1806,7 +1806,7 @@
   if
    i32.const 0
    i32.const 128
-   i32.const 567
+   i32.const 570
    i32.const 2
    call $~lib/builtins/abort
    unreachable

tests/compiler/for.optimized.wat

@@ -1855,7 +1855,7 @@
   if
    i32.const 0
    i32.const 64
-   i32.const 567
+   i32.const 570
    i32.const 2
    call $~lib/builtins/abort
    unreachable

tests/compiler/for.untouched.wat

@@ -3479,7 +3479,7 @@
   if
    i32.const 0
    i32.const 64
-   i32.const 567
+   i32.const 570
    i32.const 2
    call $~lib/builtins/abort
    unreachable