Function write_diagnostics

src/foundation/diagnostics.c:513–621

}

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();

    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;
    (void)cbm_mem_map_collect_os(&map);
    size_t residual =
        map.os_committed_bytes > map.live_bytes ? map.os_committed_bytes - map.live_bytes : 0;
    char buckets[CBM_SZ_512];
    int bucket_length = 0;
    for (int i = 0;
         i < CBM_MEM_MAP_BUCKETS && bucket_length >= 0 && (size_t)bucket_length < sizeof(buckets);
         i++) {
        int written =
            snprintf(buckets + bucket_length, sizeof(buckets) - (size_t)bucket_length,
                     "%s{\"limit\": %zu, \"bytes\": %zu, \"blocks\": %zu}", i == 0 ? "" : ", ",
                     cbm_mem_map_bucket_limit(i), map.bucket_bytes[i], map.bucket_blocks[i]);
        if (written < 0) {
            break;