Function mem_map_collect_impl

src/foundation/mem.c:572–626

}

static bool mem_map_collect_impl(cbm_mem_map_t *out, bool walk_allocator) {
    if (!out) {
        return false;
    }
    memset(out, 0, sizeof(*out));

    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);
    out->os_rss_bytes = current_rss ? current_rss : cbm_mem_rss();
    out->os_committed_bytes = current_commit;

    /* Does plain malloc actually land in the allocator's regions? This single
     * bit distinguishes "nothing is live" from "the allocator does not own
     * this build's allocations", which are opposite conclusions from the same
     * zero. Probe with a real malloc/free pair rather than inferring from
     * build flags, because the Windows static-CRT override is defined at
     * compile time yet can still fail to take effect at link time. */
    void *probe = malloc(CBM_SZ_64);
    if (probe) {
        out->malloc_is_allocator_owned = mi_is_in_heap_region(probe);
        free(probe);
    }

    /* Walk only heaps this thread may safely read.
     *
     * mi_heap_main() is the process-wide aggregate: any other thread can be
     * allocating into it while the walk runs, which is a data race by
     * construction and TSan reports it as one (init.c:452 in mi_heap_main).
     * A diagnostic must not introduce a race into the code it measures, so the
     * aggregate walk is gone. What remains is safe by ownership: this thread's
     * own theap, plus abandoned pages, which by definition have no owning
     * thread left to race with.
     *
     * That includes mi_heap_main() itself: merely CALLING it reads the
     * allocator's main-heap pointer, which a thread exiting concurrently
     * rewrites from _mi_thread_done -> _mi_theap_default_set. TSan caught
     * exactly that pairing on macOS, so the abandoned-page walk goes too --
     * it could only be reached through mi_heap_main().
     *
     * The cost is coverage -- other threads' live blocks and abandoned pages
     * are not attributed -- and that is exactly what the residual in mem.h
     * exists to carry. An unmeasured map must never read as an empty one. */
    if (walk_allocator) {
        (void)mi_theap_visit_blocks(mi_theap_get_default(), false, mem_map_visit_area, out);
    }
    return true;
}

/* ── Allocator ownership audit (see mem.h) ─────────────────────────── */