diff --git a/packages/engine/src/services/frameCapture-staticDedupParallelVerify.test.ts b/packages/engine/src/services/frameCapture-staticDedupParallelVerify.test.ts new file mode 100644 index 0000000000..79e5004426 --- /dev/null +++ b/packages/engine/src/services/frameCapture-staticDedupParallelVerify.test.ts @@ -0,0 +1,111 @@ +import { describe, expect, it } from "vitest"; +import { + planStaticVerification, + verifyStaticFramesSafe, + type CaptureSession, +} from "./frameCapture.js"; + +const fps = 30; +type FakePage = { frame: number; evaluate: (fn: unknown, time: number) => Promise }; + +function fakePage(): FakePage { + const page: FakePage = { + frame: 0, + evaluate: async (_fn, time) => { + page.frame = Math.round(time * fps); + }, + }; + return page; +} + +function framesForRuns(runs: Array<[number, number]>): Set { + const frames = new Set(); + for (const [a, b] of runs) for (let f = a; f <= b; f++) frames.add(f); + return frames; +} + +/** Screenshots of a page show `contentAt(frame)`; `inFlight.max` records how many ran at once. */ +function capturing(contentAt: (frame: number) => string) { + const inFlight = { now: 0, max: 0 }; + const capture = async (target: unknown) => { + inFlight.now++; + inFlight.max = Math.max(inFlight.max, inFlight.now); + await new Promise((resolve) => setImmediate(resolve)); + inFlight.now--; + return Buffer.from(contentAt((target as FakePage).frame)); + }; + return { capture, inFlight }; +} + +function verify( + pages: FakePage[], + frames: Set, + capture: (target: unknown) => Promise, + now?: () => number, +) { + return verifyStaticFramesSafe( + { options: {} } as unknown as CaptureSession, + pages as unknown as Parameters[1], + frames, + fps, + 1, + { capture: capture as never, ...(now ? { now } : {}) }, + ); +} + +const runs: Array<[number, number]> = [ + [1, 40], + [50, 90], + [100, 140], + [150, 190], +]; + +describe("verifyStaticFramesSafe on several pages", () => { + it("verifies runs on every page at once", async () => { + const { capture, inFlight } = capturing(() => "still"); + + const result = await verify([fakePage(), fakePage()], framesForRuns(runs), capture); + + expect(result.outcome).toBe("verified"); + expect(result.verifiedFrames).toEqual(framesForRuns(runs)); + expect(inFlight.max).toBe(2); + }); + + it("a mismatch on one page clears the runs another page verified", async () => { + const { capture } = capturing((frame) => (frame >= 150 ? "moved" : "still")); + + const result = await verify([fakePage(), fakePage()], framesForRuns(runs), capture); + + expect(result.outcome).toBe("mismatch"); + expect(result.verifiedFrames.size).toBe(0); + }); + + it("gives the verdict one page gives", async () => { + const one = await verify([fakePage()], framesForRuns(runs), capturing(() => "still").capture); + const three = await verify( + [fakePage(), fakePage(), fakePage()], + framesForRuns(runs), + capturing(() => "still").capture, + ); + + expect(three.outcome).toBe(one.outcome); + expect(three.verifiedFrames).toEqual(one.verifiedFrames); + expect(three.stats.completedRuns).toBe(one.stats.completedRuns); + }); + + it("scales its time budget from the first shot when pages capture together", async () => { + const frames = framesForRuns(runs); + const shotMs = Math.ceil(20_000 / planStaticVerification(frames, 1).plannedScreenshots); + let clock = 0; + const { capture } = capturing(() => "still"); + const slowCapture = async (target: unknown) => { + clock += shotMs; + return capture(target); + }; + + const result = await verify([fakePage(), fakePage()], frames, slowCapture, () => clock); + + expect(result.outcome).toBe("verified"); + expect(result.verifiedFrames).toEqual(frames); + }); +}); diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts index 7de204e498..d792d14475 100644 --- a/packages/engine/src/services/frameCapture.ts +++ b/packages/engine/src/services/frameCapture.ts @@ -18,6 +18,7 @@ import { type ConsoleMessage, } from "puppeteer-core"; import { existsSync, mkdirSync, writeFileSync } from "fs"; +import { availableParallelism } from "os"; import { join } from "path"; import { COMPOSITION_SOURCE_URL, @@ -4071,6 +4072,7 @@ const STATIC_VERIFY_REFERENCE_STRIDE = 24; const STATIC_VERIFY_MAX_MS = 15_000; const STATIC_VERIFY_HEADROOM = 1.5; const STATIC_VERIFY_CEILING_MS = 60_000; +const STATIC_VERIFY_MAX_PAGES = 4; // Two captures (anchor + comparison) are the minimum proof for a run. Four hundred // therefore permits 200 fully verified runs while bounding pathological schedules. const STATIC_VERIFY_MIN_SCREENSHOT_CAP = 400; @@ -4305,7 +4307,7 @@ export async function createStaticVerificationPage(session: CaptureSession): Pro */ export async function verifyStaticFramesSafe( session: CaptureSession, - page: Page, + page: Page | readonly Page[], staticFrames: Set, fps: number, sampleCount: number, @@ -4341,10 +4343,11 @@ export async function verifyStaticFramesSafe( stats, }); if (plan.runs.length === 0) return finish("unprofitable"); - const seekToFrame = async (frameIdx: number): Promise => { + const pages = Array.isArray(page) ? page : [page]; + const seekToFrame = async (target: Page, frameIdx: number): Promise => { stats.seeks++; const t = quantizeTimeToFrame(frameIdx / fps, fps); - await page.evaluate((tt: number) => { + await target.evaluate((tt: number) => { const hf = ( window as unknown as { __hf?: { seek?: (t: number, options?: { suppressEvents?: boolean }) => void }; @@ -4360,6 +4363,7 @@ export async function verifyStaticFramesSafe( ); let firstShotMs = 0; const seekCapture = async ( + target: Page, frameIdx: number, ): Promise => { const spent = now() - startedAt; @@ -4373,46 +4377,75 @@ export async function verifyStaticFramesSafe( if (spent >= budget) return "time_budget"; if (stats.screenshots >= hardCap) return "count_budget"; const shotStart = now(); - await seekToFrame(frameIdx); - stats.screenshots++; - const buf = await capture(page, session.options); + await seekToFrame(target, frameIdx); + const first = stats.screenshots++ === 0; + const buf = await capture(target, session.options); session.options.onStaticDedupActivity?.(); - if (stats.screenshots === 1) firstShotMs = now() - shotStart; + if (first) firstShotMs = now() - shotStart; return buf; }; - // Verify profitable runs in deterministic savings order. A run is added to the armed - // set only after its anchor and every planner-selected comparison match. Budget exits - // retain completed runs; mismatch or infrastructure failure clears all verified frames. - try { - for (const run of plan.runs) { - const anchorBuf = await seekCapture(run.anchor); - if (typeof anchorBuf === "string") return finish(anchorBuf, run.a); + // Each page takes the next profitable run in savings order. A run is added to the armed set + // only after its anchor and every planner-selected comparison match. Budget exits retain + // completed runs; a mismatch or infrastructure failure on any page clears all verified frames. + let next = 0; + let budgetExit: StaticVerificationResult | undefined; + let mismatchAt: number | undefined; + let failed = false; + const stopped = () => budgetExit !== undefined || mismatchAt !== undefined || failed; + const verifyOn = async (target: Page): Promise => { + while (!stopped() && next < plan.runs.length) { + const run = plan.runs[next++]!; + const anchorBuf = await seekCapture(target, run.anchor); + if (typeof anchorBuf === "string") { + budgetExit ??= finish(anchorBuf, run.a); + return; + } stats.completedAnchors++; for (const f of run.comparisons) { - const cur = await seekCapture(f); - if (typeof cur === "string") return finish(cur, f); + const cur = await seekCapture(target, f); + if (typeof cur === "string") { + budgetExit ??= finish(cur, f); + return; + } stats.completedComparisons++; stats.byteComparisons++; if (!anchorBuf.equals(cur)) { - verifiedFrames.clear(); - stats.verifiedFrames = 0; - stats.unverifiedFrames = plan.predictedFrames; - return finish("mismatch", f); + mismatchAt ??= f; + return; } } + if (mismatchAt !== undefined || failed) return; stats.completedRuns++; for (let frame = run.a; frame <= run.b; frame++) verifiedFrames.add(frame); stats.verifiedFrames = verifiedFrames.size; stats.unverifiedFrames = plan.predictedFrames - verifiedFrames.size; } - return finish("verified"); - } catch { + }; + const clearVerified = () => { verifiedFrames.clear(); stats.verifiedFrames = 0; stats.unverifiedFrames = plan.predictedFrames; - return finish("infrastructure"); + }; + try { + const settled = await Promise.allSettled( + pages.map((target) => + verifyOn(target).catch((error: unknown) => { + failed = true; + throw error; + }), + ), + ); + if (settled.some((lane) => lane.status === "rejected")) { + clearVerified(); + return finish("infrastructure"); + } + if (mismatchAt !== undefined) { + clearVerified(); + return finish("mismatch", mismatchAt); + } + return budgetExit ?? finish("verified"); } finally { - await seekToFrame(0).catch(() => {}); + await Promise.all(pages.map((target) => seekToFrame(target, 0).catch(() => {}))); stats.elapsedMs = Math.max(0, now() - startedAt); } } @@ -4733,6 +4766,13 @@ async function verifyOrShareStaticFrames( } } +/** Pages that verify static runs side by side; seeks and screenshots mostly wait on Chrome, not the CPU. */ +function staticVerificationPageCount(): number { + const forced = Number(process.env.HF_STATIC_DEDUP_VERIFY_PAGES); + if (Number.isInteger(forced) && forced >= 1) return forced; + return Math.min(STATIC_VERIFY_MAX_PAGES, Math.max(1, availableParallelism())); +} + async function verifyAndArmStaticDedup( session: CaptureSession, stats: Awaited>, @@ -4741,13 +4781,19 @@ async function verifyAndArmStaticDedup( logInitPhase: (phase: string) => void, onVerdict: (verdict: StaticVerificationResult) => void, ): Promise { - let verificationPage: Page | undefined; + let verificationPages: Page[] = []; let verdict: StaticVerificationResult; try { - verificationPage = await createStaticVerificationPage(session); + const opened = await Promise.allSettled( + Array.from({ length: staticVerificationPageCount() }, () => + createStaticVerificationPage(session), + ), + ); + verificationPages = opened.flatMap((p) => (p.status === "fulfilled" ? [p.value] : [])); + if (verificationPages.length === 0) throw new Error("no verification page opened"); verdict = await verifyStaticFramesSafe( session, - verificationPage, + verificationPages, stats.staticFrameSet, fps, samples, @@ -4757,7 +4803,7 @@ async function verifyAndArmStaticDedup( logInitPhase("static-frame dedup: disabled (verification infrastructure failure)"); return; } finally { - await verificationPage?.close().catch(() => {}); + await Promise.all(verificationPages.map((p) => p.close().catch(() => {}))); } session.staticDedupVerification = verdict; onVerdict(verdict); diff --git a/packages/engine/src/utils/urlDownloader.runtimes.test.ts b/packages/engine/src/utils/urlDownloader.runtimes.test.ts index 311b9d72b8..9402d5cc61 100644 --- a/packages/engine/src/utils/urlDownloader.runtimes.test.ts +++ b/packages/engine/src/utils/urlDownloader.runtimes.test.ts @@ -6,6 +6,7 @@ import { describe, expect, it, vi } from "vitest"; import { fetchPublicHttpsText } from "./urlDownloader.js"; const FIXTURE = fileURLToPath(new URL("./__fixtures__/downloadPrivateAnswer.mjs", import.meta.url)); +const BUN_START_MS = 60_000; const PROXY_VARS = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "NODE_USE_ENV_PROXY"]; function envWithoutProxy(): NodeJS.ProcessEnv { @@ -33,15 +34,19 @@ describe("a name that resolves to a private address is refused on every runtime" } }); - it("under Bun, which the Cloud Run image runs", () => { - const run = spawnSync("bun", [FIXTURE], { - encoding: "utf8", - env: envWithoutProxy(), - timeout: 60_000, - }); - expect(run.status, run.stderr).toBe(0); - const result = JSON.parse(run.stdout.trim().split("\n").at(-1) ?? "{}"); - expect(result.outcome).toBe("http_rejected"); - expect(result.lookups).toBeGreaterThan(0); - }); + it( + "under Bun, which the Cloud Run image runs", + () => { + const run = spawnSync("bun", [FIXTURE], { + encoding: "utf8", + env: envWithoutProxy(), + timeout: BUN_START_MS, + }); + expect(run.status, run.stderr).toBe(0); + const result = JSON.parse(run.stdout.trim().split("\n").at(-1) ?? "{}"); + expect(result.outcome).toBe("http_rejected"); + expect(result.lookups).toBeGreaterThan(0); + }, + BUN_START_MS, + ); });