@zk-tech/bedrock 0.0.1

package/src/scheduler/core/chunk-scheduler.test.ts

@@ -0,0 +1,54 @@
+import { ChunkScheduler } from './chunk-scheduler';
+import { getScheduler } from './scheduler';
+import { Task } from './task';
+
+const scheduler = getScheduler();
+
+describe('ChunkScheduler', () => {
+  beforeEach(() => {
+    scheduler.taskQueue.waitingTasks.clear();
+    scheduler.taskQueue.timerTasks.clear();
+  });
+
+  // 续上task执行
+  test('continueExecute1', () => {
+    const fn1 = vi.fn();
+    const fn2 = vi.fn();
+    const task = new Task(fn1, 10, 30);
+    scheduler.taskQueue.waitingTasks.insert(task);
+    task.clearCallback();
+
+    const chunkScheduler = new ChunkScheduler(task, scheduler);
+    chunkScheduler.continueExecute(fn2);
+
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(1);
+    expect(task.getCallback()).toBe(fn2);
+  });
+
+  // task没有执行完，就进行continue，报错
+  test('continueExecute2', () => {
+    const fn1 = vi.fn();
+    const fn2 = vi.fn();
+    const task = new Task(fn1, 10, 30);
+    scheduler.taskQueue.waitingTasks.insert(task);
+
+    const chunkScheduler = new ChunkScheduler(task, scheduler);
+    expect(() => {
+      chunkScheduler.continueExecute(fn2);
+    }).toThrowError();
+  });
+
+  // task正常执行
+  test('execute', () => {
+    const fn1 = vi.fn();
+    const fn2 = vi.fn();
+    const task = new Task(fn1, 10, 30);
+    scheduler.taskQueue.waitingTasks.insert(task);
+    task.clearCallback();
+
+    const chunkScheduler = new ChunkScheduler(task, scheduler);
+    chunkScheduler.execute(fn2);
+
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
+  });
+});

package/src/scheduler/core/chunk-scheduler.ts

@@ -0,0 +1,28 @@
+import type { Scheduler } from './scheduler';
+import { Task } from './task';
+import { type IChunkScheduler, type IScheduledCallback, type IOptions } from '../type';
+import { makeTask } from './utils';
+
+export class ChunkScheduler implements IChunkScheduler {
+  private _needContinue: boolean = false;
+
+  constructor(
+    private readonly _task: Task,
+    private readonly _scheduler: Scheduler,
+  ) {}
+
+  get needContinue() {
+    return this._needContinue;
+  }
+
+  continueExecute(callback: IScheduledCallback) {
+    this._needContinue = true;
+    // 该task还需要延续执行，更新一些信息
+    this._task.setCallback(callback);
+  }
+
+  execute(callback: IScheduledCallback, options: IOptions = {}) {
+    const newTask = makeTask(callback, options);
+    this._scheduler.addTask(newTask);
+  }
+}

package/src/scheduler/core/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"1.0.1","results":[[":task.test.ts",{"duration":0,"failed":true}],[":task-queue.test.ts",{"duration":0,"failed":true}],[":actuator.test.ts",{"duration":0,"failed":true}],[":actuator-args.test.ts",{"duration":0,"failed":true}],[":scheduler.test.ts",{"duration":0,"failed":true}],[":chunk-scheduler.test.ts",{"duration":0,"failed":true}]]}

package/src/scheduler/core/scheduler.test.ts

