Function write_diagnostics

src/foundation/diagnostics.c:514–636

}

static void write_diagnostics(void) {
#ifdef CBM_DIAGNOSTICS_ENABLE_TEST_API
    diag_test_pause_writer();
#endif
    if (atomic_load_explicit(&g_diag_stop, memory_order_acquire)) {
        return;
    }

    size_t elapsed_ms = 0;
    size_t user_ms = 0;
    size_t sys_ms = 0;
    size_t current_rss = 0;
    size_t peak_rss = 0;
    size_t current_commit = 0;
    size_t peak_commit = 0;
    size_t page_faults = 0;
    mi_process_info(&elapsed_ms, &user_ms, &sys_ms, &current_rss, &peak_rss, &current_commit,
                    &peak_commit, &page_faults);
    /* Do NOT report mi_process_info's rss fields: on Linux mimalloc never sets
     * current_rss, so the field keeps mimalloc's internal committed-page
     * counter — deliberately tuned low here (purge_decommits=1, purge_delay=0)
     * and able to go transiently NEGATIVE under purge, which wraps through
     * size_t and printed rss_bytes of ~2^64 (soak read it as a 17-exabyte
     * "leak"). cbm_mem_rss()/cbm_mem_peak_rss() already encode the whole
     * lesson: /proc statm is authoritative on Linux, mimalloc is correct on
     * macOS/Windows, and peak is reconciled to never undercut current. */
    current_rss = cbm_mem_rss();
    peak_rss = cbm_mem_peak_rss();
    /* The committed pair has the same failure: the counter is signed and
     * merged per thread at thread exit, so a thread-per-connection daemon
     * reads it negative once short-lived threads have freed what a long-lived
     * one committed (query-leak soak, Linux 2026-09-14: heap_committed_bytes
     * printed 2^64 - 121 MB from the second sample on). cbm_mem_allocator_
     * committed reports 0 for a negative reading; the peak never undercuts
     * the current value and never carries a wrapped one. */
    current_commit = cbm_mem_allocator_committed();
    if (peak_commit > (SIZE_MAX >> 1)) {
        peak_commit = 0;
    }
    if (peak_commit < current_commit) {
        peak_commit = current_commit;
    }

    int fds = count_open_fds();
    time_t now = time(NULL);
    long uptime = (long)(now - g_start_time);
    int qcount = atomic_load(&g_query_stats.count);
    int qerrors = atomic_load(&g_query_stats.errors);
    long long qtime = atomic_load(&g_query_stats.time_us);
    long long qmax = atomic_load(&g_query_stats.max_us);
    long long qavg = qcount > 0 ? qtime / qcount : 0;

    /* Memory map: live allocator bytes on this thread's heap, a size-class
     * histogram, and the residual the walk does NOT account for. The residual
     * is what keeps this honest — see mem.h. */
    diag_write_allocator_stats();

    cbm_mem_map_t map;