flopscope-server 0.4.3__tar.gz → 0.6.0__tar.gz

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: flopscope-server
-Version: 0.4.3
+Version: 0.6.0
 Summary: Backend server for flopscope client-server architecture
 License-Expression: MIT
 Requires-Python: >=3.10
-Requires-Dist: flopscope==0.4.3
+Requires-Dist: flopscope==0.6.0
 Requires-Dist: msgpack>=1.0.0
 Requires-Dist: numpy<2.5.0,>=2.0.0
 Requires-Dist: pyzmq>=26.0.0

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flopscope-server"
-version = "0.4.3"
+version = "0.6.0"
 description = "Backend server for flopscope client-server architecture"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
-    "flopscope==0.4.3",
+    "flopscope==0.6.0",
     "numpy>=2.0.0,<2.5.0",
     "pyzmq>=26.0.0",
     "msgpack>=1.0.0",

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/src/flopscope_server/__init__.py

@@ -1,3 +1,3 @@
 """Flopscope backend server — executes numpy operations on behalf of remote clients."""
 
-__version__ = "0.4.3"
+__version__ = "0.6.0"

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/src/flopscope_server/_request_handler.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import re
+from time import perf_counter_ns
 from typing import Any
 
 import numpy as np
@@ -86,6 +87,20 @@ class RequestHandler:
 
     def __init__(self, session: Session) -> None:
         self._session = session
+        self._kernel_ns: int = 0
+
+    @property
+    def kernel_ns(self) -> int:
+        """Pure numpy-kernel nanoseconds accumulated during the last handle()."""
+        return self._kernel_ns
+
+    def _run_kernel(self, fn, *args, **kwargs):
+        """Invoke a numpy compute call, attributing only its wall to kernel time."""
+        t0 = perf_counter_ns()
+        try:
+            return fn(*args, **kwargs)
+        finally:
+            self._kernel_ns += perf_counter_ns() - t0
 
     # ------------------------------------------------------------------
     # Public entry point
@@ -96,6 +111,7 @@ class RequestHandler:
 
         The ``request["op"]`` field determines which handler is invoked.
         """
+        self._kernel_ns = 0
         try:
             op = request["op"]
 
@@ -249,7 +265,7 @@ class RequestHandler:
             raise ValueError("__getitem__ requires [handle, key]")
         arr = self._resolve_arg(args[0])
         key = self._decode_index_key(args[1])
-        result = arr[key]
+        result = self._run_kernel(lambda: arr[key])
         return self._pack_result(result)
 
     # ------------------------------------------------------------------
@@ -267,7 +283,7 @@ class RequestHandler:
             dtype = raw_args[1] if len(raw_args) > 1 else kwargs.get("dtype")
             if isinstance(dtype, bytes):
                 dtype = dtype.decode("utf-8")
-            result = arr.astype(dtype)
+            result = self._run_kernel(arr.astype, dtype)
             return self._pack_result(result)
 
         # Generator method calls: op is "Generator.<method>" with the remote
@@ -285,14 +301,14 @@ class RequestHandler:
             gen = self._resolve_arg(raw_args[0])
             rest = [self._resolve_arg(a) for a in raw_args[1:]]
             resolved_kwargs = {k: self._resolve_arg(v) for k, v in kwargs.items()}
-            result = getattr(gen, method)(*rest, **resolved_kwargs)
+            result = self._run_kernel(getattr(gen, method), *rest, **resolved_kwargs)
             return self._pack_result(result)
 
         func = _get_flopscope_func(op)
         resolved_args = [self._resolve_arg(a) for a in raw_args]
         resolved_kwargs = {k: self._resolve_arg(v) for k, v in kwargs.items()}
 
-        result = func(*resolved_args, **resolved_kwargs)
+        result = self._run_kernel(func, *resolved_args, **resolved_kwargs)
 
         return self._pack_result(result)
 

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/src/flopscope_server/_server.py

@@ -172,7 +172,7 @@ class FlopscopeServer:
 
         # --- Record comms overhead ---
         comms_ns = (t1 - t0) + (t3 - t2)
-        compute_ns = t2 - t1
+        compute_ns = self._handler.kernel_ns
 
         self._session.comms_tracker.record_request(
             bytes_received=len(raw),
@@ -222,7 +222,7 @@ class FlopscopeServer:
         t3 = perf_counter_ns()
 
         comms_ns = (t1 - t0) + (t3 - t2)
-        compute_ns = t2 - t1
+        compute_ns = 0  # session creation is not a numpy kernel
         self._session.comms_tracker.record_request(
             bytes_received=0,
             bytes_sent=len(response_bytes),

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/tests/test_server.py

@@ -308,3 +308,44 @@ def test_normalize_msg_kwargs_handle_dict():
     assert isinstance(out_val, dict)
     assert "__handle__" in out_val
     assert out_val["__handle__"] == "a5"
+
+
+# ---------------------------------------------------------------------------
+# kernel_ns timing tests (pure numpy kernel attribution)
+# ---------------------------------------------------------------------------
+
+
+def test_compute_time_is_kernel_only():
+    """A compute op records kernel time that does not exceed the full handle() wall."""
+    import time
+
+    import numpy as np
+    from flopscope_server._request_handler import RequestHandler
+    from flopscope_server._session import Session
+
+    session = Session(flop_budget=10**12)
+    handler = RequestHandler(session)
+    h = session.store_array(np.ones((256, 256)))
+
+    t0 = time.perf_counter_ns()
+    handler.handle({"op": "dot", "args": [h, h], "kwargs": None})
+    handle_ns = time.perf_counter_ns() - t0
+
+    assert handler.kernel_ns > 0
+    assert handler.kernel_ns <= handle_ns
+    session.close()
+
+
+def test_fetch_contributes_no_kernel():
+    """A fetch op is data movement, not a numpy kernel — kernel_ns stays 0."""
+    import numpy as np
+    from flopscope_server._request_handler import RequestHandler
+    from flopscope_server._session import Session
+
+    session = Session(flop_budget=10**12)
+    handler = RequestHandler(session)
+    h = session.store_array(np.ones((8, 8)))
+
+    handler.handle({"op": "fetch", "id": h})
+    assert handler.kernel_ns == 0
+    session.close()

{flopscope_server-0.4.3 → flopscope_server-0.6.0}/tests/test_session.py

@@ -253,3 +253,21 @@ def test_budget_remaining_reflects_context():
     s = Session(flop_budget=100_000)
     assert s.budget_remaining == 100_000
     s.close()
+
+
+# ---------------------------------------------------------------------------
+# Server contract: close() surfaces recorded compute time
+# ---------------------------------------------------------------------------
+
+
+def test_close_surfaces_recorded_compute_time(session):
+    """close()'s comms_summary carries the compute time the client reads as backend."""
+    session.comms_tracker.record_request(
+        bytes_received=10,
+        bytes_sent=20,
+        comms_overhead_ns=100,
+        compute_time_ns=5000,
+        is_fetch=False,
+    )
+    summary = session.close()
+    assert summary["comms_summary"]["total_compute_time_ns"] == 5000