@@ -0,0 +1,328 @@
+/* eslint-disable max-lines-per-function */
+import { Task } from './task';
+import { getScheduler } from './scheduler';
+import { getCurrentTime } from './utils';
+
+const scheduler = getScheduler();
+
+function pending(timeMs: number) {
+  const now = getCurrentTime();
+  vi.useRealTimers();
+  const fakeNow = now + timeMs;
+  vi.useFakeTimers({ now: fakeNow });
+}
+
+describe('Scheduler', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    scheduler.taskQueue.waitingTasks.clear();
+    scheduler.taskQueue.timerTasks.clear();
+  });
+
+  // 添加单个及时任务
+  it('add callback task1', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time,
+      time + 10,
+    );
+    scheduler.addTask(task);
+
+    vi.advanceTimersByTime(10);
+
+    expect(data).toStrictEqual([1]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加多个及时任务，顺序不变
+  it('add callback task2', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time,
+      time + 10,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time,
+      time + 15,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+
+    vi.advanceTimersByTime(10);
+
+    expect(data).toStrictEqual([1, 2]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加多个及时任务，触发插队
+  it('add callback task3', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time,
+      time + 10,
+    );
+    scheduler.addTask(task1);
+
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time,
+      time + 5,
+    );
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+
+    vi.advanceTimersByTime(10);
+
+    expect(data).toStrictEqual([2, 1]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加多个及时任务，分两次执行
+  it('add callback task4', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        pending(20);
+        data.push(1);
+      }),
+      time,
+      time + 10,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time,
+      time + 30,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+
+    vi.advanceTimersByTime(5);
+
+    expect(data).toStrictEqual([1]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(1);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+
+    vi.advanceTimersByTime(10);
+
+    expect(data).toStrictEqual([1, 2]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加单个延迟任务
+  it('add timeout task1', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time + 100,
+      time + 20,
+    );
+    scheduler.addTask(task);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
+
+    vi.advanceTimersByTime(10);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
+    expect(data).toStrictEqual([]);
+
+    vi.advanceTimersByTime(200);
+    expect(data).toStrictEqual([1]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加多个延迟任务
+  it('add timeout task2', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time + 10,
+      time + 20,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time + 10,
+      time + 20,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(2);
+
+    vi.advanceTimersByTime(100);
+
+    expect(data).toStrictEqual([1, 2]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加多个延迟任务，顺序变化
+  it('add timeout task3', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time + 10,
+      time + 20,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time + 10,
+      time + 10,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(2);
+
+    vi.advanceTimersByTime(100);
+
+    expect(data).toStrictEqual([2, 1]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加多个延迟任务，分两次执行
+  it('add timeout task4', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time + 10,
+      time + 20,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time + 100,
+      time + 120,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(2);
+
+    vi.advanceTimersByTime(30);
+    expect(data).toStrictEqual([1]);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
+
+    vi.advanceTimersByTime(200);
+
+    expect(data).toStrictEqual([1, 2]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加及时任务与延迟任务
+  it('add mix task1', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        data.push(1);
+      }),
+      time,
+      time + 10,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time + 10,
+      time + 20,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(1);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
+
+    vi.advanceTimersByTime(50);
+
+    expect(data).toStrictEqual([1, 2]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 添加及时任务与延迟任务，延迟任务会插队
+  it('add mix task2', () => {
+    const data: number[] = [];
+    const time = getCurrentTime();
+    const task1 = new Task(
+      vi.fn(() => {
+        pending(20);
+        data.push(1);
+      }),
+      time,
+      time + 10,
+    );
+    const task2 = new Task(
+      vi.fn(() => {
+        data.push(2);
+      }),
+      time,
+      time + 30,
+    );
+    const task3 = new Task(
+      vi.fn(() => {
+        data.push(3);
+      }),
+      time + 10,
+      time + 20,
+    );
+    scheduler.addTask(task1);
+    scheduler.addTask(task2);
+    scheduler.addTask(task3);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
+
+    // 因为要触发两次scheduler的requestHostCallback，用fakeTime就得这么写
+    vi.advanceTimersByTime(50);
+    vi.advanceTimersByTime(0);
+
+    expect(data).toStrictEqual([1, 3, 2]);
+    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
+    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
+  });
+});

package/src/scheduler/core/scheduler.ts

@@ -0,0 +1,172 @@
+import { Actuator } from './actuator';
+import { TaskQueue } from './task-queue';
+import { Task } from './task';
+import { getCurrentTime } from './utils';
+import { lvAssert } from '../../assert';
+import type { IExecutor } from '../executor/executor.interface';
+import { makeExecutor } from '../executor/make-executor';
+
+declare const global: {
+  navigator:
+    | (Navigator & {
+        scheduling?: {
+          isInputPending?: () => boolean;
+        };
+      })
+    | undefined;
+};
+
+/**
+ * 调度器
+ * 负责推动任务的执行，闲时和非闲时的处理
+ */
+export class Scheduler {
+  private _isHostTimeoutScheduled: boolean = false;
+  private _isHostCallbackScheduled: boolean = false;
+  private _isWorking: boolean = false;
+  private _enableInputPending: boolean = true;
+  private readonly _executor: IExecutor = makeExecutor();
+
+  private readonly _taskQueue: TaskQueue = new TaskQueue();
+  private readonly _actuator: Actuator = new Actuator(this._taskQueue, this);
+
+  public get taskQueue() {
+    return this._taskQueue;
+  }
+
+  public get executor() {
+    return this._executor;
+  }
+
+  /**
+   * 是否需要让出事件给宿主
+   */
+  public shouldYieldToHost = (() => {
+    try {
+      if (global.navigator?.scheduling?.isInputPending !== undefined) {
+        const { scheduling } = global.navigator;
+        return (deadline: number) => {
+          if (this._enableInputPending && scheduling.isInputPending!()) {
+            // 当遇到inputPending时，认为需要释放时间片
+            return true;
+          }
+          return getCurrentTime() >= deadline;
+        };
+      }
+    } catch (e) {
+      // ...
+    }
+    return (deadline: number) => {
+      // 如果不考虑isInputPending的情况下
+      // 当前时间已经超了，认为需要释放时间片，返回true
+      return getCurrentTime() >= deadline;
+    };
+  })();
+
+  /**
+   * 设置是否开启InputPending
+   */
+  public setEnableInputPending(val: boolean) {
+    this._enableInputPending = val;
+  }
+
+  /**
+   * 调度器中添加任务
+   */
+  public addTask(task: Task) {
+    const currentTime = getCurrentTime();
+    if (task.getStartTime() > currentTime) {
+      task.setSortIndex(task.getStartTime());
+      this._taskQueue.timerTasks.insert(task);
+
+      // 如果等待队列为空，延迟队列队首是该任务，进行延迟调度
+      if (this._taskQueue.waitingTasks.peek() === null && task === this._taskQueue.timerTasks.peek()) {
+        // 如果之前已经有延迟调度了，取消再重新延迟调度
+        // 有可能之前延迟10s
+        // 最新的任务只需要延迟3s
+        if (this._isHostTimeoutScheduled) {
+          this._executor.cancelHostTimeout();
+        } else {
+          this._isHostTimeoutScheduled = true;
+        }
+        this._executor.requestHostTimeout(this._handleHostTimeout, task.getStartTime() - currentTime);
+      }
+    } else {
+      task.setSortIndex(task.getExpirationTime());
+      this._taskQueue.waitingTasks.insert(task);
+
+      // 如果当前没有在及时调度或者执行中，进行及时调度
+      if (!this._isHostCallbackScheduled && !this._isWorking) {
+        this._isHostCallbackScheduled = true;
+        this._executor.requestHostCallback(this._handleHostCallback);
+      }
+    }
+  }
+
+  /**
+   * 尝试启动异步任务调度
+   */
+  public requestHostTimeout(currentTime: number) {
+    this._requestHostTimeout(currentTime);
+  }
+
+  private readonly _handleHostTimeout = () => {
+    this._isHostTimeoutScheduled = false;
+    const currentTime = getCurrentTime();
+    this._taskQueue.advance(currentTime);
+
+    if (this._isHostCallbackScheduled) {
+      return;
+    }
+
+    if (this._taskQueue.waitingTasks.peek() !== null) {
+      this._isHostCallbackScheduled = true;
+      this._executor.requestHostCallback(this._handleHostCallback);
+      return;
+    }
+
+    this._requestHostTimeout(currentTime);
+  };
+
+  private readonly _handleHostCallback = (
+    hasTimeRemaining: boolean,
+    initialTime: number,
+    deadline: number,
+  ) => {
+    this._isHostCallbackScheduled = false;
+
+    if (this._isHostTimeoutScheduled) {
+      // 如果有异步任务调度中，直接取消，应该没必要了
+      this._isHostTimeoutScheduled = false;
+      this._executor.cancelHostTimeout();
+    }
+
+    // 进入work状态
+    this._isWorking = true;
+    try {
+      return this._actuator.workLoop(hasTimeRemaining, initialTime, deadline);
+    } finally {
+      this._isWorking = false;
+    }
+  };
+
+  private _requestHostTimeout(currentTime: number) {
+    // 调用该函数时，一定不在及时调度和异步调度的状态中
+    lvAssert(!this._isHostCallbackScheduled);
+    lvAssert(!this._isHostTimeoutScheduled);
+    const firstTimerTask = this._taskQueue.timerTasks.peek();
+    if (firstTimerTask !== null) {
+      this._isHostTimeoutScheduled = true;
+      this._executor.requestHostTimeout(this._handleHostTimeout, firstTimerTask.getStartTime() - currentTime);
+    }
+  }
+}
+
+// 考虑到外界复杂的场景，不编译时构造，按需构造
+let scheduler: Scheduler | undefined;
+export function getScheduler() {
+  if (!scheduler) {
+    scheduler = new Scheduler();
+  }
+  return scheduler;
+}

package/src/scheduler/core/task-queue.test.ts

@@ -0,0 +1,78 @@
+import { Task } from './task';
+import { TaskQueue } from './task-queue';
+
+describe('TaskQueue', () => {
+  // 保留在异步队列中
+  test('advance1', () => {
+    const taskQueue = new TaskQueue();
+    const fn = vi.fn();
+    const task1 = new Task(fn, 10, 30);
+    const task2 = new Task(fn, 20, 40);
+    taskQueue.timerTasks.insert(task1);
+    taskQueue.timerTasks.insert(task2);
+    taskQueue.advance(0);
+
+    expect(taskQueue.waitingTasks.size()).toBe(0);
+    expect(taskQueue.timerTasks.size()).toBe(2);
+  });
+
+  // 一个延时任务进入到等待任务队列
+  test('advance2', () => {
+    const taskQueue = new TaskQueue();
+    const fn = vi.fn();
+    const task1 = new Task(fn, 10, 30);
+    const task2 = new Task(fn, 20, 40);
+    taskQueue.timerTasks.insert(task1);
+    taskQueue.timerTasks.insert(task2);
+    taskQueue.advance(15);
+
+    expect(taskQueue.waitingTasks.size()).toBe(1);
+    const task = taskQueue.waitingTasks.peek()!;
+    expect(task).not.toBeUndefined();
+    expect(task.getCallback()).toBe(fn);
+    expect(task.getExpirationTime()).toBe(30);
+    expect(task.getSortIndex()).toBe(30);
+
+    expect(taskQueue.timerTasks.size()).toBe(1);
+  });
+
+  // 所有延时任务进入到等待任务队列，保持顺序
+  test('advance3', () => {
+    const taskQueue = new TaskQueue();
+    const fn = vi.fn();
+    const task1 = new Task(fn, 10, 30);
+    const task2 = new Task(fn, 20, 40);
+    taskQueue.timerTasks.insert(task1);
+    taskQueue.timerTasks.insert(task2);
+    taskQueue.advance(25);
+
+    expect(taskQueue.waitingTasks.size()).toBe(2);
+    const task = taskQueue.waitingTasks.peek()!;
+    expect(task).not.toBeUndefined();
+    expect(task.getCallback()).toBe(fn);
+    expect(task.getExpirationTime()).toBe(30);
+    expect(task.getSortIndex()).toBe(30);
+
+    expect(taskQueue.timerTasks.size()).toBe(0);
+  });
+
+  // 所有延时任务进入到等待任务队列，保持顺序
+  test('advance4', () => {
+    const taskQueue = new TaskQueue();
+    const fn = vi.fn();
+    const task1 = new Task(fn, 10, 50);
+    const task2 = new Task(fn, 20, 40);
+    taskQueue.timerTasks.insert(task1);
+    taskQueue.timerTasks.insert(task2);
+    taskQueue.advance(25);
+
+    expect(taskQueue.waitingTasks.size()).toBe(2);
+    const task = taskQueue.waitingTasks.peek()!;
+    expect(task).not.toBeUndefined();
+    expect(task.getCallback()).toBe(fn);
+    expect(task.getExpirationTime()).toBe(40);
+    expect(task.getSortIndex()).toBe(40);
+
+    expect(taskQueue.timerTasks.size()).toBe(0);
+  });
+});

package/src/scheduler/core/task-queue.ts

@@ -0,0 +1,44 @@
+import { MinHeap } from '../../structure/min-heap';
+import type { Task } from './task';
+
+function compare(lhs: Task, rhs: Task) {
+  return lhs.getSortIndex() - rhs.getSortIndex();
+}
+
+/**
+ * 任务存储队列
+ * 本身是两个小根堆
+ */
+export class TaskQueue {
+  // 延时任务
+  private readonly _timerTasks = new MinHeap<Task>(compare);
+  // 等待执行的任务
+  private readonly _waitingTasks = new MinHeap<Task>(compare);
+
+  get timerTasks() {
+    return this._timerTasks;
+  }
+
+  get waitingTasks() {
+    return this._waitingTasks;
+  }
+
+  advance(currentTime: number) {
+    let task = this._timerTasks.peek();
+    while (task !== null) {
+      if (task.getCallback() === null) {
+        // 任务已经取消
+        this._timerTasks.remove();
+      } else if (task.getStartTime() <= currentTime) {
+        // 任务触发，移动到等待队列
+        this._timerTasks.remove();
+        task.setSortIndex(task.getExpirationTime());
+        this._waitingTasks.insert(task);
+      } else {
+        // 剩余的异步任务pending即可
+        return;
+      }
+      task = this._timerTasks.peek();
+    }
+  }
+}