Skip to content
Source
Sign inSign up
TanStack/db
Open History to see the last commit

incremental-update.ts

1,044 lines27.1 KB

1import { execSync } from 'node:child_process'
2import { mkdirSync, writeFileSync } from 'node:fs'
3import { cpus, platform, release } from 'node:os'
4import { dirname, join } from 'node:path'
5import {
6 BTreeIndex,
7 count,
8 createCollection,
9 createLiveQueryCollection,
10 createTransaction,
11 eq,
12 materialize,
13} from '../../packages/db/src/index.js'
14import type {
15 ChangeMessageOrDeleteKeyMessage,
16 Collection,
17 SyncConfig,
18} from '../../packages/db/src/index.js'
19​
20type Issue = {
21 id: number
22 status: `open` | `closed`
23 authorId: number
24 createdAt: number
25 title: string
26 body: string
27 updateTick: number
29​
30type User = {
31 id: number
32 name: string
33 reputation: number
35​
36type Comment = {
37 id: number
38 issueId: number
39 authorId: number
40 createdAt: number
41 body: string
42 updateTick: number
44​
45type ManualSyncUtils<T extends object, TKey extends string | number> = {
46 begin: Parameters<SyncConfig<T, TKey>[`sync`]>[0][`begin`]
47 write: (message: ChangeMessageOrDeleteKeyMessage<T, TKey>) => void
48 commit: Parameters<SyncConfig<T, TKey>[`sync`]>[0][`commit`]
50​
51type ManualCollection<
52 T extends object,
53 TKey extends string | number,
54> = Collection<T, TKey, ManualSyncUtils<T, TKey>, never, T>
55​
56type BenchmarkCollection = Collection<Record<string, unknown>, string | number>
57​
58type Fixture = {
59 seed: number
60 issues: ManualCollection<Issue, number>
61 users: ManualCollection<User, number>
62 comments: ManualCollection<Comment, number>
63 issueById: Map<number, Issue>
64 userById: Map<number, User>
65 commentById: Map<number, Comment>
66 visibleIssueId: number
67 selectedIssueId: number
68 nextCommentId: number
70​
71type BenchmarkOptions = {
72 seed: number
73 levels: Array<number>
74 sourceIndexModes: Array<SourceIndexMode>
75 mutationModes: Array<MutationMode>
76 issueCount?: number
77 userCount?: number
78 commentCount?: number
79 warmup: number
80 iterations: number
81 outDir: string
82 outFile?: string
84​
85type FixtureScale = {
86 label: string
87 issueCount: number
88 userCount: number
89 commentCount: number
91​
92type BenchmarkRunOptions = {
93 seed: number
94 scale: FixtureScale
95 issueCount: number
96 userCount: number
97 commentCount: number
98 sourceIndexMode: SourceIndexMode
99 warmup: number
100 iterations: number
102​
103type Summary = {
104 iterations: number
105 medianMs: number
106 p75Ms: number
107 p95Ms: number
108 minMs: number
109 maxMs: number
110 stddevMs: number
112​
113type RunResult = {
114 query: string
115 scenario: string
116 scale: FixtureScale
117 sourceIndexMode: SourceIndexMode
118 mutationMode: MutationMode
119 coldHydrateMs: number
120 writeSummary: Summary
122​
123type MutationMode = `synced` | `optimistic`
124type SourceIndexMode = `none` | `manual` | `auto`
125​
126type WriteCleanup = () => void | Promise<void>
127​
128type WriteResult = void | { cleanup: WriteCleanup }
129​
130type QueryCase = {
131 name: string
132 scenario: string
133 createQuery: (fixture: Fixture) => BenchmarkCollection
134 write: (
135 fixture: Fixture,
136 iteration: number,
137 mutationMode: MutationMode,
138 ) => WriteResult
140​
141const defaultOptions: BenchmarkOptions = {
142 seed: 42,
143 levels: [100, 1_000, 10_000],
144 sourceIndexModes: [`none`, `manual`],
145 mutationModes: [`synced`, `optimistic`],
146 warmup: 10,
147 iterations: 50,
148 outDir: `.tmp/perf`,
150​
151const defaultCustomScale: FixtureScale = {
152 label: `custom`,
153 issueCount: 10_000,
154 userCount: 1_000,
155 commentCount: 40_000,
157​
158const options = parseArgs(process.argv.slice(2), defaultOptions)
159​
160const queryCases: Array<QueryCase> = [
161 {
162 name: `list: newest 50 open`,
163 scenario: `visible issue update`,
164 createQuery: ({ issues }) =>
165 createLiveQueryCollection((q) =>
166 q
167 .from({ issue: issues })
168 .where(({ issue }) => eq(issue.status, `open`))
169 .orderBy(({ issue }) => issue.createdAt, `desc`)
170 .limit(50)
171 .select(({ issue }) => ({
172 id: issue.id,
173 title: issue.title,
174 createdAt: issue.createdAt,
175 })),
176 ) as unknown as BenchmarkCollection,
177 write: updateVisibleIssue,
178 },
179 {
180 name: `list: newest 50 open`,
181 scenario: `visible issue delete`,
182 createQuery: ({ issues }) =>
183 createLiveQueryCollection((q) =>
184 q
185 .from({ issue: issues })
186 .where(({ issue }) => eq(issue.status, `open`))
187 .orderBy(({ issue }) => issue.createdAt, `desc`)
188 .limit(50)
189 .select(({ issue }) => ({
190 id: issue.id,
191 title: issue.title,
192 createdAt: issue.createdAt,
193 })),
194 ) as unknown as BenchmarkCollection,
195 // A visible delete makes an ordered, limited query refill its window.
196 write: deleteVisibleIssue,
197 },
198 {
199 name: `list + author`,
200 scenario: `visible author update`,
201 createQuery: ({ issues, users }) =>
202 createLiveQueryCollection((q) =>
203 q
204 .from({ issue: issues })
205 .where(({ issue }) => eq(issue.status, `open`))
206 .join({ author: users }, ({ issue, author }) =>
207 eq(issue.authorId, author.id),
208 )
209 .orderBy(({ issue }) => issue.createdAt, `desc`)
210 .limit(50)
211 .select(({ issue, author }) => ({
212 id: issue.id,
213 title: issue.title,
214 createdAt: issue.createdAt,
215 authorName: author.name,
216 })),
217 ) as unknown as BenchmarkCollection,
218 write: updateVisibleAuthor,
219 },
220 {
221 name: `list + comment count`,
222 scenario: `visible issue comment insert`,
223 createQuery: ({ issues, comments }) =>
224 createLiveQueryCollection((q) =>
225 q
226 .from({ issue: issues })
227 .where(({ issue }) => eq(issue.status, `open`))
228 .orderBy(({ issue }) => issue.createdAt, `desc`)
229 .limit(50)
230 .select(({ issue }) => ({
231 id: issue.id,
232 title: issue.title,
233 commentCount: materialize(
234 q
235 .from({ comment: comments })
236 .where(({ comment }) => eq(comment.issueId, issue.id))
237 .select(({ comment }) => count(comment.id))
238 .findOne(),
239 ),
240 })),
241 ) as unknown as BenchmarkCollection,
242 write: insertVisibleComment,
243 },
244 {
245 name: `list + 3 recent comments`,
246 scenario: `visible issue comment insert`,
247 createQuery: ({ issues, comments }) =>
248 createLiveQueryCollection((q) =>
249 q
250 .from({ issue: issues })
251 .where(({ issue }) => eq(issue.status, `open`))
252 .orderBy(({ issue }) => issue.createdAt, `desc`)
253 .limit(50)
254 .select(({ issue }) => ({
255 id: issue.id,
256 title: issue.title,
257 recentComments: q
258 .from({ comment: comments })
259 .where(({ comment }) => eq(comment.issueId, issue.id))
260 .orderBy(({ comment }) => comment.createdAt, `desc`)
261 .limit(3)
262 .select(({ comment }) => ({
263 id: comment.id,
264 body: comment.body,
265 createdAt: comment.createdAt,
266 })),
267 })),
268 ) as unknown as BenchmarkCollection,
269 write: insertVisibleComment,
270 },
271 {
272 name: `issue detail + comments`,
273 scenario: `selected issue comment insert`,
274 createQuery: ({ issues, comments, selectedIssueId }) =>
275 createLiveQueryCollection((q) =>
276 q
277 .from({ issue: issues })
278 .where(({ issue }) => eq(issue.id, selectedIssueId))
279 .select(({ issue }) => ({
280 id: issue.id,
281 title: issue.title,
282 comments: q
283 .from({ comment: comments })
284 .where(({ comment }) => eq(comment.issueId, issue.id))
285 .orderBy(({ comment }) => comment.createdAt, `desc`)
286 .select(({ comment }) => ({
287 id: comment.id,
288 body: comment.body,
289 createdAt: comment.createdAt,
290 })),
291 })),
292 ) as unknown as BenchmarkCollection,
293 write: insertSelectedIssueComment,
294 },
296​
297const scales = resolveScales(options)
298const results: Array<RunResult> = []
299for (const scale of scales) {
300 for (const sourceIndexMode of options.sourceIndexModes) {
301 const runOptions = createRunOptions(options, scale, sourceIndexMode)
302 for (const mutationMode of options.mutationModes) {
303 for (const queryCase of queryCases) {
304 results.push(await runCase(queryCase, mutationMode, runOptions))
305 }
306 }
307 }
309​
310const report = {
311 metadata: runtimeMetadata(options, scales),
312 results,
314​
315const outputPath =
316 options.outFile ??
317 join(options.outDir, `incremental-update-${Date.now()}.json`)
318mkdirSync(dirname(outputPath), { recursive: true })
319writeFileSync(outputPath, JSON.stringify(report, null, 2))
320​
321console.log(formatTextReport(report, outputPath))
322​
323async function runCase(
324 queryCase: QueryCase,
325 mutationMode: MutationMode,
326 options: BenchmarkRunOptions,
327): Promise<RunResult> {
328 const fixture = createFixture(options)
329 const query = queryCase.createQuery(fixture)
330​
331 const coldStart = performance.now()
332 await query.preload()
333 await flushMicrotasks()
334 const coldHydrateMs = performance.now() - coldStart
335​
336 for (let i = 0; i < options.warmup; i++) {
337 const writeResult = queryCase.write(fixture, i, mutationMode)
338 await flushMicrotasks()
339 await cleanupWrite(writeResult)
340 }
341​
342 const samples: Array<number> = []
343 for (let i = 0; i < options.iterations; i++) {
344 const start = performance.now()
345 const writeResult = queryCase.write(
346 fixture,
347 options.warmup + i,
348 mutationMode,
349 )
350 await flushMicrotasks()
351 samples.push(performance.now() - start)
352 await cleanupWrite(writeResult)
353 }
354​
355 await cleanupFixture(fixture, query)
356​
357 return {
358 query: queryCase.name,
359 scenario: queryCase.scenario,
360 scale: options.scale,
361 sourceIndexMode: options.sourceIndexMode,
362 mutationMode,
363 coldHydrateMs,
364 writeSummary: summarize(samples),
365 }
367​
368function createManualCollection<T extends object, TKey extends string | number>(
369 id: string,
370 initialData: Array<T>,
371 getKey: (item: T) => TKey,
372 sourceIndexMode: SourceIndexMode,
373): ManualCollection<T, TKey> {
374 let begin: Parameters<SyncConfig<T, TKey>[`sync`]>[0][`begin`] | undefined
375 let write: Parameters<SyncConfig<T, TKey>[`sync`]>[0][`write`] | undefined
376 let commit: Parameters<SyncConfig<T, TKey>[`sync`]>[0][`commit`] | undefined
377​
378 const utils: ManualSyncUtils<T, TKey> = {
379 begin: () => begin!(),
380 write: (message) => write!(message),
381 commit: () => commit!(),
382 }
383​
384 return createCollection<T, TKey, ManualSyncUtils<T, TKey>>({
385 id,
386 getKey,
387 utils,
388 startSync: true,
389 autoIndex: sourceIndexMode === `auto` ? `eager` : `off`,
390 defaultIndexType: BTreeIndex,
391 sync: {
392 rowUpdateMode: `full`,
393 sync: (methods) => {
394 begin = methods.begin
395 write = methods.write
396 commit = methods.commit
397​
398 begin()
399 for (const value of initialData) {
400 write({
401 type: `insert`,
402 value,
403 })
404 }
405 commit()
406 methods.markReady()
407​
408 return () => {
409 begin = undefined
410 write = undefined
411 commit = undefined
412 }
413 },
414 },
415 })
417​
418function createFixture(options: BenchmarkRunOptions): Fixture {
419 const random = seededRandom(options.seed)
420 const usersData: Array<User> = []
421 for (let id = 1; id <= options.userCount; id++) {
422 usersData.push({
423 id,
424 name: `User ${id}`,
425 reputation: Math.floor(random() * 10_000),
426 })
427 }
428​
429 const issuesData: Array<Issue> = []
430 for (let id = 1; id <= options.issueCount; id++) {
431 issuesData.push({
432 id,
433 status: id % 3 === 0 ? `closed` : `open`,
434 authorId: 1 + (id % options.userCount),
435 createdAt: id,
436 title: `Issue ${id}`,
437 body: `Body ${id}`,
438 updateTick: 0,
439 })
440 }
441​
442 const visibleIssueId = findNewestOpenIssueId(issuesData)
443 const selectedIssueId = visibleIssueId
444 const commentsData: Array<Comment> = []
445 for (let id = 1; id <= options.commentCount; id++) {
446 const hotIssueId =
447 id % 5 === 0
448 ? 1 + Math.floor(random() * Math.min(options.issueCount, 50))
449 : 1 + Math.floor(random() * options.issueCount)
450 commentsData.push({
451 id,
452 issueId: hotIssueId,
453 authorId: 1 + (id % options.userCount),
454 createdAt: id,
455 body: `Comment ${id}`,
456 updateTick: 0,
457 })
458 }
459​
460 const fixture = {
461 seed: options.seed,
462 issues: createManualCollection(
463 `bench-issues`,
464 issuesData,
465 (issue) => issue.id,
466 options.sourceIndexMode,
467 ),
468 users: createManualCollection(
469 `bench-users`,
470 usersData,
471 (user) => user.id,
472 options.sourceIndexMode,
473 ),
474 comments: createManualCollection(
475 `bench-comments`,
476 commentsData,
477 (comment) => comment.id,
478 options.sourceIndexMode,
479 ),
480 issueById: new Map(issuesData.map((issue) => [issue.id, issue])),
481 userById: new Map(usersData.map((user) => [user.id, user])),
482 commentById: new Map(commentsData.map((comment) => [comment.id, comment])),
483 visibleIssueId,
484 selectedIssueId,
485 nextCommentId: options.commentCount + 1,
486 }
487​
488 applySourceIndexes(fixture, options.sourceIndexMode)
489​
490 return fixture
492​
493function applySourceIndexes(
494 fixture: Fixture,
495 sourceIndexMode: SourceIndexMode,
496): void {
497 if (sourceIndexMode !== `manual`) return
498​
499 fixture.issues.createIndex((issue) => issue.id)
500 fixture.issues.createIndex((issue) => issue.status)
501 fixture.issues.createIndex((issue) => issue.authorId)
502 fixture.issues.createIndex((issue) => issue.createdAt)
503 fixture.users.createIndex((user) => user.id)
504 fixture.comments.createIndex((comment) => comment.issueId)
505 fixture.comments.createIndex((comment) => comment.createdAt)
507​
508function updateVisibleIssue(
509 fixture: Fixture,
510 iteration: number,
511 mutationMode: MutationMode,
512): WriteResult {
513 const issue = fixture.issueById.get(fixture.visibleIssueId)!
514 const next = {
515 ...issue,
516 title: `Issue ${issue.id} tick ${iteration}`,
517 updateTick: iteration,
518 }
519 fixture.issueById.set(issue.id, next)
520​
521 if (mutationMode === `synced`) {
522 writeSync(fixture.issues, {
523 type: `update`,
524 value: next,
525 })
526 return
527 }
528​
529 const transaction = writeOptimistic(() => {
530 fixture.issues.update(issue.id, (draft) => {
531 draft.title = next.title
532 draft.updateTick = next.updateTick
533 })
534 })
535​
536 return {
537 cleanup: () => {
538 transaction.rollback()
539 fixture.issueById.set(issue.id, issue)
540 },
541 }
543​
544function deleteVisibleIssue(
545 fixture: Fixture,
546 _iteration: number,
547 mutationMode: MutationMode,
548): WriteResult {
549 const issue = fixture.issueById.get(fixture.visibleIssueId)!
550​
551 if (mutationMode === `synced`) {
552 writeSync(fixture.issues, { type: `delete`, value: issue })
553 return {
554 cleanup: () =>
555 writeSync(fixture.issues, { type: `insert`, value: issue }),
556 }
557 }
558​
559 const transaction = writeOptimistic(() => {
560 fixture.issues.delete(issue.id)
561 })
562 return { cleanup: () => transaction.rollback() }
564​
565function updateVisibleAuthor(
566 fixture: Fixture,
567 iteration: number,
568 mutationMode: MutationMode,
569): WriteResult {
570 const issue = fixture.issueById.get(fixture.visibleIssueId)!
571 const user = fixture.userById.get(issue.authorId)!
572 const next = {
573 ...user,
574 name: `User ${user.id} tick ${iteration}`,
575 reputation: user.reputation + 1,
576 }
577 fixture.userById.set(user.id, next)
578​
579 if (mutationMode === `synced`) {
580 writeSync(fixture.users, {
581 type: `update`,
582 value: next,
583 })
584 return
585 }
586​
587 const transaction = writeOptimistic(() => {
588 fixture.users.update(user.id, (draft) => {
589 draft.name = next.name
590 draft.reputation = next.reputation
591 })
592 })
593​
594 return {
595 cleanup: () => {
596 transaction.rollback()
597 fixture.userById.set(user.id, user)
598 },
599 }
601​
602function insertVisibleComment(
603 fixture: Fixture,
604 iteration: number,
605 mutationMode: MutationMode,
606): WriteResult {
607 return insertCommentForIssue(
608 fixture,
609 fixture.visibleIssueId,
610 iteration,
611 mutationMode,
612 )
614​
615function insertSelectedIssueComment(
616 fixture: Fixture,
617 iteration: number,
618 mutationMode: MutationMode,
619): WriteResult {
620 return insertCommentForIssue(
621 fixture,
622 fixture.selectedIssueId,
623 iteration,
624 mutationMode,
625 )
627​
628function insertCommentForIssue(
629 fixture: Fixture,
630 issueId: number,
631 iteration: number,
632 mutationMode: MutationMode,
633): WriteResult {
634 const comment: Comment = {
635 id: fixture.nextCommentId++,
636 issueId,
637 authorId: 1 + (iteration % fixture.userById.size),
638 createdAt: 1_000_000_000 + iteration,
639 body: `Inserted comment ${iteration}`,
640 updateTick: iteration,
641 }
642 fixture.commentById.set(comment.id, comment)
643​
644 if (mutationMode === `synced`) {
645 writeSync(fixture.comments, {
646 type: `insert`,
647 value: comment,
648 })
649 return
650 }
651​
652 const transaction = writeOptimistic(() => {
653 fixture.comments.insert(comment)
654 })
655​
656 return {
657 cleanup: () => {
658 transaction.rollback()
659 fixture.commentById.delete(comment.id)
660 },
661 }
663​
664function writeSync<T extends object, TKey extends string | number>(
665 collection: ManualCollection<T, TKey>,
666 message: ChangeMessageOrDeleteKeyMessage<T, TKey>,
667): void {
668 collection.utils.begin()
669 collection.utils.write(message)
670 collection.utils.commit()
672​
673function writeOptimistic(write: () => void) {
674 const transaction = createTransaction({
675 autoCommit: false,
676 mutationFn: async () => {},
677 })
678 transaction.isPersisted.promise.catch(() => undefined)
679 transaction.mutate(write)
680 return transaction
682​
683async function cleanupWrite(writeResult: WriteResult): Promise<void> {
684 if (!writeResult) return
685 await writeResult.cleanup()
686 await flushMicrotasks()
688​
689async function cleanupFixture(
690 fixture: Fixture,
691 query: BenchmarkCollection,
692): Promise<void> {
693 await Promise.all([
694 query.cleanup(),
695 fixture.issues.cleanup(),
696 fixture.users.cleanup(),
697 fixture.comments.cleanup(),
698 ])
700​
701function summarize(samples: Array<number>): Summary {
702 const sorted = [...samples].sort((a, b) => a - b)
703 const total = sorted.reduce((sum, value) => sum + value, 0)
704 const mean = total / sorted.length
705 const variance =
706 sorted.reduce((sum, value) => sum + (value - mean) ** 2, 0) / sorted.length
707 return {
708 iterations: sorted.length,
709 medianMs: percentile(sorted, 0.5),
710 p75Ms: percentile(sorted, 0.75),
711 p95Ms: percentile(sorted, 0.95),
712 minMs: sorted[0] ?? 0,
713 maxMs: sorted[sorted.length - 1] ?? 0,
714 stddevMs: Math.sqrt(variance),
715 }
717​
718function percentile(sorted: Array<number>, p: number): number {
719 if (sorted.length === 0) return 0
720 const index = Math.min(sorted.length - 1, Math.ceil(sorted.length * p) - 1)
721 return sorted[index]!
723​
724function runtimeMetadata(
725 options: BenchmarkOptions,
726 scales: Array<FixtureScale>,
727) {
728 return {
729 seed: options.seed,
730 levels: options.levels,
731 scales,
732 sourceIndexModes: options.sourceIndexModes,
733 mutationModes: options.mutationModes,
734 warmup: options.warmup,
735 iterations: options.iterations,
736 node: process.version,
737 platform: `${platform()} ${release()}`,
738 cpu: cpus()[0]?.model ?? `unknown`,
739 gitSha: gitSha(),
740 gcAvailable: typeof global.gc === `function`,
741 }
743​
744function formatTextReport(
745 report: {
746 metadata: ReturnType<typeof runtimeMetadata>
747 results: Array<RunResult>
748 },
749 outputPath: string,
750): string {
751 const lines: Array<string> = []
752 lines.push(`Incremental update benchmark`)
753 lines.push(`seed=${report.metadata.seed}`)
754 lines.push(`scales=${report.metadata.scales.map(formatScale).join(`; `)}`)
755 lines.push(`sourceIndexModes=${report.metadata.sourceIndexModes.join(`,`)}`)
756 lines.push(`mutationModes=${report.metadata.mutationModes.join(`,`)}`)
757 lines.push(
758 `runtime=node ${report.metadata.node} ${report.metadata.platform} ${report.metadata.cpu}`,
759 )
760 lines.push(`git=${report.metadata.gitSha}`)
761 lines.push(`json=${outputPath}`)
762 lines.push(``)
763​
764 for (const scale of uniqueScales(report.results)) {
765 lines.push(`scale=${formatScale(scale)}`)
766 for (const sourceIndexMode of report.metadata.sourceIndexModes) {
767 lines.push(`sourceIndexMode=${sourceIndexMode}`)
768 for (const mutationMode of report.metadata.mutationModes) {
769 lines.push(`mutationMode=${mutationMode}`)
770 for (const result of report.results.filter(
771 (item) =>
772 scaleKey(item.scale) === scaleKey(scale) &&
773 item.sourceIndexMode === sourceIndexMode &&
774 item.mutationMode === mutationMode,
775 )) {
776 lines.push(`${result.query} | ${result.scenario}`)
777 lines.push(
778 ` cold=${formatMs(result.coldHydrateMs)} median=${formatMs(
779 result.writeSummary.medianMs,
780 )} p95=${formatMs(result.writeSummary.p95Ms)} min=${formatMs(
781 result.writeSummary.minMs,
782 )} max=${formatMs(result.writeSummary.maxMs)} stddev=${formatMs(
783 result.writeSummary.stddevMs,
784 )}`,
785 )
786 }
787 lines.push(``)
788 }
789 }
790 }
791​
792 return lines.join(`\n`)
794​
795function resolveScales(options: BenchmarkOptions): Array<FixtureScale> {
796 const hasCustomScale =
797 options.issueCount !== undefined ||
798 options.userCount !== undefined ||
799 options.commentCount !== undefined
800​
801 if (hasCustomScale) {
802 return [
803 {
804 label: `custom`,
805 issueCount: options.issueCount ?? defaultCustomScale.issueCount,
806 userCount: options.userCount ?? defaultCustomScale.userCount,
807 commentCount: options.commentCount ?? defaultCustomScale.commentCount,
808 },
809 ]
810 }
811​
812 return options.levels.map((level) => ({
813 label: String(level),
814 issueCount: level,
815 userCount: level,
816 commentCount: level,
817 }))
819​
820function createRunOptions(
821 options: BenchmarkOptions,
822 scale: FixtureScale,
823 sourceIndexMode: SourceIndexMode,
824): BenchmarkRunOptions {
825 return {
826 seed: options.seed,
827 scale,
828 issueCount: scale.issueCount,
829 userCount: scale.userCount,
830 commentCount: scale.commentCount,
831 sourceIndexMode,
832 warmup: options.warmup,
833 iterations: options.iterations,
834 }
836​
837function uniqueScales(results: Array<RunResult>): Array<FixtureScale> {
838 const scales = new Map<string, FixtureScale>()
839 for (const result of results) {
840 scales.set(scaleKey(result.scale), result.scale)
841 }
842 return [...scales.values()]
844​
845function scaleKey(scale: FixtureScale): string {
846 return `${scale.label}:${scale.issueCount}:${scale.userCount}:${scale.commentCount}`
848​
849function formatScale(scale: FixtureScale): string {
850 if (
851 scale.issueCount === scale.userCount &&
852 scale.userCount === scale.commentCount
853 ) {
854 return `${formatInteger(scale.issueCount)} rows/collection`
855 }
856​
857 return `issues:${formatInteger(scale.issueCount)} users:${formatInteger(
858 scale.userCount,
859 )} comments:${formatInteger(scale.commentCount)}`
861​
862function formatMs(value: number): string {
863 return `${formatNumber(value)}ms`
865​
866function formatNumber(value: number): string {
867 return value.toFixed(3)
869​
870function formatInteger(value: number): string {
871 return value.toLocaleString(`en-US`)
873​
874function parseArgs(
875 args: Array<string>,
876 defaults: BenchmarkOptions,
877): BenchmarkOptions {
878 const parsed = {
879 ...defaults,
880 levels: [...defaults.levels],
881 sourceIndexModes: [...defaults.sourceIndexModes],
882 mutationModes: [...defaults.mutationModes],
883 }
884​
885 for (const arg of args) {
886 const [name, value] = arg.replace(/^--/, ``).split(`=`)
887 if (!name || value === undefined) continue
888​
889 switch (name) {
890 case `seed`:
891 parsed.seed = parseNonNegativeInteger(value, name)
892 break
893 case `levels`:
894 parsed.levels = parseLevels(value)
895 break
896 case `sourceIndexes`:
897 case `sourceIndexModes`:
898 parsed.sourceIndexModes = parseSourceIndexModes(value)
899 break
900 case `mutationModes`:
901 parsed.mutationModes = parseMutationModes(value)
902 break
903 case `issues`:
904 parsed.issueCount = parsePositiveCount(value, name)
905 break
906 case `users`:
907 parsed.userCount = parsePositiveCount(value, name)
908 break
909 case `comments`:
910 parsed.commentCount = parsePositiveCount(value, name)
911 break
912 case `warmup`:
913 parsed.warmup = parseNonNegativeInteger(value, name)
914 break
915 case `iterations`:
916 parsed.iterations = parsePositiveInteger(value, name)
917 break
918 case `outDir`:
919 parsed.outDir = value
920 break
921 case `outFile`:
922 parsed.outFile = value
923 break
924 }
925 }
926​
927 return parsed
929​
930function parseLevels(value: string): Array<number> {
931 const levels = value
932 .split(`,`)
933 .map((part) => part.trim())
934 .filter((part) => part.length > 0)
935 .map((part) => parsePositiveCount(part, `levels`))
936​
937 if (levels.length === 0) {
938 throw new Error(`--levels must contain at least one positive integer`)
939 }
940​
941 return levels
943​
944function parseMutationModes(value: string): Array<MutationMode> {
945 const modes = value
946 .split(`,`)
947 .map((part) => part.trim())
948 .filter((part) => part.length > 0)
949​
950 if (modes.length === 0) {
951 throw new Error(`--mutationModes must contain at least one mode`)
952 }
953​
954 for (const mode of modes) {
955 if (mode !== `synced` && mode !== `optimistic`) {
956 throw new Error(`--mutationModes must contain synced and/or optimistic`)
957 }
958 }
959​
960 return modes
962​
963function parseSourceIndexModes(value: string): Array<SourceIndexMode> {
964 const modes = value
965 .split(`,`)
966 .map((part) => part.trim())
967 .filter((part) => part.length > 0)
968​
969 if (modes.length === 0) {
970 throw new Error(`--sourceIndexes must contain at least one mode`)
971 }
972​
973 for (const mode of modes) {
974 if (mode !== `none` && mode !== `manual` && mode !== `auto`) {
975 throw new Error(`--sourceIndexes must contain none, manual, and/or auto`)
976 }
977 }
978​
979 return modes
981​
982function parsePositiveCount(value: string, name: string): number {
983 const normalized = value.trim().toLowerCase()
984 const parsed = normalized.endsWith(`k`)
985 ? Number(normalized.slice(0, -1)) * 1_000
986 : Number(normalized)
987​
988 if (!Number.isInteger(parsed) || parsed < 1) {
989 throw new Error(`--${name} must be a positive integer or k-suffixed count`)
990 }
991 return parsed
993​
994function parsePositiveInteger(value: string, name: string): number {
995 const parsed = Number(value)
996 if (!Number.isInteger(parsed) || parsed < 1) {
997 throw new Error(`--${name} must be a positive integer`)
998 }
999 return parsed
1001​
1002function parseNonNegativeInteger(value: string, name: string): number {
1003 const parsed = Number(value)
1004 if (!Number.isInteger(parsed) || parsed < 0) {
1005 throw new Error(`--${name} must be a non-negative integer`)
1007 return parsed
1009​
1010function seededRandom(seed: number): () => number {
1011 let state = seed >>> 0
1012 return () => {
1013 state ^= state << 13
1014 state ^= state >>> 17
1015 state ^= state << 5
1016 return ((state >>> 0) % 1_000_000) / 1_000_000
1019​
1020function findNewestOpenIssueId(issues: Array<Issue>): number {
1021 for (let index = issues.length - 1; index >= 0; index--) {
1022 const issue = issues[index]!
1023 if (issue.status === `open`) {
1024 return issue.id
1027 throw new Error(`Fixture must contain at least one open issue`)
1029​
1030function gitSha(): string {
1031 try {
1032 return execSync(`git rev-parse --short HEAD`, {
1033 encoding: `utf8`,
1034 stdio: [`ignore`, `pipe`, `ignore`],
1035 }).trim()
1036 } catch {
1037 return `unknown`
1040​
1041async function flushMicrotasks(): Promise<void> {
1042 await Promise.resolve()
1043 await Promise.resolve()