Method modules_report

crates/backend/src/memory_profiler.rs:491–556

(&self, top: usize)

    }

    pub fn modules_report(&self, top: usize) -> MemoryModuleReport {
        let Some(_guard) = ReentryGuard::enter() else {
            return MemoryModuleReport {
                generated_at_ms: now_ms(),
                top: normalize_top(top),
                total_live_bytes_estimate: 0,
                process_rss_bytes: 0,
                entries: Vec::new(),
            };
        };
        let top = normalize_top(top);
        let (process_rss_bytes, _) = read_process_memory();
        let (total_live_bytes, rows) = self.collect_stack_rows();

        let mut agg: HashMap<String, ModuleAggregate> = HashMap::new();
        for (stack, stats) in rows {
            let function = self.resolve_function_for_stack(&stack);
            let module = module_name_from_function(&function);
            let entry = agg
                .entry(module.clone())
                .or_insert_with(|| ModuleAggregate {
                    module,
                    live_bytes: 0,
                    alloc_bytes_total: 0,
                    function_names: HashSet::new(),
                    stack_count: 0,
                    alloc_count: 0,
                    free_count: 0,
                });
            entry.live_bytes = entry.live_bytes.saturating_add(stats.live_bytes);
            entry.alloc_bytes_total = entry
                .alloc_bytes_total
                .saturating_add(stats.alloc_bytes_total);
            entry.function_names.insert(function);
            entry.stack_count = entry.stack_count.saturating_add(1);
            entry.alloc_count = entry.alloc_count.saturating_add(stats.alloc_count);
            entry.free_count = entry.free_count.saturating_add(stats.free_count);
        }

        let mut values = agg.into_values().collect::<Vec<_>>();
        values.sort_by(|left, right| right.live_bytes.cmp(&left.live_bytes));

        let entries = values
            .into_iter()
            .take(top)
            .map(|item| MemoryModuleEntry {
                module: item.module,
                live_bytes_estimate: item.live_bytes,
                alloc_bytes_total_estimate: item.alloc_bytes_total,
                function_count: item.function_names.len(),
                stack_count: item.stack_count,
                alloc_count: item.alloc_count,
                free_count: item.free_count,
                live_ratio_heap: ratio(item.live_bytes, total_live_bytes),
                live_ratio_rss: ratio(item.live_bytes, process_rss_bytes),
            })
            .collect();