debont80
384870ee4a
PERF3: pumpBench.test.ts pins pump()'s pipeline cost — 0.43ms @5k items, 1.47ms @20k (median) — negligible at a few events/sec, so the count+pointer rewrite of the core queue is declined as risk without reward; the benchmark stays as a 5ms regression tripwire. PERF6/L162: closed as documented-by-design (virtualization bounds mounted thumbs; a theme prop conflicts with PERF5's stable renderer). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
79 lines
3.0 KiB
TypeScript
79 lines
3.0 KiB
TypeScript
/**
|
|
* PERF3 evidence: pump() rescans the whole items array per queue event
|
|
* (filter + filter/reverse/slice + Set + map). The audit deferred a
|
|
* count+pointer rewrite as risk > reward on a bounded list — this benchmark
|
|
* pins that judgment with numbers at and beyond realistic queue sizes
|
|
* (a large channel enqueue is a few thousand items; events arrive a few times
|
|
* per second while downloads run).
|
|
*
|
|
* The measured pipeline below replicates pump()'s exact array operations on
|
|
* the same item shape (the real pump also spawns downloads, which would drown
|
|
* the scan in noise); the generous assertion doubles as a regression tripwire.
|
|
*/
|
|
import { describe, it, expect } from 'vitest'
|
|
import type { DownloadItem } from '../src/renderer/src/store/downloadTypes'
|
|
|
|
function makeItems(n: number): DownloadItem[] {
|
|
const statuses: DownloadItem['status'][] = ['completed', 'queued', 'downloading', 'error']
|
|
return Array.from({ length: n }, (_, i) => ({
|
|
id: `i${i}`,
|
|
url: `https://example.com/v/${i}`,
|
|
title: `Video ${i}`,
|
|
kind: 'video',
|
|
quality: '1080p',
|
|
status: statuses[i % statuses.length]!,
|
|
progress: 0
|
|
}))
|
|
}
|
|
|
|
/** pump()'s scan/promote pipeline, byte-for-byte the same array operations. */
|
|
function pumpScan(items: DownloadItem[], maxConcurrent: number): number {
|
|
const running = items.filter((i) => i.status === 'downloading').length
|
|
const slots = maxConcurrent - running
|
|
if (slots <= 0) return 0
|
|
const toStart = items
|
|
.filter((i) => i.status === 'queued')
|
|
.reverse()
|
|
.slice(0, slots)
|
|
if (toStart.length === 0) return 0
|
|
const ids = new Set(toStart.map((i) => i.id))
|
|
const next = items.map((i) => (ids.has(i.id) ? { ...i, status: 'downloading' as const } : i))
|
|
return next.length
|
|
}
|
|
|
|
function bench(items: DownloadItem[], maxConcurrent: number, iterations: number): number {
|
|
// Warm up JIT + caches.
|
|
for (let i = 0; i < 20; i++) pumpScan(items, maxConcurrent)
|
|
const times: number[] = []
|
|
for (let i = 0; i < iterations; i++) {
|
|
const t0 = performance.now()
|
|
pumpScan(items, maxConcurrent)
|
|
times.push(performance.now() - t0)
|
|
}
|
|
times.sort((a, b) => a - b)
|
|
return times[Math.floor(times.length / 2)]!
|
|
}
|
|
|
|
describe('pump() cost at scale (PERF3)', () => {
|
|
it('a full scan+promote over 5,000 items is well under a millisecond-scale budget', () => {
|
|
const median = bench(makeItems(5_000), 3 + 1_250, 50) // slots open → full pipeline
|
|
|
|
console.log(`pump pipeline @5k items: median ${median.toFixed(3)} ms`)
|
|
expect(median).toBeLessThan(5)
|
|
})
|
|
|
|
it('a full scan+promote over 20,000 items stays inside a 5 ms budget', () => {
|
|
const median = bench(makeItems(20_000), 3 + 5_000, 50)
|
|
|
|
console.log(`pump pipeline @20k items: median ${median.toFixed(3)} ms`)
|
|
expect(median).toBeLessThan(5)
|
|
})
|
|
|
|
it('the no-free-slot fast path (the per-progress-event case) is trivially cheap', () => {
|
|
const median = bench(makeItems(20_000), 1, 100) // running >= cap → early return
|
|
|
|
console.log(`pump no-slot path @20k items: median ${median.toFixed(3)} ms`)
|
|
expect(median).toBeLessThan(2)
|
|
})
|
|
})
|