flopscope-server 0.4.2__tar.gz → 0.5.0__tar.gz

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: flopscope-server
-Version: 0.4.2
+Version: 0.5.0
 Summary: Backend server for flopscope client-server architecture
 License-Expression: MIT
 Requires-Python: >=3.10
-Requires-Dist: flopscope==0.4.2
+Requires-Dist: flopscope==0.5.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.2 → flopscope_server-0.5.0}/pyproject.toml

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

{flopscope_server-0.4.2 → flopscope_server-0.5.0}/src/flopscope_server/__init__.py

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

{flopscope_server-0.4.2 → flopscope_server-0.5.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
@@ -49,6 +50,28 @@ def _make_serializable(obj):
     return obj
 
 
+_MSGPACK_SCALARS = (type(None), bool, int, float, str, bytes)
+
+
+def _is_msgpack_native(obj) -> bool:
+    """True if *obj* is composed only of msgpack-encodable Python types.
+
+    ``_make_serializable`` flattens numpy types but passes unknown objects
+    through unchanged; this distinguishes a genuinely-encodable result from one
+    that would only fail later inside ``msgpack.packb``.
+    """
+    if isinstance(obj, _MSGPACK_SCALARS):
+        return True
+    if isinstance(obj, (list, tuple)):
+        return all(_is_msgpack_native(item) for item in obj)
+    if isinstance(obj, dict):
+        return all(
+            isinstance(k, (str, bytes, int)) and _is_msgpack_native(v)
+            for k, v in obj.items()
+        )
+    return False
+
+
 #: Maximum allowed array size in bytes (configurable via environment variable).
 MAX_ARRAY_BYTES = int(os.environ.get("FLOPSCOPE_MAX_ARRAY_BYTES", 100 * 1024 * 1024))
 
@@ -64,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
@@ -74,6 +111,7 @@ class RequestHandler:
 
         The ``request["op"]`` field determines which handler is invoked.
         """
+        self._kernel_ns = 0
         try:
             op = request["op"]
 
@@ -113,6 +151,12 @@ class RequestHandler:
                 "error_type": "UnsupportedFunctionError",
                 "message": str(e),
             }
+        except flops.UnsupportedReturnType as e:
+            return {
+                "status": "error",
+                "error_type": "UnsupportedReturnType",
+                "message": str(e),
+            }
         except (ValueError, TypeError) as e:
             return {
                 "status": "error",
@@ -221,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)
 
     # ------------------------------------------------------------------
@@ -239,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
@@ -257,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)
 
@@ -420,16 +464,19 @@ class RequestHandler:
             handle = self._session.store_generator(result)
             return {"status": "ok", "result": {"gen_id": handle}, "budget": budget}
 
-        # Fallback: try to make it serializable
-        try:
-            serializable = _make_serializable(result)
+        # Fallback: flatten nested numpy structures to JSON-safe values. If the
+        # result still isn't msgpack-native, fail loudly + attributably rather
+        # than silently str()-degrading (which previously surfaced downstream as
+        # an opaque "failed to serialize response" error). The registry-driven
+        # conformance test (tests/test_registry_conformance.py) catches any op
+        # whose return type lands here.
+        serializable = _make_serializable(result)
+        if _is_msgpack_native(serializable):
             return {"status": "ok", "result": {"value": serializable}, "budget": budget}
-        except Exception:
-            return {
-                "status": "ok",
-                "result": {"value": str(result), "dtype": "str"},
-                "budget": budget,
-            }
+        raise flops.UnsupportedReturnType(
+            f"{type(result).__name__} is not serializable across the "
+            f"client/server boundary"
+        )
 
 
 # ---------------------------------------------------------------------------

{flopscope_server-0.4.2 → flopscope_server-0.5.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.2 → flopscope_server-0.5.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.2 → flopscope_server-0.5.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