draft

Author: justjake

c/interface.c

@@ -184,43 +184,13 @@ void QTS_RuntimeSetMemoryLimit(JSRuntime *rt, size_t limit) {
  * Memory diagnostics
  */
 
-JSValue *QTS_RuntimeComputeMemoryUsage(JSRuntime *rt, JSContext *ctx) {
-  JSMemoryUsage s;
-  JS_ComputeMemoryUsage(rt, &s);
-
-  // Note that we're going to allocate more memory just to report the memory usage.
-  // A more sound approach would be to bind JSMemoryUsage struct directly - but that's
-  // a lot of work. This should be okay in the mean time.
-  JSValue result = JS_NewObject(ctx);
-
-  // Manually generated via editor-fu from JSMemoryUsage struct definition in quickjs.h
-  JS_SetPropertyStr(ctx, result, "malloc_limit", JS_NewInt64(ctx, s.malloc_limit));
-  JS_SetPropertyStr(ctx, result, "memory_used_size", JS_NewInt64(ctx, s.memory_used_size));
-  JS_SetPropertyStr(ctx, result, "malloc_count", JS_NewInt64(ctx, s.malloc_count));
-  JS_SetPropertyStr(ctx, result, "memory_used_count", JS_NewInt64(ctx, s.memory_used_count));
-  JS_SetPropertyStr(ctx, result, "atom_count", JS_NewInt64(ctx, s.atom_count));
-  JS_SetPropertyStr(ctx, result, "atom_size", JS_NewInt64(ctx, s.atom_size));
-  JS_SetPropertyStr(ctx, result, "str_count", JS_NewInt64(ctx, s.str_count));
-  JS_SetPropertyStr(ctx, result, "str_size", JS_NewInt64(ctx, s.str_size));
-  JS_SetPropertyStr(ctx, result, "obj_count", JS_NewInt64(ctx, s.obj_count));
-  JS_SetPropertyStr(ctx, result, "obj_size", JS_NewInt64(ctx, s.obj_size));
-  JS_SetPropertyStr(ctx, result, "prop_count", JS_NewInt64(ctx, s.prop_count));
-  JS_SetPropertyStr(ctx, result, "prop_size", JS_NewInt64(ctx, s.prop_size));
-  JS_SetPropertyStr(ctx, result, "shape_count", JS_NewInt64(ctx, s.shape_count));
-  JS_SetPropertyStr(ctx, result, "shape_size", JS_NewInt64(ctx, s.shape_size));
-  JS_SetPropertyStr(ctx, result, "js_func_count", JS_NewInt64(ctx, s.js_func_count));
-  JS_SetPropertyStr(ctx, result, "js_func_size", JS_NewInt64(ctx, s.js_func_size));
-  JS_SetPropertyStr(ctx, result, "js_func_code_size", JS_NewInt64(ctx, s.js_func_code_size));
-  JS_SetPropertyStr(ctx, result, "js_func_pc2line_count", JS_NewInt64(ctx, s.js_func_pc2line_count));
-  JS_SetPropertyStr(ctx, result, "js_func_pc2line_size", JS_NewInt64(ctx, s.js_func_pc2line_size));
-  JS_SetPropertyStr(ctx, result, "c_func_count", JS_NewInt64(ctx, s.c_func_count));
-  JS_SetPropertyStr(ctx, result, "array_count", JS_NewInt64(ctx, s.array_count));
-  JS_SetPropertyStr(ctx, result, "fast_array_count", JS_NewInt64(ctx, s.fast_array_count));
-  JS_SetPropertyStr(ctx, result, "fast_array_elements", JS_NewInt64(ctx, s.fast_array_elements));
-  JS_SetPropertyStr(ctx, result, "binary_object_count", JS_NewInt64(ctx, s.binary_object_count));
-  JS_SetPropertyStr(ctx, result, "binary_object_size", JS_NewInt64(ctx, s.binary_object_size));
-
-  return jsvalue_to_heap(result);
+JSMemoryUsage *QTS_RuntimeComputeMemoryUsage(JSRuntime *rt) {
+  JSMemoryUsage *s = malloc(sizeof(JSMemoryUsage));
+  if (s == NULL) {
+    return NULL;
+  }
+  JS_ComputeMemoryUsage(rt, s);
+  return s;
 }
 
 OwnedHeapChar *QTS_RuntimeDumpMemoryUsage(JSRuntime *rt) {

exportedRuntimeMethods.json

@@ -1 +1,8 @@
-["cwrap", "stringToUTF8", "lengthBytesUTF8", "UTF8ToString", "___lsan_do_recoverable_leak_check"]
+[
+  "cwrap",
+  "stringToUTF8",
+  "lengthBytesUTF8",
+  "UTF8ToString",
+  "___lsan_do_recoverable_leak_check",
+  "getValue"
+]

packages/quickjs-emscripten-core/src/runtime.ts

@@ -14,7 +14,13 @@ import type { Disposable } from "./lifetime"
 import { DisposableResult, Lifetime, Scope, UsingDisposable } from "./lifetime"
 import { ModuleMemory } from "./memory"
 import type { QuickJSModuleCallbacks, RuntimeCallbacks } from "./module"
-import type { ContextOptions, JSModuleLoader, JSModuleNormalizer, QuickJSHandle } from "./types"
+import type {
+  ContextOptions,
+  JSMemoryUsage,
+  JSModuleLoader,
+  JSModuleNormalizer,
+  QuickJSHandle,
+} from "./types"
 import { intrinsicsToFlags } from "./types"
 
 /**
@@ -287,17 +293,53 @@ export class QuickJSRuntime extends UsingDisposable implements Disposable {
   }
 
   /**
-   * Compute memory usage for this runtime. Returns the result as a handle to a
-   * JSValue object. Use {@link QuickJSContext#dump} to convert to a native object.
-   * Calling this method will allocate more memory inside the runtime. The information
-   * is accurate as of just before the call to `computeMemoryUsage`.
-   * For a human-digestible representation, see {@link dumpMemoryUsage}.
+   * Compute memory usage for this runtime. The information is accurate as of
+   * just before the call to `computeMemoryUsage`. For a human-digestible
+   * representation, see {@link dumpMemoryUsage}.
    */
-  computeMemoryUsage(): QuickJSHandle {
-    const serviceContextMemory = this.getSystemContext().getMemory(this.rt.value)
-    return serviceContextMemory.heapValueHandle(
-      this.ffi.QTS_RuntimeComputeMemoryUsage(this.rt.value, serviceContextMemory.ctx.value),
-    )
+  computeMemoryUsage(): JSMemoryUsage {
+    const ptr = this.ffi.QTS_RuntimeComputeMemoryUsage(this.rt.value)
+    if (ptr === 0) {
+      throw new Error("Failed to compute memory usage")
+    }
+
+    let offset = 0
+    const getNextInt64 = () => {
+      const value = this.module.getValue(ptr + offset, "i64")
+      offset += 8
+      return value
+    }
+    const usage: JSMemoryUsage = {
+      malloc_size: getNextInt64(),
+      malloc_limit: getNextInt64(),
+      memory_used_size: getNextInt64(),
+      malloc_count: getNextInt64(),
+      memory_used_count: getNextInt64(),
+      atom_count: getNextInt64(),
+      atom_size: getNextInt64(),
+      str_count: getNextInt64(),
+      str_size: getNextInt64(),
+      obj_count: getNextInt64(),
+      obj_size: getNextInt64(),
+      prop_count: getNextInt64(),
+      prop_size: getNextInt64(),
+      shape_count: getNextInt64(),
+      shape_size: getNextInt64(),
+      js_func_count: getNextInt64(),
+      js_func_size: getNextInt64(),
+      js_func_code_size: getNextInt64(),
+      js_func_pc2line_count: getNextInt64(),
+      js_func_pc2line_size: getNextInt64(),
+      c_func_count: getNextInt64(),
+      array_count: getNextInt64(),
+      fast_array_count: getNextInt64(),
+      fast_array_elements: getNextInt64(),
+      binary_object_count: getNextInt64(),
+      binary_object_size: getNextInt64(),
+    }
+
+    this.module._free(ptr)
+    return usage
   }
 
   /**

packages/quickjs-emscripten-core/src/types.ts

@@ -344,3 +344,35 @@ export function concat<T>(...values: Array<T[] | T | undefined>): T[] {
   }
   return result
 }
+
+/**
+ * Result of computing memory usage of a runtime with {@link QuickJSRuntime#computeMemoryUsage}.
+ */
+export interface JSMemoryUsage {
+  malloc_size: number
+  malloc_limit: number
+  memory_used_size: number
+  malloc_count: number
+  memory_used_count: number
+  atom_count: number
+  atom_size: number
+  str_count: number
+  str_size: number
+  obj_count: number
+  obj_size: number
+  prop_count: number
+  prop_size: number
+  shape_count: number
+  shape_size: number
+  js_func_count: number
+  js_func_size: number
+  js_func_code_size: number
+  js_func_pc2line_count: number
+  js_func_pc2line_size: number
+  c_func_count: number
+  array_count: number
+  fast_array_count: number
+  fast_array_elements: number
+  binary_object_count: number
+  binary_object_size: number
+}

packages/quickjs-ffi-types/src/emscripten-types.ts

@@ -152,6 +152,7 @@ export interface EmscriptenModule extends EmscriptenModuleLoaderOptions {
     argTypes: Emscripten.ValueType[],
     opts?: Emscripten.CCallOpts,
   ): (...args: any[]) => any
+  getValue(ptr: number, type: "i8" | "i16" | "i32" | "i64" | "float" | "double"): number
 
   // USE_TYPED_ARRAYS == 2
   HEAP8: Int8Array