Every cursor cache and reopen cycle across all threads currently updates a single shared field (conn->open_cursor_count) using atomic read-modify-writes. This change replaces that shared counter with a per-session field updated without atomics, aggregating it across sessions only when connection statistics are read. This eliminates a cross-thread cache-line bounce during cursor open and close operations while keeping the reported statistic value intact.

The connection statistic cursor: open cursor count (cursor_open_count) is stored in conn->open_cursor_count (src/include/connection.h:1049, develop at 50c032ba6). Four locations in src/cursor/cur_std.c update it with a relaxed atomic read-modify-write:

The only reader is __wt_conn_stat_init (src/conn/conn_stat.c:87-88), which runs when a statistics: cursor opens (src/cursor/cur_stat.c:374), including during statistics log server dumps (__statlog_dump, src/conn/conn_stat.c:317). No test reads the statistic since WT-18455.

Every cursor cache cycle on every thread and table writes to this shared cache line.

History

WT-2029 (87bb02959) split connection statistics into per-session buckets updated without atomics. Values requiring exact tracking moved to connection fields: "There are only 3 statistics we maintain atomically: the count of open cursors and the split-stash bytes and object counts. Move them to WT_CONNECTION_IMPL fields, and copy them into the statistics on demand". WT-15754 (685336070) made bucketed connection and data-source statistic updates relaxed atomic read-modify-writes, preventing lost updates. A bucketed statistic remains unsuitable here: it requires a shared atomic read-modify-write on a bucket shared by all sessions with the same id % 23, and updates are skipped when statistics=(none), creating an offset if enabled later via WT_CONNECTION::reconfigure. A counter in the session avoids both issues.

Why it matters for MongoDB

With default wiredTigerCursorCacheSize (100), mongod closes cursors when returning a session to the pool and reopens them from the session cursor cache on the next operation. Each operation executes one cache/reopen cycle per touched table (record store and indexes), producing two atomic read-modify-writes on conn>open_cursor_count per table per operation across all threads. SERVER-122455 estimates the close, cache, and reopen cycle at about 1.6% CPU on YCSB in-cache 100% read with 128 threads. mongod exposes this counter in serverStatus().wiredTiger.cursor["open cursor count"] and in FTDC every second for tracking cursor leaks (SERVER-118759), requiring its behavior to remain consistent.

Measurements

Microbenchmark configuration: T threads, each with its own session, loop open_cursor (served from the session cursor cache) and close, or open_cursor, search, and close inside one snapshot transaction per thread. Threads access separate tables (distinct) or a single table (shared); in_memory=true, statistics=(fast), 10,000 rows per table, 1 s warm-up, and 2 s measured. Base commit is develop 50c032ba6; patch includes this change; both built with Release (-O2). 5 alternating runs per data point. Values show total M ops/s across all threads, median [min..max]; p is an exact two-sided permutation test on the difference of means over the 5 + 5 runs (0.008 indicates complete separation between builds). Except for one run measuring 1.001, all runs reported 1.0 cursor reopens per operation.

With distinct tables, develop degrades from 2 to 12 threads due to cache contention on conn->open_cursor_count. With one shared table, throughput is gated by data handle atomics (session_inuse, references, handle read lock), yielding variable deltas (+31.5% at 2 threads, -18.2% at 8 threads) that require dedicated machine validation.

Read cost for cursor: open cursor count through a statistics: cursor (open, search, read, close) with one thread, no workers, and idle sessions with one open/close cycle each (5 runs, microseconds, median [min..max]):

The session walk adds roughly 1.9 ns per session slot (+7.6 us at 4000 sessions). Idle sessions remain cached. Active sessions updating cursors may cause cache misses; estimated at ~100 ns per miss, this would add roughly 0.4 ms per read with 4000 sessions, or 0.04% of a core at a 1-second FTDC poll rate.

Test environment: Apple M4 Pro, 14 cores (10 performance, 4 efficiency), macOS 26.5.2, Apple clang 21.0.0. macOS lacks thread pinning, placing some threads on efficiency cores at 12 threads. Contention is inferred from throughput due to lack of perf c2c. The machine ran concurrent workloads during execution: 1-minute load average 7.91-26.78 (median 17.98) for open/close, 16.99-22.32 for transaction runs, and 15.64-21.15 for statistics latency. Cross-core cache transfers on this single die are faster than multi-socket or large Graviton/x86 architectures. This benchmark isolates the cursor cache path; mongod additionally runs transactions, query parsing, and network I/O.

Proposed change

• Replace conn->open_cursor_count with WT_SESSION_IMPL::open_cursor_count. The same four sites update this field. Because these call sites already update the session cursor list without locks, updates use relaxed loads and stores without atomic read-modify-writes.
• __wt_conn_stat_init iterates over active sessions (including internal sessions) via __wt_session_array_walk to sum the field, matching __wt_gen_oldest and hazard pointer checks.
• Preserves statistic behavior: updated regardless of statistics setting, excludes cached cursors, and includes internal session cursors and metadata cursors. The aggregation is non-atomic and may diverge from an exact point-in-time snapshot by in-flight cursor state transitions during the walk. It cannot produce negative values.
• Reading connection statistics accesses one field per session slot up to the active array bound.
• Diagnostic builds assert that session counters do not drop below zero and equal zero upon session close.
• Added test_stat19 to verify that the statistic tracks cursors opened, cached, reopened, and closed across distinct sessions.

Pull request: https://github.com/wiredtiger/wiredtiger/pull/14944