flopscope 0.4.2__tar.gz → 0.5.0__tar.gz

{flopscope-0.4.2 → flopscope-0.5.0}/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## v0.5.0 (2026-06-06)
+
+### BREAKING CHANGE
+
+- multi-operand einsum path selection and billed totals may
+change where FMA=2 vs FMA=1 flips the cheapest order.
+- FLOP costs change for dot/inner with >2-D operands.
+- FLOP costs change for vecmat, matvec, vecdot, and N-D/mixed
+matmul. Consumers that pin or budget on absolute FLOP counts should re-baseline.
+
+### Feat
+
+- **timing**: precise client/server timing split (#115)
+
+### Fix
+
+- **cost**: broadcast size-1 axes in the accumulation cost model
+- **opt-einsum**: FMA=2 accumulation cost in contraction-path search
+- **cost**: route dot/inner N-D through einsum (outer-product subscripts)
+- **linalg**: lstsq uses matmul_cost now that matmul 2-D×1-D is exact
+- **cost**: count batch/broadcast axes in vecmat/matvec/vecdot + matmul N-D
+
+### Refactor
+
+- **pointwise**: extract _einsum_routed_binary contraction-cost helper
+
+## v0.4.3 (2026-06-02)
+
+### Fix
+
+- **server**: raise UnsupportedReturnType for unpackable results
+
 ## v0.4.2 (2026-06-01)
 
 ### Feat
@@ -144,5 +176,3 @@ analytically, so compute budgets stop being guesswork.
 See the [README](README.md) for the API overview and the
 [docs site](https://aicrowd.github.io/flopscope/) for guides and the
 full API reference.
-
-## Unreleased

{flopscope-0.4.2 → flopscope-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flopscope
-Version: 0.4.2
+Version: 0.5.0
 Summary: NumPy-compatible math primitives with FLOP counting for the Mechanistic Estimation Challenge
 License-Expression: MIT
 Requires-Python: >=3.10
@@ -20,7 +20,7 @@ Requires-Dist: scipy>=1.10; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: numpydoc>=1.10; extra == 'docs'
 Provides-Extra: server
-Requires-Dist: flopscope-server==0.4.2; extra == 'server'
+Requires-Dist: flopscope-server==0.5.0; extra == 'server'
 Provides-Extra: sympy
 Requires-Dist: sympy>=1.11; extra == 'sympy'
 Description-Content-Type: text/markdown

{flopscope-0.4.2 → flopscope-0.5.0}/benchmarks/_contractions.py

@@ -72,8 +72,8 @@ def _analytical_cost(op: str, **kwargs: int) -> int:
         "vdot": 1_000_000,
         # vecdot: batched dot product A(1000,512) . B(1000,512)
         # Output (1000,) with contracted axis 512.
-        # Runtime charges result.size * contracted = 1000 * 512 (FMA=2 textbook).
-        "vecdot": 1000 * 512,
+        # FMA=2: result.size * (2*contracted - 1) = 1000 * (2*512 - 1) = 1000 * 1023.
+        "vecdot": 1000 * (2 * 512 - 1),
         # outer: outer product of two 5000-element vectors
         "outer": 5000 * 5000,
         # tensordot: A(64,64,64) . B(64,64,64) axes=1 -> contract last of A with first of B

{flopscope-0.4.2 → flopscope-0.5.0}/benchmarks/_linalg_delegates.py

@@ -95,7 +95,7 @@ def _analytical_cost(op_name: str) -> int:
         "tensorinv": 64**3,  # n^3 after reshape
         "tensorsolve": 64**3,  # n^3 after reshape
         "trace": 10_000,  # min(m,n)
-        "vecdot": 1000 * 512,  # batch*K
+        "vecdot": 1000 * (2 * 512 - 1),  # FMA=2: batch * (2*K - 1)
         "vector_norm": 2 * 10_000_000,  # 2*numel (FMA=2)
     }
     return costs[short]

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flopscope-client"
-version = "0.4.2"
+version = "0.5.0"
 description = "Lightweight flopscope client — drop-in replacement with no numpy dependency"
 readme = "README.md"
 requires-python = ">=3.10"

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/__init__.py

@@ -18,7 +18,7 @@ import builtins
 import struct
 from typing import Any
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"
 
 # ---------------------------------------------------------------------------
 # Errors
@@ -33,6 +33,7 @@ from flopscope._budget import (  # noqa: E402
     budget,
     budget_summary_dict,
 )
+from flopscope._dispatch import timed_dispatch  # noqa: E402
 from flopscope._display import budget_live, budget_summary  # noqa: E402
 from flopscope._math_compat import e, inf, nan, pi  # noqa: E402
 from flopscope._perm_group import SymmetryGroup  # noqa: E402
@@ -136,7 +137,7 @@ def _make_proxy(op_name: str):
 
     proxy.__name__ = op_name
     proxy.__qualname__ = op_name
-    return proxy
+    return timed_dispatch(proxy)
 
 
 # ---------------------------------------------------------------------------
@@ -182,6 +183,7 @@ def _infer_dtype(values):
     return "float64"  # mixed or float values
 
 
+@timed_dispatch
 def array(object, dtype=None, **kwargs):
     """Create a remote array from a Python list, tuple, or existing RemoteArray.
 
@@ -272,6 +274,7 @@ def array(object, dtype=None, **kwargs):
 # ---------------------------------------------------------------------------
 
 
+@timed_dispatch
 def einsum(subscripts, *operands, **kwargs):
     """Einstein summation on remote arrays.
 

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/_budget.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
+import time
+
 from flopscope._connection import get_connection
+from flopscope._dispatch import dispatch_span, total_dispatch_ns
 from flopscope._protocol import (
     encode_budget_close,
     encode_budget_open,
@@ -13,6 +16,67 @@ from flopscope._protocol import (
 _active_context = None
 
 
+def _extract_compute_ns(close_response: object) -> int:
+    """Pull total server compute (ns) out of a ``budget_close`` response.
+
+    Returns 0 if the ``result.comms_summary.total_compute_time_ns`` path is
+    absent or unparseable (defensive; the version handshake makes it present in
+    practice).
+    """
+    if not isinstance(close_response, dict):
+        return 0
+    result = close_response.get("result")
+    if not isinstance(result, dict):
+        return 0
+    comms = result.get("comms_summary")
+    if not isinstance(comms, dict):
+        return 0
+    try:
+        return int(comms.get("total_compute_time_ns", 0))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _extract_close_budget(close_response: object) -> dict:
+    """Pull the ``budget_breakdown`` dict (which carries ``flops_used``) out of a
+    ``budget_close`` response.
+
+    The authoritative FLOP count is nested at ``result.budget_breakdown`` —
+    unlike ``budget_status``, which exposes ``flops_used`` directly under
+    ``result``. Returns ``{}`` if the path is absent (defensive; the version
+    handshake makes it present in practice).
+    """
+    if not isinstance(close_response, dict):
+        return {}
+    result = close_response.get("result")
+    if not isinstance(result, dict):
+        return {}
+    breakdown = result.get("budget_breakdown")
+    return breakdown if isinstance(breakdown, dict) else {}
+
+
+def _decompose_timing(
+    wall_ns: int, dispatch_ns: int, kernel_ns: int
+) -> tuple[float, float, float, float]:
+    """Decompose context wall into (wall, backend, overhead, residual) seconds.
+
+    - backend  = pure server numpy kernel (``kernel_ns``)
+    - overhead = all other flopscope machinery: client dispatch + wire +
+      server marshaling/store/framing = ``dispatch − kernel``; not billed
+    - residual = the participant's own Python = ``wall − dispatch``; billed
+
+    Each is clamped to >= 0 for cross-clock skew. In the normal regime
+    (``kernel <= dispatch <= wall``) no clamp fires and
+    ``wall == backend + overhead + residual`` exactly.
+    """
+    wall_s = wall_ns / 1e9
+    backend_s = max(0, kernel_ns) / 1e9
+    dispatch_s = dispatch_ns / 1e9
+    overhead_s = max(0.0, dispatch_s - backend_s)
+    residual_s = max(0.0, wall_s - dispatch_s)
+    return wall_s, backend_s, overhead_s, residual_s
+
+
 class OpRecord:
     """Record of a single operation's FLOP cost.
 
@@ -75,6 +139,14 @@ class BudgetContext:
         self._close_summary: str | None = None
         self._is_open: bool = False
         self._previous_context = None
+        # Timing split — populated on __exit__. None until then for wall/residual,
+        # 0.0 for backend/overhead, mirroring the in-process flopscope contract.
+        self._wall_time_s: float | None = None
+        self._flopscope_backend_time: float = 0.0
+        self._flopscope_overhead_time: float = 0.0
+        self._residual_wall_time: float | None = None
+        self._wall_start_ns: int | None = None
+        self._dispatch_baseline_ns: int = 0
 
     # ------------------------------------------------------------------
     # Properties
@@ -110,6 +182,28 @@ class BudgetContext:
         """Optional namespace label for this context."""
         return self._namespace
 
+    @property
+    def wall_time_s(self) -> float | None:
+        """Total wall-clock seconds spanned by the context (None until closed)."""
+        return self._wall_time_s
+
+    @property
+    def flopscope_backend_time(self) -> float:
+        """Seconds of real op compute on the server (0.0 until closed)."""
+        return self._flopscope_backend_time
+
+    @property
+    def flopscope_overhead_time(self) -> float:
+        """Seconds of flopscope transport overhead — serialization + network +
+        server-side comms (0.0 until closed). Not billed."""
+        return self._flopscope_overhead_time
+
+    @property
+    def residual_wall_time(self) -> float | None:
+        """Seconds of participant Python outside flopscope calls (None until
+        closed). The billed bucket: C_m = F_m + lambda * residual."""
+        return self._residual_wall_time
+
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------
@@ -141,7 +235,8 @@ class BudgetContext:
             Human-readable summary of budget usage.
         """
         conn = get_connection()
-        response = conn.send_recv(encode_budget_status())
+        with dispatch_span():
+            response = conn.send_recv(encode_budget_status())
         # Budget status is nested inside "result" key
         result = response.get("result", {})
         self._update_budget(result)
@@ -179,21 +274,44 @@ class BudgetContext:
             )
         self._previous_context = _active_context
         conn = get_connection()
-        response = conn.send_recv(
-            encode_budget_open(self._flop_budget, self._flop_multiplier)
-        )
-        self._update_budget(response)
+        self._wall_start_ns = time.perf_counter_ns()
+        self._dispatch_baseline_ns = total_dispatch_ns()
+        with dispatch_span():
+            response = conn.send_recv(
+                encode_budget_open(self._flop_budget, self._flop_multiplier)
+            )
+            self._update_budget(response)
         self._is_open = True
         _active_context = self
         return self
 
     def __exit__(self, *args: object) -> None:
-        """Close the budget on the server and store the close summary."""
+        """Close the budget, compute the timing split, store summary."""
         global _active_context
         if self._is_open:
             conn = get_connection()
-            response = conn.send_recv(encode_budget_close())
-            self._update_budget(response)
+            with dispatch_span():
+                response = conn.send_recv(encode_budget_close())
+                # flops_used is nested at result.budget_breakdown in the close
+                # response; refresh the cache from there so a plain `with` block
+                # reports the server's count without a separate summary() call.
+                self._update_budget(_extract_close_budget(response))
+            # _wall_start_ns is always set by __enter__ before _is_open=True; the
+            # fallback only guards the never-exercised "exit without enter" path.
+            start_ns = (
+                self._wall_start_ns
+                if self._wall_start_ns is not None
+                else time.perf_counter_ns()
+            )
+            wall_ns = time.perf_counter_ns() - start_ns
+            dispatch_ns = total_dispatch_ns() - self._dispatch_baseline_ns
+            kernel_ns = _extract_compute_ns(response)
+            (
+                self._wall_time_s,
+                self._flopscope_backend_time,
+                self._flopscope_overhead_time,
+                self._residual_wall_time,
+            ) = _decompose_timing(wall_ns, dispatch_ns, kernel_ns)
             self._close_summary = (
                 f"BudgetContext closed: {self._flops_used}/{self._flop_budget} "
                 f"FLOPs used"
@@ -218,10 +336,23 @@ class BudgetContext:
 class NamespaceRecord:
     """Snapshot of a BudgetContext's state at close time."""
 
-    def __init__(self, namespace, flop_budget, flops_used):
+    def __init__(
+        self,
+        namespace,
+        flop_budget,
+        flops_used,
+        wall_time_s=0.0,
+        backend_time_s=0.0,
+        overhead_time_s=0.0,
+        residual_time_s=0.0,
+    ):
         self.namespace = namespace
         self.flop_budget = flop_budget
         self.flops_used = flops_used
+        self.wall_time_s = wall_time_s
+        self.backend_time_s = backend_time_s
+        self.overhead_time_s = overhead_time_s
+        self.residual_time_s = residual_time_s
 
 
 class BudgetAccumulator:
@@ -231,11 +362,17 @@ class BudgetAccumulator:
         self._records = []
 
     def record(self, ctx):
+        # `or 0.0` coerces the Optional timing fields (wall_time_s /
+        # residual_wall_time are None on a never-closed context) to 0.0.
         self._records.append(
             NamespaceRecord(
                 namespace=ctx.namespace,
                 flop_budget=ctx.flop_budget,
                 flops_used=ctx.flops_used,
+                wall_time_s=getattr(ctx, "wall_time_s", 0.0) or 0.0,
+                backend_time_s=getattr(ctx, "flopscope_backend_time", 0.0) or 0.0,
+                overhead_time_s=getattr(ctx, "flopscope_overhead_time", 0.0) or 0.0,
+                residual_time_s=getattr(ctx, "residual_wall_time", 0.0) or 0.0,
             )
         )
 
@@ -247,6 +384,10 @@ class BudgetAccumulator:
             "flops_used": total_used,
             "flops_remaining": total_budget - total_used,
             "operations": {},
+            "wall_time_s": sum(r.wall_time_s for r in self._records),
+            "flopscope_backend_time_s": sum(r.backend_time_s for r in self._records),
+            "flopscope_overhead_time_s": sum(r.overhead_time_s for r in self._records),
+            "residual_wall_time_s": sum(r.residual_time_s for r in self._records),
         }
         if by_namespace:
             by_ns = {}
@@ -304,14 +445,18 @@ def _get_global_default():
             quiet=True,
             namespace=None,
         )
-        # Open it on the server
+        # Open it on the server. Defensive: keep the round-trip inside a
+        # dispatch span so it counts as overhead (never billed residual) if this
+        # implicit global-default path is ever wired up. It is currently
+        # unreferenced, but the invariant is "every send_recv lives in a span".
         conn = get_connection()
-        response = conn.send_recv(
-            encode_budget_open(
-                _global_default._flop_budget, _global_default._flop_multiplier
+        with dispatch_span():
+            response = conn.send_recv(
+                encode_budget_open(
+                    _global_default._flop_budget, _global_default._flop_multiplier
+                )
             )
-        )
-        _global_default._update_budget(response)
+            _global_default._update_budget(response)
         _global_default._is_open = True
         _active_context = _global_default
     return _global_default

flopscope-0.5.0/flopscope-client/src/flopscope/_dispatch.py

@@ -0,0 +1,65 @@
+"""Client-side dispatch-time accumulator.
+
+Times the *full* client dispatch of each flopscope op (request encode → socket
+send/recv → response decode → result reconstruction) and accumulates it into a
+single per-process counter. ``BudgetContext`` snapshots a baseline on enter and
+reads the delta on exit; ``overhead = dispatch - backend`` and
+``residual = wall - dispatch``.
+
+Nesting is handled with a baseline/delta trick (ported from the in-process
+``_counted_wrapper``): each span adds only its own remainder
+(``wall - inner_already_counted``), so a span that contains nested spans counts
+each op's wall exactly once. Single participant process, single-threaded (the
+server allows one session at a time), so a module-level counter is safe.
+"""
+
+from __future__ import annotations
+
+import functools
+import time
+from contextlib import contextmanager
+
+_total_dispatch_ns: int = 0
+
+
+def _now_ns() -> int:
+    """Monotonic nanosecond clock (indirected so tests can fake it)."""
+    return time.perf_counter_ns()
+
+
+def total_dispatch_ns() -> int:
+    """Total client dispatch nanoseconds accumulated so far this process."""
+    return _total_dispatch_ns
+
+
+def reset_dispatch() -> None:
+    """Reset the accumulator (tests only)."""
+    global _total_dispatch_ns
+    _total_dispatch_ns = 0
+
+
+@contextmanager
+def dispatch_span():
+    """Bracket one full op dispatch; add only this span's own remainder."""
+    global _total_dispatch_ns
+    t0 = _now_ns()
+    baseline = _total_dispatch_ns
+    try:
+        yield
+    finally:
+        wall = _now_ns() - t0
+        inner = _total_dispatch_ns - baseline
+        # inner > wall is impossible with a monotonic clock; max() guards only
+        # against cross-clock skew / faked-clock edge cases.
+        _total_dispatch_ns += max(0, wall - inner)
+
+
+def timed_dispatch(fn):
+    """Decorator: time the full dispatch of *fn* into the accumulator."""
+
+    @functools.wraps(fn)
+    def wrapped(*args, **kwargs):
+        with dispatch_span():
+            return fn(*args, **kwargs)
+
+    return wrapped

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/_display.py

@@ -17,6 +17,11 @@ def _pct(used: int, total: int) -> str:
     return f"{100 * used / total:.1f}%"
 
 
+def _format_seconds(s: float) -> str:
+    """Format a wall-time value (seconds) for the budget summary."""
+    return f"{s:.3f}s"
+
+
 def _usage_color(used: int, total: int) -> str:
     """Return a Rich color name based on usage percentage."""
     if total == 0:
@@ -43,6 +48,19 @@ def _plain_text_summary() -> str:
         f"  Remaining:       {_format_flops(data['flops_remaining']):>20}  ({_pct(data['flops_remaining'], data['flop_budget'])})",
     ]
 
+    wall = data.get("wall_time_s") or 0.0
+    if wall > 0:
+        lines.append(f"  Wall time:       {_format_seconds(wall):>20}")
+        lines.append(
+            f"    backend  (compute):          {_format_seconds(data.get('flopscope_backend_time_s') or 0.0):>10}"
+        )
+        lines.append(
+            f"    overhead (flopscope):        {_format_seconds(data.get('flopscope_overhead_time_s') or 0.0):>10}"
+        )
+        lines.append(
+            f"    residual (your code, billed):{_format_seconds(data.get('residual_wall_time_s') or 0.0):>10}"
+        )
+
     by_ns = data.get("by_namespace", {})
     if by_ns:
         lines.append("")
@@ -185,6 +203,22 @@ def _rich_summary():
             f"{_format_flops(display_remaining)}  ({_pct(display_remaining, display_budget)})",
         )
 
+    wall = data.get("wall_time_s") or 0.0
+    if wall > 0:
+        totals.add_row("Wall time", _format_seconds(wall))
+        totals.add_row(
+            "  backend (compute)",
+            _format_seconds(data.get("flopscope_backend_time_s") or 0.0),
+        )
+        totals.add_row(
+            "  overhead (flopscope)",
+            _format_seconds(data.get("flopscope_overhead_time_s") or 0.0),
+        )
+        totals.add_row(
+            "  residual (your code, billed)",
+            _format_seconds(data.get("residual_wall_time_s") or 0.0),
+        )
+
     renderables = [totals]
 
     # Per-namespace panels

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/_remote_array.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import struct
 from typing import Any
 
+from flopscope._dispatch import timed_dispatch
 from flopscope._math_compat import prod as _prod
 
 # ---------------------------------------------------------------------------
@@ -363,6 +364,7 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
 
     # -- data access (auto-fetch from server) -------------------------------
 
+    @timed_dispatch
     def _fetch_data(self) -> tuple[bytes, tuple, str]:
         """Fetch the raw data from the server.
 
@@ -378,11 +380,13 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
         result = resp.get("result", {})
         return result["data"], tuple(result["shape"]), result["dtype"]
 
+    @timed_dispatch
     def tolist(self) -> Any:
         """Fetch data and convert to a nested Python list."""
         data, shape, dtype = self._fetch_data()
         return _bytes_to_list(data, shape, dtype)
 
+    @timed_dispatch
     def __repr__(self) -> str:
         try:
             values = self.tolist()
@@ -393,9 +397,11 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
                 f"shape={self._shape}, dtype={self._dtype!r})"
             )
 
+    @timed_dispatch
     def __str__(self) -> str:
         return self.__repr__()
 
+    @timed_dispatch
     def __float__(self) -> float:
         if self.size != 1:
             raise TypeError("only size-1 arrays can be converted to Python scalars")
@@ -406,6 +412,7 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
             result = result[0]
         return float(result)
 
+    @timed_dispatch
     def __int__(self) -> int:
         if self.size != 1:
             raise TypeError("only size-1 arrays can be converted to Python scalars")
@@ -415,6 +422,7 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
             result = result[0]
         return int(result)
 
+    @timed_dispatch
     def __bool__(self) -> bool:
         if self.size != 1:
             raise ValueError(
@@ -432,6 +440,7 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
         for i in range(self._shape[0]):
             yield self[i]
 
+    @timed_dispatch
     def __getitem__(self, key):
         """Index into the array, dispatching to the server.
 
@@ -456,6 +465,7 @@ class RemoteArray(metaclass=_RemoteArrayMeta):
 
     # -- operator overloads (dispatch to server) ----------------------------
 
+    @timed_dispatch
     def _dispatch_op(self, op_name: str, *args: Any, **kwargs: Any) -> Any:
         """Encode and send an operation to the server, return the result."""
         from flopscope._connection import get_connection
@@ -623,6 +633,7 @@ class RemoteGenerator:
     def __repr__(self) -> str:
         return f"RemoteGenerator(handle_id={self._handle_id!r})"
 
+    @timed_dispatch
     def _call(self, method: str, *args: Any, **kwargs: Any) -> Any:
         from flopscope._connection import get_connection
         from flopscope._protocol import encode_request

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/errors.py

@@ -45,6 +45,13 @@ class UnsupportedFunctionError(FlopscopeError):
         super().__init__(message)
 
 
+class UnsupportedReturnType(FlopscopeError):
+    """Raised when an op's result cannot be serialized across the client/server boundary."""
+
+    def __init__(self, message: str = "") -> None:
+        super().__init__(message)
+
+
 class FlopscopeWarning(UserWarning):
     """Warning issued when flopscope detects potential numerical issues."""
 
@@ -72,6 +79,7 @@ _FLOPSCOPE_ERRORS: frozenset[str] = frozenset(
         "NoBudgetContextError",
         "SymmetryError",
         "UnsupportedFunctionError",
+        "UnsupportedReturnType",
     }
 )
 
