mplang-nightly 0.1.dev330__py3-none-any.whl → 0.1.dev332__py3-none-any.whl

mplang/backends/simp_driver/mem.py

@@ -23,9 +23,10 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, cast
 
 from mplang.backends.simp_driver.state import SimpDriver
-from mplang.backends.simp_worker import WORKER_HANDLERS, SimpWorker
-from mplang.backends.simp_worker.comm_context import CommContext
+from mplang.backends.simp_worker import WORKER_HANDLERS
+from mplang.backends.simp_worker.infra import DEFAULT_ASYNC_OPS, WorkerInfra
 from mplang.backends.simp_worker.mem import LocalMesh
+from mplang.backends.simp_worker.request import create_request_interpreter
 from mplang.runtime.interpreter import ExecutionTracer, Interpreter
 from mplang.runtime.object_store import FileSystemBackend, ObjectStore
 
@@ -37,10 +38,14 @@ if TYPE_CHECKING:
 
 
 class MemCluster:
-    """Orchestrator that creates and manages local worker Interpreters.
+    """Orchestrator that creates and manages local worker infrastructure.
 
     This class handles worker lifecycle management. It does NOT attach to
     an Interpreter - instead, it creates a SimpMemDriver that can be attached.
+
+    Per-request Interpreters are created on-the-fly by ``create_request_interpreter``
+    to isolate mutable state (CommContext, SimpWorker, SPUState) across concurrent
+    requests.
     """
 
     def __init__(
@@ -75,8 +80,9 @@ class MemCluster:
         )
         self.tracer.start()
 
-        # Create Workers
-        self._workers: list[Interpreter] = []
+        # Create shared WorkerInfra per rank (replaces per-rank Interpreters)
+        self._infras: list[WorkerInfra] = []
+        self._stores: list[ObjectStore] = []
         for rank in range(world_size):
             worker_root = cluster_root / f"node{rank}"
             store = ObjectStore(
@@ -84,60 +90,50 @@ class MemCluster:
                     root_path=str(worker_root / "store"),
                 )
             )
+            self._stores.append(store)
 
-            worker_state = SimpWorker(
+            w_handlers: dict[str, Callable[..., Any]] = {**WORKER_HANDLERS}  # type: ignore[dict-item]
+            infra = WorkerInfra(
                 rank=rank,
                 world_size=world_size,
                 communicator=self._mesh.comms[rank],
                 store=store,
-            )
-
-            w_handlers: dict[str, Callable[..., Any]] = {**WORKER_HANDLERS}  # type: ignore[dict-item]
-            comm_ctx = CommContext(
-                self._mesh.comms[rank],
-                context_id="ctx",
-                my_rank=rank,
-            )
-            w_interp = Interpreter(
-                name=f"Worker-{rank}",
+                handlers=w_handlers,
                 tracer=self.tracer,
                 trace_pid=rank,
-                store=store,
                 root_dir=worker_root,
-                handlers=w_handlers,
-                comm_ctx=comm_ctx,
+                # async_ops has no effect when executor is None (MemCluster
+                # runs each request synchronously on the mesh executor thread).
+                # We still set it so that WorkerInfra carries the canonical set
+                # for introspection and consistency with the HTTP Worker path.
+                async_ops=DEFAULT_ASYNC_OPS,
             )
-            w_interp.set_dialect_state("simp", worker_state)
-
-            w_interp.async_ops = {
-                "bfv.add",
-                "bfv.mul",
-                "bfv.rotate",
-                "bfv.batch_encode",
-                "bfv.relinearize",
-                "bfv.encrypt",
-                "bfv.decrypt",
-                "field.solve_okvs",
-                "field.decode_okvs",
-                "field.aes_expand",
-                "field.mul",
-                "simp.shuffle",
-            }
-            self._workers.append(w_interp)
+            self._infras.append(infra)
 
     @property
     def world_size(self) -> int:
         return self._world_size
 
     @property
-    def workers(self) -> list[Interpreter]:
-        return self._workers
+    def infras(self) -> list[WorkerInfra]:
+        return self._infras
+
+    @property
+    def workers(self) -> list[WorkerInfra]:
+        """Backward-compatible alias for ``infras``.
+
+        .. note:: Returns ``WorkerInfra`` objects (not ``Interpreter``).  Only
+           the ``.store`` attribute is guaranteed by this interface.  Callers
+           needing full Interpreter access should use
+           ``create_request_interpreter(infra, job_id)`` instead.
+        """
+        return self._infras
 
     def create_state(self) -> SimpMemDriver:
         """Create a SimpMemDriver that can be attached to a Driver Interpreter."""
         return SimpMemDriver(
             world_size=self._world_size,
-            workers=self._workers,
+            infras=self._infras,
             mesh=self._mesh,
         )
 
@@ -158,11 +154,11 @@ class SimpMemDriver(SimpDriver):
     def __init__(
         self,
         world_size: int,
-        workers: list[Interpreter],
+        infras: list[WorkerInfra],
         mesh: Any,  # LocalMesh from simp_worker.mem
     ) -> None:
         self._world_size = world_size
-        self._workers = workers
+        self._infras = infras
         self._mesh = mesh
 
     def shutdown(self) -> None:
@@ -174,9 +170,18 @@ class SimpMemDriver(SimpDriver):
         return self._world_size
 
     @property
-    def workers(self) -> list[Interpreter]:
-        """Worker interpreters (for backward compatibility)."""
-        return self._workers
+    def infras(self) -> list[WorkerInfra]:
+        """Worker infrastructure (shared, immutable)."""
+        return self._infras
+
+    @property
+    def workers(self) -> list[WorkerInfra]:
+        """Backward-compatible alias for ``infras``.
+
+        .. note:: Returns ``WorkerInfra`` objects (not ``Interpreter``).  Only
+           the ``.store`` attribute is guaranteed by this interface.
+        """
+        return self._infras
 
     def submit(
         self, rank: int, graph: Graph, inputs: list[Any], job_id: str | None = None
@@ -205,31 +210,32 @@ class SimpMemDriver(SimpDriver):
 
     def fetch(self, rank: int, uri: str) -> Future[Any]:
         """Fetch directly from worker store."""
-        worker = self._workers[rank]
-        worker_ctx = cast(SimpWorker, worker.get_dialect_state("simp"))
-        return self._mesh.executor.submit(lambda: worker_ctx.store.get(uri))  # type: ignore[no-any-return]
+        infra = self._infras[rank]
+        return self._mesh.executor.submit(lambda: infra.store.get(uri))  # type: ignore[no-any-return]
 
     def _run_worker(
         self, rank: int, graph: Graph, inputs: list[Any], job_id: str | None = None
     ) -> Any:
-        """Execute on worker interpreter."""
-        worker_interp = self._workers[rank]
-        worker_ctx = cast(SimpWorker, worker_interp.get_dialect_state("simp"))
-
-        # Resolve URI inputs (None means rank has no data)
-        resolved_inputs = [
-            worker_ctx.store.get(inp) if inp is not None else None for inp in inputs
-        ]
-
-        # Execute
-        results = worker_interp.evaluate_graph(graph, resolved_inputs, job_id)
-
-        # Store results (results is always a list)
-        if not graph.outputs:
-            return None
-        return [
-            worker_ctx.store.put(res) if res is not None else None for res in results
-        ]
+        """Execute on a per-request Interpreter."""
+        infra = self._infras[rank]
+        request_interp = create_request_interpreter(infra, job_id or "anonymous")
+        try:
+            # Resolve URI inputs (None means rank has no data)
+            resolved_inputs = [
+                infra.store.get(inp) if inp is not None else None for inp in inputs
+            ]
+
+            # Execute
+            results = request_interp.evaluate_graph(graph, resolved_inputs, job_id)
+
+            # Store results (results is always a list)
+            if not graph.outputs:
+                return None
+            return [
+                infra.store.put(res) if res is not None else None for res in results
+            ]
+        finally:
+            request_interp.shutdown()
 
 
 def make_simulator(

mplang/backends/simp_worker/__init__.py

@@ -38,11 +38,14 @@ from mplang.backends.simp_worker.http import (
     RecvTimeoutError,
     SendTimeoutError,
 )
+from mplang.backends.simp_worker.infra import DEFAULT_ASYNC_OPS, WorkerInfra
 from mplang.backends.simp_worker.mem import LocalMesh, ThreadCommunicator
 from mplang.backends.simp_worker.ops import WORKER_HANDLERS
+from mplang.backends.simp_worker.request import create_request_interpreter
 from mplang.backends.simp_worker.state import SimpWorker
 
 __all__ = [
+    "DEFAULT_ASYNC_OPS",
     "WORKER_HANDLERS",
     "CommConfig",
     "CommStats",
@@ -56,6 +59,8 @@ __all__ = [
     "SendTimeoutError",
     "SimpWorker",
     "ThreadCommunicator",
+    "WorkerInfra",
+    "create_request_interpreter",
     "testall",
     "testany",
     "wait_all",

mplang/backends/simp_worker/comm_context.py

@@ -62,15 +62,25 @@ class CommContext:
     def world_size(self) -> int:
         return self._comm.world_size
 
-    def spawn(self) -> CommContext:
+    def spawn(self, suffix: str | None = None) -> CommContext:
         """Create a child context with independent counter namespace.
 
