Spaces:
Running
Running
| /* measure.js — how fast this machine reads an OPFS file the way a disk tier does. Run it where the tier will run | |
| * (a page or a worker); OPFS speed varies a lot between machines and browsers. | |
| * | |
| * const r = await measure(); // writes a 256 MB probe, measures, removes it | |
| * const r = await measure({ path: 'diskformer/<key>/experts.bin', recordBytes: 3345408 }); // an existing store | |
| * // → { bytes, sequentialMBps, random: { recordBytes, reads, p50Ms, p90Ms, MBps }, burst8: { p50Ms, MBps } } | |
| * | |
| * A probe the call just wrote is likely in the OS page cache, so its numbers are an upper bound; point `path` at a | |
| * store larger than RAM to see the disk itself. | |
| */ | |
| import { OpfsReaderPool, OpfsWriter, removeOpfs } from './opfs-reader.js'; | |
| const pct = (a, q) => { const s = [...a].sort((x, y) => x - y); return s[Math.min(s.length - 1, Math.floor(q * s.length))]; }; | |
| export async function measure({ path = null, bytes = 256 << 20, recordBytes = 3 << 20, reads = 64, workers = 4, chunkBytes = 64 << 20 } = {}) { | |
| const probe = !path; | |
| if (probe) { | |
| path = 'diskformer/.measure/probe.bin'; | |
| const w = await OpfsWriter.open(path, { truncate: true }); | |
| const chunk = new Uint8Array(Math.min(chunkBytes, bytes)); | |
| for (let i = 0; i < chunk.length; i += 4096) chunk[i] = i & 255; | |
| for (let at = 0; at < bytes; at += chunk.length) await w.write(chunk.subarray(0, Math.min(chunk.length, bytes - at)), at); | |
| await w.close(); | |
| } | |
| const pool = await OpfsReaderPool.open(path, { workers }); | |
| try { | |
| const size = pool.size; | |
| // Sequential: the load pattern (64 MB chunks, one at a time per worker). | |
| let t0 = performance.now(), done = 0, inflight = []; | |
| for (let at = 0; at < size; at += chunkBytes) { | |
| inflight.push(pool.read(at, Math.min(chunkBytes, size - at)).then((r) => { done += r.got; })); | |
| if (inflight.length >= workers) { await Promise.all(inflight); inflight = []; } | |
| } | |
| await Promise.all(inflight); | |
| const sequentialMBps = done / 1e6 / ((performance.now() - t0) / 1000); | |
| // Random whole records: the per-token pattern, one at a time, then bursts of 8 (one MoE layer's misses). | |
| const n = Math.max(1, Math.floor(size / recordBytes)); | |
| const at = () => Math.floor(Math.random() * n) * recordBytes; | |
| // Throughput comes from the total time: browsers coarsen performance.now() (0.1 ms in a worker without | |
| // cross-origin isolation), which rounds a single small read to zero. | |
| const one = []; let t1 = performance.now(); | |
| for (let i = 0; i < reads; i++) { const s = performance.now(); await pool.read(at(), recordBytes); one.push(performance.now() - s); } | |
| const oneMs = performance.now() - t1; | |
| const burst = [], bursts = Math.max(1, Math.round(reads / 8)); t1 = performance.now(); | |
| for (let i = 0; i < bursts; i++) { | |
| const s = performance.now(); | |
| await Promise.all(Array.from({ length: 8 }, () => pool.read(at(), recordBytes))); | |
| burst.push(performance.now() - s); | |
| } | |
| const burstMs = performance.now() - t1; | |
| const mbps = (count, ms) => Math.round((count * recordBytes) / 1e6 / (Math.max(ms, 0.1) / 1000)); | |
| return { | |
| path, bytes: size, workers, sequentialMBps: Math.round(sequentialMBps), | |
| random: { recordBytes, reads, p50Ms: +pct(one, 0.5).toFixed(2), p90Ms: +pct(one, 0.9).toFixed(2), MBps: mbps(reads, oneMs) }, | |
| burst8: { bursts, p50Ms: +pct(burst, 0.5).toFixed(2), MBps: mbps(8 * bursts, burstMs) }, | |
| }; | |
| } finally { | |
| await pool.close(); | |
| if (probe) await removeOpfs('diskformer/.measure').catch(() => {}); | |
| } | |
| } | |