Reduce passing around objects for increased performance

Author: W4G1

src/lib/check_move_args.ts

@@ -9,23 +9,48 @@ import {
 } from "./lib.ts";
 import { toSerialized } from "./shared.ts";
 
+const WARNING_MSG =
+  "Warning: You are passing a SharedArrayBuffer to a worker without locking. Please wrap this data in a Mutex() or RwLock() to prevent race conditions.";
+
+function warnUnsafe() {
+  console.warn(WARNING_MSG);
+}
+
 export function checkMoveArgs(args: any[]) {
-  for (const arg of args) {
-    const isRawSAB = arg instanceof SharedArrayBuffer;
-    // Check if it's a TypedArray (e.g. Uint8Array) viewing a Shared buffer
-    const isViewSAB = ArrayBuffer.isView(arg) &&
-      arg.buffer instanceof SharedArrayBuffer;
-    const isThreadSafe = arg instanceof Mutex || arg instanceof Condvar ||
-      arg instanceof RwLock || arg instanceof Sender ||
-      arg instanceof Receiver || arg instanceof Semaphore ||
-      arg instanceof Barrier;
-    const isLibrarySAB = !isThreadSafe &&
-      typeof arg[toSerialized] !== "undefined";
-
-    if (isRawSAB || isViewSAB || isLibrarySAB) {
-      console.warn(
-        "Warning: You are passing a SharedArrayBuffer to a worker without locking. Please wrap this data in a Mutex() or RwLock() to prevent race conditions.",
-      );
+  const len = args.length;
+
+  for (let i = 0; i < len; i++) {
+    const arg = args[i];
+
+    // If it's null or not an object, it cannot be a SAB or Class Instance.
+    if (!arg || typeof arg !== "object") continue;
+
+    if (arg instanceof SharedArrayBuffer) {
+      warnUnsafe();
+      continue;
+    }
+
+    // We strictly use isView first (native slot check) to avoid accessing .buffer on random objects
+    if (ArrayBuffer.isView(arg) && arg.buffer instanceof SharedArrayBuffer) {
+      warnUnsafe();
+      continue;
+    }
+
+    if (arg[toSerialized] !== undefined) {
+      if (
+        arg instanceof Mutex ||
+        arg instanceof Condvar ||
+        arg instanceof RwLock ||
+        arg instanceof Sender ||
+        arg instanceof Receiver ||
+        arg instanceof Semaphore ||
+        arg instanceof Barrier
+      ) {
+        continue;
+      }
+
+      // If it had the symbol but wasn't a lock, it's unsafe.
+      warnUnsafe();
     }
   }
 }

src/lib/json_buffer.ts

@@ -1469,17 +1469,13 @@ class SharedJsonBufferImpl<T extends Proxyable> extends Serializable {
   }
 
   [toSerialized]() {
-    return {
-      value: this.buffer,
-      transfer: [],
-      typeId: 7,
-    };
+    return [this.buffer, [] as any, 7] as const;
   }
 
   static override [toDeserialized](
     data: ReturnType<
       SharedJsonBufferImpl<any>[typeof toSerialized]
-    >["value"],
+    >[0],
   ) {
     return new SharedJsonBufferImpl(null as any, data);
   }

src/lib/lib.ts

@@ -11,9 +11,19 @@ export type { JoinHandle, Result, SharedMemoryView } from "./types.ts";
 let globalPool: WorkerPool | null = null;
 let globalConfig = { maxWorkers: navigator.hardwareConcurrency || 4 };
 
+let functionIdCounter = 0;
 const globalFunctionRegistry = new WeakMap<
   UserFunction,
-  { id: string; code: string }
+  [
+    /**
+     * fnId
+     */
+    number,
+    /**
+     * code
+     */
+    string,
+  ]
 >();
 
 export function initRuntime(config: { maxWorkers: number }) {
@@ -82,7 +92,8 @@ export function spawn(arg1: any, arg2?: any): JoinHandle<any> {
 
   if (!meta) {
     // Cache miss: Generate ID and patch code
-    const id = Math.random().toString(36).slice(2);
+    // const id = Math.random().toString(36).slice(2);
+    const id = functionIdCounter++;
     const callerLocation = getCallerLocation();
 
     // We wrap this in a try-catch block inside the cache logic
@@ -92,7 +103,7 @@ export function spawn(arg1: any, arg2?: any): JoinHandle<any> {
         "export default " + fn.toString(),
         callerLocation.filePath,
       );
-      meta = { id, code };
+      meta = [id, code];
       globalFunctionRegistry.set(fn, meta);
     } catch (err) {
       console.error(err);
@@ -112,11 +123,11 @@ export function spawn(arg1: any, arg2?: any): JoinHandle<any> {
   // Task submission
   (async () => {
     try {
-      const task: ThreadTask = {
-        fnId: meta!.id,
-        code: meta!.code,
+      const task: ThreadTask = [
+        meta![0],
+        meta![1],
         args,
-      };
+      ];
 
       const val = await pool.submit(task);
       resolve({ ok: true, value: val });