mplang-nightly 0.1.dev152__py3-none-any.whl → 0.1.dev153__py3-none-any.whl

mplang/core/cluster.py

@@ -25,23 +25,28 @@ from typing import Any
 
 @dataclass(frozen=True)
 class RuntimeInfo:
-    """
-    Structured representation of a Physical Node's runtime capabilities.
+    """Per-physical-node runtime configuration.
+
+    ``op_bindings`` is a per-node override map (logical_op -> kernel_id) merged
+    into that node's ``RuntimeContext``. Unknown future / auxiliary fields are
+    preserved in ``extra``.
     """
 
     version: str
     platform: str
-    backends: list[str]
+    # Per-node partial override dispatch table (merged over project defaults).
+    op_bindings: dict[str, str] = field(default_factory=dict)
 
-    # A catch-all for any other custom or future properties
+    # A catch-all for any other custom or future properties (must not collide
+    # with reserved keys: version, platform, op_bindings).
     extra: dict[str, Any] = field(default_factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        """Convert RuntimeInfo to a dictionary."""
+        """Convert RuntimeInfo to a dictionary (stable field names)."""
         result = {
             "version": self.version,
             "platform": self.platform,
-            "backends": self.backends,
+            "op_bindings": self.op_bindings,
         }
         result.update(self.extra)
         return result
@@ -175,7 +180,8 @@ class ClusterSpec:
 
         # 2. Parse Physical Nodes, using the list index as the rank
         nodes_map: dict[str, Node] = {}
-        known_runtime_fields = {"version", "platform", "backends"}
+        # Reserved runtime info keys we recognize explicitly.
+        known_runtime_fields = {"version", "platform", "op_bindings"}
         for i, node_cfg in enumerate(config["nodes"]):
             if "rank" in node_cfg:
                 # Optionally, we can log a warning that the explicit 'rank' is ignored.
@@ -187,11 +193,12 @@ class ClusterSpec:
                 for k, v in runtime_info_cfg.items()
                 if k not in known_runtime_fields
             }
-
+            # Gracefully ignore legacy 'backends' if present (treated as extra)
+            # for backward compatibility.
             runtime_info = RuntimeInfo(
                 version=runtime_info_cfg.get("version", "N/A"),
                 platform=runtime_info_cfg.get("platform", "N/A"),
-                backends=runtime_info_cfg.get("backends", []),
+                op_bindings=runtime_info_cfg.get("op_bindings", {}) or {},
                 extra=extra_runtime_info,
             )
 
@@ -227,32 +234,96 @@ class ClusterSpec:
         return cls(nodes=nodes_map, devices=devices_map)
 
     @classmethod
-    def simple(cls, world_size: int) -> ClusterSpec:
-        """Creates a simple cluster spec for simulation with the given number of parties."""
-        nodes = {
-            f"node{i}": Node(
+    def simple(
+        cls,
+        world_size: int,
+        *,
+        endpoints: list[str] | None = None,
+        spu_protocol: str = "SEMI2K",
+        spu_field: str = "FM128",
+        runtime_version: str = "simulated",
+        runtime_platform: str = "simulated",
+        op_bindings: list[dict[str, str]] | None = None,
+        enable_local_device: bool = True,
+        enable_spu_device: bool = True,
+    ) -> ClusterSpec:
+        """Convenience constructor used heavily in tests.
+
+        Parameters
+        ----------
+        world_size:
+            Number of parties (physical nodes).
+        endpoints:
+            Optional explicit endpoint list of length ``world_size``. Each element may
+            include scheme (``http://``) or not; stored verbatim. If not provided we
+            synthesize ``localhost:{5000 + i}`` (5000 is a fixed default; pass explicit
+            endpoints for control). Deprecated ``base_port`` legacy kwarg can adjust it.
+        spu_protocol / spu_field:
+            SPU device config values.
+        runtime_version / runtime_platform:
+            Populated into each node's ``RuntimeInfo``.
+        op_bindings:
+            Optional list of length ``world_size`` supplying per-node op_bindings
+            override dicts (defaults to empty dicts).
+        enable_local_device:
+            If True (default), create one ``local_{rank}`` device per node.
+        enable_spu_device:
+            If True (default) create a shared SPU device named ``SP0``.
+        """
+        base_port = 5000
+
+        if endpoints is not None and len(endpoints) != world_size:
+            raise ValueError(
+                "len(endpoints) must equal world_size when provided: "
+                f"{len(endpoints)} != {world_size}"
+            )
+
+        if op_bindings is not None and len(op_bindings) != world_size:
+            raise ValueError(
+                "len(op_bindings) must equal world_size when provided: "
+                f"{len(op_bindings)} != {world_size}"
+            )
+
+        if not enable_local_device and not enable_spu_device:
+            raise ValueError(
+                "At least one of enable_local_device or enable_spu_device must be True"
+            )
+
+        nodes: dict[str, Node] = {}
+        for i in range(world_size):
+            ep = endpoints[i] if endpoints is not None else f"localhost:{base_port + i}"
+            node_op_bindings = op_bindings[i] if op_bindings is not None else {}
+            nodes[f"node{i}"] = Node(
                 name=f"node{i}",
                 rank=i,
-                endpoint=f"localhost:{5000 + i}",
+                endpoint=ep,
                 runtime_info=RuntimeInfo(
-                    version="simulated",
-                    platform="simulated",
-                    backends=["__all__"],
+                    version=runtime_version,
+                    platform=runtime_platform,
+                    op_bindings=node_op_bindings,
                 ),
             )
-            for i in range(world_size)
-        }
 
-        devices = {
-            "SP0": Device(
+        devices: dict[str, Device] = {}
+        # Optional per-node local devices
+        if enable_local_device:
+            for i in range(world_size):
+                devices[f"local_{i}"] = Device(
+                    name=f"local_{i}",
+                    kind="local",
+                    members=[nodes[f"node{i}"]],
+                )
+
+        # Shared SPU device
+        if enable_spu_device:
+            devices["SP0"] = Device(
                 name="SP0",
                 kind="SPU",
                 members=list(nodes.values()),
                 config={
-                    "protocol": "SEMI2K",
-                    "field": "FM128",
+                    "protocol": spu_protocol,
+                    "field": spu_field,
                 },
             )
-        }
 
         return cls(nodes=nodes, devices=devices)

mplang/runtime/client.py

@@ -81,21 +81,14 @@ class HttpExecutorClient:
         self,
         name: str,
         rank: int,
-        endpoints: list[str],
-        *,
-        spu_mask: int = 0,
-        spu_protocol: str = "SEMI2K",
-        spu_field: str = "FM64",
+        cluster_spec: dict,
     ) -> str:
         """Create a new session.
 
         Args:
             name: Session name/ID.
-            rank: The rank of this party in the session.
-            endpoints: List of endpoint URLs for all parties, indexed by rank.
-            spu_mask: SPU mask for the session, 0 means no SPU.
-            spu_protocol: SPU protocol for the session (e.g., "SEMI2K", "ABY3").
-            spu_field: SPU field for the session (e.g., "FM64", "FM128").
+            rank: This party's rank.
+            cluster_spec: Full cluster specification dict (ClusterSpec.to_dict()).
 
         Returns:
             The session name/ID
@@ -104,14 +97,7 @@ class HttpExecutorClient:
             RuntimeError: If session creation fails
         """
         url = f"/sessions/{name}"
-
-        payload: dict[str, Any] = {
-            "rank": rank,
-            "endpoints": endpoints,
-            "spu_mask": spu_mask,
-            "spu_protocol": spu_protocol,
-            "spu_field": spu_field,
-        }
+        payload: dict[str, Any] = {"rank": rank, "cluster_spec": cluster_spec}
 
         try:
             response = await self._client.put(url, json=payload)

mplang/runtime/driver.py

@@ -145,8 +145,6 @@ class Driver(InterpContext):
         """Get existing session or create a new one across all HTTP servers."""
         if self._session_id is None:
             new_session_id = new_uuid()
-            endpoints_list = list(self.node_addrs.values())
-
             # Create temporary clients for session creation
             clients = self._create_clients()
             try:
@@ -158,10 +156,7 @@ class Driver(InterpContext):
                     task = client.create_session(
                         name=new_session_id,
                         rank=rank,
-                        endpoints=endpoints_list,
-                        spu_mask=self.spu_mask_int,
-                        spu_protocol=self.spu_protocol_str,
-                        spu_field=self.spu_field_str,
+                        cluster_spec=self.cluster_spec.to_dict(),
                     )
                     tasks.append(task)
 

mplang/runtime/server.py

@@ -32,14 +32,30 @@ from mplang.core.table import TableType
 from mplang.core.tensor import TensorType
 from mplang.kernels.base import KernelContext
 from mplang.protos.v1alpha1 import mpir_pb2
-from mplang.runtime import resource
 from mplang.runtime.data_providers import DataProvider, ResolvedURI, register_provider
 from mplang.runtime.exceptions import InvalidRequestError, ResourceNotFound
+from mplang.runtime.session import (
+    Computation,
+    Session,
+    Symbol,
+)
 
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
+# per-server global state
+_sessions: dict[str, Session] = {}
+_global_symbols: dict[str, Symbol] = {}
+
+
+def register_session(session: Session) -> Session:  # pragma: no cover - test helper
+    existing = _sessions.get(session.name)
+    if existing:
+        return existing
+    _sessions[session.name] = session
+    return session
+
 
 class _SymbolsProvider(DataProvider):
     """Server-local symbols provider backed by BackendRuntime.state."""
@@ -83,7 +99,7 @@ class _SymbolsProvider(DataProvider):
         ctx: KernelContext,
     ) -> Any:  # type: ignore[override]
         name = self._symbol_name(uri)
-        sym = resource.get_global_symbol(name)
+        sym = _global_symbols.get(name)
         if sym is None:
             raise ResourceNotFound(f"Global symbol '{name}' not found")
         return sym.data
@@ -102,8 +118,13 @@ class _SymbolsProvider(DataProvider):
             raise InvalidRequestError(
                 f"Failed to encode value for symbols:// write: {e!s}"
             ) from e
-
-        resource.create_global_symbol(name, {}, data_b64)
+        try:
+            obj = pickle.loads(base64.b64decode(data_b64))
+        except Exception as e:  # pragma: no cover - defensive
+            raise InvalidRequestError(
+                f"Failed to decode value for symbols:// write: {e!s}"
+            ) from e
+        _global_symbols[name] = Symbol(name=name, mptype={}, data=obj)
 
 
 # Register symbols provider explicitly for server runtime
@@ -168,11 +189,7 @@ def validate_name(name: str, name_type: str) -> None:
 # Request/Response Models
 class CreateSessionRequest(BaseModel):
     rank: int
-    endpoints: list[str]
-    # SPU related
-    spu_mask: int
-    spu_protocol: str
-    spu_field: str
+    cluster_spec: dict
 
 
 class SessionResponse(BaseModel):
@@ -229,7 +246,7 @@ async def health_check() -> dict[str, str]:
 @app.get("/sessions", response_model=SessionListResponse)
 def list_sessions() -> SessionListResponse:
     """List all session names."""
-    return SessionListResponse(sessions=resource.list_all_sessions())
+    return SessionListResponse(sessions=list(_sessions.keys()))
 
 
 # List all computations in a session
@@ -238,39 +255,44 @@ def list_sessions() -> SessionListResponse:
 )
 def list_session_computations(session_name: str) -> ComputationListResponse:
     """List all computation names in a session."""
-    session = resource.get_session(session_name)
-    if not session:
+    sess = _sessions.get(session_name)
+    if not sess:
         raise ResourceNotFound(f"Session '{session_name}' not found")
-    return ComputationListResponse(computations=list(session.computations.keys()))
+    return ComputationListResponse(computations=sess.list_computations())
 
 
 # Session endpoints
 @app.put("/sessions/{session_name}", response_model=SessionResponse)
 def create_session(session_name: str, request: CreateSessionRequest) -> SessionResponse:
     validate_name(session_name, "session")
-    session = resource.create_session(
-        name=session_name,
-        rank=request.rank,
-        endpoints=request.endpoints,
-        spu_mask=request.spu_mask,
-        spu_protocol=request.spu_protocol,
-        spu_field=request.spu_field,
-    )
-    return SessionResponse(name=session.name)
+    # Delegate cluster spec parsing & session construction to resource layer
+    from mplang.core.cluster import ClusterSpec  # local import to avoid cycles
+
+    if session_name in _sessions:
+        sess = _sessions[session_name]
+    else:
+        spec = ClusterSpec.from_dict(request.cluster_spec)
+        if len(spec.get_devices_by_kind("SPU")) == 0:
+            raise InvalidRequestError("No SPU device found in cluster_spec for session")
+        sess = Session(name=session_name, rank=request.rank, cluster_spec=spec)
+        _sessions[session_name] = sess
+    return SessionResponse(name=sess.name)
 
 
 @app.get("/sessions/{session_name}", response_model=SessionResponse)
 def get_session(session_name: str) -> SessionResponse:
-    session = resource.get_session(session_name)
-    if not session:
+    sess = _sessions.get(session_name)
+    if not sess:
         raise ResourceNotFound(f"Session '{session_name}' not found")
-    return SessionResponse(name=session.name)
+    return SessionResponse(name=sess.name)
 
 
 @app.delete("/sessions/{session_name}")
 def delete_session(session_name: str) -> dict[str, str]:
     """Delete a session and all its associated resources."""
-    if resource.delete_session(session_name):
+    if session_name in _sessions:
+        del _sessions[session_name]
+        logging.info(f"Session {session_name} deleted successfully")
         return {"message": f"Session '{session_name}' deleted successfully"}
     else:
         raise ResourceNotFound(f"Session '{session_name}' not found")
@@ -299,18 +321,25 @@ def create_and_execute_computation(
         raise InvalidRequestError("Failed to parse expression from protobuf")
 
     # Create the computation resource
-    computation = resource.create_computation(session_name, computation_id, expr)
-    # Execute with input/output names
-    resource.execute_computation(
-        session_name, computation.name, request.input_names, request.output_names
-    )
-    return ComputationResponse(name=computation.name)
+    sess = _sessions.get(session_name)
+    if not sess:
+        raise ResourceNotFound(f"Session '{session_name}' not found.")
+    comp = sess.get_computation(computation_id)
+    if not comp:
+        comp = Computation(name=computation_id, expr=expr)
+        sess.add_computation(comp)
+    sess.execute(comp, request.input_names, request.output_names)
+    return ComputationResponse(name=computation_id)
 
 
 @app.delete("/sessions/{session_name}/computations/{computation_id}")
 def delete_computation(session_name: str, computation_id: str) -> dict[str, str]:
     """Delete a specific computation."""
-    if resource.delete_computation(session_name, computation_id):
+    sess = _sessions.get(session_name)
+    if sess and sess.delete_computation(computation_id):
+        logging.info(
+            f"Computation {computation_id} deleted from session {session_name}"
+        )
         return {"message": f"Computation '{computation_id}' deleted successfully"}
     else:
         raise ResourceNotFound(
@@ -326,9 +355,15 @@ def create_session_symbol(
     session_name: str, symbol_name: str, request: CreateSymbolRequest
 ) -> SymbolResponse:
     """Create a symbol in a session."""
-    symbol = resource.create_symbol(
-        session_name, symbol_name, request.mptype, request.data
-    )
+    sess = _sessions.get(session_name)
+    if not sess:
+        raise ResourceNotFound(f"Session '{session_name}' not found.")
+    try:
+        obj = pickle.loads(base64.b64decode(request.data))
+    except Exception as e:
+        raise InvalidRequestError(f"Invalid symbol data: {e!s}") from e
+    symbol = Symbol(name=symbol_name, mptype=request.mptype, data=obj)
+    sess.add_symbol(symbol)
     # Return the base64 data back to client; server stores Python object
     return SymbolResponse(
         name=symbol.name,
@@ -346,8 +381,8 @@ def get_session_symbol(session_name: str, symbol_name: str) -> SymbolResponse:
         logger.debug(
             f"Looking for symbol: '{symbol_name}' in session: '{session_name}'"
         )
-
-        symbol = resource.get_symbol(session_name, symbol_name)
+        sess = _sessions.get(session_name)
+        symbol = sess.get_symbol(symbol_name) if sess else None
         if not symbol:
             raise HTTPException(
                 status_code=404, detail=f"Symbol {symbol_name} not found"
@@ -368,14 +403,19 @@ def get_session_symbol(session_name: str, symbol_name: str) -> SymbolResponse:
 @app.get("/sessions/{session_name}/symbols")
 def list_session_symbols(session_name: str) -> dict[str, list[str]]:
     """List all symbols in a session."""
-    symbols = resource.list_symbols(session_name)
+    sess = _sessions.get(session_name)
+    if not sess:
+        raise ResourceNotFound(f"Session '{session_name}' not found.")
+    symbols = sess.list_symbols()
     return {"symbols": symbols}
 
 
 @app.delete("/sessions/{session_name}/symbols/{symbol_name}")
 def delete_symbol(session_name: str, symbol_name: str) -> dict[str, str]:
     """Delete a specific symbol."""
-    if resource.delete_symbol(session_name, symbol_name):
+    sess = _sessions.get(session_name)
+    if sess and sess.delete_symbol(symbol_name):
+        logging.info(f"Symbol {symbol_name} deleted from session {session_name}")
         return {"message": f"Symbol '{symbol_name}' deleted successfully"}
     else:
         raise ResourceNotFound(
@@ -389,13 +429,18 @@ def create_global_symbol(
     symbol_name: str, request: CreateSymbolRequest
 ) -> GlobalSymbolResponse:
     validate_name(symbol_name, "symbol")
-    sym = resource.create_global_symbol(symbol_name, request.mptype, request.data)
+    try:
+        obj = pickle.loads(base64.b64decode(request.data))
+    except Exception as e:
+        raise InvalidRequestError(f"Invalid global symbol data: {e!s}") from e
+    sym = Symbol(name=symbol_name, mptype=request.mptype, data=obj)
+    _global_symbols[symbol_name] = sym
     return GlobalSymbolResponse(name=sym.name, mptype=sym.mptype, data=request.data)
 
 
 @app.get("/api/v1/symbols/{symbol_name}", response_model=GlobalSymbolResponse)
-def get_global_symbol(symbol_name: str) -> GlobalSymbolResponse:
-    sym = resource.get_global_symbol(symbol_name)
+def get_global_symbol(symbol_name: str) -> GlobalSymbolResponse:  # route handler
+    sym = _global_symbols.get(symbol_name)
     if not sym:
         raise ResourceNotFound(f"Global symbol '{symbol_name}' not found")
     data_bytes = pickle.dumps(sym.data)
@@ -405,12 +450,13 @@ def get_global_symbol(symbol_name: str) -> GlobalSymbolResponse:
 
 @app.get("/api/v1/symbols")
 def list_global_symbols() -> dict[str, list[str]]:
-    return {"symbols": resource.list_global_symbols()}
+    return {"symbols": list(_global_symbols.keys())}
 
 
 @app.delete("/api/v1/symbols/{symbol_name}")
-def delete_global_symbol(symbol_name: str) -> dict[str, str]:
-    if resource.delete_global_symbol(symbol_name):
+def delete_global_symbol(symbol_name: str) -> dict[str, str]:  # route handler
+    if symbol_name in _global_symbols:
+        del _global_symbols[symbol_name]
         return {"message": f"Global symbol '{symbol_name}' deleted successfully"}
     else:
         raise ResourceNotFound(f"Global symbol '{symbol_name}' not found")
@@ -426,8 +472,8 @@ def comm_send(
     Receive a message from another party and deliver it to the session's communicator.
     This endpoint runs on the receiver's server.
     """
-    session = resource.get_session(session_name)
-    if not session or not session.communicator:
+    sess = _sessions.get(session_name)
+    if not sess or not sess.communicator:
         logger.error(f"Session or communicator not found: session={session_name}")
         raise HTTPException(status_code=404, detail="Session or communicator not found")
 
@@ -435,5 +481,5 @@ def comm_send(
     # We don't need to validate to_rank since the request is coming to this server
 
     # Use the proper onSent mechanism from CommunicatorBase
-    session.communicator.onSent(from_rank, key, request.data)
+    sess.communicator.onSent(from_rank, key, request.data)
     return {"status": "ok"}

mplang/runtime/session.py

@@ -0,0 +1,285 @@
+# Copyright 2025 Ant Group Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Core Session model (pure, no global registries).
+
+Contents:
+    * SessionState dataclass
+    * LinkCommFactory (SPU link reuse cache)
+    * Session (topology derivation, runtime init, SPU env seeding, local symbol/computation storage)
+
+Process-wide registries (sessions, global symbols) live in the server layer
+(`server.py`) so this module remains portable and easy to unit test.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, cast
+from urllib.parse import urlparse
+
+import spu.libspu as libspu
+
+from mplang.core.expr.ast import Expr
+from mplang.core.expr.evaluator import IEvaluator, create_evaluator
+from mplang.core.mask import Mask
+from mplang.kernels.context import RuntimeContext
+from mplang.kernels.spu import PFunction  # type: ignore
+from mplang.runtime.communicator import HttpCommunicator
+from mplang.runtime.exceptions import ResourceNotFound
+from mplang.runtime.link_comm import LinkCommunicator
+from mplang.utils.spu_utils import parse_field, parse_protocol
+
+if TYPE_CHECKING:  # pragma: no cover - import only for type checking
+    from mplang.core.cluster import ClusterSpec, Node, RuntimeInfo
+
+
+class LinkCommFactory:
+    """Factory for creating and caching link communicators."""
+
+    def __init__(self) -> None:
+        self._cache: dict[tuple[int, tuple[str, ...]], LinkCommunicator] = {}
+
+    def create_link(self, rel_rank: int, addrs: list[str]) -> LinkCommunicator:
+        key = (rel_rank, tuple(addrs))
+        link = self._cache.get(key)
+        if link is not None:
+            return link
+        logging.info(f"LinkCommunicator created: rel_rank={rel_rank} addrs={addrs}")
+        link = LinkCommunicator(rel_rank, addrs)
+        self._cache[key] = link
+        return link
+
+
+# Shared link factory (module-local, not global registry of sessions)
+g_link_factory = LinkCommFactory()
+
+
+@dataclass
+class Symbol:
+    name: str
+    mptype: Any
+    data: Any
+
+
+@dataclass
+class Computation:
+    name: str
+    expr: Expr
+
+
+@dataclass
+class SessionState:
+    runtime: RuntimeContext | None = None
+    computations: dict[str, Computation] = field(default_factory=dict)
+    symbols: dict[str, Symbol] = field(default_factory=dict)
+    spu_seeded: bool = False
+    created_ts: float = field(default_factory=time.time)
+    last_access_ts: float = field(default_factory=time.time)
+
+
+class Session:
+    """Represents the per-rank execution context.
+
+    Immutable config: name, rank, cluster_spec.
+    Derived: node, runtime_info, endpoints, spu_device, spu_mask, protocol/field, is_spu_party.
+    Mutable: state (runtime object, symbols, computations, seeded flag).
+    """
+
+    def __init__(self, name: str, rank: int, cluster_spec: ClusterSpec):
+        self.name = name
+        self.rank = rank
+        self.cluster_spec = cluster_spec
+        self.state = SessionState()
+        self.communicator = HttpCommunicator(
+            session_name=name, rank=rank, endpoints=self.endpoints
+        )
+
+    # --- Derived topology ---
+    @cached_property
+    def node(self) -> Node:
+        return self.cluster_spec.get_node_by_rank(self.rank)
+
+    @property
+    def runtime_info(self) -> RuntimeInfo:
+        return self.node.runtime_info
+
+    @cached_property
+    def endpoints(self) -> list[str]:
+        eps: list[str] = []
+        for n in sorted(
+            self.cluster_spec.nodes.values(),
+            key=lambda x: x.rank,  # type: ignore[attr-defined]
+        ):
+            ep = n.endpoint
+            if not ep.startswith(("http://", "https://")):
+                ep = f"http://{ep}"
+            eps.append(ep)
+        return eps
+
+    @cached_property
+    def spu_device(self):  # type: ignore
+        devs = self.cluster_spec.get_devices_by_kind("SPU")
+        if len(devs) != 1:
+            raise RuntimeError(
+                f"Expected exactly one SPU device, got {len(devs)} (session={self.name})"
+            )
+        return devs[0]
+
+    @cached_property
+    def spu_mask(self) -> Mask:
+        return Mask.from_ranks([m.rank for m in self.spu_device.members])
+
+    @property
+    def spu_protocol(self) -> str:
+        return cast(str, self.spu_device.config.get("protocol", "SEMI2K"))
+
+    @property
+    def spu_field(self) -> str:
+        return cast(str, self.spu_device.config.get("field", "FM64"))
+
+    @property
+    def is_spu_party(self) -> bool:
+        return self.rank in self.spu_mask
+
+    # --- Runtime helpers ---
+    def ensure_runtime(self) -> RuntimeContext:
+        if self.state.runtime is None:
+            self.state.runtime = RuntimeContext(
+                rank=self.rank,
+                world_size=len(self.cluster_spec.nodes),  # type: ignore[attr-defined]
+                initial_bindings=(
+                    self.runtime_info.op_bindings if self.runtime_info else {}
+                ),
+            )
+        return self.state.runtime
+
+    def ensure_spu_env(self) -> None:
+        """Ensure SPU kernel env (config/world[/link]) registered on this runtime.
+
+        Previous logic only seeded SPU parties; non-participating ranks then raised
+        a hard error when the evaluator encountered SPU ops in the global program,
+        because the kernel pocket lacked config/world. For now we register the
+        config/world on ALL parties (idempotent) and only attach a link context for
+        participating SPU ranks. Non-parties will still error later if they try to
+        execute a link-dependent SPU kernel (which should be guarded by masks in the
+        IR), but they will no longer fail early with a misleading
+        "SPU kernel state not initialized" message.
+        """
+        if self.state.spu_seeded:
+            return
+
+        link_ctx = None
+        # Fixed port offset for SPU runtime link services (legacy value retained).
+        # TODO: make configurable if future deployments require dynamic offset.
+        SPU_PORT_OFFSET = 100
+
+        if self.is_spu_party:
+            # Build SPU address list across all endpoints for ranks in mask
+            spu_addrs: list[str] = []
+            for r, addr in enumerate(self.communicator.endpoints):
+                if r in self.spu_mask:
+                    if "//" not in addr:
+                        addr = f"//{addr}"
+                    parsed = urlparse(addr)
+                    assert isinstance(parsed.port, int)
+                    new_addr = f"{parsed.hostname}:{parsed.port + SPU_PORT_OFFSET}"
+                    spu_addrs.append(new_addr)
+            rel_index = sum(1 for r in range(self.rank) if r in self.spu_mask)
+            link_ctx = g_link_factory.create_link(rel_index, spu_addrs)
+
+        spu_config = libspu.RuntimeConfig(
+            protocol=parse_protocol(self.spu_protocol),
+            field=parse_field(self.spu_field),
+            fxp_fraction_bits=18,
+        )
+        seed_pfunc = PFunction(
+            fn_type="spu.seed_env",
+            ins_info=(),
+            outs_info=(),
+            config=spu_config,
+            world=self.spu_mask.num_parties(),
+            link=link_ctx,
+        )
+        self.ensure_runtime().run_kernel(seed_pfunc, [])
+        self.state.spu_seeded = True
+
+    # --- Computations & Symbols (instance-local) ---
+    def add_computation(self, computation: Computation) -> None:
+        self.state.computations[computation.name] = computation
+
+    def get_computation(self, name: str) -> Computation | None:
+        return self.state.computations.get(name)
+
+    def add_symbol(self, symbol: Symbol) -> None:
+        self.state.symbols[symbol.name] = symbol
+
+    def get_symbol(self, name: str) -> Symbol | None:
+        return self.state.symbols.get(name)
+
+    def list_symbols(self) -> list[str]:  # pragma: no cover - trivial
+        return list(self.state.symbols.keys())
+
+    def delete_symbol(self, name: str) -> bool:
+        if name in self.state.symbols:
+            del self.state.symbols[name]
+            return True
+        return False
+
+    def list_computations(self) -> list[str]:  # pragma: no cover - trivial
+        return list(self.state.computations.keys())
+
+    def delete_computation(self, name: str) -> bool:
+        if name in self.state.computations:
+            del self.state.computations[name]
+            return True
+        return False
+
+    # --- Execution ---
+    def execute(
+        self, computation: Computation, input_names: list[str], output_names: list[str]
+    ) -> None:
+        env: dict[str, Any] = {}
+        for in_name in input_names:
+            sym = self.get_symbol(in_name)
+            if sym is None:
+                raise ResourceNotFound(
+                    f"Input symbol '{in_name}' not found in session '{self.name}'"
+                )
+            env[in_name] = sym.data
+        rt = self.ensure_runtime()
+        self.ensure_spu_env()
+        evaluator: IEvaluator = create_evaluator(
+            rank=self.rank, env=env, comm=self.communicator, runtime=rt
+        )
+        results = evaluator.evaluate(computation.expr)
+        if results and len(results) != len(output_names):
+            raise RuntimeError(
+                f"Expected {len(output_names)} results, got {len(results)}"
+            )
+        for name, val in zip(output_names, results, strict=True):
+            self.add_symbol(Symbol(name=name, mptype={}, data=val))
+
+    # --- Convenience constructor ---
+    @classmethod
+    def from_cluster_spec_dict(cls, name: str, rank: int, spec_dict: dict) -> Session:
+        from mplang.core.cluster import ClusterSpec  # local import to avoid cycles
+
+        spec = ClusterSpec.from_dict(spec_dict)
+        if len(spec.get_devices_by_kind("SPU")) == 0:
+            raise RuntimeError("No SPU device found in cluster_spec")
+        return cls(name=name, rank=rank, cluster_spec=spec)

mplang/runtime/simulation.py

@@ -86,20 +86,17 @@ class Simulator(InterpContext):
         cluster_spec: ClusterSpec,
         *,
         trace_ranks: list[int] | None = None,
-        op_bindings: dict[str, str] | None = None,
     ) -> None:
         """Initialize a simulator with the given cluster specification.
 
         Args:
             cluster_spec: The cluster specification defining the simulation environment.
             trace_ranks: List of ranks to trace execution for debugging.
-            op_bindings: Optional op->kernel binding template applied to all
-                RuntimeContexts. These are static dispatch overrides (merged
-                with project defaults) and are orthogonal to the per-evaluate
-                variable ``bindings`` dict passed into ``evaluate``.
+                Per-node op binding overrides should now be provided via
+                each node's `runtime_info.op_bindings` in the supplied
+                `cluster_spec`.
         """
         super().__init__(cluster_spec)
-        self._op_bindings_template = op_bindings or {}
         self._trace_ranks = trace_ranks or []
 
         spu_devices = cluster_spec.get_devices_by_kind("SPU")
@@ -145,21 +142,22 @@ class Simulator(InterpContext):
 
         # Persistent per-rank RuntimeContext instances (reused across evaluates).
         # We no longer pre-create evaluators since each evaluate has different env bindings.
-        self._runtimes: list[RuntimeContext] = [
-            RuntimeContext(
+        # Build per-rank runtime contexts.
+        self._runtimes: list[RuntimeContext] = []
+        for rank in range(self.world_size()):
+            node = self.cluster_spec.get_node_by_rank(rank)
+            rt = RuntimeContext(
                 rank=rank,
                 world_size=self.world_size(),
-                # Static op bindings template cloned into each runtime. These are kernel
-                # dispatch mappings, not per-evaluate variable bindings.
-                initial_bindings=self._op_bindings_template,
+                initial_bindings=node.runtime_info.op_bindings,
             )
-            for rank in range(self.world_size())
-        ]
+            self._runtimes.append(rt)
 
     @classmethod
     def simple(
         cls,
         world_size: int,
+        op_bindings: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> Simulator:
         """Create a simple simulator with the given number of parties.
@@ -175,6 +173,10 @@ class Simulator(InterpContext):
             A Simulator instance with a simple cluster configuration.
         """
         cluster_spec = ClusterSpec.simple(world_size)
+        if op_bindings:
+            # Apply the same op_bindings to every node's runtime_info for convenience
+            for node in cluster_spec.nodes.values():
+                node.runtime_info.op_bindings.update(op_bindings)
         return cls(cluster_spec, **kwargs)
 
     def _do_evaluate(self, expr: Expr, evaluator_engine: IEvaluator) -> Any:

{mplang_nightly-0.1.dev152.dist-info → mplang_nightly-0.1.dev153.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mplang-nightly
-Version: 0.1.dev152
+Version: 0.1.dev153
 Summary: Multi-Party Programming Language
 Author-email: SecretFlow Team <secretflow-contact@service.alipay.com>
 License:                                  Apache License

{mplang_nightly-0.1.dev152.dist-info → mplang_nightly-0.1.dev153.dist-info}/RECORD

@@ -4,7 +4,7 @@ mplang/device.py,sha256=RmjnhzHxJkkNmtBKtYMEbpQYBZpuC43qlllkCOp-QD8,12548
 mplang/analysis/__init__.py,sha256=CTHFvRsi-nFngojqjn08UaR3RY9i7CJ7T2UdR95kCrk,1056
 mplang/analysis/diagram.py,sha256=ffwgD12gL1_KH1uJ_EYkjmIlDrfxYJJkWj-wHl09_Xk,19520
 mplang/core/__init__.py,sha256=lWxlEKfRwX7FNDzgyKZ1fiDMaCiqkyg0j5mKlZD_v7g,2244
-mplang/core/cluster.py,sha256=gqMJenvXUfHhE181Dd5JiUkD4nT07RLoicBnvsGmRkE,8598
+mplang/core/cluster.py,sha256=IqXHLogetegUEEAzmD8cWRash-UID06Wo3OBeZFwatg,11800
 mplang/core/comm.py,sha256=MByyu3etlQh_TkP1vKCFLIAPPuJOpl9Kjs6hOj6m4Yc,8843
 mplang/core/context_mgr.py,sha256=R0QJAod-1nYduVoOknLfAsxZiy-RtmuQcp-07HABYZU,1541
 mplang/core/dtype.py,sha256=0rZqFaFikFu9RxtdO36JLEgFL-E-lo3hH10whwkTVVY,10213
@@ -51,16 +51,16 @@ mplang/protos/v1alpha1/mpir_pb2.pyi,sha256=GwXR4wPB_kB_36iYS9x-cGI9KDKFMq89KhdLh
 mplang/protos/v1alpha1/mpir_pb2_grpc.py,sha256=xYOs94SXiNYAlFodACnsXW5QovLsHY5tCk3p76RH5Zc,158
 mplang/runtime/__init__.py,sha256=IRPP3TtpFC4iSt7_uaq-S4dL7CwrXL0XBMeaBoEYLlg,948
 mplang/runtime/cli.py,sha256=WehDodeVB4AukSWx1LJxxtKUqGmLPY4qjayrPlOg3bE,14438
-mplang/runtime/client.py,sha256=w8sPuQzqaJI5uS_3JHu2mf0tLaFmZH3f6-SeUBfMLMY,15737
+mplang/runtime/client.py,sha256=vkJUFSDcKIdbKiGUM5AosCKTZygl9g8uZFEjw2xwKig,15249
 mplang/runtime/communicator.py,sha256=Lek6_h_Wmr_W-_JpT-vMxL3CHxcVZdtf7jdaLGuxPgQ,3199
 mplang/runtime/data_providers.py,sha256=hH2butEOYNGq2rRZjVBDfXLxe3YUin2ftAF6htbTfLA,8226
-mplang/runtime/driver.py,sha256=Ok1jY301ctN1_KTb4jwSxOdB0lI_xhx9AwhtEGJ-VLQ,11300
+mplang/runtime/driver.py,sha256=pq2EQFZK9tH90Idops_yeF6fj0cfFVD_5mFcmy4Hzco,11089
 mplang/runtime/exceptions.py,sha256=c18U0xK20dRmgZo0ogTf5vXlkix9y3VAFuzkHxaXPEk,981
 mplang/runtime/http_api.md,sha256=-re1DhEqMplAkv_wnqEU-PSs8tTzf4-Ml0Gq0f3Go6s,4883
 mplang/runtime/link_comm.py,sha256=uNqTCGZVwWeuHAb7yXXQf0DUsMXLa8leHCkrcZdzYMU,4559
-mplang/runtime/resource.py,sha256=xNke4UpNDjsjWcr09oXWNBXsMfSZFOwsKD7FWdCVPbc,11688
-mplang/runtime/server.py,sha256=LQ5uJi95tYrKmgHwZaxUQi-aiqwSsT3W4z7pZ9dQaUQ,14716
-mplang/runtime/simulation.py,sha256=_cmUsYL58mvc6msHZ2fDjFAEHHLdJ-TRzJV8BxOP_WA,11473
+mplang/runtime/server.py,sha256=vYjuWTWhhSLHUpsO8FDnOQ8kFzPhE-fXDDyL8GHVPj4,16673
+mplang/runtime/session.py,sha256=4TQ_RPRmriv0H0S6rl_GSabxS7XrwMkdZIdcnyE8bHw,10374
+mplang/runtime/simulation.py,sha256=WyIs8ta3ZM5o3RB0Bcb0MUu6Yh88Iujr27KvZFqGxig,11497
 mplang/simp/__init__.py,sha256=xNXnA8-jZAANa2A1W39b3lYO7D02zdCXl0TpivkTGS4,11579
 mplang/simp/mpi.py,sha256=Wv_Q16TQ3rdLam6OzqXiefIGSMmagGkso09ycyOkHEs,4774
 mplang/simp/random.py,sha256=7PVgWNL1j7Sf3MqT5PRiWplUu-0dyhF3Ub566iqX86M,3898
@@ -70,8 +70,8 @@ mplang/utils/crypto.py,sha256=rvPomBFtznRHc3RPi6Aip9lsU8zW2oxBqGv1K3vn7Rs,1052
 mplang/utils/func_utils.py,sha256=vCJcZmu0bEbqhOQKdpttV2_MBllIcPSN0b8U4WjNGGo,5164
 mplang/utils/spu_utils.py,sha256=S3L9RBkBe2AvSuMSQQ12cBY5Y1NPthubvErSX_7nj1A,4158
 mplang/utils/table_utils.py,sha256=aC-IZOKkSmFkpr3NZchLM0Wt0GOn-rg_xHBHREWBwAU,2202
-mplang_nightly-0.1.dev152.dist-info/METADATA,sha256=5Mt-R98IyuopKWLvWdxbCio3Yo8KmmmYqs92FyETS5M,16547
-mplang_nightly-0.1.dev152.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mplang_nightly-0.1.dev152.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev152.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev152.dist-info/RECORD,,
+mplang_nightly-0.1.dev153.dist-info/METADATA,sha256=4dEwwbuB0n0oRHxO09vuMY2Al57Ol8O8KdXGlDpEZqo,16547
+mplang_nightly-0.1.dev153.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mplang_nightly-0.1.dev153.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev153.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev153.dist-info/RECORD,,

mplang/runtime/resource.py

@@ -1,365 +0,0 @@
-# Copyright 2025 Ant Group Co., Ltd.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-This module provides the resource management for the HTTP backend.
-It is a simplified, in-memory version of the original executor's resource manager.
-"""
-
-import base64
-import logging
-from dataclasses import dataclass, field
-from typing import Any
-from urllib.parse import urlparse
-
-import cloudpickle as pickle
-import spu.libspu as libspu
-
-from mplang.core.expr.ast import Expr
-from mplang.core.expr.evaluator import IEvaluator, create_evaluator
-from mplang.core.mask import Mask
-from mplang.kernels.context import RuntimeContext
-from mplang.kernels.spu import PFunction  # type: ignore
-from mplang.runtime.communicator import HttpCommunicator
-from mplang.runtime.exceptions import InvalidRequestError, ResourceNotFound
-from mplang.runtime.link_comm import LinkCommunicator
-from mplang.utils.spu_utils import parse_field, parse_protocol
-
-
-class LinkCommFactory:
-    """Factory for creating and caching link communicators."""
-
-    def __init__(self) -> None:
-        self._cache: dict[tuple[int, tuple[str, ...]], LinkCommunicator] = {}
-
-    def create_link(self, rank: int, addrs: list[str]) -> LinkCommunicator:
-        key = (rank, tuple(addrs))
-        val = self._cache.get(key, None)
-        if val is not None:
-            return val
-
-        logging.info(f"LinkCommunicator created: {rank} {addrs}")
-        new_link = LinkCommunicator(rank, addrs)
-        self._cache[key] = new_link
-        return new_link
-
-
-# Global link factory instance
-g_link_factory = LinkCommFactory()
-
-
-@dataclass
-class Symbol:
-    name: str
-    mptype: Any  # More flexible type to handle dict or MPType
-    data: Any  # More flexible data type
-
-
-@dataclass
-class Computation:
-    name: str
-    expr: Expr  # The computation expression
-
-
-@dataclass
-class Session:
-    name: str
-    communicator: HttpCommunicator
-    computations: dict[str, Computation] = field(default_factory=dict)
-    symbols: dict[str, Symbol] = field(default_factory=dict)  # Session-level symbols
-
-    # spu related
-    spu_mask: int = -1
-    spu_protocol: str = "SEMI2K"
-    spu_field: str = "FM64"
-
-
-# Global session storage
-_sessions: dict[str, Session] = {}
-
-
-# Session Management
-def create_session(
-    name: str,
-    rank: int,
-    endpoints: list[str],
-    # SPU related
-    spu_mask: int = 0,
-    spu_protocol: str = "SEMI2K",
-    spu_field: str = "FM64",
-) -> Session:
-    logging.info(f"Creating session: {name}, rank: {rank}, spu_mask: {spu_mask}")
-    if name in _sessions:
-        # Return existing session (idempotent operation)
-        logging.info(f"Session {name} already exists, returning existing session")
-        return _sessions[name]
-    session = Session(
-        name, HttpCommunicator(session_name=name, rank=rank, endpoints=endpoints)
-    )
-
-    session.spu_mask = spu_mask
-    session.spu_protocol = spu_protocol
-    session.spu_field = spu_field
-
-    _sessions[name] = session
-    logging.info(f"Session {name} created successfully")
-    return session
-
-
-def get_session(name: str) -> Session | None:
-    return _sessions.get(name)
-
-
-def delete_session(name: str) -> bool:
-    """Delete a session and all associated resources.
-
-    Returns:
-        True if session was deleted, False if session was not found.
-    """
-    if name in _sessions:
-        del _sessions[name]
-        logging.info(f"Session {name} deleted successfully")
-        return True
-    return False
-
-
-# Global symbol management (process-wide, not per-session)
-_global_symbols: dict[str, Symbol] = {}
-
-
-def create_global_symbol(name: str, mptype: dict[str, Any], data_b64: str) -> Symbol:
-    """Create or replace a global symbol.
-
-    Args:
-        name: Symbol identifier
-        mptype: Metadata dict (shape/dtype, etc.)
-        data_b64: Base64-encoded pickled data
-    """
-    try:
-        raw = base64.b64decode(data_b64)
-        data = pickle.loads(raw)
-    except Exception as e:  # pragma: no cover - defensive
-        raise InvalidRequestError(f"Failed to decode symbol payload: {e}") from e
-    sym = Symbol(name=name, mptype=mptype, data=data)
-    _global_symbols[name] = sym
-    return sym
-
-
-def get_global_symbol(name: str) -> Symbol:
-    sym = _global_symbols.get(name)
-    if sym is None:
-        raise ResourceNotFound(f"Global symbol '{name}' not found")
-    return sym
-
-
-def delete_global_symbol(name: str) -> bool:
-    return _global_symbols.pop(name, None) is not None
-
-
-def list_global_symbols() -> list[str]:  # pragma: no cover - trivial
-    return sorted(_global_symbols.keys())
-
-
-# Computation Management
-def create_computation(
-    session_name: str, computation_name: str, expr: Expr
-) -> Computation:
-    """Creates a computation resource within a session."""
-    session = get_session(session_name)
-    if not session:
-        raise ResourceNotFound(f"Session '{session_name}' not found.")
-    computation = Computation(computation_name, expr)
-    session.computations[computation_name] = computation
-    logging.info(f"Computation {computation_name} created for session {session_name}")
-    return computation
-
-
-def get_computation(session_name: str, comp_name: str) -> Computation | None:
-    session = get_session(session_name)
-    if session:
-        return session.computations.get(comp_name)
-    return None
-
-
-def delete_computation(session_name: str, comp_name: str) -> bool:
-    """Delete a computation from a session.
-
-    Returns:
-        True if computation was deleted, False if not found.
-    """
-    session = get_session(session_name)
-    if not session:
-        return False
-
-    if comp_name in session.computations:
-        del session.computations[comp_name]
-        logging.info(f"Computation {comp_name} deleted from session {session_name}")
-        return True
-    return False
-
-
-def execute_computation(
-    session_name: str, comp_name: str, input_names: list[str], output_names: list[str]
-) -> None:
-    """Execute a computation using the Evaluator."""
-    session = get_session(session_name)
-    if not session:
-        raise ResourceNotFound(f"Session '{session_name}' not found.")
-
-    computation = get_computation(session_name, comp_name)
-    if not computation:
-        raise ResourceNotFound(
-            f"Computation '{comp_name}' not found in session '{session_name}'."
-        )
-
-    if not session.communicator:
-        raise InvalidRequestError(
-            f"Communicator not initialized for session '{session_name}'."
-        )
-
-    # Get rank from session communicator
-    rank = session.communicator.rank
-
-    # Prepare input bindings from session symbols
-    bindings = {}
-    for input_name in input_names:
-        symbol = get_symbol(session_name, input_name)
-        if not symbol:
-            raise ResourceNotFound(
-                f"Input symbol '{input_name}' not found in session '{session_name}'"
-            )
-        bindings[input_name] = symbol.data
-
-    spu_mask = (
-        Mask(session.spu_mask)
-        if session.spu_mask != -1
-        else Mask.all(session.communicator.world_size)
-    )
-
-    # Build evaluator
-    # Explicit per-rank backend runtime (deglobalized)
-    runtime = RuntimeContext(rank=rank, world_size=session.communicator.world_size)
-    evaluator: IEvaluator = create_evaluator(
-        rank=rank, env=bindings, comm=session.communicator, runtime=runtime
-    )
-
-    # Initialize SPU runtime state for flat kernels (once per evaluator invocation)
-    if rank in spu_mask:
-        # Build SPU address list (only once per rank; consistent ordering of participating ranks)
-        spu_addrs: list[str] = []
-        for r, addr in enumerate(session.communicator.endpoints):
-            if r in spu_mask:
-                if "://" not in addr:
-                    addr = f"//{addr}"
-                parsed = urlparse(addr)
-                assert isinstance(parsed.port, int)
-                new_addr = f"{parsed.hostname}:{parsed.port + 100}"
-                spu_addrs.append(new_addr)
-        # Determine this rank's relative index among participating ranks
-        rel_index = sum(1 for r in range(rank) if r in spu_mask)
-        link_ctx = g_link_factory.create_link(rel_index, spu_addrs)
-    else:
-        link_ctx = None
-    # Always seed config/world; provide per-rank link (may be None if not participating)
-    spu_config = libspu.RuntimeConfig(
-        protocol=parse_protocol(session.spu_protocol),
-        field=parse_field(session.spu_field),
-        fxp_fraction_bits=18,
-    )
-    # Seed SPU env via backend kernel (inside evaluator's kernel context)
-    seed_pfunc = PFunction(
-        fn_type="spu.seed_env",
-        ins_info=(),
-        outs_info=(),
-        config=spu_config,
-        world=spu_mask.num_parties(),
-        link=link_ctx,
-    )
-    # Run seeding kernel with evaluator (no inputs, no outputs)
-    evaluator.runtime.run_kernel(seed_pfunc, [])
-
-    results = evaluator.evaluate(computation.expr)
-
-    # Store results in session symbols using output_names
-    if results:
-        if len(results) != len(output_names):
-            raise RuntimeError(
-                f"Expected {len(output_names)} results, got {len(results)}"
-            )
-        for name, val in zip(output_names, results, strict=True):
-            session.symbols[name] = Symbol(name=name, mptype={}, data=val)
-
-
-# Symbol Management
-def create_symbol(session_name: str, name: str, mptype: Any, data: Any) -> Symbol:
-    """Create a symbol in a session's symbol table.
-
-    The `data` is expected to be a base64-encoded pickled Python object.
-    """
-    session = get_session(session_name)
-    if not session:
-        raise ResourceNotFound(f"Session '{session_name}' not found.")
-
-    # Deserialize base64-encoded data to Python object
-    try:
-        data_bytes = base64.b64decode(data)
-        obj = pickle.loads(data_bytes)
-    except Exception as e:
-        raise InvalidRequestError(f"Invalid symbol data encoding: {e!s}") from e
-
-    symbol = Symbol(name, mptype, obj)
-    session.symbols[name] = symbol
-    return symbol
-
-
-def get_symbol(session_name: str, name: str) -> Symbol | None:
-    """Get a symbol from a session's symbol table (session-level only)."""
-    session = get_session(session_name)
-    if not session:
-        return None
-
-    # Only session-level symbols are supported now
-    return session.symbols.get(name)
-
-
-def list_symbols(session_name: str) -> list[str]:
-    """List all symbols in a session's symbol table."""
-    session = get_session(session_name)
-    if not session:
-        raise ResourceNotFound(f"Session '{session_name}' not found.")
-
-    # Only session-level symbols are supported now
-    return list(session.symbols.keys())
-
-
-def delete_symbol(session_name: str, symbol_name: str) -> bool:
-    """Delete a symbol from a session.
-
-    Returns:
-        True if symbol was deleted, False if not found.
-    """
-    session = get_session(session_name)
-    if not session:
-        return False
-
-    if symbol_name in session.symbols:
-        del session.symbols[symbol_name]
-        logging.info(f"Symbol {symbol_name} deleted from session {session_name}")
-        return True
-    return False
-
-
-def list_all_sessions() -> list[str]:
-    """List all session names."""
-    return list(_sessions.keys())