《互联网产品的 AI 架构·推理性能与成本工程》1.3 压测基线与负载模型

预填充 = baseMs + round(inputTokens × prefillMsPerToken)
首 token = 就绪时刻 + 预填充
第 i 个 token = 首 token + i × round(decodeMsPerToken)
完成时刻 = 最后一个 token 的时刻

// file: src/perf/load-model.ts
// tier: L1
// verify: node --test test/perf/load-model.test.ts

import { createHash } from "node:crypto";
import { AiError } from "../core/errors.ts";
import { percentile } from "../observe/baseline.ts";
import { decomposeTimeline, summarizeLatency } from "./metrics.ts";
import type { LatencyBreakdown, StreamTimeline } from "./metrics.ts";
import { summarizeRun } from "./goodput.ts";
import type { Completion } from "./goodput.ts";

export type LoadKind = "steady" | "burst" | "longtail";

/** 确定性 mock 推理器：服务时间只由 token 数与固定参数决定，不读随机数。 */
export interface MockModelConfig {
  workers: number;
  baseMs: number;
  /** 预填充每 token 的毫秒数，落库前取整。 */
  prefillMsPerToken: number;
  /** 解码每 token 的毫秒数，落库前取整。 */
  decodeMsPerToken: number;
  coldStartMs: number;
  /** 基线默认预热：冷启动由 1.1 单独度量，不要混进容量基线。 */
  warmup: boolean;
}

export const DEFAULT_MOCK_CONFIG: MockModelConfig = {
  workers: 3, baseMs: 15, prefillMsPerToken: 0.15,
  decodeMsPerToken: 4, coldStartMs: 1200, warmup: true,
};

export interface MockRequest {
  requestId: string; arriveAtMs: number; inputTokens: number; outputTokens: number;
}

export interface MockResult {
  requestId: string; enqueuedAtMs: number; admittedAtMs: number; readyAtMs: number;
  tokenAtMs: number[]; doneAtMs: number; cold: boolean;
}

function fail(message: string): never {
  throw new AiError("invalid-request", `load-model: ${message}`);
}

function pad(index: number): string {
  return String(index).padStart(3, "0");
}

function standardRequest(prefix: string, index: number, arriveAtMs: number): MockRequest {
  return {
    requestId: `${prefix}-${pad(index)}`,
    arriveAtMs,
    inputTokens: 400 + (index % 7) * 40,
    outputTokens: 24 + (index % 5) * 4,
  };
}

/** 三种负载都是固定构造，不依赖随机数：任何机器都会得到同一组到达时刻。 */
export function buildLoad(kind: LoadKind): MockRequest[] {
  if (kind === "steady") {
    return Array.from({ length: 60 }, (_, index) => standardRequest("steady", index, index * 120));
  }
  if (kind === "burst") {
    return Array.from({ length: 60 }, (_, index) => {
      const arriveAtMs =
        index < 15 ? index * 200 : index < 45 ? 3000 + (index - 15) * 25 : 3750 + (index - 45) * 200;
      return standardRequest("burst", index, arriveAtMs);
    });
  }
  if (kind === "longtail") {
    return Array.from({ length: 60 }, (_, index) => ({
      requestId: `longtail-${pad(index)}`,
      arriveAtMs: index * 100,
      inputTokens: 400 + (index % 4) * 30,
      // 每十条里有一条长输出，模拟摘要、代码生成这类重请求。
      outputTokens: index % 10 === 0 ? 400 : 24 + (index % 3) * 8,
    }));
  }
  fail(`未知负载 ${String(kind)}`);
}

function validateConfig(config: MockModelConfig): void {
  if (!Number.isInteger(config.workers) || config.workers < 1) fail("workers 必须是正整数");
  if (typeof config.warmup !== "boolean") fail("warmup 必须是布尔值");
  for (const [label, value] of [
    ["baseMs", config.baseMs], ["prefillMsPerToken", config.prefillMsPerToken],
    ["decodeMsPerToken", config.decodeMsPerToken], ["coldStartMs", config.coldStartMs],
  ] as const) {
    if (!Number.isFinite(value) || value < 0) fail(`${label} 必须是非负有限数`);
  }
}

/**
 * 固定 worker 数的 FIFO 模拟。每个 worker 的第一条请求支付冷启动；
 * 其余请求的服务时间 = 预填充 + 解码，全部由 token 数算出。
 */
