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({