《游戏引擎实现原理》14.1 为什么 JS 也需要 Job System

Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp

// snippet: 浏览器 Worker 的写法与 Node 不同
// 主线程
const worker = new Worker('/workers/terrain.js'); // 没有 workerData
worker.postMessage({ start: 0, end: 128 }); // 初始参数只能靠消息传
worker.onmessage = (e) => console.log(e.data);

// worker 内（terrain.js）
self.onmessage = (e) => {
  const { start, end } = e.data;
  self.postMessage(compute(start, end));
};

// snippet: 共享内存的最小例子（本机实测 SAB 初值 0，add 后 8）
const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
const counter = new Int32Array(sab);
Atomics.add(counter, 0, 8);
console.log(counter[0]); // 8——同一块内存，任何线程都看得见

// file: src/core/compute-worker.mjs
// tier: L1
// verify: node src/core/thread-probe.ts
//
// 计算 worker：对 [start, end) 的每个整数做 8 轮 xorshift 哈希链并累加。
// 纯整数运算、无分配，用来把「CPU 时间」和「调度开销」分开观察。

import { parentPort, workerData } from 'node:worker_threads';

const { start, end } = workerData;
let acc = 0 >>> 0;
for (let i = start; i < end; i++) {
  let x = i >>> 0;
  for (let k = 0; k < 8; k++) {
    x ^= x << 13; x >>>= 0;
    x ^= x >>> 17;
    x ^= x << 5; x >>>= 0;
  }
  acc = (acc + x) >>> 0;
}
parentPort.postMessage(acc);

// file: src/core/thread-shims.d.ts
// tier: L3
//
// 本工程未安装 @types/node，这里只声明 JobSystem 用到的 worker_threads API。
// 真实工程 `npm i -D @types/node` 后本文件可删。

declare module 'node:worker_threads' {
  export interface WorkerOptions {
    workerData?: unknown;
  }
  export class Worker {
    constructor(filename: string | URL, options?: WorkerOptions);
    on(event: 'message', listener: (value: unknown) => void): this;
    on(event: 'error', listener: (err: Error) => void): this;
    on(event: 'exit', listener: (code: number) => void): this;
    postMessage(value: unknown): void;
    terminate(): Promise<number>;
  }
}

// file: src/core/thread-probe.ts
// tier: L1
// verify: node src/core/thread-probe.ts
//
// helio 内核：并发能力探针。确认 Node 里 worker_threads / SharedArrayBuffer /
// Atomics 三件套是否可用，并用一个 CPU 密集任务对比「主线程串行」与
// 「4 个 worker 并行」的墙钟时间。

import { Worker } from 'node:worker_threads';
import { availableParallelism } from 'node:os';
import { performance } from 'node:perf_hooks';

// 1) 能力探针
console.log('worker_threads       :', typeof Worker);
console.log('SharedArrayBuffer    :', typeof SharedArrayBuffer);
console.log('Atomics.wait/notify  :', typeof Atomics.wait, typeof Atomics.notify);
console.log('Atomics.add/CAS      :', typeof Atomics.add, typeof Atomics.compareExchange);
console.log('availableParallelism :', availableParallelism());

// 2) 共享内存：跨线程自增一个计数器
const N = 8;
const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
const counter = new Int32Array(sab);
console.log('SAB 初值             :', counter[0]);
Atomics.add(counter, 0, N);
console.log('Atomics.add 之后      :', counter[0]);

// 3) CPU 密集任务：串行 vs 4 worker 并行
const TOTAL = 40_000_000;
const WORKERS = 4;

function hashChain(start: number, end: number): number {
  let acc = 0 >>> 0;
  for (let i = start; i < end; i++) {
    let x = i >>> 0;
    for (let k = 0; k < 8; k++) {
      x ^= x << 13; x >>>= 0;
      x ^= x >>> 17;
      x ^= x << 5; x >>>= 0;
    }
    acc = (acc + x) >>> 0;
  }
  return acc;
}

function runWorker(start: number, end: number): Promise<number> {
  return new Promise((resolve, reject) => {
    const w = new Worker(new URL('./compute-worker.mjs', import.meta.url), {
      workerData: { start, end },
    });
    w.on('message', (m) => { void w.terminate(); resolve(m as number); });
    w.on('error', reject);
  });
}

const t0 = performance.now();
const serial = hashChain(0, TOTAL);
const serialMs = performance.now() - t0;

const t1 = performance.now();
const chunk = TOTAL / WORKERS;
const parts = await Promise.all(
  Array.from({ length: WORKERS }, (_, k) =>
    runWorker(Math.floor(k * chunk), Math.floor((k + 1) * chunk)),
  ),
);
const parallelMs = performance.now() - t1;
const parallelSum = parts.reduce((a, b) => (a + b) >>> 0, 0);

console.log('serial   :', serialMs.toFixed(1), 'ms  sum', serial);
console.log('parallel :', parallelMs.toFixed(1), 'ms  sum', parallelSum);
console.log('speedup  :', (serialMs / parallelMs).toFixed(2), 'x');

worker_threads       : function
SharedArrayBuffer    : function
Atomics.wait/notify  : function function
Atomics.add/CAS      : function function
availableParallelism : 10
SAB 初值             : 0
Atomics.add 之后      : 8
serial   : 289.9 ms  sum 4274967296
parallel : 107.9 ms  sum 4274967296
speedup  : 2.69 x