Function cbm_parallel_resolve

src/pipeline/pass_parallel.c:3165–3348

}

int cbm_parallel_resolve(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *files, int file_count,
                         CBMFileResult **result_cache, _Atomic int64_t *shared_ids,
                         int worker_count, CBMLSPDef *all_defs, int def_count,
                         char *const *def_modules, struct CBMModuleDefIndex *module_def_index,
                         void *cross_registries_v) {
    /* See header: typed as void* across the TU boundary; cast back here. */
    CBMCrossLspRegistries *cross_registries = (CBMCrossLspRegistries *)cross_registries_v;
    if (file_count == 0) {
        return 0;
    }

    cbm_log_info("parallel.resolve.start", "files", itoa_log(file_count), "workers",
                 itoa_log(worker_count));

    resolve_worker_state_t *workers = NULL;
    if (cbm_aligned_alloc((void **)&workers, CBM_CACHE_LINE,
                          (size_t)worker_count * sizeof(resolve_worker_state_t)) != 0) {
        return CBM_NOT_FOUND;
    }
    memset(workers, 0, (size_t)worker_count * sizeof(resolve_worker_state_t));

    resolve_ctx_t rc = {
        .files = files,
        .file_count = file_count,
        .project_name = ctx->project_name,
        .repo_path = ctx->repo_path,
        .workers = workers,
        .max_workers = worker_count,
        .result_cache = result_cache,
        .main_gbuf = ctx->gbuf,
        .registry = ctx->registry,
        .shared_ids = shared_ids,
        .cancelled = ctx->cancelled,
        .all_defs = all_defs,
        .def_count = def_count,
        .def_modules = def_modules,
        .module_def_index = module_def_index,
        .cross_registries = cross_registries,
    };
    atomic_init(&rc.next_file_idx, 0);
    atomic_init(&rc.lsp_cross_processed, 0);
    atomic_init(&rc.lsp_cross_skipped_no_source, 0);
    /* F4 lazy shared Rust registry: mutex up before workers spawn. */
    atomic_init(&rc.rust_shared_reg, NULL);
    cbm_mutex_init(&rc.rust_shared_mu);
    rc.rust_shared_arena_live = false;

    /* Sub-phase: Dispatch resolve workers (per-file call/usage resolution, PARALLEL) */
    CBM_PROF_START(t_resolve_dispatch);
    cbm_parallel_for_opts_t opts = {.max_workers = worker_count, .force_pthreads = false};
    cbm_parallel_for(worker_count, resolve_worker, &rc, opts);
    CBM_PROF_END_N("parallel_resolve", "1_dispatch_workers_parallel", t_resolve_dispatch,
                   file_count);
    /* Workers joined: the shared Rust registry (if built) is no longer read.
     * Free its dedicated arena + the lock (registry was self-contained: it strdup'd
     * all QNs, so freeing all_defs afterward is safe). */
    if (rc.rust_shared_arena_live) {
        cbm_arena_destroy(&rc.rust_shared_arena);