Method from_snapshot

src/memray/reporters/tree.py:441–495

(
        cls,
        allocations: Iterator[AllocationRecord],
        *,
        biggest_allocs: int = 200,
        native_traces: bool,
    )

    @classmethod
    def from_snapshot(
        cls,
        allocations: Iterator[AllocationRecord],
        *,
        biggest_allocs: int = 200,
        native_traces: bool,
    ) -> "TreeReporter":
        data = Frame(location=ROOT_NODE, value=0, import_system=False, interesting=True)
        sorted_records = sorted(allocations, key=lambda alloc: alloc.size, reverse=True)
        for record in sorted_records[:biggest_allocs]:
            size = record.size
            data.value += size
            data.n_allocations += record.n_allocations

            current_frame = data
            stack = (
                tuple(record.hybrid_stack_trace())
                if native_traces
                else record.stack_trace()
            )
            for index, stack_frame in enumerate(reversed(stack)):
                if is_cpython_internal(stack_frame):
                    continue
                is_import_system = is_frame_from_import_system(stack_frame)
                is_interesting = not is_import_system and is_frame_interesting(
                    stack_frame
                )
                if stack_frame not in current_frame.children:
                    node = Frame(
                        value=0,
                        location=stack_frame,
                        import_system=is_import_system,
                        interesting=is_interesting,
                    )
                    current_frame.children[stack_frame] = node

                current_frame = current_frame.children[stack_frame]
                current_frame.value += size
                current_frame.n_allocations += record.n_allocations
                current_frame.thread_id = format_thread_name(record)

                if index > MAX_STACKS:
                    break

        elided_locations = ElidedLocations()
        elided_locations.cutoff = biggest_allocs

        for record in sorted_records[biggest_allocs:]:
            data.value += record.size
            data.n_allocations += record.n_allocations
            elided_locations.n_locations += 1
            elided_locations.n_bytes += record.size
            elided_locations.n_allocations += record.n_allocations

        return cls(data, elided_locations)

    def get_app(self) -> TreeApp:
        return TreeApp(self.data, self.elided_locations)