@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/task-scheduler/scheduler.ts

@@ -1,22 +1,17 @@
-import { prepareTaskGraph, type PlannedTask } from "./graph.ts";
-import { diagnosticTags } from "../diagnostic-logging/logger.ts";
+import type { AdmissionPolicyContext } from "../../project-definition/project-definition.ts";
+import { prepareTaskGraph } from "./graph.ts";
 import {
   decideScheduler,
   type SchedulerDecision,
   type SchedulerTrigger
 } from "./scheduler-decision.ts";
 import {
-  cancelPendingTasks,
   createSchedulerState,
-  recordSettlement,
   snapshotSchedulerState,
-  type RunningTaskCompletion,
   type RunTaskGraphOptions,
   type SchedulerState,
-  type TaskGraphRun,
-  type TaskSettlement
+  type TaskGraphRun
 } from "./execution-state.ts";
-
 export type {
   RunTaskGraphOptions,
   SettledTask,
@@ -24,35 +19,234 @@ export type {
   TaskGraphRun,
   TaskSettlement
 } from "./execution-state.ts";
+import { AdmissionPolicyFault } from "./scheduler-admission-decision.ts";
+import { replayCoreForcedBlocks } from "./forced-block-effect-replay.ts";
+import { SchedulerPerformanceDiagnostics } from "./measurement/diagnostics.ts";
+import {
+  observeAdmissionPolicyFault,
+  observeSchedulerDecision,
+  observeSchedulerGraph,
+  performanceState
+} from "./scheduler-observation.ts";
+import { observeTerminalMeasurement } from "./scheduler-terminal-measurement.ts";
+import {
+  applyAdmission,
+  applyAdmissionPolicyFault,
+  applyBlockedSettlement,
+  applyCancellation,
+  buildTaskGraphRun,
+  nextRunningSettlement,
+  settleRunningTask
+} from "./scheduler-task-lifecycle.ts";
+import {
+  cancelPendingAdmissionCore,
+  reconcileAdmissionCore,
+  selectAdmissionCore,
+  settleRunningAdmissionCore,
+  type AdmissionCoreEffect
+} from "./admission-core/core.ts";
 
 export async function runTaskGraph<TResult>(
   options: RunTaskGraphOptions<TResult>
 ): Promise<TaskGraphRun<TResult>> {
   const graph = prepareTaskGraph(options.graph, options.maxParallel);
   const state = createSchedulerState(graph, options);
+  observeSchedulerGraph(state);
+  const measurementInput =
+    options.performanceDiagnostics ??
+    (state.admissionPolicy.requiresMeasurement === true
+      ? Object.freeze({
+          clock: Object.freeze({ now: () => performance.now() }),
+          declarativeFingerprint: ""
+        })
+      : undefined);
+  const diagnostics =
+    measurementInput === undefined
+      ? undefined
+      : new SchedulerPerformanceDiagnostics(measurementInput, performanceState(state));
+  const initialReconciliation = reconcileAdmissionCore(state.admissionCore);
+  replayCoreForcedBlocks(
+    state,
+    initialReconciliation.effects,
+    initialReconciliation.effectStates,
+    diagnostics,
+    triggerForInitialReconciliation()
+  );
   let trigger: SchedulerTrigger = Object.freeze({ kind: "execution-started" });
 
   while (true) {
-    const decision = decideScheduler(snapshotSchedulerState(state), trigger);
-    observeSchedulerDecision(state, decision);
+    let decision: SchedulerDecision;
+    try {
+      const snapshot = snapshotSchedulerState(state);
+      const measurement =
+        state.admissionPolicy.requiresMeasurement === true
+          ? () => decisionBoundaryMeasurement(diagnostics)
+          : undefined;
+      decision =
+        diagnostics?.measureControlPath(() =>
+          decideScheduler(
+            snapshot,
+            trigger,
+            state.admissionPolicy,
+            measurement,
+            state.admissionCore
+          )
+        ) ??
+        decideScheduler(snapshot, trigger, state.admissionPolicy, measurement, state.admissionCore);
+    } catch (error) {
+      if (!(error instanceof AdmissionPolicyFault)) throw error;
+      const cancellation = cancelPendingAdmissionCore(state.admissionCore);
+      state.admissionCore = cancellation.state;
+      diagnostics?.beforePendingSettlement(state.pending.map((task) => task.id));
+      if (diagnostics === undefined) applyAdmissionPolicyFault(state, error);
+      else
+        diagnostics.measureControlPath(() => {
+          applyAdmissionPolicyFault(state, error);
+        });
+      diagnostics?.captureState(performanceState(state));
+      observeAdmissionPolicyFault(state, error);
+      trigger = Object.freeze({ kind: "cancellation-applied" });
+      continue;
+    }
+    observeSchedulerDecision(state, decision, diagnostics);
 
     switch (decision.kind) {
-      case "admit":
-        applyAdmission(state, decision);
+      case "admit": {
+        if (state.signal?.aborted === true) {
+          const cancellation = cancelPendingAdmissionCore(state.admissionCore);
+          state.admissionCore = cancellation.state;
+          diagnostics?.beforePendingSettlement(state.pending.map((task) => task.id));
+          const lifecycleFault = new AdmissionPolicyFault("lifecycle-invalid-select");
+          if (diagnostics === undefined) applyAdmissionPolicyFault(state, lifecycleFault);
+          else
+            diagnostics.measureControlPath(() => {
+              applyAdmissionPolicyFault(state, lifecycleFault);
+            });
+          diagnostics?.captureState(performanceState(state));
+          observeAdmissionPolicyFault(state, lifecycleFault);
+          trigger = Object.freeze({ kind: "cancellation-applied" });
+          continue;
+        }
+        const selection = selectAdmissionCore(state.admissionCore, decision.taskId);
+        if (!selection.accepted) {
+          throw new Error("shared admission core rejected a Scheduler hard-guarded selection");
+        }
+        const admissionEffect = selection.transition.effects[0];
+        if (admissionEffect === undefined) {
+          throw new Error("shared admission core omitted a Scheduler admission effect");
+        }
+        state.admissionCore = selection.transition.state;
+        diagnostics?.beforeAdmission(decision.taskId, [...state.runningById.keys()]);
+        if (diagnostics === undefined) applyAdmission(state, decision);
+        else
+          diagnostics.measureControlPath(() => {
+            applyAdmission(state, decision);
+          });
+        diagnostics?.captureState(performanceState(state));
+        if (state.admissionPolicy.requiresMeasurement === true) {
+          diagnostics?.beginSelectedPolicyAction(decision.taskId);
+          diagnostics?.recordEffect(Object.freeze({ kind: "admitted", taskId: decision.taskId }));
+        }
+        observeAdmissionCoreEffect(state, admissionEffect);
         trigger = Object.freeze({ kind: "admission-continued" });
         continue;
+      }
       case "settle-blocked":
-        applyBlockedSettlement(state, decision);
-        trigger = Object.freeze({ kind: "blocked-settled", taskId: decision.taskId });
+        diagnostics?.beforePendingSettlement([decision.taskId]);
+        if (diagnostics === undefined) applyBlockedSettlement(state, decision);
+        else
+          diagnostics.measureControlPath(() => {
+            applyBlockedSettlement(state, decision);
+          });
+        diagnostics?.captureState(performanceState(state));
+        diagnostics?.recordEffect(
+          Object.freeze({
+            kind: "settled",
+            settlementKind: "blocked",
+            taskId: decision.taskId
+          })
+        );
+        trigger = Object.freeze({
+          kind: "blocked-settled",
+          taskId: decision.taskId
+        });
         continue;
       case "cancel-pending":
-        applyCancellation(state, decision);
+        state.admissionCore = cancelPendingAdmissionCore(state.admissionCore).state;
+        diagnostics?.beforePendingSettlement(decision.taskIds);
+        if (diagnostics === undefined) applyCancellation(state, decision);
+        else
+          diagnostics.measureControlPath(() => {
+            applyCancellation(state, decision);
+          });
+        diagnostics?.captureState(performanceState(state));
+        for (const taskId of decision.taskIds) {
+          diagnostics?.recordEffect(
+            Object.freeze({
+              kind: "settled",
+              settlementKind: "cancelled-before-start",
+              taskId
+            })
+          );
+        }
         trigger = Object.freeze({ kind: "cancellation-applied" });
         continue;
       case "await-running": {
-        applyReservationUpdate(state, decision.reservationUpdate);
+        if (decision.proposal?.kind === "wait") {
+          diagnostics?.beforeAcceptedWait();
+          if (state.admissionPolicy.requiresMeasurement === true) {
+            diagnostics?.beginWaitPolicyAction();
+          }
+        }
         const completion = await nextRunningSettlement(state);
-        settleRunningTask(state, completion);
+        diagnostics?.beforeRunningSettlement(completion.taskId);
+        if (diagnostics === undefined) settleRunningTask(state, completion);
+        else
+          diagnostics.measureControlPath(() => {
+            settleRunningTask(state, completion);
+          });
+        const settlementKind = completion.settlement.kind;
+        if (
+          settlementKind !== "completed" &&
+          settlementKind !== "prerequisite-unsatisfied" &&
+          settlementKind !== "failed"
+        ) {
+          throw new Error("running Task completed with a non-running settlement kind");
+        }
+        const transition = settleRunningAdmissionCore(
+          state.admissionCore,
+          completion.taskId,
+          settlementKind
+        );
+        if (!transition.accepted) {
+          throw new Error("shared admission core rejected a Scheduler running settlement");
+        }
+        const directEffect = transition.transition.effects[0];
+        const directState = transition.transition.effectStates[0];
+        if (directEffect === undefined || directState === undefined) {
+          throw new Error("shared admission core omitted a Scheduler running settlement effect");
+        }
+        state.admissionCore = directState;
+        diagnostics?.captureState(performanceState(state));
+        diagnostics?.recordEffect(
+          Object.freeze({
+            kind: "settled",
+            settlementKind: completion.settlement.kind,
+            taskId: completion.taskId
+          })
+        );
+        observeAdmissionCoreEffect(state, directEffect);
+        replayCoreForcedBlocks(
+          state,
+          transition.transition.effects.slice(1),
+          transition.transition.effectStates.slice(1),
+          diagnostics,
+          Object.freeze({
+            kind: "task-settled",
+            settlementKind: completion.settlement.kind,
+            taskId: completion.taskId
+          })
+        );
         trigger = Object.freeze({
           kind: "task-settled",
           settlementKind: completion.settlement.kind,
@@ -60,169 +254,37 @@ export async function runTaskGraph<TResult>(
         });
         continue;
       }
-      case "complete":
-        return buildTaskGraphRun(state);
+      case "complete": {
+        if (diagnostics === undefined) return buildTaskGraphRun(state);
+        const run = diagnostics.measureControlPath(() => buildTaskGraphRun(state));
+        const terminalMeasurement = await observeTerminalMeasurement({
+          diagnostics,
+          options,
+          state
+        });
+        return Object.freeze({ ...run, terminalMeasurement });
+      }
     }
   }
 }
 
-function observeSchedulerDecision<TResult>(
-  state: SchedulerState<TResult>,
-  decision: SchedulerDecision
-): void {
-  state.diagnosticLogger?.observe({
-    event: "scheduler.decision",
-    tags: schedulerDecisionTags(decision),
-    details: decision
-  });
-}
-
-function schedulerDecisionTags(decision: SchedulerDecision): readonly string[] {
-  return diagnosticTags(
-    "SCHEDULER",
-    decision.kind.toUpperCase(),
-    ...("taskId" in decision ? [`TASK:${decision.taskId}`] : [])
-  );
-}
-
-function applyAdmission<TResult>(
-  state: SchedulerState<TResult>,
-  decision: Extract<SchedulerDecision, { readonly kind: "admit" }>
-): void {
-  const task = takePendingTask(state, decision.taskId, "admission");
-  applyReservationUpdate(state, decision.reservationUpdate);
-  for (const mutex of task.mutex) {
-    state.runningMutexes.add(mutex);
-  }
-  activateScope(state, decision.scopeToActivate);
-
-  const completion = Promise.resolve()
-    .then(() => state.execute(task, Object.freeze({ signal: state.signal })))
-    .then((value) => completedTaskCompletion(task.id, value))
-    .catch((error: unknown) => failedTaskCompletion<TResult>(task.id, error));
-  state.runningById.set(task.id, { task, completion });
-}
-
-function activateScope<TResult>(state: SchedulerState<TResult>, scopeId: string | null): void {
-  if (scopeId === null) return;
-  const scope = state.scopesById.get(scopeId);
-  if (scope === undefined)
-    throw new Error(`scheduler admission references unknown scope ${scopeId}`);
-  scope.isActive = true;
-}
-
-function applyBlockedSettlement<TResult>(
+function observeAdmissionCoreEffect<TResult>(
   state: SchedulerState<TResult>,
-  decision: Extract<SchedulerDecision, { readonly kind: "settle-blocked" }>
+  effect: AdmissionCoreEffect
 ): void {
-  const task = takePendingTask(state, decision.taskId, "blocked settlement");
-  recordSettlement(
-    state,
-    task,
-    Object.freeze({ kind: "blocked", dependencyIds: decision.dependencyIds })
-  );
+  if (state.onAdmissionCoreEffect === undefined) return;
+  state.onAdmissionCoreEffect(Object.freeze({ effect, state: state.admissionCore }));
 }
 
-function applyCancellation<TResult>(
-  state: SchedulerState<TResult>,
-  decision: Extract<SchedulerDecision, { readonly kind: "cancel-pending" }>
-): void {
-  const pendingTaskIds = state.pending.map((task) => task.id);
-  if (!sameTaskIds(pendingTaskIds, decision.taskIds)) {
-    throw new Error("scheduler cancellation decision no longer matches pending tasks");
-  }
-  if ((state.reservationTaskId ?? null) !== decision.reservation.taskId) {
-    throw new Error("scheduler cancellation decision no longer matches reservation state");
-  }
-  cancelPendingTasks(state);
+function triggerForInitialReconciliation(): SchedulerTrigger {
+  return Object.freeze({ kind: "execution-started" });
 }
 
-function applyReservationUpdate<TResult>(
-  state: SchedulerState<TResult>,
-  reservation: Extract<
-    SchedulerDecision,
-    { readonly kind: "admit" | "await-running" }
-  >["reservationUpdate"]
-): void {
-  switch (reservation.kind) {
-    case "unchanged":
-      return;
-    case "set":
-      state.reservationTaskId = reservation.taskId;
-      return;
-    case "clear":
-      state.reservationTaskId = undefined;
-      return;
+function decisionBoundaryMeasurement(
+  diagnostics: SchedulerPerformanceDiagnostics | undefined
+): AdmissionPolicyContext["measurement"] {
+  if (diagnostics === undefined) {
+    throw new Error("custom policy measurement collector is unavailable");
   }
-}
-
-function takePendingTask<TResult>(
-  state: SchedulerState<TResult>,
-  taskId: string,
-  action: string
-): PlannedTask {
-  const index = state.pending.findIndex((task) => task.id === taskId);
-  if (index < 0) throw new Error(`task ${taskId} is not pending for ${action}`);
-  const [task] = state.pending.splice(index, 1);
-  if (task === undefined) throw new Error(`task ${taskId} disappeared during ${action}`);
-  return task;
-}
-
-async function nextRunningSettlement<TResult>(
-  state: SchedulerState<TResult>
-): Promise<RunningTaskCompletion<TResult>> {
-  if (state.runningById.size === 0) {
-    throw new Error("scheduler cannot await a task when no task is running");
-  }
-  return Promise.race([...state.runningById.values()].map((running) => running.completion));
-}
-
-function settleRunningTask<TResult>(
-  state: SchedulerState<TResult>,
-  result: RunningTaskCompletion<TResult>
-): void {
-  const running = state.runningById.get(result.taskId);
-  if (running === undefined) {
-    throw new Error(`task ${result.taskId} settled without admission`);
-  }
-  state.runningById.delete(result.taskId);
-  for (const mutex of running.task.mutex) {
-    state.runningMutexes.delete(mutex);
-  }
-  recordSettlement(state, running.task, result.settlement);
-}
-
-function completedTaskCompletion<TResult>(
-  taskId: string,
-  value: TResult
-): RunningTaskCompletion<TResult> {
-  const settlement: TaskSettlement<TResult> = { kind: "completed", value };
-  return Object.freeze({ taskId, settlement: Object.freeze(settlement) });
-}
-
-function failedTaskCompletion<TResult>(
-  taskId: string,
-  error: unknown
-): RunningTaskCompletion<TResult> {
-  const settlement: TaskSettlement<TResult> = { kind: "failed", error };
-  return Object.freeze({ taskId, settlement: Object.freeze(settlement) });
-}
-
-function buildTaskGraphRun<TResult>(state: SchedulerState<TResult>): TaskGraphRun<TResult> {
-  return Object.freeze({
-    cancelled: state.isCancelled,
-    settlements: Object.freeze(
-      state.graph.tasks.map((task) => {
-        const settlement = state.settlementsByTaskId.get(task.id);
-        if (settlement === undefined) {
-          throw new Error(`task ${task.id} was not settled`);
-        }
-        return Object.freeze({ task, settlement });
-      })
-    )
-  });
-}
-
-function sameTaskIds(left: readonly string[], right: readonly string[]): boolean {
-  return left.length === right.length && left.every((taskId, index) => taskId === right[index]);
+  return diagnostics.policyMeasurement();
 }