@devries-cameron20 / t3code Mirror · read-only / commits / 0200dcf242
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 14:45 UTC

perf(shared): queued SQLite reads stop waiting on one reader while another is free (#27979)

Co-authored-by: maria-rcks <maria@kuuro.net> Co-authored-by: Julius Marminge <julius0216@outlook.com>

Pyseph committed Nov 14, 2026 at 13:20 UTC 0200dcf2423c1b954c9ebca092d112426009c04d
2 files changed +131 -35
packages/shared/src/nodeSqliteClient.test.ts
+75
@@ -15,6 +15,7 @@ import * as SqlError from "effect/sql/SqlError";
15 import * as Statement from "effect/sql/Statement";
16 import { ChildProcess, ChildProcessSpawner } from "effect/process";
17 import * as Stream from "effect/Stream";
18 +import * as TestClock from "effect/testing/TestClock";
19 import type * as Tracer from "effect/Tracer";
20 import { vi } from "vite-plus/test";
21
@@ -426,6 +427,80 @@ it.effect("serves another read while a read-only transaction is open", () =>
427 ),
428 );
429
430 +it.effect("gives a queued read the first reader that frees up", () =>
431 + withReaderClient((sql) =>
432 + Effect.gen(function* () {
433 + const holders = yield* Effect.forEach([0, 1, 2, 3], () =>
434 + Effect.gen(function* () {
435 + const held = yield* Deferred.make<void>();
436 + const release = yield* Deferred.make<void>();
437 + const fiber = yield* sql
438 + .withTransaction(
439 + countEntries(sql).pipe(
440 + Effect.andThen(Deferred.succeed(held, undefined)),
441 + Effect.andThen(Deferred.await(release)),
442 + ),
443 + )
444 + .pipe(SqliteClient.readOnly, Effect.forkChild);
445 + yield* Deferred.await(held);
446 + return { fiber, release };
447 + }),
448 + );
449 + const cancelled = yield* Effect.uninterruptibleMask((restore) =>
450 + SqliteClient.readOnly(restore(sql.withTransaction(countEntries(sql)))),
451 + ).pipe((effect) => Effect.forkChild(effect, { startImmediately: true }));
452 + yield* Fiber.interrupt(cancelled);
453 + const cancelledRead = yield* Effect.uninterruptibleMask((restore) =>
454 + SqliteClient.readOnly(restore(countEntries(sql))),
455 + ).pipe((effect) => Effect.forkChild(effect, { startImmediately: true }));
456 + yield* Fiber.interrupt(cancelledRead);
457 + const queuedSpan = yield* Deferred.make<Tracer.Span>();
458 + const observeQueued: Statement.Transformer = (statement, _sql, _fiber, span) =>
459 + Deferred.succeed(queuedSpan, span).pipe(Effect.as(statement));
460 + const queued = yield* countEntries(sql).pipe(
461 + Effect.provideService(Statement.CurrentTransformer, observeQueued),
462 + Effect.provideService(Statement.SpanPropagationEnabled, true),
463 + SqliteClient.readOnly,
464 + (effect) => Effect.forkChild(effect, { startImmediately: true }),
465 + );
466 + // Masked read-only work keeps its cancellation pending and still runs once a reader frees up.
467 + let maskedRan = 0;
468 + const maskedRuns = yield* Effect.forEach(
469 + [
470 + Effect.scoped(
471 + Effect.flatMap(sql.reserve, (connection) =>
472 + connection.executeUnprepared("SELECT 1", [], undefined),
473 + ),
474 + ).pipe(Effect.asVoid),
475 + sql.withTransaction(countEntries(sql)).pipe(Effect.asVoid),
476 + ],
477 + (effect) =>
478 + effect.pipe(
479 + Effect.andThen(Effect.sync(() => maskedRan++)),
480 + Effect.uninterruptible,
481 + SqliteClient.readOnly,
482 + (masked) => Effect.forkChild(masked, { startImmediately: true }),
483 + ),
484 + );
485 + const interrupting = yield* Effect.forEach(maskedRuns, (fiber) =>
486 + Effect.forkChild(Fiber.interrupt(fiber), { startImmediately: true }),
487 + );
488 + yield* TestClock.adjust("1 second");
489 + yield* Deferred.succeed(holders[1]!.release, undefined);
490 + yield* Fiber.join(holders[1]!.fiber);
491 + // Pinned to the first reader it saw, this read would wait for that reader's transaction.
492 + assert.equal(yield* Fiber.join(queued), 1);
493 + assert.equal((yield* Deferred.await(queuedSpan)).attributes.get("db.lock_wait_ms"), 1000);
494 + for (const { fiber, release } of [holders[0]!, holders[2]!, holders[3]!]) {
495 + yield* Deferred.succeed(release, undefined);
496 + yield* Fiber.join(fiber);
497 + }
498 + yield* Effect.forEach(interrupting, Fiber.join);
499 + assert.equal(maskedRan, 2);
500 + }),
501 + ),
502 +);
503 +
504 // regression: #19226 read-only transactions run on the separate reader connection
505 it.effect("rejects a write in a read-only transaction", () =>
506 withReaderClient((sql) =>
packages/shared/src/nodeSqliteClient.ts
+56 -35
@@ -875,11 +875,13 @@ const make = Effect.fn("makeWithDatabase")(function* (
875 ([acquire, lock]) => ({
876 acquire,
877 lock,
878 - claims: 0,
878 + claimed: false,
879 }),
880 ),
881 )
882 : [];
883 + // One permit per slot, so a queued read waits for any reader, not one it picked while all were busy.
884 + const readerAdmission = yield* Semaphore.make(readers.length);
885
886 interface Target {
887 readonly name: Acquired["connection"];
@@ -893,31 +895,45 @@ const make = Effect.fn("makeWithDatabase")(function* (
895 }));
896 let activeWriter: ConnectionOwner | undefined;
897 // Callers must run route uninterruptibly and pass `claimed` a finalizer that runs `release` once.
896 - const route = (claimed: (release: Effect.Effect<void>) => Effect.Effect<void>) =>
898 + // Waits use the caller's `restore`, not readOnly's, which may have been captured outside a mask.
899 + const route = (
900 + claimed: (release: Effect.Effect<void>) => Effect.Effect<void>,
901 + restore: typeof Effect.interruptible,
902 + ) =>
903 Effect.withFiber((fiber): Effect.Effect<Target, SqlError> => {
904 if (readers.length === 0 || readerPool.unavailable || !Context.get(fiber.context, ReadOnly)) {
905 return writer;
906 }
901 - // Least claimed wins and ties go to the lowest slot, so idle slots never start a worker.
902 - let slot = readers[0]!;
903 - for (const candidate of readers) if (candidate.claims < slot.claims) slot = candidate;
904 - slot.claims++;
905 - const reader = slot;
906 - return Effect.andThen(
907 - claimed(
908 - Effect.sync(() => {
909 - reader.claims--;
910 - }),
911 - ),
912 - Effect.flatMap(reader.acquire, (readerConnection) =>
913 - readerConnection === undefined
914 - ? writer
915 - : Effect.succeed<Target>({
916 - name: "reader",
917 - lock: reader.lock,
918 - connection: readerConnection,
919 - }),
920 - ),
907 + const claim = Effect.andThen(
908 + restore(readerAdmission.take(1)),
909 + Effect.suspend(() => {
910 + // Holding a permit leaves a slot idle; the lowest wins, so idle slots never start a worker.
911 + const reader = readers.find((slot) => !slot.claimed)!;
912 + reader.claimed = true;
913 + const release = Effect.andThen(
914 + Effect.sync(() => {
915 + reader.claimed = false;
916 + }),
917 + readerAdmission.release(1),
918 + );
919 + return Effect.as(claimed(release), reader);
920 + }),
921 + );
922 + return Effect.flatMap(
923 + // A scheduler yield after taking the permit must not precede its release finalizer.
924 + Effect.provideService(claim, Scheduler.PreventSchedulerYield, true),
925 + (reader) =>
926 + Effect.flatMap(
927 + Effect.provideService(reader.acquire, ReadOnly, restore),
928 + (readerConnection) =>
929 + readerConnection === undefined
930 + ? writer
931 + : Effect.succeed<Target>({
932 + name: "reader",
933 + lock: reader.lock,
934 + connection: readerConnection,
935 + }),
936 + ),
937 );
938 });
939
@@ -937,17 +953,21 @@ const make = Effect.fn("makeWithDatabase")(function* (
953 Effect.sync(() => {
954 release = next;
955 });
940 - return Effect.flatMap(route(claimed), (target) => restore(borrowTarget(target, use))).pipe(
941 - Effect.ensuring(Effect.suspend(() => release)),
942 - );
956 + // Started before routing, so lock wait includes waiting for reader admission.
957 + return Effect.withFiber((fiber) => {
958 + const start = fiber.getRef(Clock.Clock).monotonicTimeNanosUnsafe();
959 + return Effect.flatMap(route(claimed, restore), (target) =>
960 + restore(borrowTarget(target, use, start)),
961 + );
962 + }).pipe(Effect.ensuring(Effect.suspend(() => release)));
963 });
964 const borrowTarget = <A, E, R>(
965 target: Target,
966 use: (connection: Connection) => Effect.Effect<A, E, R>,
967 + start: bigint,
968 ): Effect.Effect<A, E, R> =>
969 Effect.withFiber((fiber) => {
970 const clock = fiber.getRef(Clock.Clock);
950 - const start = clock.monotonicTimeNanosUnsafe();
971 const ownerAtWaitStart = target.name === "writer" ? activeWriter : undefined;
972 const owner = target.name === "writer" ? connectionOwner(fiber) : undefined;
973 const useConnection = Effect.suspend(() => {
@@ -974,17 +994,18 @@ const make = Effect.fn("makeWithDatabase")(function* (
994 Effect.withFiber((fiber) =>
995 Scope.addFinalizer(Context.getUnsafe(fiber.context, Scope.Scope), release),
996 );
977 - const transactionAcquirer = Effect.uninterruptible(route(claimedUntilScopeCloses)).pipe(
978 - Effect.flatMap((target) =>
979 - Effect.uninterruptibleMask((restore) => {
980 - const fiber = Fiber.getCurrent()!;
997 + // Started before routing, so lock wait includes waiting for reader admission.
998 + const transactionAcquirer = Effect.uninterruptibleMask((maskRestore) =>
999 + Effect.withFiber((fiber) => {
1000 + const start = fiber.getRef(Clock.Clock).monotonicTimeNanosUnsafe();
1001 + const pending = fiber.getRef(TransactionAcquire);
1002 + const restore = pending?.restore ?? maskRestore;
1003 + return Effect.flatMap(route(claimedUntilScopeCloses, restore), (target) => {
1004 const scope = Context.getUnsafe(fiber.context, Scope.Scope);
1005 const clock = fiber.getRef(Clock.Clock);
983 - const start = clock.monotonicTimeNanosUnsafe();
984 - const pending = fiber.getRef(TransactionAcquire);
1006 const ownerAtWaitStart = target.name === "writer" ? activeWriter : undefined;
1007 const owner = target.name === "writer" ? connectionOwner(fiber) : undefined;
987 - const acquire = Effect.tap((pending?.restore ?? restore)(target.lock.take(1)), () => {
1008 + const acquire = Effect.tap(restore(target.lock.take(1)), () => {
1009 if (target.name === "writer") activeWriter = owner;
1010 if (pending !== undefined) {
1011 pending.acquired = acquired(target, clock, start);
@@ -1002,8 +1023,8 @@ const make = Effect.fn("makeWithDatabase")(function* (
1023 Effect.provideService(acquire, Scheduler.PreventSchedulerYield, true),
1024 target.connection,
1025 );
1005 - }),
1006 - ),
1026 + });
1027 + }),
1028 );
1029
1030 const client = yield* Client.make({