def show_summary(trace: ProcessedTrace) -> None:
    print(f"{trace.NumberGCs} GCs")
    for k, v in trace.number_gcs_in_each_generation.items():
        print(f"  {k.name}: {v}")
    print(f"{trace.HeapCount} heaps")
    for m in ("HeapSizeAfterMB_Mean", "HeapSizeAfterMB_Max"):
        print(f"{m}: {trace.unwrap_metric_from_name(m)}")
    # TODO: how to get mean/max memory load? Is it possible?

    metrics: Sequence[str] = ("PauseDurationMSec", "PromotedMBPerSec",
                              "HeapSizeAfterMB")
    num_metrics = len(metrics)
    kind_to_metric_to_values: List[List[List[float]]] = [
        [[] for _ in range(num_metrics)] for _ in range(4)
    ]
    for gc in trace.gcs:
        gc_kind = get_gc_kind(gc)
        for metric_index, metric in enumerate(metrics):
            metric_index_to_values = kind_to_metric_to_values[enum_value(
                gc_kind)]
            values = metric_index_to_values[metric_index]
            values.append(gc.unwrap_metric_from_name(metric))

    for kind in GCKind:
        histograms: List[BasicHistogram] = []
        for metric_index, metric in enumerate(metrics):
            histograms.append(
                BasicHistogram(
                    values=kind_to_metric_to_values[enum_value(kind)]
                    [metric_index],
                    name=metric,
                    x_label=kind.name,
                ))

        basic_chart(histograms)
Example #2
0
def _custom2(trace: ProcessedTrace) -> None:
    gen_to_suspension_datas: List[List[_SuspensionData]] = [[] for _ in range(3)]

    for gc in trace.gcs:
        if gc.PauseDurationMSec < 50:
            continue

        gen_to_suspension_datas[enum_value(gc.Generation)].append(
            _SuspensionData(
                PauseToStartMSec=gc.SuspendToGCStartMSec,
                DurationMSec=gc.DurationMSec,
                PauseDurationMSec=gc.PauseDurationMSec,
                SuspendDurationMSec=gc.SuspendDurationMSec,
                PromotedMB=gc.PromotedMB,
            )
        )

    for gen in ALL_GC_GENS:
        print(f"\n=== {gen.name} suspensions ===\n")
        rows = []
        for susp_data in sorted(
            gen_to_suspension_datas[0], key=lambda sd: sd.DurationMSec, reverse=True
        ):
            rows.append(
                [
                    Cell(x)
                    for x in (
                        susp_data.PauseDurationMSec,
                        susp_data.DurationMSec,
                        # susp_data.PctPauseFromSuspend,
                        # susp_data.PauseToStartMSec,
                        susp_data.SuspendDurationMSec,
                        # susp_data.SuspensionPercent,
                        susp_data.PromotedMB,
                        susp_data.PromotedMBPerSec,
                    )
                ]
            )
        handle_doc(
            single_table_document(
                Table(
                    headers=(
                        "pause msec",
                        "duration msec",
                        # "pause %",
                        # "pause to start",
                        "suspend msec",
                        # "suspend %",
                        "promoted mb",
                        "promoted mb/sec",
                    ),
                    rows=rows,
                )
            )
        )