-        Child ``context_id = f"{parent_id}.{spawn_seq}"``.  ``spawn_seq``
-        increments in the calling thread's order, so if all ranks call
-        ``spawn()`` in the same program-order position, children get matching
-        IDs across ranks.
+        Args:
+            suffix: Explicit suffix for the child context ID.  When provided,
+                ``context_id = f"{parent_id}.{suffix}"``.  This is used when
+                the caller needs a deterministic, content-based ID that is
+                stable across ranks regardless of call order (e.g. the async
+                DAG scheduler uses ``f"{graph_exec_key}.{op_idx}"``).
+
+                When *None* (default), an auto-incrementing counter is used:
+                ``context_id = f"{parent_id}.{spawn_seq}"``.  This is suitable
+                for SPMD code where all ranks call ``spawn()`` in the same
+                program-order position.
         """
-        child_id = f"{self._id}.{self._spawn_counter}"
+        if suffix is None:
+            child_id = f"{self._id}.{self._spawn_counter}"
+        else:
+            child_id = f"{self._id}.{self._spawn_counter}.{suffix}"
         self._spawn_counter += 1
         return CommContext(self._comm, child_id, self._rank)
 

mplang/backends/simp_worker/http.py

@@ -61,10 +61,10 @@ from mplang.backends.simp_worker.base import (
     wait_all,
     wait_any,
 )
-from mplang.backends.simp_worker.state import SimpWorker
+from mplang.backends.simp_worker.infra import WorkerInfra
 from mplang.edsl import serde
 from mplang.edsl.graph import Graph
-from mplang.runtime.interpreter import ExecutionTracer, Interpreter
+from mplang.runtime.interpreter import ExecutionTracer
 from mplang.runtime.object_store import FileSystemBackend, ObjectStore
 from mplang.utils.logging import get_logger
 
@@ -636,7 +636,7 @@ def register_routes(
     *,
     rank: int,
     world_size: int,
-    worker: Interpreter,
+    infra: WorkerInfra,
     comm: HttpCommunicator,
     store: ObjectStore,
     exec_pool: concurrent.futures.ThreadPoolExecutor,
@@ -648,36 +648,38 @@ def register_routes(
     enabling reuse in custom server setups.
 
     Note:
-        The *worker* ``Interpreter`` must have the ``"simp"`` dialect state
-        registered (via ``worker.set_dialect_state("simp", ctx)``) before
-        any request is served, as the ``/fetch`` and ``/objects`` endpoints
-        rely on it.
+        The *infra* ``WorkerInfra`` contains all shared infrastructure needed
+        to create per-request Interpreters.
 
     Args:
         app: The FastAPI application to register routes on.
         rank: This worker's rank.
         world_size: Total number of workers.
-        worker: The Interpreter instance for graph execution.
+        infra: The WorkerInfra for creating per-request Interpreters.
         comm: The HttpCommunicator for inter-worker communication.
         store: The ObjectStore for data persistence.
         exec_pool: Thread pool for executing graphs.
     """
-    from typing import cast
+    from mplang.backends.simp_worker.request import create_request_interpreter
 
     def _do_execute(graph: Graph, inputs: list[Any], job_id: str | None = None) -> Any:
