《移动游戏产品的架构·客户端与移动运行时》13.2 性能预算与机型分档基线

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

import { TIER_RULES } from "./memory-budget.ts";
import type { DeviceTier } from "./memory-budget.ts";

export type ProductId = "match3" | "ark";

export interface ProductBaseline {
  readonly product: ProductId;
  readonly targetFps: 30 | 60;
  readonly steadyLowEndMb: number;
  readonly alarmMb: number;
  readonly jankRatePercent: number;
  readonly lowEndSharePercent: number;
}

export const BASELINES: readonly ProductBaseline[] = [
  {
    product: "match3",
    targetFps: 30,
    steadyLowEndMb: 420,
    alarmMb: 520,
    jankRatePercent: 2.1,
    lowEndSharePercent: 35,
  },
  {
    product: "ark",
    targetFps: 60,
    steadyLowEndMb: 1150,
    alarmMb: 1450,
    jankRatePercent: 1.4,
    lowEndSharePercent: 15,
  },
];

export function frameBudgetMs(fps: number): number {
  return Math.round((1000 / fps) * 10) / 10;
}

export function validateBaseline(baseline: ProductBaseline): readonly string[] {
  const problems: string[] = [];
  if (baseline.targetFps !== 30 && baseline.targetFps !== 60) {
    problems.push(`${baseline.product}: target fps must be 30 or 60`);
  }
  if (baseline.alarmMb <= baseline.steadyLowEndMb) {
    problems.push(`${baseline.product}: alarm must be above steady memory`);
  }
  if (baseline.alarmMb < baseline.steadyLowEndMb * 1.2) {
    problems.push(`${baseline.product}: alarm headroom below 20 percent`);
  }
  if (baseline.jankRatePercent < 0 || baseline.jankRatePercent > 100) {
    problems.push(`${baseline.product}: jank rate out of range`);
  }
  if (baseline.lowEndSharePercent < 0 || baseline.lowEndSharePercent > 100) {
    problems.push(`${baseline.product}: low-end share out of range`);
  }
  return problems;
}

export interface Comparison {
  readonly comparableJank: boolean;
  readonly budgetRatio: number;
  readonly note: string;
}

export function compareJank(a: ProductBaseline, b: ProductBaseline): Comparison {
  const comparableJank = a.targetFps === b.targetFps;
  const budgetRatio = Math.round((b.targetFps / a.targetFps) * 100) / 100;
  const note = comparableJank
    ? "same target fps: jank rates share the same denominator rule"
    : "different target fps: long frames are counted over different totals, do not compare directly";
  return { comparableJank, budgetRatio, note };
}

export function deviceBudgetMb(deviceRamMb: number, tier: DeviceTier): number {
  const rule = TIER_RULES.find((item) => item.tier === tier);
  if (!rule) {
    throw new Error(`unknown device tier: ${tier}`);
  }
  return Math.floor((deviceRamMb * rule.budgetPercent) / 100);
}

export function headroomAgainstTier(
  baseline: ProductBaseline,
  deviceRamMb: number,
  tier: DeviceTier,
): number {
  return deviceBudgetMb(deviceRamMb, tier) - baseline.steadyLowEndMb;
}

export function formatBaselineTable(baselines: readonly ProductBaseline[]): string {
  const header = "product\tfps\tbudget_ms\tsteady_mb\talarm_mb\tjank_percent";
  const rows = baselines.map(
    (item) =>
      `${item.product}\t${item.targetFps}\t${frameBudgetMs(item.targetFps)}\t${
        item.steadyLowEndMb
      }\t${item.alarmMb}\t${item.jankRatePercent}`,
  );
  return [header, ...rows].join("\n");
}

product  fps  budget_ms  steady_mb  alarm_mb  jank_percent
match3   30   33.3       420        520       2.1
ark      60   16.7       1150       1450      1.4