export function simulateMockInference(
  requests: readonly MockRequest[],
  config: MockModelConfig = DEFAULT_MOCK_CONFIG,
): MockResult[] {
  validateConfig(config);
  if (requests.length === 0) return [];
  for (const request of requests) {
    if (!Number.isFinite(request.arriveAtMs) || request.arriveAtMs < 0) {
      fail(`${request.requestId}: arriveAtMs 必须是非负有限数`);
    }
    if (!Number.isInteger(request.inputTokens) || request.inputTokens < 1) {
      fail(`${request.requestId}: inputTokens 必须是正整数`);
    }
    if (!Number.isInteger(request.outputTokens) || request.outputTokens < 1) {
      fail(`${request.requestId}: outputTokens 必须是正整数`);
    }
  }

  const pending = [...requests].sort(
    (left, right) => left.arriveAtMs - right.arriveAtMs || left.requestId.localeCompare(right.requestId),
  );
  const workerFreeAt = Array.from({ length: config.workers }, () => 0);
  const coldLeft = Array.from({ length: config.workers }, () => (config.warmup ? 0 : 1));
  const results: MockResult[] = [];

  for (const request of pending) {
    let worker = 0;
    for (let index = 1; index < workerFreeAt.length; index += 1) {
      if (workerFreeAt[index] < workerFreeAt[worker]) worker = index;
    }
    const admittedAtMs = Math.max(request.arriveAtMs, workerFreeAt[worker]);
    const cold = coldLeft[worker] > 0;
    if (cold) coldLeft[worker] -= 1;
    const readyAtMs = admittedAtMs + (cold ? config.coldStartMs : 0);
    const prefillMs = config.baseMs + Math.round(request.inputTokens * config.prefillMsPerToken);
    const firstTokenAtMs = readyAtMs + prefillMs;
    const tokenAtMs = Array.from(
      { length: request.outputTokens },
      (_, index) => firstTokenAtMs + index * Math.round(config.decodeMsPerToken),
    );
    const doneAtMs = tokenAtMs[tokenAtMs.length - 1];
    workerFreeAt[worker] = doneAtMs;
    results.push({ requestId: request.requestId, enqueuedAtMs: request.arriveAtMs, admittedAtMs, readyAtMs, tokenAtMs, doneAtMs, cold });
  }
  return results;
}

export interface LoadReport {
  load: LoadKind; requests: number; workers: number; windowMs: number;
  throughputRps: number; tokenThroughput: number;
  ttftP50Ms: number; ttftP95Ms: number; ttftMaxMs: number; tpotP95Ms: number;
  e2eP50Ms: number; e2eP95Ms: number; e2eMaxMs: number; queueP95Ms: number;
  metSlo: number; goodputRps: number; goodputRatio: number; coldRequests: number;
}

function toTimeline(result: MockResult): StreamTimeline {
  return {
    requestId: result.requestId, enqueuedAtMs: result.enqueuedAtMs,
    admittedAtMs: result.admittedAtMs, readyAtMs: result.readyAtMs, tokenAtMs: result.tokenAtMs,
  };
}

function toCompletion(result: MockResult): Completion {
  return {
    requestId: result.requestId, arriveAtMs: result.enqueuedAtMs,
    startAtMs: result.admittedAtMs, doneAtMs: result.doneAtMs,
    latencyMs: result.doneAtMs - result.enqueuedAtMs,
    outputTokens: result.tokenAtMs.length, batchSize: 1,
  };
}

/** 单次负载的基线行。数字全部由 mock 推理器算出，可直接逐条复算。 */
export function runLoad(
  kind: LoadKind,
  config: MockModelConfig = DEFAULT_MOCK_CONFIG,
  sloMs = 1000,
): LoadReport {
  const results = simulateMockInference(buildLoad(kind), config);
  const breakdowns: LatencyBreakdown[] = results.map((result) => decomposeTimeline(toTimeline(result)));
  const latency = summarizeLatency(breakdowns);
  const run = summarizeRun(results.map(toCompletion), sloMs);
  return {
    load: kind, requests: results.length, workers: config.workers, windowMs: run.windowMs,
    throughputRps: run.throughputRps, tokenThroughput: run.tokenThroughput,
    ttftP50Ms: latency.ttftP50Ms, ttftP95Ms: latency.ttftP95Ms,
    ttftMaxMs: Math.max(...breakdowns.map((item) => item.firstToken.ttftMs)),
    tpotP95Ms: latency.tpotP95Ms, e2eP50Ms: latency.e2eP50Ms, e2eP95Ms: latency.e2eP95Ms,
    e2eMaxMs: Math.max(...breakdowns.map((item) => item.e2eMs)),
    queueP95Ms: percentile(breakdowns.map((item) => item.firstToken.queueMs), 0.95),
    metSlo: run.metSlo, goodputRps: run.goodputRps, goodputRatio: run.goodputRatio,
    coldRequests: results.filter((item) => item.cold).length,
  };
}

export interface BaselineReport {
  config: MockModelConfig; sloMs: number; loads: LoadReport[];
  /** 相同输入必须得到相同指纹；它是“可复现”的机器可读证据。 */
  fingerprint: string;
}

export function fingerprintOf(value: unknown): string {
  return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
}

/** 一次生成三份负载基线；报告不含时间戳，因此可以逐字段比对。 */
export function buildBaselineReport(
  config: MockModelConfig = DEFAULT_MOCK_CONFIG,
  sloMs = 1000,
): BaselineReport {
  const body = {
    config, sloMs,
    loads: [runLoad("steady", config, sloMs), runLoad("burst", config, sloMs), runLoad("longtail", config, sloMs)],
  };
  return { ...body, fingerprint: fingerprintOf(body) };
}

node --test test/perf/load-model.test.ts

ℹ tests 6
ℹ pass 6
ℹ fail 0
ℹ duration_ms 179.885833