scope-profiler 0.2.4__tar.gz → 0.2.6__tar.gz

{scope_profiler-0.2.4 → scope_profiler-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scope-profiler
-Version: 0.2.4
+Version: 0.2.6
 Summary: Profile code regions in python, optionally with LIKWID markers.
 Author: Max
 Project-URL: Source, https://github.com/max-models/scope-profiler

{scope_profiler-0.2.4 → scope_profiler-0.2.6}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "scope-profiler"
-version = "0.2.4"
+version = "0.2.6"
 description = "Profile code regions in python, optionally with LIKWID markers."
 readme = "README.md"
 keywords = [ "python" ]

{scope_profiler-0.2.4 → scope_profiler-0.2.6}/src/scope_profiler/plotting_scripts.py

@@ -99,32 +99,44 @@ def _get_cmap_colors(cmap: str, n_colors: int) -> list[str]:
 def _add_gantt_bars(
     canvas,
     row: int | None,
-    tasks: Sequence[str],
-    starts: Sequence[float],
-    durations: Sequence[float],
-    colors: Sequence[str],
+    lanes: Sequence[str],
+    bars: Sequence[tuple[int, float, float, str]],
     alpha: float = 0.7,
 ) -> None:
-    """Draw ``Canvas.gantt`` bars, one call per color.
-
-    ``Canvas.gantt`` takes a single color per call: maxplotlib's Plotly
-    backend reads ``color`` as one RGB(A) value, so passing a per-bar list
-    raises. One call is therefore issued per distinct color, with the bars
-    belonging to the other colors passed as NaN. NaN bars draw nothing on
-    either backend while still occupying their row, which keeps every call
-    on the row ``Canvas.gantt`` assigns it (``y = arange(len(tasks))``).
+    """Draw ``Canvas.gantt`` bars, every call of a lane on that lane's row.
+
+    ``Canvas.gantt`` puts bar *i* of a call on row *i* (``y =
+    arange(len(tasks))``, on both backends) and takes a single color for the
+    whole call, since maxplotlib's Plotly backend reads ``color`` as one
+    RGB(A) value. Each drawing call therefore passes one entry per lane --- so
+    the entry index is the lane's row --- and only fills in the bars sharing
+    one color; the rest are NaN, which draws nothing on either backend.
+
+    Lanes hold several calls, so bars are grouped by their position within the
+    lane as well: the *k*-th call of every lane goes into the same group,
+    leaving at most one bar per lane per drawing call.
     """
     col = None if row is None else 0
-    starts = np.asarray(starts, dtype=float)
-    durations = np.asarray(durations, dtype=float)
-    colors = np.asarray(colors, dtype=object)
-
-    for color in dict.fromkeys(colors.tolist()):
-        mask = colors == color
+    n_lanes = len(lanes)
+
+    # (color, index within the lane) -> the bars drawn together.
+    groups: dict[tuple[str, int], list[tuple[int, float, float]]] = defaultdict(list)
+    calls_per_lane: dict[int, int] = defaultdict(int)
+    for lane, start, duration, color in bars:
+        slot = calls_per_lane[lane]
+        calls_per_lane[lane] += 1
+        groups[(color, slot)].append((lane, start, duration))
+
+    for (color, _), group in groups.items():
+        starts = np.full(n_lanes, np.nan)
+        durations = np.full(n_lanes, np.nan)
+        for lane, start, duration in group:
+            starts[lane] = start
+            durations[lane] = duration
         canvas.gantt(
-            list(tasks),
-            np.where(mask, starts, np.nan),
-            np.where(mask, durations, np.nan),
+            list(lanes),
+            starts,
+            durations,
             row=row,
             col=col,
             color=color,
@@ -169,19 +181,6 @@ def _render(
         _close_matplotlib_figure(canvas)
 
 
-def _block_ticks(tasks: Sequence[str]) -> tuple[list[float], list[str]]:
-    """Return one tick per run of identical task names, at the run's centre."""
-    ticks: list[float] = []
-    labels: list[str] = []
-    start = 0
-    for index in range(1, len(tasks) + 1):
-        if index == len(tasks) or tasks[index] != tasks[start]:
-            ticks.append((start + index - 1) / 2)
-            labels.append(tasks[start])
-            start = index
-    return ticks, labels
-
-
 def _panel_gridspec(
     fig_width: float, fig_height: float, label_chars: int, multi_panel: bool
 ) -> dict:
@@ -575,30 +574,43 @@ def plot_gantt(
         else:
             print(f"Plotting combined Gantt chart for files: {', '.join(labels)}")
 
-    # Canvas.gantt gives every bar its own row (y = arange(len(tasks))), so a
-    # panel is as tall as the number of calls it draws, and the rows of one
-    # region form a contiguous block labelled at its centre.
+    # One lane per (region, rank): every call of a region lands on the same
+    # row, so a panel is as tall as the number of lanes it draws.
     single_panel = len(prepared) == 1
-    panel_bars = [
-        [
-            (
-                f"{region.name} (rank {rank})",
-                float(start - first_start_time),
-                float(end - start),
-                _to_hex(region.color),
-            )
-            for region in regions
-            for rank in selected_ranks
-            for start, end in zip(region[rank].start_times, region[rank].end_times)
-        ]
-        for _, regions, selected_ranks, first_start_time in prepared
-    ]
+    panel_lanes: list[list[str]] = []
+    panel_bars: list[list[tuple[int, float, float, str]]] = []
+    for _, regions, selected_ranks, first_start_time in prepared:
+        lanes: list[str] = []
+        bars: list[tuple[int, float, float, str]] = []
+        for region in regions:
+            for rank in selected_ranks:
+                # A region need not have been entered on every rank.
+                if rank not in region:
+                    continue
+                region_data = region[rank]
+                if not len(region_data.start_times):
+                    continue
+                lane = len(lanes)
+                lanes.append(f"{region.name} (rank {rank})")
+                color = _to_hex(region.color)
+                for start, end in zip(region_data.start_times, region_data.end_times):
+                    bars.append(
+                        (
+                            lane,
+                            float(start - first_start_time),
+                            float(end - start),
+                            color,
+                        )
+                    )
+        panel_lanes.append(lanes)
+        panel_bars.append(bars)
+
     if not any(panel_bars):
         raise ValueError("No calls recorded for the requested ranks.")
 
-    panel_heights = [max(2.5, 0.22 * len(bars)) for bars in panel_bars]
+    panel_heights = [max(2.5, 0.35 * len(lanes)) for lanes in panel_lanes]
     fig_width, fig_height = 12.0, 1.0 + sum(panel_heights)
-    lane_label_chars = max(len(bar[0]) for bars in panel_bars for bar in bars)
+    lane_label_chars = max(len(lane) for lanes in panel_lanes for lane in lanes)
     canvas = Canvas(
         nrows=len(prepared),
         ncols=1,
@@ -608,27 +620,20 @@ def plot_gantt(
         ),
     )
 
-    for idx, (label, bars) in enumerate(zip(labels, panel_bars)):
+    for idx, (label, lanes, bars) in enumerate(zip(labels, panel_lanes, panel_bars)):
         row = None if single_panel else idx
         col = None if single_panel else 0
 
-        tasks = [bar[0] for bar in bars]
-        starts = [bar[1] for bar in bars]
-        durations = [bar[2] for bar in bars]
-        colors = [bar[3] for bar in bars]
-        _add_gantt_bars(canvas, row, tasks, starts, durations, colors)
+        _add_gantt_bars(canvas, row, lanes, bars)
 
-        # Label each region's block of rows once, at its centre, instead of
-        # repeating the region name on every call's row.
-        yticks, yticklabels = _block_ticks(tasks)
-        canvas.set_yticks(yticks, labels=yticklabels, row=row, col=col)
+        canvas.set_yticks(list(range(len(lanes))), labels=lanes, row=row, col=col)
         canvas.set_xlim(
             0,
-            max(start + duration for start, duration in zip(starts, durations)),
+            max(start + duration for _, start, duration, _ in bars),
             row=row,
             col=col,
         )
-        canvas.set_ylim(-0.6, len(tasks) - 0.4, row=row, col=col)
+        canvas.set_ylim(-0.6, len(lanes) - 0.4, row=row, col=col)
         canvas.set_xlabel("Time (seconds)", row=row, col=col)
         canvas.set_title(
             "Profiling Gantt Chart" if single_panel else label, row=row, col=col
@@ -1005,6 +1010,213 @@ def plot_durations(
     return saved_paths
 
 
+def _duration_timeseries(
+    region,
+    ranks: list[int] | None,
+    first_start_time: float,
+) -> dict[str, np.ndarray] | None:
+    """Aggregate one region's calls over ranks into a duration-versus-time series.
+
+    Calls are matched across ranks by call index, so point ``i`` describes the
+    i-th call of the region on every rank that got that far. Ranks that stopped
+    calling the region earlier simply drop out of the later points, which keeps
+    ragged call counts (e.g. a rank-dependent number of iterations) usable.
+
+    Returns ``None`` if no selected rank recorded any call.
+    """
+    if ranks is None:
+        selected_ranks = sorted(region.regions)
+    else:
+        selected_ranks = [rank for rank in ranks if rank in region.regions]
+
+    per_rank = [
+        (rank, region.regions[rank])
+        for rank in selected_ranks
+        if region.regions[rank].durations.size
+    ]
+    if not per_rank:
+        return None
+
+    max_calls = max(len(region_data.durations) for _, region_data in per_rank)
+    times, means, minima, maxima, counts = [], [], [], [], []
+    for index in range(max_calls):
+        starts = [
+            float(region_data.start_times[index]) - first_start_time
+            for _, region_data in per_rank
+            if len(region_data.durations) > index
+        ]
+        durations = [
+            float(region_data.durations[index])
+            for _, region_data in per_rank
+            if len(region_data.durations) > index
+        ]
+        times.append(float(np.mean(starts)))
+        means.append(float(np.mean(durations)))
+        minima.append(float(np.min(durations)))
+        maxima.append(float(np.max(durations)))
+        counts.append(len(durations))
+
+    return {
+        "time": np.asarray(times, dtype=float),
+        "mean": np.asarray(means, dtype=float),
+        "min": np.asarray(minima, dtype=float),
+        "max": np.asarray(maxima, dtype=float),
+        "num_ranks": np.asarray(counts, dtype=int),
+        "ranks": np.asarray([rank for rank, _ in per_rank], dtype=int),
+    }
+
+
+def plot_duration_timeseries(
+    profiling_data: ProfilingH5Reader | Sequence[ProfilingH5Reader],
+    ranks: list[int] | int | None = None,
+    include: list[str] | str | None = None,
+    exclude: list[str] | str | None = None,
+    filepath: str | None = None,
+    show: bool = False,
+    verbose: bool = True,
+    cmap: str = DEFAULT_CMAP,
+    data_filepath: str | Path | None = None,
+    data_format: str = "csv",
+    backend: str = "matplotlib",
+) -> None:
+    """Plot each region's call duration over wall-clock time, with a min-max band.
+
+    One line per region tracks the mean duration over the ranks that recorded
+    each call, shaded between the minimum and maximum duration seen across
+    those ranks, so rank imbalance shows up as a widening band.
+
+    Parameters
+    ----------
+    backend : str
+        Backend to use for rendering: "matplotlib" (default) or "plotly".
+    """
+    Canvas = _get_canvas()
+    readers = _as_readers(profiling_data)
+    if not readers:
+        raise ValueError("No profiling data provided.")
+
+    normalized_ranks = _normalize_ranks(ranks)
+
+    reader_regions = []
+    all_region_names: set[str] = set()
+    for reader in readers:
+        regions = reader.get_regions(include=include, exclude=exclude)
+        if not regions:
+            raise ValueError("No regions matched the selected filters.")
+        all_region_names.update(region.name for region in regions)
+        reader_regions.append((reader, regions))
+
+    color_map = _region_color_map(all_region_names, cmap=cmap)
+
+    prepared = []
+    for reader, regions in reader_regions:
+        first_start_time = reader.minimum_start_time
+        series = [
+            (
+                region.name,
+                _duration_timeseries(region, normalized_ranks, first_start_time),
+            )
+            for region in regions
+        ]
+        series = [(name, values) for name, values in series if values is not None]
+        if series:
+            prepared.append((reader, series))
+
+    if not prepared:
+        raise ValueError("No calls recorded for the requested ranks.")
+
+    labels = _unique_labels([reader.file_path.stem for reader, _ in prepared])
+
+    if data_filepath:
+        records = []
+        for label, (_, series) in zip(labels, prepared):
+            for region_name, values in series:
+                for index in range(values["time"].size):
+                    records.append(
+                        [
+                            label,
+                            region_name,
+                            index,
+                            float(values["time"][index]),
+                            float(values["mean"][index]),
+                            float(values["min"][index]),
+                            float(values["max"][index]),
+                            int(values["num_ranks"][index]),
+                        ]
+                    )
+        header = [
+            "file",
+            "region",
+            "call_index",
+            "time_seconds",
+            "mean_duration_seconds",
+            "min_duration_seconds",
+            "max_duration_seconds",
+            "num_ranks",
+        ]
+        if data_format == "json":
+            points = [dict(zip(header, record)) for record in records]
+            colors_map = {
+                name: _to_hex(color) for name, color in sorted(color_map.items())
+            }
+            _write_json(data_filepath, {"points": points, "colors": colors_map})
+        else:
+            _write_csv(data_filepath, header, records)
+
+    if verbose:
+        print("Plotting duration over time for files: " + ", ".join(labels))
+
+    single_panel = len(prepared) == 1
+    fig_width, fig_height = 12.0, 1.0 + 4.0 * len(prepared)
+    canvas = Canvas(
+        nrows=len(prepared),
+        ncols=1,
+        figsize=(fig_width, fig_height),
+        # Duration tick labels plus the "Duration (seconds)" axis label.
+        gridspec_kw=_panel_gridspec(fig_width, fig_height, 12, not single_panel),
+    )
+
+    for idx, (reader, series) in enumerate(prepared):
+        row = None if single_panel else idx
+        col = None if single_panel else 0
+
+        for region_name, values in series:
+            color = _to_hex(color_map[region_name])
+            canvas.fill_between(
+                values["time"],
+                values["min"],
+                values["max"],
+                row=row,
+                col=col,
+                color=color,
+                alpha=0.25,
+            )
+            canvas.add_line(
+                values["time"],
+                values["mean"],
+                row=row,
+                col=col,
+                linewidth=1.8,
+                color=color,
+                label=region_name,
+            )
+
+        canvas.set_xlabel("Time (seconds)", row=row, col=col)
+        canvas.set_ylabel("Duration per call (seconds)", row=row, col=col)
+        canvas.set_title(
+            "Region duration over time" if single_panel else reader.file_path.stem,
+            row=row,
+            col=col,
+        )
+        canvas.set_grid(True, row=row, col=col)
+        canvas.set_legend(row=row, col=col)
+
+    if not single_panel:
+        canvas.suptitle("Region duration over time")
+
+    _render(canvas, filepath, show, backend)
+
+
 def plot_speedup(
     profiling_data: ProfilingH5Reader | Sequence[ProfilingH5Reader],
     x_field: str = "num_ranks",

{scope_profiler-0.2.4 → scope_profiler-0.2.6}/src/scope_profiler/post_processing.py

@@ -7,6 +7,7 @@ import os
 from scope_profiler.h5reader import ProfilingH5Reader
 from scope_profiler.plotting_scripts import (
     DEFAULT_CMAP,
+    plot_duration_timeseries,
     plot_durations,
     plot_flame,
     plot_gantt,
@@ -60,7 +61,8 @@ def build_parser() -> argparse.ArgumentParser:
         help=(
             "Directory where outputs are saved "
             "(gantt_plot.png, flame_plot.png, durations_plot.png, "
-            "optional speedup_plot.png, and region_statistics.json)"
+            "duration_timeseries_plot.png, optional speedup_plot.png, "
+            "and region_statistics.json)"
         ),
     )
     parser.add_argument(
@@ -90,16 +92,30 @@ def build_parser() -> argparse.ArgumentParser:
             "Supports comma-separated values and ranges (e.g., 1-3,5)."
         ),
     )
+    parser.add_argument(
+        "--plots",
+        "-p",
+        nargs="*",
+        type=str,
+        choices=["gantt", "flame", "durations", "timeseries", "speedup"],
+        default=None,
+        help=(
+            "Which plots to generate (default: all). "
+            "Choices: gantt, flame, durations, timeseries, speedup. "
+            "Example: --plots gantt durations"
+        ),
+    )
     parser.add_argument(
         "--metrics",
         "-m",
         nargs="*",
         type=str,
         choices=["avg", "min", "max", "total"],
-        default=None,
+        default=["total"],
         help=(
             "Which duration statistics to include in the durations bar plot "
-            "(default: all of avg, min, max, total)."
+            "(default: total). "
+            "Example: --metrics avg min max total"
         ),
     )
     parser.add_argument(
@@ -140,7 +156,8 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help=(
             "Also write the exact data behind each plot as a data file "
-            "(gantt_data, flame_data, durations_data, optional speedup_data; "
+            "(gantt_data, flame_data, durations_data, "
+            "duration_timeseries_data, optional speedup_data; "
             "see --export-data-format for the file extension/content), so "
             "charts can be reconstructed later without the original HDF5 "
             "files. Requires -o/--output."
@@ -243,6 +260,9 @@ def main(argv: list[str] | None = None):
             "--export-speedscope."
         )
 
+    _ALL_PLOTS = {"gantt", "flame", "durations", "timeseries", "speedup"}
+    selected_plots: set[str] = set(args.plots) if args.plots is not None else _ALL_PLOTS
+
     if args.ranks:
         ranks = []
         for spec in args.ranks:
@@ -274,11 +294,13 @@ def main(argv: list[str] | None = None):
     gantt_path = None
     flame_path = None
     durations_path = None
+    timeseries_path = None
     speedup_path = None
     statistics_path = None
     gantt_data_path = None
     flame_data_path = None
     durations_data_path = None
+    timeseries_data_path = None
     speedup_data_path = None
     prof_path = None
     prof_paths: list = []
@@ -291,20 +313,34 @@ def main(argv: list[str] | None = None):
             # Plotly's native output is a self-contained interactive page;
             # writing .png from it would additionally require kaleido.
             ext = "html" if args.backend == "plotly" else "png"
-            gantt_path = os.path.join(args.output, f"gantt_plot.{ext}")
-            flame_path = os.path.join(args.output, f"flame_plot.{ext}")
-            durations_path = os.path.join(args.output, f"durations_plot.{ext}")
-            if len(readers) > 1:
+            if "gantt" in selected_plots:
+                gantt_path = os.path.join(args.output, f"gantt_plot.{ext}")
+            if "flame" in selected_plots:
+                flame_path = os.path.join(args.output, f"flame_plot.{ext}")
+            if "durations" in selected_plots:
+                durations_path = os.path.join(args.output, f"durations_plot.{ext}")
+            if "timeseries" in selected_plots:
+                timeseries_path = os.path.join(
+                    args.output, f"duration_timeseries_plot.{ext}"
+                )
+            if len(readers) > 1 and "speedup" in selected_plots:
                 speedup_path = os.path.join(args.output, f"speedup_plot.{ext}")
         statistics_path = os.path.join(args.output, "region_statistics.json")
         if args.export_data:
             data_ext = args.export_data_format
-            gantt_data_path = os.path.join(args.output, f"gantt_data.{data_ext}")
-            flame_data_path = os.path.join(args.output, f"flame_data.{data_ext}")
-            durations_data_path = os.path.join(
-                args.output, f"durations_data.{data_ext}"
-            )
-            if len(readers) > 1:
+            if "gantt" in selected_plots:
+                gantt_data_path = os.path.join(args.output, f"gantt_data.{data_ext}")
+            if "flame" in selected_plots:
+                flame_data_path = os.path.join(args.output, f"flame_data.{data_ext}")
+            if "durations" in selected_plots:
+                durations_data_path = os.path.join(
+                    args.output, f"durations_data.{data_ext}"
+                )
+            if "timeseries" in selected_plots:
+                timeseries_data_path = os.path.join(
+                    args.output, f"duration_timeseries_data.{data_ext}"
+                )
+            if len(readers) > 1 and "speedup" in selected_plots:
                 speedup_data_path = os.path.join(
                     args.output, f"speedup_data.{data_ext}"
                 )
@@ -339,47 +375,64 @@ def main(argv: list[str] | None = None):
         )
 
     if render_plots:
-        plot_gantt(
-            profiling_data=readers,
-            filepath=gantt_path,
-            show=args.show,
-            include=args.include,
-            exclude=args.exclude,
-            ranks=args.ranks,
-            cmap=args.cmap,
-            data_filepath=gantt_data_path,
-            data_format=args.export_data_format,
-            backend=args.backend,
-        )
+        if "gantt" in selected_plots:
+            plot_gantt(
+                profiling_data=readers,
+                filepath=gantt_path,
+                show=args.show,
+                include=args.include,
+                exclude=args.exclude,
+                ranks=args.ranks,
+                cmap=args.cmap,
+                data_filepath=gantt_data_path,
+                data_format=args.export_data_format,
+                backend=args.backend,
+            )
 
-        plot_flame(
-            profiling_data=readers,
-            filepath=flame_path,
-            show=args.show,
-            include=args.include,
-            exclude=args.exclude,
-            ranks=args.ranks,
-            cmap=args.cmap,
-            data_filepath=flame_data_path,
-            data_format=args.export_data_format,
-            backend=args.backend,
-        )
+        if "flame" in selected_plots:
+            plot_flame(
+                profiling_data=readers,
+                filepath=flame_path,
+                show=args.show,
+                include=args.include,
+                exclude=args.exclude,
+                ranks=args.ranks,
+                cmap=args.cmap,
+                data_filepath=flame_data_path,
+                data_format=args.export_data_format,
+                backend=args.backend,
+            )
 
-        durations_paths = plot_durations(
-            profiling_data=readers,
-            filepath=durations_path,
-            show=args.show,
-            include=args.include,
-            exclude=args.exclude,
-            ranks=args.ranks,
-            metrics=args.metrics,
-            cmap=args.cmap,
-            data_filepath=durations_data_path,
-            data_format=args.export_data_format,
-            backend=args.backend,
-        )
+        if "durations" in selected_plots:
+            durations_paths = plot_durations(
+                profiling_data=readers,
+                filepath=durations_path,
+                show=args.show,
+                include=args.include,
+                exclude=args.exclude,
+                ranks=args.ranks,
+                metrics=args.metrics,
+                cmap=args.cmap,
+                data_filepath=durations_data_path,
+                data_format=args.export_data_format,
+                backend=args.backend,
+            )
+
+        if "timeseries" in selected_plots:
+            plot_duration_timeseries(
+                profiling_data=readers,
+                filepath=timeseries_path,
+                show=args.show,
+                include=args.include,
+                exclude=args.exclude,
+                ranks=args.ranks,
+                cmap=args.cmap,
+                data_filepath=timeseries_data_path,
+                data_format=args.export_data_format,
+                backend=args.backend,
+            )
 
-        if len(readers) > 1:
+        if len(readers) > 1 and "speedup" in selected_plots:
             plot_speedup(
                 profiling_data=readers,
                 x_field=args.x_field,
@@ -410,11 +463,13 @@ def main(argv: list[str] | None = None):
                 gantt_path,
                 flame_path,
                 *durations_paths,
+                timeseries_path,
                 speedup_path,
                 statistics_path,
                 gantt_data_path,
                 flame_data_path,
                 durations_data_path,
+                timeseries_data_path,
                 speedup_data_path,
                 *prof_paths,
                 *speedscope_paths,

{scope_profiler-0.2.4 → scope_profiler-0.2.6}/src/scope_profiler/tests/test_post_processing.py

@@ -7,6 +7,8 @@ import pytest
 from scope_profiler.h5reader import ProfilingH5Reader
 from scope_profiler.plotting_scripts import (
     _build_call_stack_intervals,
+    _duration_timeseries,
+    plot_duration_timeseries,
     plot_durations,
     plot_flame,
     plot_gantt,
@@ -36,6 +38,11 @@ def _write_sample_h5(path, rank_regions, metadata=None):
                 )
 
 
+def _seconds(nanoseconds):
+    """Timestamps are written in nanoseconds; the reader reports seconds."""
+    return [value / 1e9 for value in nanoseconds]
+
+
 def _sample_file_data(rank_count, setup_duration, solve_duration):
     return {
         rank: {
@@ -56,7 +63,13 @@ def test_plot_durations_comparison(tmp_path):
 
     readers = [ProfilingH5Reader(file_one), ProfilingH5Reader(file_two)]
 
-    saved_paths = plot_durations(readers, filepath=out_file, show=False, verbose=False)
+    saved_paths = plot_durations(
+        readers,
+        filepath=out_file,
+        show=False,
+        verbose=False,
+        metrics=["avg", "min", "max", "total"],
+    )
 
     assert len(saved_paths) == 4
     for metric in ("avg", "min", "max", "total"):
@@ -65,6 +78,91 @@ def test_plot_durations_comparison(tmp_path):
         assert metric_file.stat().st_size > 0
 
 
+def test_duration_timeseries_bands_span_ranks(tmp_path):
+    file_path = tmp_path / "run.h5"
+    # Two calls of "solve" per rank, with rank 1 slower on the second call, so
+    # the band has to widen between the two points.
+    _write_sample_h5(
+        file_path,
+        {
+            0: {"solve": ([0, 100], [10, 110])},
+            1: {"solve": ([0, 100], [20, 140])},
+        },
+    )
+    reader = ProfilingH5Reader(file_path)
+
+    series = _duration_timeseries(reader.get_region("solve"), None, 0.0)
+
+    assert list(series["num_ranks"]) == [2, 2]
+    assert series["min"] == pytest.approx(_seconds([10, 10]))
+    assert series["max"] == pytest.approx(_seconds([20, 40]))
+    assert series["mean"] == pytest.approx(_seconds([15, 25]))
+    assert series["time"] == pytest.approx(_seconds([0, 100]))
+
+
+def test_duration_timeseries_handles_ragged_call_counts(tmp_path):
+    file_path = tmp_path / "run.h5"
+    _write_sample_h5(
+        file_path,
+        {
+            0: {"solve": ([0, 100], [10, 130])},
+            1: {"solve": ([0], [20])},
+        },
+    )
+    reader = ProfilingH5Reader(file_path)
+
+    series = _duration_timeseries(reader.get_region("solve"), None, 0.0)
+
+    # The second call exists on rank 0 only, so its band collapses to a point.
+    assert list(series["num_ranks"]) == [2, 1]
+    assert series["min"] == pytest.approx(_seconds([10, 30]))
+    assert series["max"] == pytest.approx(_seconds([20, 30]))
+
+
+def test_duration_timeseries_respects_rank_selection(tmp_path):
+    file_path = tmp_path / "run.h5"
+    _write_sample_h5(
+        file_path,
+        {
+            0: {"solve": ([0], [10])},
+            1: {"solve": ([0], [50])},
+        },
+    )
+    reader = ProfilingH5Reader(file_path)
+
+    series = _duration_timeseries(reader.get_region("solve"), [0], 0.0)
+
+    assert list(series["num_ranks"]) == [1]
+    assert series["min"] == pytest.approx(series["max"])
+    assert series["max"] == pytest.approx(_seconds([10]))
+
+
+def test_plot_duration_timeseries_export_data_json(tmp_path):
+    file_path = tmp_path / "run.h5"
+    data_file = tmp_path / "duration_timeseries_data.json"
+
+    _write_sample_h5(file_path, _sample_file_data(2, 10, 20))
+    reader = ProfilingH5Reader(file_path)
+
+    plot_duration_timeseries(
+        reader,
+        filepath=tmp_path / "duration_timeseries_plot.png",
+        show=False,
+        verbose=False,
+        data_filepath=data_file,
+        data_format="json",
+    )
+
+    assert (tmp_path / "duration_timeseries_plot.png").stat().st_size > 0
+    payload = json.loads(data_file.read_text(encoding="utf-8"))
+    assert {point["region"] for point in payload["points"]} == {"setup", "solve"}
+    for point in payload["points"]:
+        assert point["min_duration_seconds"] <= point["mean_duration_seconds"]
+        assert point["mean_duration_seconds"] <= point["max_duration_seconds"]
+        assert point["num_ranks"] == 2
+    assert set(payload["colors"]) == {"setup", "solve"}
+
+
 def test_plot_gantt_combined(tmp_path):
     file_one = tmp_path / "run_one.h5"
     file_two = tmp_path / "run_two.h5"
@@ -81,6 +179,59 @@ def test_plot_gantt_combined(tmp_path):
     assert out_file.stat().st_size > 0
 
 
+def test_plot_gantt_puts_every_call_of_a_region_on_one_lane(tmp_path, monkeypatch):
+    """Repeated calls of a region share one row per rank, not a row each."""
+    h5_path = tmp_path / "run.h5"
+    _write_sample_h5(
+        h5_path,
+        {
+            rank: {
+                "setup": ([0], [10]),
+                "solve": ([20, 40, 60], [30, 50, 70]),
+            }
+            for rank in range(2)
+        },
+    )
+
+    bars_by_lane = {}
+
+    class _RecordingCanvas:
+        """Collect what plot_gantt draws instead of rendering it."""
+
+        def __init__(self, *args, **kwargs):
+            self.lanes = None
+
+        def gantt(self, tasks, start_times, durations, **kwargs):
+            self.lanes = tasks
+            for lane, start in enumerate(start_times):
+                if not np.isnan(start):
+                    bars_by_lane.setdefault(lane, []).append(float(start))
+
+        def __getattr__(self, name):
+            # set_yticks, set_xlim, set_title, ... are all no-ops here.
+            return lambda *args, **kwargs: None
+
+    import scope_profiler.plotting_scripts as plotting_scripts
+
+    canvas = _RecordingCanvas()
+    monkeypatch.setattr(
+        plotting_scripts, "_get_canvas", lambda: lambda *a, **kw: canvas
+    )
+    monkeypatch.setattr(plotting_scripts, "_render", lambda *a, **kw: None)
+
+    plot_gantt(ProfilingH5Reader(h5_path), show=False, verbose=False)
+
+    # One lane per (region, rank), and solve's three calls share their lane.
+    assert canvas.lanes == [
+        "setup (rank 0)",
+        "setup (rank 1)",
+        "solve (rank 0)",
+        "solve (rank 1)",
+    ]
+    assert sorted(bars_by_lane) == [0, 1, 2, 3]
+    assert [len(bars_by_lane[lane]) for lane in sorted(bars_by_lane)] == [1, 1, 3, 3]
+
+
 def test_build_call_stack_intervals_reconstructs_nesting(tmp_path):
     # "outer" [0, 100) encloses two sequential "inner" calls, [10, 40) and
     # [50, 90), which in turn each enclose a "leaf" call.
@@ -294,6 +445,7 @@ def test_post_processing_cli_supports_multiple_files(tmp_path):
 
     gantt_plot = output_dir / "gantt_plot.png"
     flame_plot = output_dir / "flame_plot.png"
+    timeseries_plot = output_dir / "duration_timeseries_plot.png"
     speedup_plot = output_dir / "speedup_plot.png"
     stats_json = output_dir / "region_statistics.json"
 
@@ -301,10 +453,11 @@ def test_post_processing_cli_supports_multiple_files(tmp_path):
     assert gantt_plot.stat().st_size > 0
     assert flame_plot.exists()
     assert flame_plot.stat().st_size > 0
-    for metric in ("avg", "min", "max", "total"):
-        metric_file = output_dir / f"durations_plot_{metric}.png"
-        assert metric_file.exists()
-        assert metric_file.stat().st_size > 0
+    durations_plot = output_dir / "durations_plot.png"
+    assert durations_plot.exists()
+    assert durations_plot.stat().st_size > 0
+    assert timeseries_plot.exists()
+    assert timeseries_plot.stat().st_size > 0
     assert speedup_plot.exists()
     assert speedup_plot.stat().st_size > 0
     assert stats_json.exists()
@@ -338,10 +491,9 @@ def test_post_processing_cli_supports_wildcard_file_patterns(tmp_path):
     assert gantt_plot.stat().st_size > 0
     assert flame_plot.exists()
     assert flame_plot.stat().st_size > 0
-    for metric in ("avg", "min", "max", "total"):
-        metric_file = output_dir / f"durations_plot_{metric}.png"
-        assert metric_file.exists()
-        assert metric_file.stat().st_size > 0
+    durations_plot = output_dir / "durations_plot.png"
+    assert durations_plot.exists()
+    assert durations_plot.stat().st_size > 0
     assert speedup_plot.exists()
     assert speedup_plot.stat().st_size > 0
     assert stats_json.exists()
@@ -410,6 +562,7 @@ def test_plot_durations_export_data_json(tmp_path):
         verbose=False,
         data_filepath=data_file,
         data_format="json",
+        metrics=["avg", "min", "max", "total"],
     )
 
     payload = json.loads(data_file.read_text(encoding="utf-8"))

{scope_profiler-0.2.4 → scope_profiler-0.2.6}/src/scope_profiler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scope-profiler
-Version: 0.2.4
+Version: 0.2.6
 Summary: Profile code regions in python, optionally with LIKWID markers.
 Author: Max
 Project-URL: Source, https://github.com/max-models/scope-profiler