pytest-codspeed 2.2.1__tar.gz → 3.0.0__tar.gz

{pytest_codspeed-2.2.1 → pytest_codspeed-3.0.0}/.gitignore

@@ -162,3 +162,5 @@ cython_debug/
 .venvubuntu
 .python-version
 *.o
+
+.codspeed

{pytest_codspeed-2.2.1 → pytest_codspeed-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pytest-codspeed
-Version: 2.2.1
+Version: 3.0.0
 Summary: Pytest plugin to create CodSpeed benchmarks
 Project-URL: Homepage, https://codspeed.io/
 Project-URL: Documentation, https://docs.codspeed.io/
@@ -35,27 +35,30 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: System :: Benchmark
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.7
-Requires-Dist: cffi>=1.15.1
+Requires-Python: >=3.9
+Requires-Dist: cffi>=1.17.1
 Requires-Dist: filelock>=3.12.2
+Requires-Dist: importlib-metadata>=8.5.0; python_version < '3.10'
 Requires-Dist: pytest>=3.8
+Requires-Dist: rich>=13.8.1
 Requires-Dist: setuptools; python_full_version >= '3.12.0'
+Provides-Extra: build
+Requires-Dist: semver>=3.0.2; extra == 'build'
 Provides-Extra: compat
-Requires-Dist: pytest-benchmark~=4.0.0; extra == 'compat'
-Requires-Dist: pytest-xdist~=2.0.0; extra == 'compat'
+Requires-Dist: pytest-benchmark~=5.0.0; extra == 'compat'
+Requires-Dist: pytest-xdist~=3.6.1; extra == 'compat'
 Provides-Extra: lint
-Requires-Dist: mypy~=1.3.0; extra == 'lint'
-Requires-Dist: ruff~=0.3.3; extra == 'lint'
+Requires-Dist: mypy~=1.11.2; extra == 'lint'
+Requires-Dist: ruff~=0.6.5; extra == 'lint'
 Provides-Extra: test
 Requires-Dist: pytest-cov~=4.0.0; extra == 'test'
 Requires-Dist: pytest~=7.0; extra == 'test'
@@ -66,7 +69,7 @@ Description-Content-Type: text/markdown
 
 [![CI](https://github.com/CodSpeedHQ/pytest-codspeed/actions/workflows/ci.yml/badge.svg)](https://github.com/CodSpeedHQ/pytest-codspeed/actions/workflows/ci.yml)
 [![PyPi Version](https://img.shields.io/pypi/v/pytest-codspeed?color=%2334D058&label=pypi)](https://pypi.org/project/pytest-codspeed)
-![Python Version](https://img.shields.io/badge/python-3.7%20|%203.8%20|%203.9%20|%203.10%20|%203.11%20|%203.12-informational.svg)
+![Python Version](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12%20|%203.13-informational.svg)
 [![Discord](https://img.shields.io/badge/chat%20on-discord-7289da.svg)](https://discord.com/invite/MxpaCfKSqF)
 [![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/CodSpeedHQ/pytest-codspeed)
 
@@ -76,7 +79,7 @@ Pytest plugin to create CodSpeed benchmarks
 
 ## Requirements
 
-**Python**: 3.7 and later
+**Python**: 3.9 and later
 
 **pytest**: any recent version
 
@@ -151,7 +154,7 @@ You can use the [CodSpeedHQ/action](https://github.com/CodSpeedHQ/action) to run
 Example workflow:
 
 ```yaml
-name: benchmarks
+name: CodSpeed
 
 on:
   push:
@@ -161,16 +164,17 @@ on:
 
 jobs:
   benchmarks:
+    name: Run benchmarks
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
+          python-version: "3.12"
       - name: Install dependencies
         run: pip install -r requirements.txt
       - name: Run benchmarks
-        uses: CodSpeedHQ/action@v2
+        uses: CodSpeedHQ/action@v3
         with:
           token: ${{ secrets.CODSPEED_TOKEN }}
           run: pytest tests/ --codspeed

{pytest_codspeed-2.2.1 → pytest_codspeed-3.0.0}/README.md

@@ -3,7 +3,7 @@
 
 [![CI](https://github.com/CodSpeedHQ/pytest-codspeed/actions/workflows/ci.yml/badge.svg)](https://github.com/CodSpeedHQ/pytest-codspeed/actions/workflows/ci.yml)
 [![PyPi Version](https://img.shields.io/pypi/v/pytest-codspeed?color=%2334D058&label=pypi)](https://pypi.org/project/pytest-codspeed)
-![Python Version](https://img.shields.io/badge/python-3.7%20|%203.8%20|%203.9%20|%203.10%20|%203.11%20|%203.12-informational.svg)
+![Python Version](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12%20|%203.13-informational.svg)
 [![Discord](https://img.shields.io/badge/chat%20on-discord-7289da.svg)](https://discord.com/invite/MxpaCfKSqF)
 [![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/CodSpeedHQ/pytest-codspeed)
 
@@ -13,7 +13,7 @@ Pytest plugin to create CodSpeed benchmarks
 
 ## Requirements
 
-**Python**: 3.7 and later
+**Python**: 3.9 and later
 
 **pytest**: any recent version
 
@@ -88,7 +88,7 @@ You can use the [CodSpeedHQ/action](https://github.com/CodSpeedHQ/action) to run
 Example workflow:
 
 ```yaml
-name: benchmarks
+name: CodSpeed
 
 on:
   push:
@@ -98,16 +98,17 @@ on:
 
 jobs:
   benchmarks:
+    name: Run benchmarks
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
+          python-version: "3.12"
       - name: Install dependencies
         run: pip install -r requirements.txt
       - name: Run benchmarks
-        uses: CodSpeedHQ/action@v2
+        uses: CodSpeedHQ/action@v3
         with:
           token: ${{ secrets.CODSPEED_TOKEN }}
           run: pytest tests/ --codspeed

{pytest_codspeed-2.2.1 → pytest_codspeed-3.0.0}/pyproject.toml

@@ -13,7 +13,7 @@ dynamic = ["version"]
 description = "Pytest plugin to create CodSpeed benchmarks"
 readme = "README.md"
 license = { file = "LICENSE" }
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 authors = [{ name = "Arthur Pastel", email = "arthur@codspeed.io" }]
 keywords = ["codspeed", "benchmark", "performance", "pytest"]
 classifiers = [
@@ -23,31 +23,36 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Software Development :: Testing",
     "Topic :: System :: Benchmark",
     "Topic :: Utilities",
     "Typing :: Typed",
 ]
 dependencies = [
-    "cffi >= 1.15.1",
+    "cffi >= 1.17.1",
     # cffi doesn't automatically install setuptools with python 3.12+
     # cf https://github.com/python-cffi/cffi/releases/tag/v1.16.0
     "setuptools; python_full_version >= '3.12.0'",
     "pytest>=3.8",
     "filelock >= 3.12.2",
+    "rich>=13.8.1",
+    "importlib-metadata>=8.5.0; python_version < '3.10'",
 ]
 
 [project.optional-dependencies]
-lint = ["mypy ~= 1.3.0", "ruff ~= 0.3.3"]
-compat = ["pytest-benchmark ~= 4.0.0", "pytest-xdist ~= 2.0.0"]
+build = ["semver>=3.0.2"]
+lint = ["mypy ~= 1.11.2", "ruff ~= 0.6.5"]
+compat = [
+    "pytest-benchmark ~= 5.0.0",
+    "pytest-xdist ~= 3.6.1",
+    # "pytest-speed>=0.3.5",
+]
 test = ["pytest ~= 7.0", "pytest-cov ~= 4.0.0"]
-
 [project.entry-points]
 pytest11 = { codspeed = "pytest_codspeed.plugin" }
 
@@ -59,7 +64,7 @@ features = ["lint", "test", "compat"]
 features = ["test"]
 
 [[tool.hatch.envs.test.matrix]]
-python = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+python = ["3.9", "3.10", "3.11", "3.12", "3.13"]
 features = ["compat", "test"]
 
 [tool.hatch.version]
@@ -72,9 +77,11 @@ include = ["/src"]
 python_version = "3.12"
 
 [tool.ruff]
-line-length = 88
+target-version = "py37"
+
 [tool.ruff.lint]
-select = ["E", "F", "I", "C"]
+select = ["E", "F", "I", "C", "TCH", "FA", "UP"]
+flake8-type-checking = { exempt-modules = [], strict = true }
 
 [tool.isort]
 line_length = 88
@@ -85,8 +92,9 @@ force_grid_wrap = 0
 float_to_top = true
 
 [tool.pytest.ini_options]
-addopts = "--ignore=tests/benchmarks --ignore=tests/examples"
+addopts = "--ignore=tests/benchmarks --ignore=tests/examples --ignore=tests/benchmarks/TheAlgorithms"
 filterwarnings = ["ignore::DeprecationWarning:pytest_benchmark.utils.*:"]
+pythonpath = ["tests/benchmarks/TheAlgorithms", "./scripts"]
 
 [tool.coverage.run]
 branch = true

pytest_codspeed-3.0.0/src/pytest_codspeed/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "3.0.0"
+# We also have the semver version since __version__ is not semver compliant
+__semver_version__ = "3.0.0"
+
+from .plugin import BenchmarkFixture
+
+__all__ = ["BenchmarkFixture", "__version__", "__semver_version__"]

pytest_codspeed-3.0.0/src/pytest_codspeed/instruments/__init__.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, ClassVar, ParamSpec, TypeVar
+
+    import pytest
+
+    from pytest_codspeed.plugin import CodSpeedConfig
+
+    T = TypeVar("T")
+    P = ParamSpec("P")
+
+
+class Instrument(metaclass=ABCMeta):
+    instrument: ClassVar[str]
+
+    @abstractmethod
+    def __init__(self, config: CodSpeedConfig): ...
+
+    @abstractmethod
+    def get_instrument_config_str_and_warns(self) -> tuple[str, list[str]]: ...
+
+    @abstractmethod
+    def measure(
+        self,
+        name: str,
+        uri: str,
+        fn: Callable[P, T],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T: ...
+
+    @abstractmethod
+    def report(self, session: pytest.Session) -> None: ...
+
+    @abstractmethod
+    def get_result_dict(
+        self,
+    ) -> dict[str, Any]: ...
+
+
+class MeasurementMode(str, Enum):
+    Instrumentation = "instrumentation"
+    WallTime = "walltime"
+
+
+def get_instrument_from_mode(mode: MeasurementMode) -> type[Instrument]:
+    from pytest_codspeed.instruments.valgrind import (
+        ValgrindInstrument,
+    )
+    from pytest_codspeed.instruments.walltime import WallTimeInstrument
+
+    if mode == MeasurementMode.Instrumentation:
+        return ValgrindInstrument
+    else:
+        return WallTimeInstrument

pytest_codspeed-3.0.0/src/pytest_codspeed/instruments/valgrind/__init__.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING
+
+from pytest_codspeed import __semver_version__
+from pytest_codspeed.instruments import Instrument
+from pytest_codspeed.instruments.valgrind._wrapper import get_lib
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+    from pytest import Session
+
+    from pytest_codspeed.instruments import P, T
+    from pytest_codspeed.instruments.valgrind._wrapper import LibType
+    from pytest_codspeed.plugin import CodSpeedConfig
+
+SUPPORTS_PERF_TRAMPOLINE = sys.version_info >= (3, 12)
+
+
+class ValgrindInstrument(Instrument):
+    instrument = "valgrind"
+    lib: LibType | None
+
+    def __init__(self, config: CodSpeedConfig) -> None:
+        self.benchmark_count = 0
+        self.should_measure = os.environ.get("CODSPEED_ENV") is not None
+        if self.should_measure:
+            self.lib = get_lib()
+            self.lib.dump_stats_at(
+                f"Metadata: pytest-codspeed {__semver_version__}".encode("ascii")
+            )
+            if SUPPORTS_PERF_TRAMPOLINE:
+                sys.activate_stack_trampoline("perf")  # type: ignore
+        else:
+            self.lib = None
+
+    def get_instrument_config_str_and_warns(self) -> tuple[str, list[str]]:
+        config = (
+            f"mode: instrumentation, "
+            f"callgraph: {'enabled' if SUPPORTS_PERF_TRAMPOLINE  else 'not supported'}"
+        )
+        warnings = []
+        if not self.should_measure:
+            warnings.append(
+                "\033[1m"
+                "NOTICE: codspeed is enabled, but no performance measurement"
+                " will be made since it's running in an unknown environment."
+                "\033[0m"
+            )
+        return config, warnings
+
+    def measure(
+        self,
+        name: str,
+        uri: str,
+        fn: Callable[P, T],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T:
+        self.benchmark_count += 1
+        if self.lib is None:  # Thus should_measure is False
+            return fn(*args, **kwargs)
+
+        def __codspeed_root_frame__() -> T:
+            return fn(*args, **kwargs)
+
+        if SUPPORTS_PERF_TRAMPOLINE:
+            # Warmup CPython performance map cache
+            __codspeed_root_frame__()
+
+        self.lib.zero_stats()
+        self.lib.start_instrumentation()
+        try:
+            return __codspeed_root_frame__()
+        finally:
+            # Ensure instrumentation is stopped even if the test failed
+            self.lib.stop_instrumentation()
+            self.lib.dump_stats_at(uri.encode("ascii"))
+
+    def report(self, session: Session) -> None:
+        reporter = session.config.pluginmanager.get_plugin("terminalreporter")
+        count_suffix = "benchmarked" if self.should_measure else "benchmark tested"
+        reporter.write_sep(
+            "=",
+            f"{self.benchmark_count} {count_suffix}",
+        )
+
+    def get_result_dict(self) -> dict[str, Any]:
+        return {
+            "instrument": {"type": self.instrument},
+            # bench results will be dumped by valgrind
+        }

{pytest_codspeed-2.2.1/src/pytest_codspeed → pytest_codspeed-3.0.0/src/pytest_codspeed/instruments/valgrind}/_wrapper/.gitignore

@@ -1 +1,2 @@
 dist_callgrind_wrapper.*
+build.lock

{pytest_codspeed-2.2.1/src/pytest_codspeed → pytest_codspeed-3.0.0/src/pytest_codspeed/instruments/valgrind}/_wrapper/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 from typing import TYPE_CHECKING
 
@@ -22,7 +24,7 @@ def _get_ffi():
     return ffi
 
 
-def get_lib() -> "LibType":
+def get_lib() -> LibType:
     try:
         ffi = _get_ffi()
         build_lock = FileLock(f"{_wrapper_dir}/build.lock")

pytest_codspeed-3.0.0/src/pytest_codspeed/instruments/walltime.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from math import ceil
+from statistics import mean, quantiles, stdev
+from time import get_clock_info, perf_counter_ns
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.markup import escape
+from rich.table import Table
+from rich.text import Text
+
+from pytest_codspeed.instruments import Instrument
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+    from pytest import Session
+
+    from pytest_codspeed.instruments import P, T
+    from pytest_codspeed.plugin import CodSpeedConfig
+
+DEFAULT_WARMUP_TIME_NS = 1_000_000_000
+DEFAULT_MAX_TIME_NS = 3_000_000_000
+TIMER_RESOLUTION_NS = get_clock_info("perf_counter").resolution * 1e9
+DEFAULT_MIN_ROUND_TIME_NS = TIMER_RESOLUTION_NS * 100
+
+
+@dataclass
+class BenchmarkConfig:
+    warmup_time_ns: int
+    min_round_time_ns: float
+    max_time_ns: int
+    max_rounds: int | None
+
+    @classmethod
+    def from_codspeed_config(cls, config: CodSpeedConfig) -> BenchmarkConfig:
+        return cls(
+            warmup_time_ns=config.warmup_time_ns
+            if config.warmup_time_ns is not None
+            else DEFAULT_WARMUP_TIME_NS,
+            min_round_time_ns=DEFAULT_MIN_ROUND_TIME_NS,
+            max_time_ns=config.max_time_ns
+            if config.max_time_ns is not None
+            else DEFAULT_MAX_TIME_NS,
+            max_rounds=config.max_rounds,
+        )
+
+
+@dataclass
+class BenchmarkStats:
+    min_ns: float
+    max_ns: float
+    mean_ns: float
+    stdev_ns: float
+
+    q1_ns: float
+    median_ns: float
+    q3_ns: float
+
+    rounds: int
+    total_time: float
+    iqr_outlier_rounds: int
+    stdev_outlier_rounds: int
+    iter_per_round: int
+    warmup_iters: int
+
+    @classmethod
+    def from_list(
+        cls,
+        times_ns: list[float],
+        *,
+        rounds: int,
+        iter_per_round: int,
+        warmup_iters: int,
+        total_time: float,
+    ) -> BenchmarkStats:
+        stdev_ns = stdev(times_ns) if len(times_ns) > 1 else 0
+        mean_ns = mean(times_ns)
+        if len(times_ns) > 1:
+            q1_ns, median_ns, q3_ns = quantiles(times_ns, n=4)
+        else:
+            q1_ns, median_ns, q3_ns = (
+                mean_ns,
+                mean_ns,
+                mean_ns,
+            )
+        iqr_ns = q3_ns - q1_ns
+        iqr_outlier_rounds = sum(
+            1 for t in times_ns if t < q1_ns - 1.5 * iqr_ns or t > q3_ns + 1.5 * iqr_ns
+        )
+        stdev_outlier_rounds = sum(
+            1
+            for t in times_ns
+            if t < mean_ns - 3 * stdev_ns or t > mean_ns + 3 * stdev_ns
+        )
+
+        return cls(
+            min_ns=min(times_ns),
+            max_ns=max(times_ns),
+            stdev_ns=stdev_ns,
+            mean_ns=mean_ns,
+            q1_ns=q1_ns,
+            median_ns=median_ns,
+            q3_ns=q3_ns,
+            rounds=rounds,
+            total_time=total_time,
+            iqr_outlier_rounds=iqr_outlier_rounds,
+            stdev_outlier_rounds=stdev_outlier_rounds,
+            iter_per_round=iter_per_round,
+            warmup_iters=warmup_iters,
+        )
+
+
+@dataclass
+class Benchmark:
+    name: str
+    uri: str
+
+    config: BenchmarkConfig
+    stats: BenchmarkStats
+
+
+def run_benchmark(
+    name: str, uri: str, fn: Callable[P, T], args, kwargs, config: BenchmarkConfig
+) -> tuple[Benchmark, T]:
+    # Compute the actual result of the function
+    out = fn(*args, **kwargs)
+
+    # Warmup
+    times_ns: list[float] = []
+    warmup_start = start = perf_counter_ns()
+    while True:
+        start = perf_counter_ns()
+        fn(*args, **kwargs)
+        end = perf_counter_ns()
+        times_ns.append(end - start)
+        if end - warmup_start > config.warmup_time_ns:
+            break
+
+    # Round sizing
+    warmup_mean_ns = mean(times_ns)
+    warmup_iters = len(times_ns)
+    times_ns.clear()
+    iter_per_round = (
+        int(ceil(config.min_round_time_ns / warmup_mean_ns))
+        if warmup_mean_ns <= config.min_round_time_ns
+        else 1
+    )
+    if config.max_rounds is None:
+        round_time_ns = warmup_mean_ns * iter_per_round
+        rounds = int(config.max_time_ns / round_time_ns)
+    else:
+        rounds = config.max_rounds
+    rounds = max(1, rounds)
+
+    # Benchmark
+    iter_range = range(iter_per_round)
+    run_start = perf_counter_ns()
+    for _ in range(rounds):
+        start = perf_counter_ns()
+        for _ in iter_range:
+            fn(*args, **kwargs)
+        end = perf_counter_ns()
+        times_ns.append(end - start)
+
+        if end - run_start > config.max_time_ns:
+            # TODO: log something
+            break
+    benchmark_end = perf_counter_ns()
+    total_time = (benchmark_end - run_start) / 1e9
+
+    stats = BenchmarkStats.from_list(
+        times_ns,
+        rounds=rounds,
+        total_time=total_time,
+        iter_per_round=iter_per_round,
+        warmup_iters=warmup_iters,
+    )
+
+    return Benchmark(name=name, uri=uri, config=config, stats=stats), out
+
+
+class WallTimeInstrument(Instrument):
+    instrument = "walltime"
+
+    def __init__(self, config: CodSpeedConfig) -> None:
+        self.config = config
+        self.benchmarks: list[Benchmark] = []
+
+    def get_instrument_config_str_and_warns(self) -> tuple[str, list[str]]:
+        return f"mode: walltime, timer_resolution: {TIMER_RESOLUTION_NS:.1f}ns", []
+
+    def measure(
+        self,
+        name: str,
+        uri: str,
+        fn: Callable[P, T],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T:
+        bench, out = run_benchmark(
+            name=name,
+            uri=uri,
+            fn=fn,
+            args=args,
+            kwargs=kwargs,
+            config=BenchmarkConfig.from_codspeed_config(self.config),
+        )
+        self.benchmarks.append(bench)
+        return out
+
+    def report(self, session: Session) -> None:
+        reporter = session.config.pluginmanager.get_plugin("terminalreporter")
+
+        if len(self.benchmarks) == 0:
+            reporter.write_sep(
+                "=",
+                f"{len(self.benchmarks)} benchmarked",
+            )
+            return
+        self._print_benchmark_table()
+        reporter.write_sep(
+            "=",
+            f"{len(self.benchmarks)} benchmarked",
+        )
+
+    def _print_benchmark_table(self) -> None:
+        table = Table(title="Benchmark Results")
+
+        table.add_column("Benchmark", justify="right", style="cyan", no_wrap=True)
+        table.add_column("Time (best)", justify="right", style="green bold")
+        table.add_column(
+            "Rel. StdDev",
+            justify="right",
+        )
+        table.add_column("Run time", justify="right")
+        table.add_column("Iters", justify="right")
+
+        for bench in self.benchmarks:
+            rsd = bench.stats.stdev_ns / bench.stats.mean_ns
+            rsd_text = Text(f"{rsd*100:.1f}%")
+            if rsd > 0.1:
+                rsd_text.stylize("red bold")
+            table.add_row(
+                escape(bench.name),
+                f"{bench.stats.min_ns/bench.stats.iter_per_round:,.0f}ns",
+                rsd_text,
+                f"{bench.stats.total_time:,.2f}s",
+                f"{bench.stats.iter_per_round * bench.stats.rounds:,}",
+            )
+
+        console = Console()
+        print("\n")
+        console.print(table)
+
+    def get_result_dict(self) -> dict[str, Any]:
+        return {
+            "instrument": {
+                "type": self.instrument,
+                "clock_info": get_clock_info("perf_counter").__dict__,
+            },
+            "benchmarks": [asdict(bench) for bench in self.benchmarks],
+        }