scope-profiler 0.2.7__tar.gz → 0.2.8__tar.gz

{scope_profiler-0.2.7 → scope_profiler-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scope-profiler
-Version: 0.2.7
+Version: 0.2.8
 Summary: Profile code regions in python, optionally with LIKWID markers.
 Author: Max
 Project-URL: Source, https://github.com/max-models/scope-profiler
@@ -16,6 +16,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: h5py
 Requires-Dist: numpy
+Provides-Extra: fortran
+Requires-Dist: meson; extra == "fortran"
+Requires-Dist: ninja; extra == "fortran"
 Provides-Extra: likwid
 Requires-Dist: pylikwid; extra == "likwid"
 Provides-Extra: line-profiler
@@ -26,14 +29,14 @@ Provides-Extra: pproc
 Requires-Dist: ipykernel; extra == "pproc"
 Requires-Dist: jupyterlab; extra == "pproc"
 Requires-Dist: matplotlib; extra == "pproc"
-Requires-Dist: maxplotlibx>=0.1.5; extra == "pproc"
+Requires-Dist: maxplotlibx>=0.1.6; extra == "pproc"
 Requires-Dist: pandas; extra == "pproc"
 Requires-Dist: snakeviz; extra == "pproc"
 Provides-Extra: dev
 Requires-Dist: black[jupyter]; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Requires-Dist: scope-profiler[docs,line-profiler,mpi,pproc,test]; extra == "dev"
+Requires-Dist: scope-profiler[docs,fortran,line-profiler,mpi,pproc,test]; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: nbconvert; extra == "docs"
@@ -110,7 +113,6 @@ profiling_data.h5  (1 rank(s))
   ----------------------------------------------------------------------------------------
   TOTAL                11   0.00150754
 
-  Regions may nest, so the summed total can exceed the wall-clock time.
 ```
 
 `finalize()` prints the same table as `scope-profiler inspect` and
@@ -206,17 +208,60 @@ against a bare function call:
 ![Profiling overhead by region type](https://raw.githubusercontent.com/max-models/scope-profiler/refs/heads/devel/figures/benchmark_overhead.png)
 
 The default **TimeOnly** mode — nanosecond timestamps for every call — adds
-roughly **0.75 µs** per instrumented call.
+roughly **0.33 µs** per instrumented call.
 
 Profiling can also be fully deactivated at setup time
-(`deactivate_profiling=True`) to reduce the overhead to ~0.03 µs — barely
+(`deactivate_profiling=True`) to reduce the overhead to ~0.1 µs — barely
 above a bare function call — making it safe to leave instrumentation in
 production code and toggle it on only when needed.
 
-The **LineProfiler** mode is intentionally heavier (~41 µs/call) because
+The **LineProfiler** mode is intentionally heavier (~50 µs/call) because
 `line_profiler` traces every source line. It is designed for targeted
 debugging of individual functions, not for always-on use in hot loops.
 
+## Profiling native code (C, C++, Fortran)
+
+C and Fortran region APIs ship with the package, so native code — or the
+kernels under a Python driver — can be profiled into the same output. They
+share one trace format, so a program built from both lands in one profile.
+
+```c
+#include "scope_profiler.h"
+
+sp_init("profile", my_rank);
+int solve = sp_region("solve");
+sp_begin(solve);
+solve_system();
+sp_end(solve);
+sp_finalize();
+```
+
+```fortran
+use scope_profiler
+integer :: solve
+
+call sp_init("profile", rank=my_rank)
+solve = sp_region("solve")
+call sp_begin(solve)
+call solve_system()
+call sp_end(solve)
+call sp_finalize()
+```
+
+```bash
+scope-profiler import-native . -o profiling_data.h5   # then pproc/inspect as usual
+```
+
+Both are one self-contained file (Fortran 2008, or C99 with an `extern "C"`
+header for C++ callers): no HDF5, no MPI, nothing to link beyond libc.
+
+Timestamps come from the same clock as Python's `time.perf_counter_ns()`, so a
+Python driver and the native kernels it calls land on a single timeline —
+`ProfileManager.finalize(native_traces=".")` folds them into one profile, with
+the native regions nested inside the Python ones that called them. See the
+[Fortran](https://scope-profiler.readthedocs.io/en/latest/guide/fortran.html)
+and [C](https://scope-profiler.readthedocs.io/en/latest/guide/c.html) guides.
+
 ## Recursive profiling of nested calls
 
 You can profile nested Python calls from one decorated entrypoint:
@@ -454,34 +499,35 @@ The JSON payload additionally includes a `colors` map (region or file label
 to `#rrggbb`) matching the colors used in the matplotlib plot, so a
 JavaScript charting library like Plotly can reproduce the same look.
 
-`scope-profiler pproc --export-data` does the same for every plot in one
-run, writing `gantt_data`, `flame_data`, `durations_data`, and (for multiple
-input files) `speedup_data` alongside the PNGs. Pass `--export-data-format
-json` to get `.json` files instead of the default `.csv`:
+`scope-profiler pproc --export data` does the same for every selected plot in
+one run, writing `gantt_data`, `flame_data`, `durations_data`, and (for
+multiple input files) `speedup_data` alongside the PNGs. Pass
+`--export-data-format json` to get `.json` files instead of the default
+`.csv`:
 
 ```bash
-scope-profiler pproc profiling_data.h5 -o figures --export-data
-scope-profiler pproc profiling_data.h5 -o figures --export-data --export-data-format json
+scope-profiler pproc profiling_data.h5 -o figures --export data
+scope-profiler pproc profiling_data.h5 -o figures --export data --export-data-format json
 ```
 
-Pass `--skip-plot-images` (requires `--export-data`) to skip rendering the
-PNGs entirely and only write the exported data plus `region_statistics.json`
-— useful when a website renders charts client-side (e.g. with Plotly)
-straight from the JSON:
+Pass `--skip-plot-images` (requires `--export`) to skip rendering the PNGs
+entirely and only write the exported data plus `region_statistics.json` —
+useful when a website renders charts client-side (e.g. with Plotly) straight
+from the JSON:
 
 ```bash
 scope-profiler pproc profiling_data.h5 -o figures \
-  --export-data --export-data-format json --skip-plot-images
+  --export data --export-data-format json --skip-plot-images
 ```
 
 ### Viewing a run in snakeviz
 
-`--export-prof` writes the profile in the `.prof` format of the standard
+`--export prof` writes the profile in the `.prof` format of the standard
 library's `cProfile`, so a run can be explored with
 [snakeviz](https://jiffyclub.github.io/snakeviz/) or `python -m pstats`:
 
 ```bash
-scope-profiler pproc profiling_data.h5 -o figures --export-prof --skip-plot-images
+scope-profiler pproc profiling_data.h5 -o figures --export prof --skip-plot-images
 snakeviz figures/profile_rank0.prof
 ```
 
@@ -492,12 +538,12 @@ written per exported rank, since `.prof` has no notion of ranks — see
 
 ### Viewing a run in speedscope
 
-`--export-speedscope` writes the run as a
+`--export speedscope` writes the run as a
 [speedscope](https://www.speedscope.app) JSON file. Unlike `.prof`, it keeps
 every individual call, so the timeline shows the run as it happened:
 
 ```bash
-scope-profiler pproc profiling_data.h5 -o figures --export-speedscope --skip-plot-images
+scope-profiler pproc profiling_data.h5 -o figures --export speedscope --skip-plot-images
 npx speedscope figures/profile.speedscope.json  # or drop the file on speedscope.app
 ```
 

{scope_profiler-0.2.7 → scope_profiler-0.2.8}/README.md

@@ -61,7 +61,6 @@ profiling_data.h5  (1 rank(s))
   ----------------------------------------------------------------------------------------
   TOTAL                11   0.00150754
 
-  Regions may nest, so the summed total can exceed the wall-clock time.
 ```
 
 `finalize()` prints the same table as `scope-profiler inspect` and
@@ -157,17 +156,60 @@ against a bare function call:
 ![Profiling overhead by region type](https://raw.githubusercontent.com/max-models/scope-profiler/refs/heads/devel/figures/benchmark_overhead.png)
 
 The default **TimeOnly** mode — nanosecond timestamps for every call — adds
-roughly **0.75 µs** per instrumented call.
+roughly **0.33 µs** per instrumented call.
 
 Profiling can also be fully deactivated at setup time
-(`deactivate_profiling=True`) to reduce the overhead to ~0.03 µs — barely
+(`deactivate_profiling=True`) to reduce the overhead to ~0.1 µs — barely
 above a bare function call — making it safe to leave instrumentation in
 production code and toggle it on only when needed.
 
-The **LineProfiler** mode is intentionally heavier (~41 µs/call) because
+The **LineProfiler** mode is intentionally heavier (~50 µs/call) because
 `line_profiler` traces every source line. It is designed for targeted
 debugging of individual functions, not for always-on use in hot loops.
 
+## Profiling native code (C, C++, Fortran)
+
+C and Fortran region APIs ship with the package, so native code — or the
+kernels under a Python driver — can be profiled into the same output. They
+share one trace format, so a program built from both lands in one profile.
+
+```c
+#include "scope_profiler.h"
+
+sp_init("profile", my_rank);
+int solve = sp_region("solve");
+sp_begin(solve);
+solve_system();
+sp_end(solve);
+sp_finalize();
+```
+
+```fortran
+use scope_profiler
+integer :: solve
+
+call sp_init("profile", rank=my_rank)
+solve = sp_region("solve")
+call sp_begin(solve)
+call solve_system()
+call sp_end(solve)
+call sp_finalize()
+```
+
+```bash
+scope-profiler import-native . -o profiling_data.h5   # then pproc/inspect as usual
+```
+
+Both are one self-contained file (Fortran 2008, or C99 with an `extern "C"`
+header for C++ callers): no HDF5, no MPI, nothing to link beyond libc.
+
+Timestamps come from the same clock as Python's `time.perf_counter_ns()`, so a
+Python driver and the native kernels it calls land on a single timeline —
+`ProfileManager.finalize(native_traces=".")` folds them into one profile, with
+the native regions nested inside the Python ones that called them. See the
+[Fortran](https://scope-profiler.readthedocs.io/en/latest/guide/fortran.html)
+and [C](https://scope-profiler.readthedocs.io/en/latest/guide/c.html) guides.
+
 ## Recursive profiling of nested calls
 
 You can profile nested Python calls from one decorated entrypoint:
@@ -405,34 +447,35 @@ The JSON payload additionally includes a `colors` map (region or file label
 to `#rrggbb`) matching the colors used in the matplotlib plot, so a
 JavaScript charting library like Plotly can reproduce the same look.
 
-`scope-profiler pproc --export-data` does the same for every plot in one
-run, writing `gantt_data`, `flame_data`, `durations_data`, and (for multiple
-input files) `speedup_data` alongside the PNGs. Pass `--export-data-format
-json` to get `.json` files instead of the default `.csv`:
+`scope-profiler pproc --export data` does the same for every selected plot in
+one run, writing `gantt_data`, `flame_data`, `durations_data`, and (for
+multiple input files) `speedup_data` alongside the PNGs. Pass
+`--export-data-format json` to get `.json` files instead of the default
+`.csv`:
 
 ```bash
-scope-profiler pproc profiling_data.h5 -o figures --export-data
-scope-profiler pproc profiling_data.h5 -o figures --export-data --export-data-format json
+scope-profiler pproc profiling_data.h5 -o figures --export data
+scope-profiler pproc profiling_data.h5 -o figures --export data --export-data-format json
 ```
 
-Pass `--skip-plot-images` (requires `--export-data`) to skip rendering the
-PNGs entirely and only write the exported data plus `region_statistics.json`
-— useful when a website renders charts client-side (e.g. with Plotly)
-straight from the JSON:
+Pass `--skip-plot-images` (requires `--export`) to skip rendering the PNGs
+entirely and only write the exported data plus `region_statistics.json` —
+useful when a website renders charts client-side (e.g. with Plotly) straight
+from the JSON:
 
 ```bash
 scope-profiler pproc profiling_data.h5 -o figures \
-  --export-data --export-data-format json --skip-plot-images
+  --export data --export-data-format json --skip-plot-images
 ```
 
 ### Viewing a run in snakeviz
 
-`--export-prof` writes the profile in the `.prof` format of the standard
+`--export prof` writes the profile in the `.prof` format of the standard
 library's `cProfile`, so a run can be explored with
 [snakeviz](https://jiffyclub.github.io/snakeviz/) or `python -m pstats`:
 
 ```bash
-scope-profiler pproc profiling_data.h5 -o figures --export-prof --skip-plot-images
+scope-profiler pproc profiling_data.h5 -o figures --export prof --skip-plot-images
 snakeviz figures/profile_rank0.prof
 ```
 
@@ -443,12 +486,12 @@ written per exported rank, since `.prof` has no notion of ranks — see
 
 ### Viewing a run in speedscope
 
-`--export-speedscope` writes the run as a
+`--export speedscope` writes the run as a
 [speedscope](https://www.speedscope.app) JSON file. Unlike `.prof`, it keeps
 every individual call, so the timeline shows the run as it happened:
 
 ```bash
-scope-profiler pproc profiling_data.h5 -o figures --export-speedscope --skip-plot-images
+scope-profiler pproc profiling_data.h5 -o figures --export speedscope --skip-plot-images
 npx speedscope figures/profile.speedscope.json  # or drop the file on speedscope.app
 ```
 

{scope_profiler-0.2.7 → scope_profiler-0.2.8}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "scope-profiler"
-version = "0.2.7"
+version = "0.2.8"
 description = "Profile code regions in python, optionally with LIKWID markers."
 readme = "README.md"
 keywords = [ "python" ]
@@ -26,6 +26,13 @@ dependencies = [
   "numpy",
 ]
 
+optional-dependencies.fortran = [
+  # f2py's build backend, for building Fortran kernels into an extension
+  # module. The Fortran API itself needs only a compiler.
+  "meson",
+  "ninja",
+]
+
 optional-dependencies.likwid = [
   "pylikwid",
 ]
@@ -42,7 +49,7 @@ optional-dependencies.pproc = [
   "ipykernel",
   "jupyterlab",
   "matplotlib",
-  "maxplotlibx >= 0.1.5",
+  "maxplotlibx >= 0.1.6",
   "pandas",
   "snakeviz",
 ]
@@ -51,7 +58,7 @@ optional-dependencies.dev = [
   "black[jupyter]",
   "isort",
   "ruff",
-  "scope-profiler[docs,line-profiler,mpi,pproc,test]",
+  "scope-profiler[docs,fortran,line-profiler,mpi,pproc,test]",
 ]
 # https://medium.com/@pratikdomadiya123/build-project-documentation-quickly-with-the-sphinx-python-2a9732b66594
 optional-dependencies.docs = [
@@ -75,5 +82,17 @@ scripts.scope-profiler = "scope_profiler.__main__:main"
 [tool.setuptools.packages.find]
 where = [ "src" ]
 
+# The native region APIs ship with the wheel: they are source a user compiles
+# into their own program, so they have to survive `pip install`.
+# native_trace.fortran_source_path() / c_source_path() locate them at run time.
+[tool.setuptools.package-data]
+scope_profiler = [
+  "fortran/*.f90",
+  "fortran/Makefile",
+  "c/*.c",
+  "c/*.h",
+  "c/Makefile",
+]
+
 [tool.isort]
 profile = "black"

{scope_profiler-0.2.7 → scope_profiler-0.2.8}/src/scope_profiler/__init__.py

@@ -12,7 +12,7 @@ from scope_profiler.likwid_data import LikwidRegionResult
 from scope_profiler.mpi_region import MPIRegion
 from scope_profiler.profile_manager import ProfileManager
 from scope_profiler.region import Region
-from scope_profiler.results import ProfilingResults
+from scope_profiler.results import ProfilingResults, merge_results
 
 try:
     __version__ = version("scope-profiler")
@@ -46,6 +46,7 @@ __all__ = [
     "build_call_stack",
     "call_stack_children",
     "call_stack_roots",
+    "merge_results",
     "read_h5",
     *sorted(_LAZY_ATTRS),
 ]

{scope_profiler-0.2.7 → scope_profiler-0.2.8}/src/scope_profiler/__main__.py

@@ -2,7 +2,7 @@
 
 Also runnable as ``python -m scope_profiler <command> ...``.
 
-Three subcommands:
+Five subcommands:
 
 - ``scope-profiler run script.py [args...]`` -- profiles a script's function
   calls without requiring any decorators or context managers in the script
@@ -17,12 +17,22 @@ Three subcommands:
 - ``scope-profiler inspect file.h5 [...]`` -- prints the run metadata and a
   per-region statistics table for merged HDF5 profiling output, without
   producing any plots. See ``scope_profiler.inspection``.
+- ``scope-profiler diff a.h5 b.h5`` -- compares region statistics between two
+  merged HDF5 profiling files, region by region, so a regression (or
+  improvement) between two runs shows up in one table. See
+  ``scope_profiler.diff``.
+- ``scope-profiler import-native traces/ -o out.h5`` -- converts the trace
+  files written by the Fortran region API
+  (``scope_profiler/fortran/scope_profiler.f90``)
+  into the usual HDF5 output, so a Fortran run post-processes exactly like a
+  Python one. See ``scope_profiler.native_trace``.
 """
 
 import argparse
 import os
 import sys
 
+from scope_profiler import __version__
 from scope_profiler.profile_manager import ProfileManager
 
 
@@ -107,21 +117,102 @@ def _inspect(argv):
     return inspect_main(argv)
 
 
+def _diff(argv):
+    """Handle ``scope-profiler diff``: delegate to the diff CLI."""
+    from scope_profiler.diff import main as diff_main
+
+    return diff_main(argv)
+
+
+def _import_fortran(argv):
+    """Handle ``scope-profiler import-native``: Fortran traces -> HDF5."""
+    from scope_profiler.native_trace import TRACE_SUFFIX, convert_traces
+
+    parser = argparse.ArgumentParser(
+        prog="scope-profiler import-native",
+        description=(
+            "Convert the trace files written by the Fortran region API into a "
+            "standard scope-profiler HDF5 file."
+        ),
+    )
+    parser.add_argument(
+        "inputs",
+        nargs="+",
+        help=f"trace files (*{TRACE_SUFFIX}) and/or directories containing them",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="profiling_data.h5",
+        help="HDF5 file to write (default: profiling_data.h5)",
+    )
+    parser.add_argument(
+        "--label",
+        default=None,
+        help="name for the run in summaries, charts and exports",
+    )
+    parser.add_argument(
+        "--merge",
+        metavar="PROFILE.h5",
+        default=None,
+        help="an existing profile to combine the traces with, for a run whose "
+        "Python side was profiled separately; region names must not clash",
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="do not print the summary table",
+    )
+    args = parser.parse_args(argv)
+
+    if args.merge is None:
+        path = convert_traces(args.inputs, args.output, label=args.label)
+    else:
+        from scope_profiler.h5reader import read_h5
+        from scope_profiler.native_trace import load_traces, write_results
+        from scope_profiler.results import merge_results
+
+        path = write_results(
+            merge_results(
+                read_h5(args.merge),
+                load_traces(args.inputs),
+                label=args.label,
+                file_path=args.output,
+            ),
+            args.output,
+        )
+
+    if not args.quiet:
+        from scope_profiler.h5reader import read_h5
+
+        read_h5(path).print_summary()
+        print(f"\nwrote {path}")
+    return 0
+
+
 _COMMANDS = {
     "run": _run,
     "pproc": _pproc,
     "inspect": _inspect,
+    "diff": _diff,
+    "import-native": _import_fortran,
 }
 
 
 def main(argv=None):
-    """Dispatch to the ``run`` or ``pproc`` subcommand."""
+    """Dispatch to the requested subcommand."""
     argv = sys.argv[1:] if argv is None else list(argv)
 
     parser = argparse.ArgumentParser(
         prog="scope-profiler",
         description="Profile scripts and post-process the resulting HDF5 output.",
     )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
     subparsers = parser.add_subparsers(dest="command")
     subparsers.add_parser(
         "run",
@@ -140,12 +231,24 @@ def main(argv=None):
         help="Print metadata and region statistics of HDF5 profiling data "
         "(see `scope-profiler inspect --help`)",
     )
+    subparsers.add_parser(
+        "diff",
+        add_help=False,
+        help="Compare region statistics between two HDF5 profiling files "
+        "(see `scope-profiler diff --help`)",
+    )
+    subparsers.add_parser(
+        "import-native",
+        add_help=False,
+        help="Convert Fortran API trace files into HDF5 "
+        "(see `scope-profiler import-native --help`)",
+    )
 
     if not argv:
         parser.print_help()
         raise SystemExit(1)
-    if argv[0] in ("-h", "--help"):
-        parser.parse_args(argv)  # prints help and exits(0)
+    if argv[0] in ("-h", "--help", "--version"):
+        parser.parse_args(argv)  # prints help/version and exits(0)
         return
 
     command, *rest = argv

scope_profiler-0.2.8/src/scope_profiler/c/Makefile

@@ -0,0 +1,37 @@
+# Build the C region API and its example.
+#
+#   make                       # build example into build/
+#   make CC=icx                # use a different compiler
+#   make BUILD_DIR=/tmp/sp     # build somewhere else
+#   make run                   # build, run, and import the trace
+#   make clean
+#
+# There is nothing to link beyond libc (and libm, for the example's sqrt):
+# the implementation is one C99 file, no HDF5 and no MPI.
+
+CC ?= cc
+CFLAGS ?= -std=c99 -O2 -Wall -Wextra
+BUILD_DIR ?= build
+
+LIB_OBJ := $(BUILD_DIR)/scope_profiler.o
+EXAMPLE := $(BUILD_DIR)/example
+
+.PHONY: all run clean
+
+all: $(EXAMPLE)
+
+$(BUILD_DIR):
+	mkdir -p $(BUILD_DIR)
+
+$(LIB_OBJ): scope_profiler.c scope_profiler.h | $(BUILD_DIR)
+	$(CC) $(CFLAGS) -I. -c scope_profiler.c -o $@
+
+$(EXAMPLE): example.c $(LIB_OBJ)
+	$(CC) $(CFLAGS) -I. example.c $(LIB_OBJ) -lm -o $@
+
+run: $(EXAMPLE)
+	cd $(BUILD_DIR) && ./example
+	scope-profiler import-native $(BUILD_DIR) -o $(BUILD_DIR)/profiling_data.h5
+
+clean:
+	rm -rf $(BUILD_DIR)

scope_profiler-0.2.8/src/scope_profiler/c/example.c

@@ -0,0 +1,78 @@
+/* Runnable example of the C region API.
+ *
+ *     cc -O2 -c scope_profiler.c
+ *     cc -O2 example.c scope_profiler.o -lm -o example
+ *     ./example
+ *     scope-profiler import-native . -o profiling_data.h5
+ *     scope-profiler inspect profiling_data.h5
+ */
+#include "scope_profiler.h"
+
+#include <math.h>
+#include <stdio.h>
+
+/* Something the compiler cannot optimise away. */
+static double busy_work(int n)
+{
+    double acc = 0.0;
+    int i;
+
+    for (i = 1; i <= n; ++i) {
+        acc += sqrt((double)i);
+    }
+    return acc;
+}
+
+/* Recursion: every invocation reserves its own slot in the same region. */
+static int fib(int n)
+{
+    int id = sp_region("fib_call");
+    int value;
+
+    sp_begin(id);
+    value = n < 2 ? n : fib(n - 1) + fib(n - 2);
+    sp_end(id);
+    return value;
+}
+
+int main(void)
+{
+    int step, solve, assemble, io;
+    double total = 0.0;
+
+    sp_init("profile", 0);
+
+    /* Resolve the names once; the handles are what the hot loop uses. */
+    solve = sp_region("solve");
+    assemble = sp_region("assemble");
+    io = sp_region("checkpoint");
+
+    for (step = 1; step <= 20; ++step) {
+        sp_begin(assemble);
+        total += busy_work(20000);
+        sp_end(assemble);
+
+        sp_begin(solve);
+        total += busy_work(50000);
+        sp_end(solve);
+
+        if (step % 10 == 0) {
+            sp_begin(io);
+            total += busy_work(5000);
+            sp_end(io);
+        }
+    }
+
+    sp_begin(sp_region("fibonacci"));
+    step = fib(12);
+    sp_end(sp_region("fibonacci"));
+
+    printf("solve entered %lld time(s)\n", (long long)sp_num_calls(solve));
+    printf("checksum (ignore): %.4f\n", total + (double)step);
+
+    if (sp_finalize() != 0) {
+        return 1;
+    }
+    printf("wrote profile_rank00000.spt\n");
+    return 0;
+}