-        """Execute graph in worker thread."""
-        # Resolve URI inputs (None means rank has no data)
-        resolved_inputs = [
-            store.get(inp) if inp is not None else None for inp in inputs
-        ]
+        """Execute graph in worker thread with per-request isolation."""
+        request_interp = create_request_interpreter(infra, job_id or "anonymous")
+        try:
+            # Resolve URI inputs (None means rank has no data)
+            resolved_inputs = [
+                store.get(inp) if inp is not None else None for inp in inputs
+            ]
 
-        result = worker.evaluate_graph(graph, resolved_inputs)
-        comm.wait_pending_sends()
+            result = request_interp.evaluate_graph(graph, resolved_inputs, job_id)
+            comm.wait_pending_sends()
 
-        # Store results and return URIs (result is always a list)
-        if not graph.outputs:
-            return None
-        return [store.put(res) if res is not None else None for res in result]
+            # Store results and return URIs (result is always a list)
+            if not graph.outputs:
+                return None
+            return [store.put(res) if res is not None else None for res in result]
+        finally:
+            request_interp.shutdown()
 
     # Mutable closure state shared between endpoint handlers and exec_pool threads.
     async_tasks: dict[str, AsyncTaskState] = {}
@@ -845,8 +847,7 @@ def register_routes(
         """Fetch data by URI (e.g. ``mem://abc123``, ``fs://ckpt/s100``)."""
         logger.debug(f"Worker {rank} received fetch request for {req.uri}")
         try:
-            state = cast(SimpWorker, worker.get_dialect_state("simp"))
-            val = state.store.get(req.uri)
+            val = store.get(req.uri)
             return {"result": serde.dumps_b64(val)}
         except Exception as e:
             logger.error(f"Worker {rank} fetch failed: {e}")
@@ -856,8 +857,7 @@ def register_routes(
     def list_objects() -> dict[str, list[str]]:
         """List all objects in the worker's store (transient + persistent)."""
         try:
-            state = cast(SimpWorker, worker.get_dialect_state("simp"))
-            return {"objects": state.store.list_keys()}
+            return {"objects": store.list_keys()}
         except Exception as e:
             logger.error(f"Worker {rank} list_objects failed: {e}")
             raise HTTPException(status_code=500, detail=str(e)) from e
@@ -917,22 +917,22 @@ def create_worker_app(
     comm = HttpCommunicator(rank, world_size, endpoints, tracer=tracer)
     if store is None:
         store = ObjectStore(persistent=FileSystemBackend(root_path=str(root_dir)))
-    ctx = SimpWorker(rank, world_size, comm, store, spu_endpoints)
 
     handlers: dict[str, Callable[..., Any]] = {**WORKER_HANDLERS}  # type: ignore[dict-item]
 
-    from mplang.backends.simp_worker.comm_context import CommContext
+    from mplang.backends.simp_worker.infra import DEFAULT_ASYNC_OPS, WorkerInfra
 
-    comm_ctx = CommContext(comm, context_id="ctx", my_rank=rank)
-    worker = Interpreter(
+    infra = WorkerInfra(
+        rank=rank,
+        world_size=world_size,
+        communicator=comm,
+        store=store,
+        handlers=handlers,
+        spu_endpoints=spu_endpoints,
         tracer=tracer,
         root_dir=root_dir,
-        handlers=handlers,
-        store=store,
-        comm_ctx=comm_ctx,
+        async_ops=DEFAULT_ASYNC_OPS,
     )
-    # Register SimpWorker context as 'simp' dialect state
-    worker.set_dialect_state("simp", ctx)
 
     exec_pool = concurrent.futures.ThreadPoolExecutor(
         max_workers=2, thread_name_prefix=f"exec_{rank}"
@@ -941,7 +941,7 @@ def create_worker_app(
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         yield
-        await asyncio.to_thread(worker.shutdown)
+        await asyncio.to_thread(infra.shutdown)
         await asyncio.to_thread(comm.shutdown)
         await asyncio.to_thread(exec_pool.shutdown, wait=True)
 
@@ -951,7 +951,7 @@ def create_worker_app(
         app,
         rank=rank,
         world_size=world_size,
-        worker=worker,
+        infra=infra,
         comm=comm,
         store=store,
         exec_pool=exec_pool,

mplang/backends/simp_worker/infra.py

@@ -0,0 +1,108 @@
+# Copyright 2026 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.
+
+"""WorkerInfra: shared infrastructure container for per-request Interpreter creation.
+
+Created once at Worker startup. Passed to ``create_request_interpreter()`` for
+each incoming request. All fields are either immutable or thread-safe.
+"""
+
+from __future__ import annotations
+
+import concurrent.futures
+import pathlib
+import threading
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from mplang.backends.simp_worker.base import CommunicatorProtocol
+from mplang.runtime.interpreter import ExecutionTracer
+from mplang.runtime.object_store import ObjectStore
+
+# Opcodes eligible for async DAG scheduling when an Executor is present.
+# Kept as a module-level constant so that both MemCluster and HTTP Worker
+# share the same set without duplication.
+DEFAULT_ASYNC_OPS: frozenset[str] = frozenset({
+    "bfv.add",
+    "bfv.mul",
+    "bfv.rotate",
+    "bfv.batch_encode",
+    "bfv.relinearize",
+    "bfv.encrypt",
+    "bfv.decrypt",
+    "field.solve_okvs",
+    "field.decode_okvs",
+    "field.aes_expand",
+    "field.mul",
+    "simp.shuffle",
+})
+
+
+@dataclass
+class WorkerInfra:
+    """Shared infrastructure for a Worker process.
+
+    Created once at Worker startup. Passed to each per-request Interpreter
+    factory. All fields are either immutable or thread-safe.
+    """
+
+    rank: int
+    world_size: int
+    communicator: CommunicatorProtocol
+    store: ObjectStore
+    handlers: dict[str, Callable[..., Any]]
+    spu_endpoints: dict[int, str] | None = None
+    tracer: ExecutionTracer | None = None
+    trace_pid: int | None = None
+    root_dir: pathlib.Path | None = None
+    executor: concurrent.futures.Executor | None = None
+    async_ops: frozenset[str] = field(default_factory=frozenset)
+
+    # SPU template links (lazily populated, protected by lock).
+    # Cache keys are (local_rank, spu_world_size, protocol, field, link_mode).
+    # The number of distinct keys is bounded by the Cartesian product of SPU
+    # configurations actually used at runtime -- typically 1-3 entries per
+    # worker process (one per distinct SPU device declaration).
+    _spu_lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
+    _spu_template_links: dict[tuple, Any] = field(default_factory=dict, repr=False)
+
+    def get_or_create_spu_link(
+        self,
+        cache_key: tuple,
+        create_fn: Callable[[], Any],
+    ) -> Any:
+        """Thread-safe lazy creation of template SPU links.
+
+        Args:
+            cache_key: Tuple identifying the SPU configuration.
+            create_fn: Factory function to create a new link context.
+
+        Returns:
+            A libspu.link.Context (template link) for the given configuration.
+        """
+        with self._spu_lock:
+            if cache_key not in self._spu_template_links:
+                self._spu_template_links[cache_key] = create_fn()
+            return self._spu_template_links[cache_key]
+
+    def shutdown(self) -> None:
+        """Release cached SPU template links.
+
+        Safe to call multiple times.  Should be called during process
+        shutdown to eagerly close BRPC connections rather than waiting
+        for GC / process exit.
+        """
+        with self._spu_lock:
+            self._spu_template_links.clear()

mplang/backends/simp_worker/request.py

@@ -0,0 +1,80 @@
+# Copyright 2026 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.
+
+"""Per-request Interpreter factory.
+
+Creates lightweight Interpreter instances for each incoming request,
+providing full isolation of mutable state (CommContext, SimpWorker,
+SPUState) while sharing immutable infrastructure (Communicator, Store,
+handlers).
+"""
+
+from __future__ import annotations
+
+from mplang.backends.simp_worker.comm_context import CommContext
+from mplang.backends.simp_worker.infra import WorkerInfra
+from mplang.backends.simp_worker.state import SimpWorker
+from mplang.backends.spu_state import SPUState
+from mplang.runtime.interpreter import Interpreter
+
+
+def create_request_interpreter(
+    infra: WorkerInfra,
+    job_id: str,
+) -> Interpreter:
+    """Create a lightweight Interpreter for a single request.
+
+    Cost: ~2μs (dict/TLS allocation only).
+    SPU Runtime created on-demand via link.spawn() (~120μs).
+
+    Args:
+        infra: Shared WorkerInfra (process-lifetime).
+        job_id: Unique request identifier (used as CommContext context_id).
+
+    Returns:
+        Per-request Interpreter with isolated state.
+    """
+    # Per-request CommContext with unique context_id
+    comm_ctx = CommContext(infra.communicator, context_id=job_id, my_rank=infra.rank)
+
+    # Per-request Interpreter (does not own shared executor/tracer)
+    interp = Interpreter(
+        name=f"Worker-{infra.rank}-{job_id}",
+        tracer=infra.tracer,
+        trace_pid=infra.trace_pid,
+        store=infra.store,
+        root_dir=infra.root_dir,
+        handlers=infra.handlers,
+        executor=infra.executor,
+        comm_ctx=comm_ctx,
+        owns_executor=False,
+        owns_tracer=False,
+    )
+    interp.async_ops = set(infra.async_ops)
+
+    # Per-request SimpWorker: isolates current_parties
+    worker_state = SimpWorker(
+        rank=infra.rank,
+        world_size=infra.world_size,
+        communicator=infra.communicator,  # raw comm kept for SPU BaseChannel
+        store=infra.store,
+        spu_endpoints=infra.spu_endpoints,
+    )
+    interp.set_dialect_state("simp", worker_state)
+
+    # Per-request SPUState: will use link.spawn() for Runtime isolation
+    spu_state = SPUState(infra=infra)
+    interp.set_dialect_state("spu", spu_state)
+
+    return interp

mplang/backends/spu_state.py

@@ -28,6 +28,7 @@ import spu.libspu as libspu
 from mplang.runtime.dialect_state import DialectState
 
 if TYPE_CHECKING:
+    from mplang.backends.simp_worker.infra import WorkerInfra
     from mplang.dialects import spu
 
 
@@ -37,18 +38,61 @@ class SPUState(DialectState):
     Caches SPU Runtime and Io objects per (local_rank, world_size, config, link_mode)
     to enable reuse across multiple SPU kernel executions.
 
+    When created with a ``WorkerInfra`` reference (per-request mode), template
+    links are obtained from the shared infra (thread-safe) and then spawned
+    via ``link.spawn()`` for per-request isolation.
+
     This replaces the previous global `_SPU_RUNTIMES` cache with a properly
     lifecycle-managed dialect state.
     """
 
     dialect_name: str = "spu"
 
-    def __init__(self) -> None:
-        # Key: (local_rank, world_size, protocol, field, link_mode)
+    def __init__(self, infra: WorkerInfra | None = None) -> None:
+        # Optional shared infrastructure (for per-request isolation via link.spawn)
+        self._infra = infra
+        # Key: (local_rank, world_size, protocol, field, link_mode, spu_endpoints)
         # Value: (Runtime, Io)
         self._runtimes: dict[
-            tuple[int, int, str, str, str], tuple[spu_api.Runtime, spu_api.Io]
+            tuple[int, int, str, str, str, tuple[str, ...] | None],
+            tuple[spu_api.Runtime, spu_api.Io],
         ] = {}
+        # Local template link cache (used when no WorkerInfra is provided)
+        self._template_links: dict[tuple, libspu.link.Context] = {}
+
+    def _get_template_link(
+        self,
+        cache_key: tuple,
+        local_rank: int,
+        spu_world_size: int,
+        communicator: object | None,
+        parties: list[int] | None,
+        spu_endpoints: list[str] | None,
+    ) -> libspu.link.Context:
+        """Get or create a template link for the given configuration.
+
+        With ``WorkerInfra``: uses infra's thread-safe shared cache.
+        Without: uses a local (non-thread-safe) cache on this SPUState.
+        """
+
+        def _create() -> libspu.link.Context:
+            if spu_endpoints:
+                return self._create_brpc_link(local_rank, spu_endpoints)
+            elif communicator is not None:
+                if parties is None:
+                    raise ValueError("parties required when using communicator")
+                return self._create_channels_link(
+                    local_rank, spu_world_size, communicator, parties
+                )
+            else:
+                return self._create_mem_link(local_rank, spu_world_size)
+
+        if self._infra is not None:
+            return self._infra.get_or_create_spu_link(cache_key, _create)
+
+        if cache_key not in self._template_links:
+            self._template_links[cache_key] = _create()
+        return self._template_links[cache_key]
 
     def get_or_create(
         self,
@@ -61,13 +105,18 @@ class SPUState(DialectState):
     ) -> tuple[spu_api.Runtime, spu_api.Io]:
         """Get or create SPU Runtime and Io for the given configuration.
 
+        Link mode priority: spu_endpoints (BRPC) > communicator (Channels) > mem.
+        When ``spu_endpoints`` is provided it always takes precedence, even if
+        a ``communicator`` is also supplied.
+
         Args:
             local_rank: The local rank within the SPU device (0-indexed).
             spu_world_size: The number of parties in the SPU device.
             config: SPU configuration including protocol settings.
-            spu_endpoints: Optional list of BRPC endpoints. If None, use mem link.
+            spu_endpoints: Optional list of BRPC endpoints. Takes highest
+                priority when provided.
             communicator: Optional v2 communicator (ThreadCommunicator/HttpCommunicator).
-                If provided, use Channels mode to reuse existing communication.
+                Used only when ``spu_endpoints`` is not provided.
             parties: Optional list of global ranks for SPU parties.
                 Required when communicator is provided.
 
@@ -77,10 +126,10 @@ class SPUState(DialectState):
         from mplang.backends.spu_impl import to_runtime_config
 
         # Determine link mode
-        if communicator is not None:
-            link_mode = "channels"
-        elif spu_endpoints:
+        if spu_endpoints:
             link_mode = "brpc"
+        elif communicator is not None:
+            link_mode = "channels"
         else:
             link_mode = "mem"
 
@@ -90,22 +139,22 @@ class SPUState(DialectState):
             config.protocol,
             config.field,
             link_mode,
+            tuple(spu_endpoints) if spu_endpoints else None,
         )
 
         if cache_key in self._runtimes:
             return self._runtimes[cache_key]
 
-        # Create Link
-        if communicator is not None:
-            if parties is None:
-                raise ValueError("parties required when using communicator")
-            link = self._create_channels_link(
-                local_rank, spu_world_size, communicator, parties
-            )
-        elif spu_endpoints:
-            link = self._create_brpc_link(local_rank, spu_endpoints)
-        else:
-            link = self._create_mem_link(local_rank, spu_world_size)
+        # Unified path: get-or-create template link, then spawn for isolation
+        template_link = self._get_template_link(
+            cache_key,
+            local_rank,
+            spu_world_size,
+            communicator,
+            parties,
+            spu_endpoints,
+        )
+        link = template_link.spawn()
 
         # Create Runtime and Io
         runtime_config = to_runtime_config(config)
@@ -183,5 +232,6 @@ class SPUState(DialectState):
         return libspu.link.create_brpc(desc, local_rank)
 
     def shutdown(self) -> None:
-        """Clear all cached runtimes."""
+        """Clear all cached runtimes and template links."""
         self._runtimes.clear()
+        self._template_links.clear()

mplang/runtime/interpreter.py

@@ -24,7 +24,6 @@ from __future__ import annotations
 
 import collections
 import concurrent.futures
-import contextlib
 import hashlib
 import json
 import os
@@ -32,7 +31,7 @@ import pathlib
 import queue
 import threading
 import time
-from collections.abc import Callable, Iterator
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, cast
 
 from mplang.edsl.context import AbstractInterpreter
@@ -427,6 +426,9 @@ class Interpreter(AbstractInterpreter):
         root_dir: str | pathlib.Path | None = None,
         handlers: dict[str, Callable[..., Any]] | None = None,
         comm_ctx: CommContext | None = None,
+        *,
+        owns_executor: bool = True,
+        owns_tracer: bool = True,
     ) -> None:
         # Persistence Root
         self.root_dir = (
@@ -457,26 +459,6 @@ class Interpreter(AbstractInterpreter):
         #    all sibling outputs are cached here to avoid re-execution.
         self._execution_cache: dict[Any, InterpObject] = {}
 
-        # -----------------------------------------------------------------
-        # Graph-local op execution ids (for deterministic communication tags)
-        # -----------------------------------------------------------------
-        # We assign a monotonically increasing exec_id to each op execution
-        # within a graph namespace, and keep it deterministic across parties.
-        #
-        # IMPORTANT:
-        # - We intentionally make exec_id grow across repeated executions of the
-        #   same region graph (e.g., while_loop iterations) to avoid tag/key reuse.
-        #
-        # Implementation:
-        # - Each evaluate_graph(graph, ...) reserves a contiguous exec_id range
-        #   [base, base + len(graph.operations)).
-        # - Op exec_id = base + op_index_in_graph.
-        # - Reservation is persisted per graph_exec_key (structural hash).
-        # - We forbid concurrent execution of the same graph_hash to avoid
-        #   message tag confusion when a backend uses only per-op tags.
-        self._exec_id_lock = threading.Lock()
-        self._graph_next_exec_base: dict[str, int] = {}
-        self._active_graph_exec_keys: set[str] = set()
         self._tls = threading.local()
         self.executor = executor
         self.async_ops: set[str] = set()
@@ -484,45 +466,16 @@ class Interpreter(AbstractInterpreter):
         self.trace_pid = trace_pid
         self.store: ObjectStore | None = store
         self.comm_ctx = comm_ctx
-
-    @contextlib.contextmanager
-    def _tls_exec_context(
-        self,
-        *,
-        graph_exec_key: str | None = None,
-        op_exec_id: int | None = None,
-    ) -> Iterator[None]:
-        """Temporarily set execution context in thread-local storage."""
-
-        prev_graph_key = getattr(self._tls, "current_graph_exec_key", None)
-        prev_exec_id = getattr(self._tls, "current_op_exec_id", None)
-
-        if graph_exec_key is not None:
-            self._tls.current_graph_exec_key = graph_exec_key
-        if op_exec_id is not None:
-            self._tls.current_op_exec_id = op_exec_id
-
-        try:
-            yield
-        finally:
-            if graph_exec_key is not None:
-                if prev_graph_key is None:
-                    delattr(self._tls, "current_graph_exec_key")
-                else:
-                    self._tls.current_graph_exec_key = prev_graph_key
-
-            if op_exec_id is not None:
-                if prev_exec_id is None:
-                    delattr(self._tls, "current_op_exec_id")
-                else:
-                    self._tls.current_op_exec_id = prev_exec_id
+        # Ownership flags: when False, shutdown() skips releasing these
+        # shared resources.  Per-request Interpreters set these to False.
+        self._owns_executor = owns_executor
+        self._owns_tracer = owns_tracer
 
     def _graph_exec_key(self, graph: Graph) -> str:
         """Return a deterministic, structural hash for a graph.
 
         Used for:
-        - Namespacing per-graph exec_id counters
-        - Communication tag disambiguation (worker ops may include this key)
+        - Communication tag disambiguation in async child CommContext IDs
 
         Note: we cache on the Graph object assuming graphs are immutable during
         execution (finalized graphs / regions).
@@ -657,20 +610,20 @@ class Interpreter(AbstractInterpreter):
 
         This method is idempotent and safe to call multiple times.
         It performs the following cleanup:
-        1. Shuts down the internal executor (if any).
-        2. Stops the execution tracer (if any).
+        1. Shuts down the internal executor (if owned).
+        2. Stops the execution tracer (if owned).
         3. Shuts down any attached dialect states (e.g., stopping drivers).
         """
         logger.info("Shutting down Interpreter '%s'", self.name)
 
-        # 1. Shutdown Executor
-        if self.executor:
+        # 1. Shutdown Executor (only if we own it)
+        if self.executor and self._owns_executor:
             logger.debug("Shutting down executor")
             self.executor.shutdown(wait=True)
             self.executor = None
 
-        # 2. Stop Tracer
-        if self.tracer:
+        # 2. Stop Tracer (only if we own it)
+        if self.tracer and self._owns_tracer:
             logger.debug("Stopping execution tracer")
             self.tracer.stop()
             # Don't clear self.tracer, as we might want to read stats later
@@ -923,70 +876,18 @@ class Interpreter(AbstractInterpreter):
         Returns:
             List of runtime execution results corresponding to graph.outputs.
         """
-        graph_exec_key = self._graph_exec_key(graph)
-
-        # Prevent concurrent execution of the same graph hash.
-        with self._exec_id_lock:
-            if graph_exec_key in self._active_graph_exec_keys:
-                raise RuntimeError(
-                    "Concurrent execution of the same graph is not allowed. "
-                    f"graph_exec_key={graph_exec_key}"
-                )
-            self._active_graph_exec_keys.add(graph_exec_key)
-
-        try:
-            with self._tls_exec_context(graph_exec_key=graph_exec_key):
-                logger.debug(
-                    "Evaluating graph: %d inputs, %d ops, %d outputs (job_id=%s, async=%s, graph_key=%s)",
-                    len(inputs),
-                    len(graph.operations),
-                    len(graph.outputs),
-                    job_id,
-                    self.executor is not None,
-                    graph_exec_key,
-                )
-                if self.executor:
-                    return self._evaluate_graph_async(graph, inputs, job_id)
-                else:
-                    return self._evaluate_graph_sync(graph, inputs, job_id)
-        finally:
-            with self._exec_id_lock:
-                self._active_graph_exec_keys.discard(graph_exec_key)
-
-    def _reserve_op_exec_base(self, graph: Graph) -> int:
-        """Reserve a contiguous exec_id range for a single evaluate_graph call.
-
-        Counter is namespaced by the current graph_exec_key.
-        """
-        key = self.current_graph_exec_key()
-        with self._exec_id_lock:
-            base = self._graph_next_exec_base.get(key, 0)
-            self._graph_next_exec_base[key] = base + len(graph.operations)
-        return base
-
-    def current_graph_exec_key(self) -> str:
-        """Return current graph execution key during evaluate_graph execution."""
-
-        key = getattr(self._tls, "current_graph_exec_key", None)
-        if key is None:
-            raise RuntimeError(
-                "current_graph_exec_key() called outside of evaluate_graph execution"
-            )
-        return cast(str, key)
-
-    def current_op_exec_id(self) -> int:
-        """Return current op exec_id during graph execution.
-
-        Worker-side implementations can use this to build deterministic,
-        unique communication tags without coupling to any specific op.
-        """
-
-        exec_id = getattr(self._tls, "current_op_exec_id", None)
-        if exec_id is None:
-            raise RuntimeError(
-                "current_op_exec_id() called outside of evaluate_graph execution"
-            )
-        return cast(int, exec_id)
+        logger.debug(
+            "Evaluating graph: %d inputs, %d ops, %d outputs (job_id=%s, async=%s)",
+            len(inputs),
+            len(graph.operations),
+            len(graph.outputs),
+            job_id,
+            self.executor is not None,
+        )
+        if self.executor:
+            return self._evaluate_graph_async(graph, inputs, job_id)
+        else:
+            return self._evaluate_graph_sync(graph, inputs, job_id)
 
     def current_comm_ctx(self) -> CommContext:
         """Return the current CommContext for this execution.
@@ -1043,10 +944,7 @@ class Interpreter(AbstractInterpreter):
         # Build consumer counts for intermediate value GC
         remaining_consumers = self._build_value_gc_info(graph)
 
-        op_exec_base = self._reserve_op_exec_base(graph)
-
-        for op_index, op in enumerate(graph.operations):
-            exec_id = op_exec_base + op_index
+        for _op_index, op in enumerate(graph.operations):
             # Resolve inputs
             try:
                 args = [env[val] for val in op.inputs]
@@ -1070,16 +968,15 @@ class Interpreter(AbstractInterpreter):
             if not handler:
                 handler = get_impl(op.opcode)
 
-            with self._tls_exec_context(op_exec_id=exec_id):
-                if handler:
-                    # Pass interpreter to support recursive execution (HOFs)
-                    # Pass op to access attributes and regions
-                    # Pass args as runtime values
-                    results = handler(self, op, *args)
-                else:
-                    raise NotImplementedError(
-                        f"No implementation registered for opcode: {op.opcode}"
-                    )
+            if handler:
+                # Pass interpreter to support recursive execution (HOFs)
+                # Pass op to access attributes and regions
+                # Pass args as runtime values
+                results = handler(self, op, *args)
+            else:
+                raise NotImplementedError(
+                    f"No implementation registered for opcode: {op.opcode}"
+                )
 
             # Update environment with outputs
             # Handler should return a single value or a tuple/list of values
@@ -1120,8 +1017,7 @@ class Interpreter(AbstractInterpreter):
         self, graph: Graph, inputs: list[Any], job_id: str | None = None
     ) -> list[Any]:
         """Asynchronous execution with non-blocking DAG scheduling."""
-        graph_exec_key = self.current_graph_exec_key()
-        op_exec_base = self._reserve_op_exec_base(graph)
+        graph_exec_key = self._graph_exec_key(graph)
         op_to_index = {op: i for i, op in enumerate(graph.operations)}
 
         # CommContext for this execution scope
@@ -1219,8 +1115,6 @@ class Interpreter(AbstractInterpreter):
             # Extract args from env (must be ready)
             args = [env[val] for val in op.inputs]
 
-            exec_id = op_exec_base + op_to_index[op]
-
             handler = self.handlers.get(op.opcode)
             if not handler:
                 handler = get_impl(op.opcode)
@@ -1230,20 +1124,17 @@ class Interpreter(AbstractInterpreter):
                     f"No implementation registered for opcode: {op.opcode}"
                 )
 
-            # Use the op's fixed index in the graph together with the
-            # current graph execution key to derive a deterministic child
-            # context ID.  This keeps IDs stable across ranks for the same
-            # execution while preventing collisions between concurrent
-            # evaluate_graph runs.
+            # Derive a deterministic child CommContext ID for this op.
+            # We include graph_exec_key (structural hash of the graph) to prevent
+            # op_idx collisions between *different nested graphs* within the same
+            # request.  For example, two simp.pcall_static ops in the same parent
+            # graph each trigger a sub-graph execution — without graph_exec_key,
+            # their child ops at the same positional index would share the same
+            # CommContext ID and corrupt each other's messages.
+            # Cross-request isolation is already handled by root context_id (= job_id).
             op_idx = op_to_index[op]
             if root_comm_ctx is not None:
-                from mplang.backends.simp_worker.comm_context import CommContext
-
-                child_ctx: CommContext | None = CommContext(
-                    root_comm_ctx._comm,
-                    f"{root_comm_ctx._id}.{graph_exec_key}.{op_idx}",
-                    root_comm_ctx._rank,
-                )
+                child_ctx = root_comm_ctx.spawn(suffix=f"{graph_exec_key}.{op_idx}")
             else:
                 child_ctx = None
 
@@ -1254,17 +1145,14 @@ class Interpreter(AbstractInterpreter):
 
                 # Submit to executor
                 def task() -> Any:
-                    with self._tls_exec_context(
-                        graph_exec_key=graph_exec_key, op_exec_id=exec_id
-                    ):
-                        if child_ctx is not None:
-                            self._tls.comm_ctx = child_ctx
-                        start_ts = tracer.log_start(
-                            op, pid=self.trace_pid, namespace=self.trace_pid
-                        )
-                        res = handler(self, op, *args)
-                        tracer.log_end(op, start_ts, pid=self.trace_pid)
-                        return res
+                    if child_ctx is not None:
+                        self._tls.comm_ctx = child_ctx
+                    start_ts = tracer.log_start(
+                        op, pid=self.trace_pid, namespace=self.trace_pid
+                    )
+                    res = handler(self, op, *args)
+                    tracer.log_end(op, start_ts, pid=self.trace_pid)
+                    return res
 
                 def callback(fut: Any) -> None:
                     try:
@@ -1278,17 +1166,14 @@ class Interpreter(AbstractInterpreter):
             else:
                 # Sync execution (run immediately)
                 try:
-                    with self._tls_exec_context(
-                        graph_exec_key=graph_exec_key, op_exec_id=exec_id
-                    ):
-                        if child_ctx is not None:
-                            self._tls.comm_ctx = child_ctx
-                        start_ts = tracer.log_start(
-                            op, pid=self.trace_pid, namespace=self.trace_pid
-                        )
-                        res = handler(self, op, *args)
-                        tracer.log_end(op, start_ts, pid=self.trace_pid)
-                        on_op_done(op, res)
+                    if child_ctx is not None:
+                        self._tls.comm_ctx = child_ctx
+                    start_ts = tracer.log_start(
+                        op, pid=self.trace_pid, namespace=self.trace_pid
+                    )
+                    res = handler(self, op, *args)
+                    tracer.log_end(op, start_ts, pid=self.trace_pid)
+                    on_op_done(op, res)
                 except Exception as e:
                     on_op_done(op, None, error=e)
 

{mplang_nightly-0.1.dev330.dist-info → mplang_nightly-0.1.dev332.dist-info}/METADATA

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

{mplang_nightly-0.1.dev330.dist-info → mplang_nightly-0.1.dev332.dist-info}/RECORD

@@ -11,7 +11,7 @@ mplang/backends/func_impl.py,sha256=vhkSJnvgSzvQWXqOE40O8npqOmtNqLxefzv9ETuQODQ,
 mplang/backends/phe_impl.py,sha256=CefRpFrRJvbZm3X58OYOFAyNZXKDp081Q6CT8fhdreE,4118
 mplang/backends/simp_design.md,sha256=u4YeDLKk5avsueXhzPtt4OUBToBmurOVK_BWTKTJ7w0,5246
 mplang/backends/spu_impl.py,sha256=73JTdIFqWoKgVM5jR1lJm_PODlgb9BrQUwLSDcGWi20,11876
-mplang/backends/spu_state.py,sha256=tgwOiWN6zfP-fBx2rN2cNnC-Y9GrSArqU-ZBT3NdXls,6557
+mplang/backends/spu_state.py,sha256=XKquhcAND8afEUzzfJ3VFb1wQ3ptFuPptStxHt20JpA,8652
 mplang/backends/store_impl.py,sha256=IeoMxt9Ma21aYv-dKgF7COinvO6uc09aw5gGTp-5Ctg,1599
 mplang/backends/table_impl.py,sha256=g3fjXOdHUoEEE1w330C5n5FwKcM26cQSo0jPgxNQFsE,30104
 mplang/backends/tee_impl.py,sha256=5yed94Lr55hgSDT6j3FjdTboqzhl4HpJ9lGk1YGZBXQ,7026
@@ -19,18 +19,20 @@ mplang/backends/tensor_impl.py,sha256=SkleS37V5_tW1vKzp8c4EoRyGN590lRJvyIkys1x9o
 mplang/backends/util.py,sha256=yrftyGCxOHSfyTawopGhrErUrfgV_5xXqHgEjEY3f8A,3940
 mplang/backends/simp_driver/__init__.py,sha256=pQkHGR8HagnPB4OqagPZY-Ul19y6HjIJ5dY6QXZrBH8,1243
 mplang/backends/simp_driver/http.py,sha256=cPcX2f2SIXy6NtQDjSaCJGr8qKut-WcOSmAP2UQomrk,5674
-mplang/backends/simp_driver/mem.py,sha256=NIbN5Lta5bRb4EqPY3RcLwf4AiaVtJWr45BIRfJZ3e0,9529
+mplang/backends/simp_driver/mem.py,sha256=sb4TT61VEOf384PoMK2WAOCI0SN_iH03bVLo0e7DLBU,10213
 mplang/backends/simp_driver/ops.py,sha256=WYObWDRCsiXH0UBWZX5vD5W98ZPkd88U_qBV8SE5rA8,4503
 mplang/backends/simp_driver/state.py,sha256=dNmYMFN2D2BBdgs6C0YLaHrfaBRMgs05UNxMWw6tZIs,1713
 mplang/backends/simp_driver/values.py,sha256=Lz1utNSIzH-dCzZAEjU6JRcxPsfKGfUJrYl6gIuMOGw,1509
-mplang/backends/simp_worker/__init__.py,sha256=dbUlTwwgQScJqpKjIp_uKnSDEyR0AObDICF89zoSZfA,1692
+mplang/backends/simp_worker/__init__.py,sha256=MGfnuvkP6mh9FzSOpLCZ96bgqDydE8GNYCtBhidPiWk,1922
 mplang/backends/simp_worker/base.py,sha256=sRfxktJjCuYgD7tASWMNL_gWQiAkqJkK9N053GWxhM8,12350
 mplang/backends/simp_worker/collective_algorithms.py,sha256=NFUpTu2X1Kxl5nI8ef5l1fhD2t3AffeNFDSo3hOzQYo,4667
 mplang/backends/simp_worker/collectives.py,sha256=5T29LYy9EJePLoKgC47XQezlUaZa7YCfgsQXT7XGIEY,5970
-mplang/backends/simp_worker/comm_context.py,sha256=EfIVSWyu3NhM0CkQ2exQHMk6M_kRPGKlK0IYXSrxd1E,3356
-mplang/backends/simp_worker/http.py,sha256=l8C8Tt3dKzFuz7tm_5xkDrkQ1G74VEquPP1IQOTsxu4,35228
+mplang/backends/simp_worker/comm_context.py,sha256=EmDNYOpCP5p8nCL1nJcj9Ztua8Kb_SC4cUpuVKHtZOI,3910
+mplang/backends/simp_worker/http.py,sha256=7SEnQE8a-vbNTQEd4xIo2jhI8AsaEqsYZ8IcINsg8qY,35129
+mplang/backends/simp_worker/infra.py,sha256=9f-MpuNbL3vUdkOwGg8EW6ZJPyA41JJTTnTqhvtD4A8,3848
 mplang/backends/simp_worker/mem.py,sha256=2AWTvv1awtGt-GaEpfnGLE9QoeaCCdfz1BgEKklVorA,6171
 mplang/backends/simp_worker/ops.py,sha256=SlZ9bJGkvoTwgXjvWvyrNsinf3B-zMm04XVL8IEKYMs,5628
+mplang/backends/simp_worker/request.py,sha256=J_qPh0Crj8DWvrEEzAMt7ie-F4AvEl_1AaYlfWf3TtQ,2771
 mplang/backends/simp_worker/state.py,sha256=nIu0ybvdYqRqp0TkoSneUF2u31evDHucCRduVBaDals,1445
 mplang/dialects/__init__.py,sha256=CYMmkeQVU0Znr9n3_5clZKb16u7acJ5jl5Zjbx4Tn1U,1478
 mplang/dialects/_jax_utils.py,sha256=LJhFQNvwUB7Kq4YJTfP5MAE4Q7ooNperHn4x2TsKW4s,9056
@@ -101,7 +103,7 @@ mplang/libs/mpc/vole/ldpc.py,sha256=gOmIbyOjkGE5lewyatl3p6FizNNH8LZ_1oOhp_-TOck,
 mplang/libs/mpc/vole/silver.py,sha256=EIxhpFIVNBemgeIZzCu5Cz_4wysxRm9b1Xfu0xiweVQ,12218
 mplang/runtime/__init__.py,sha256=VdUwJ3kDaI46FvGw7iMGwcsjt0HTGmmRmaBwj99xKIw,620
 mplang/runtime/dialect_state.py,sha256=HxO1i4kSOujS2tQzAF9-WmI3nChSaGgupf2_07dHetY,1277
-mplang/runtime/interpreter.py,sha256=z5UKmZdzbCB-AtTY_EhK9uo833bBz7zPJuaqV-IX5_g,50921
+mplang/runtime/interpreter.py,sha256=boz3LDziXJbgYBDCVG_NwsXD9jGteHYHqn3lksTBVGs,46199
 mplang/runtime/object_store.py,sha256=8Xqr87mkKuQIs-gVZ89Nk62o2GjJDk8meQ4TT66i4aQ,17916
 mplang/runtime/value.py,sha256=EqlhSgxLTJi_FF3ppyKjMe4eHS6-ROx-zK1YesG1U4o,4311
 mplang/tool/__init__.py,sha256=9K-T50W_vClUlyERcVx5xGZaeyv0Ts63SaQX6AZtjIs,1341
@@ -109,8 +111,8 @@ mplang/tool/program.py,sha256=W3H8bpPirnoJ4ZrmyPYuMCPadJis20o__n_1MKqCsWU,11058
 mplang/utils/__init__.py,sha256=Hwrwti2nfPxWUXV8DN6T1QaqXH_Jsd27k8UMSdBGUns,1073
 mplang/utils/func_utils.py,sha256=Jdn_60jN3jcSE_oAqSMTLQjiE8CLyPpY-H1HmPIL5mw,5354
 mplang/utils/logging.py,sha256=9dMhwprVbx1WMGJrgoQbWmV50vyYuLU4NSPnetcl1Go,7237
-mplang_nightly-0.1.dev330.dist-info/METADATA,sha256=quNqRB3lIG9sLSLtZojhQiIYDkWVCQGrKNJCg1tbzmQ,16783
-mplang_nightly-0.1.dev330.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-mplang_nightly-0.1.dev330.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev330.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev330.dist-info/RECORD,,
+mplang_nightly-0.1.dev332.dist-info/METADATA,sha256=H4LyHhbLgPXLlYVKdf1sNzDai9gAqU_JMw20NA92NEo,16783
+mplang_nightly-0.1.dev332.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mplang_nightly-0.1.dev332.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev332.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev332.dist-info/RECORD,,