@@ -81,6 +89,7 @@ _ERROR_MAP: dict[str, type[Exception]] = {
     "NoBudgetContextError": NoBudgetContextError,
     "SymmetryError": SymmetryError,
     "UnsupportedFunctionError": UnsupportedFunctionError,
+    "UnsupportedReturnType": UnsupportedReturnType,
     "FlopscopeServerError": FlopscopeServerError,
     "ValueError": ValueError,
     "TypeError": TypeError,

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/flops.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
+from flopscope._dispatch import timed_dispatch
 from flopscope._math_compat import prod as _prod
 from flopscope._weights import get_weight
 
@@ -80,6 +81,7 @@ def reduction_cost(
 # ---------------------------------------------------------------------------
 
 
+@timed_dispatch
 def einsum_cost(subscripts: str, shapes: Sequence[tuple[int, ...]]) -> int:
     """Query the server for the FLOP cost of an einsum operation.
 
@@ -109,6 +111,7 @@ def einsum_cost(subscripts: str, shapes: Sequence[tuple[int, ...]]) -> int:
     return int(result.get("value", 0))
 
 
+@timed_dispatch
 def svd_cost(m: int, n: int, k: int = 0) -> int:
     """Query the server for the FLOP cost of an SVD operation.
 

{flopscope-0.4.2 → flopscope-0.5.0}/flopscope-client/src/flopscope/linalg/__init__.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 from flopscope._connection import get_connection
+from flopscope._dispatch import timed_dispatch
 from flopscope._getattr import make_module_getattr
 from flopscope._protocol import encode_request
 from flopscope._remote_array import (
@@ -29,7 +30,7 @@ def _make_linalg_proxy(op_name: str):
 
     proxy.__name__ = op_name
     proxy.__qualname__ = f"linalg.{op_name}"
-    return proxy
+    return timed_dispatch(proxy)
 
 
 cholesky = _make_linalg_proxy("cholesky")