Method top_functions

tools/fastgrind.py:927–967

(
        self,
        start_ms: int | None = None,
        end_ms: int | None = None,
        thread_ids: Sequence[int] | None = None,
        limit: int = 10,
        metric: str = "net",
        scope: str = "exclusive",
    )

        return SeriesResponse(ticks=ticks, series=series, metric=metric, scope=scope, split=split_mode)

    def top_functions(
        self,
        start_ms: int | None = None,
        end_ms: int | None = None,
        thread_ids: Sequence[int] | None = None,
        limit: int = 10,
        metric: str = "net",
        scope: str = "exclusive",
    ) -> list[dict[str, Any]]:
        metric = _normalize_metric_name(metric)
        start_tick, end_tick = self._normalize_window(start_ms, end_ms)
        selected_threads = self._normalize_thread_ids(thread_ids)
        totals: dict[int, float] = defaultdict(float)

        for _tick_ms, _thread_id, leaf_node_id, malloc_bytes, free_bytes in self._iter_records(
            start_tick, end_tick, selected_threads
        ):
            value = float(self._metric_value(malloc_bytes, free_bytes, "net" if metric == "live" else metric))
            if scope == "exclusive":
                function_ids = (self.reader.stack_nodes[leaf_node_id].function_id,)
            else:
                function_ids = self.reader.node_paths[leaf_node_id]
            for function_id in function_ids:
                totals[function_id] += value

        rows = []
        for function_id, value in totals.items():
            rows.append(
                {
                    "function_id": function_id,
                    "display_name": self.reader.display_names[function_id],
                    "canonical_name": self.reader.function_names[function_id],
                    "value": value,
                }
            )

        if metric == "net":
            rows.sort(key=lambda row: (-abs(row["value"]), row["display_name"].casefold()))
        else:
            rows.sort(key=lambda row: (-row["value"], row["display_name"].casefold()))
        return rows[:limit]

    def stack_breakdown(
        self,