《互联网产品的 AI 架构·推理性能与成本工程》8.1 从业务量到 token 需求

requestsPerDay      = DAU × requestsPerUserPerDay
attemptsPerDay      = requestsPerDay × (1 + retryRate)
providerCallsPerDay = attemptsPerDay × (1 - cacheHitRate)
avgInputTokens      = Σ share_i × inputTokens_i
avgOutputTokens     = Σ share_i × outputTokens_i
dailyBillableTokens = attemptsPerDay × (avgInputTokens + avgOutputTokens)
avgRps              = attemptsPerDay / 86400
peakRps             = avgRps × peakFactor
peakTokensPerSecond = peakRps × (avgInputTokens + avgOutputTokens)
concurrency         ≈ peakRps × latencyMs / 1000

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

import { AiError } from "../core/errors.ts";

export interface LengthBucket {
  /** 该长度档占请求的比例，全部档位之和必须为 1。 */
  share: number;
  inputTokens: number;
  outputTokens: number;
}

export interface DemandInput {
  dau: number;
  requestsPerUserPerDay: number;
  lengthMix: readonly LengthBucket[];
  /** 可重试失败带来的额外尝试比例，0.08 表示请求量乘以 1.08。 */
  retryRate: number;
  /** 峰值速率相对日均速率的倍数。 */
  peakFactor: number;
  /** 结果缓存命中率；命中请求不消耗提供方 token，但仍占配额。 */
  cacheHitRate?: number;
}

export interface TokenDemand {
  requestsPerDay: number;
  attemptsPerDay: number;
  providerCallsPerDay: number;
  avgInputTokens: number;
  avgOutputTokens: number;
  dailyInputTokens: number;
  dailyOutputTokens: number;
  dailyBillableTokens: number;
  avgRps: number;
  peakRps: number;
  peakInputTokensPerSecond: number;
  peakOutputTokensPerSecond: number;
}

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

function finite(value: number, field: string, min = 0): number {
  if (!Number.isFinite(value) || value < min) fail(`${field} must be a finite number >= ${min}`);
  return value;
}

/** 长度分布按档位加权，避免用一个平均值抹掉长尾对 token 总量的贡献。 */
export function weightedAverage(mix: readonly LengthBucket[], pick: (bucket: LengthBucket) => number): number {
  if (mix.length === 0) fail("lengthMix must not be empty");
  let shareSum = 0;
  let total = 0;
  for (const bucket of mix) {
    finite(bucket.share, "lengthMix.share");
    finite(bucket.inputTokens, "lengthMix.inputTokens");
    finite(bucket.outputTokens, "lengthMix.outputTokens");
    shareSum += bucket.share;
    total += bucket.share * pick(bucket);
  }
  if (Math.abs(shareSum - 1) > 1e-9) fail(`lengthMix shares must sum to 1, got ${shareSum}`);
  return total;
}

/**
 * 业务量到 token 需求：先算请求，再算尝试，再按缓存命中折算提供方调用。
 * 配额按 attempts 计，成本按 providerCalls 计，两者不能混用。
 */
export function estimateTokenDemand(input: DemandInput): TokenDemand {
  finite(input.dau, "dau");
  finite(input.requestsPerUserPerDay, "requestsPerUserPerDay");
  finite(input.retryRate, "retryRate");
  if (input.peakFactor < 1) fail("peakFactor must be >= 1");
  const cacheHitRate = input.cacheHitRate ?? 0;
  if (cacheHitRate < 0 || cacheHitRate >= 1) fail("cacheHitRate must be in [0, 1)");

  const avgInputTokens = weightedAverage(input.lengthMix, (bucket) => bucket.inputTokens);
  const avgOutputTokens = weightedAverage(input.lengthMix, (bucket) => bucket.outputTokens);
  const requestsPerDay = Math.round(input.dau * input.requestsPerUserPerDay);
  const attemptsPerDay = Math.round(requestsPerDay * (1 + input.retryRate));
  const providerCallsPerDay = Math.round(attemptsPerDay * (1 - cacheHitRate));
  const dailyInputTokens = Math.round(providerCallsPerDay * avgInputTokens);
  const dailyOutputTokens = Math.round(providerCallsPerDay * avgOutputTokens);
  const avgRps = attemptsPerDay / 86_400;
  const peakRps = avgRps * input.peakFactor;

  return {
    requestsPerDay,
    attemptsPerDay,
    providerCallsPerDay,
    avgInputTokens,
    avgOutputTokens,
    dailyInputTokens,
    dailyOutputTokens,
    dailyBillableTokens: Math.round(attemptsPerDay * (avgInputTokens + avgOutputTokens)),
    avgRps,
    peakRps,
    peakInputTokensPerSecond: peakRps * avgInputTokens,
    peakOutputTokensPerSecond: peakRps * avgOutputTokens,
  };
}

export interface ConcurrencyInput {
  peakRps: number;
  latencyMs: number;
  /** 在 Little 定律结果之上额外预留的比例。 */
  headroomRatio?: number;
}

export interface ConcurrencyEstimate {
  baseConcurrency: number;
  plannedConcurrency: number;
  headroomConcurrency: number;
}

/** Little 定律：并发 = 到达速率 × 单次停留时间。延迟包含排队与生成。 */
export function estimateConcurrency(input: ConcurrencyInput): ConcurrencyEstimate {
  finite(input.peakRps, "peakRps");
  finite(input.latencyMs, "latencyMs");
  const headroom = input.headroomRatio ?? 0;
  if (headroom < 0) fail("headroomRatio must be >= 0");
  const base = (input.peakRps * input.latencyMs) / 1000;
  const planned = Math.ceil(base * (1 + headroom));
  return { baseConcurrency: base, plannedConcurrency: planned, headroomConcurrency: planned - base };
}

export * from "./capacity-peak.ts";
export * from "./capacity-quota.ts";

node --test test/perf/capacity.test.ts

ℹ tests 15
ℹ pass 15
ℹ fail 0
ℹ duration_ms 183.887334