torchmonarch-nightly 2025.7.1__cp311-cp311-manylinux2014_x86_64.whl → 2025.7.25__cp311-cp311-manylinux2014_x86_64.whl

monarch/debugger.py

@@ -1,379 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-import asyncio
-import logging
-import sys
-from dataclasses import dataclass
-from typing import Dict, List, Tuple, Union
-
-from monarch._rust_bindings.monarch_hyperactor.proc import ActorId
-from monarch.actor_mesh import Actor, ActorMeshRef, endpoint
-
-from monarch.pdb_wrapper import DebuggerWrite
-
-from monarch.proc_mesh import local_proc_mesh
-from tabulate import tabulate
-
-
-logger = logging.getLogger(__name__)
-
-
-CANCEL_TOKEN = object()
-
-
-async def _debugger_input(prompt=""):
-    return await asyncio.to_thread(input, prompt)
-
-
-def _debugger_output(msg):
-    sys.stdout.write(msg)
-    sys.stdout.flush()
-
-
-@dataclass
-class DebugSessionInfo:
-    rank: int
-    coords: Dict[str, int]
-    hostname: str
-    actor_id: ActorId
-    function: str | None
-    lineno: int | None
-
-
-class DebugSession:
-    """Represents a single session with a remote debugger."""
-
-    def __init__(
-        self, rank: int, coords: Dict[str, int], hostname: str, actor_id: ActorId
-    ):
-        self.rank = rank
-        self.coords = coords
-        self.hostname = hostname
-        self.actor_id = actor_id
-        self._active = False
-        self._message_queue = asyncio.Queue()
-        self._task = None
-        self._pending_send_to_actor = asyncio.Queue()
-        self._outputs_since_last_input = []
-        self._function_lineno = None
-        self._need_read = False
-
-    async def _event_loop(self, line=None, suppress_output=False):
-        if not suppress_output:
-            # If the user had previously attached to this debug session,
-            # then it would have printed various messages from the
-            # message queue. When the user re-attaches, we want to
-            # print out all of the output that was printed since the
-            # last command sent to this session.
-            for output in self._outputs_since_last_input:
-                _debugger_output(output.payload.decode())
-
-        while True:
-            # When the user inputs "detach", it uses up a "read" message
-            # without actually responding to the actor being debugged. We
-            # can't manually reinsert the "read" message into the message queue,
-            # so instead the self._need_read flag indicates there's an additional
-            # "read" that we need to respond to.
-            if self._need_read:
-                self._need_read = False
-                message = "read"
-            else:
-                message = await self._message_queue.get()
-            if message == "detach":
-                # Return to the main outer debug loop.
-                break
-            elif message == "read":
-                break_after = False
-                if line is not None:
-                    break_after = True
-                else:
-                    line = await _debugger_input()
-                if line.strip("\n") == "detach":
-                    self._need_read = True
-                    break
-                else:
-                    self._outputs_since_last_input = []
-                    await self._pending_send_to_actor.put((line + "\n").encode())
-                    line = None
-                    if break_after:
-                        break
-            elif message[0] == "write":
-                output = message[1]
-                # If the user sees this output but then detaches from the session,
-                # its useful to store all outputs since the last input so that
-                # they can be printed again when the user re-attaches.
-                self._outputs_since_last_input.append(output)
-                if not suppress_output:
-                    _debugger_output(output.payload.decode())
-
-        if not suppress_output:
-            print(
-                f"Detaching from debug session for rank {self.rank} ({self.hostname})"
-            )
-
-    def get_info(self):
-        function = lineno = None
-        if self._function_lineno is not None:
-            function, lineno = self._function_lineno
-        return DebugSessionInfo(
-            self.rank, self.coords, self.hostname, self.actor_id, function, lineno
-        )
-
-    async def attach(self, line=None, suppress_output=False):
-        self._active = True
-        if not suppress_output:
-            print(f"Attached to debug session for rank {self.rank} ({self.hostname})")
-        self._task = asyncio.create_task(self._event_loop(line, suppress_output))
-        await self._task
-        if not suppress_output:
-            print(f"Detached from debug session for rank {self.rank} ({self.hostname})")
-        self._active = False
-
-    async def detach(self):
-        if self._active:
-            await self._message_queue.put("detach")
-
-    async def debugger_read(self, size: int) -> DebuggerWrite:
-        await self._message_queue.put("read")
-        input_data = await self._pending_send_to_actor.get()
-        if len(input_data) > size:
-            input_data = input_data[:size]
-        return DebuggerWrite(input_data, None, None)
-
-    async def debugger_write(self, write: DebuggerWrite) -> None:
-        if write.function is not None and write.lineno is not None:
-            self._function_lineno = (write.function, write.lineno)
-        await self._message_queue.put(("write", write))
-
-
-class DebugCommand:
-    @staticmethod
-    def parse(line: str) -> Union["DebugCommand", None]:
-        parts = line.strip("\n").split(" ")
-        if len(parts) == 0:
-            return None
-        command = parts[0]
-        match command:
-            case "attach":
-                return Attach._parse(parts)
-            case "list":
-                return ListCommand()
-            case "quit":
-                return Quit()
-            case "cast":
-                return Cast._parse(parts)
-            case "help":
-                return Help()
-            case "continue":
-                return Continue()
-            case _:
-                print(
-                    f"Unknown command {command}. Expected: attach | list | quit | cast | continue | help"
-                )
-                return None
-
-
-@dataclass
-class Attach(DebugCommand):
-    rank: int
-
-    @classmethod
-    def _parse(cls, parts: List[str]) -> "Attach":
-        if len(parts) != 2:
-            raise ValueError("Invalid attach command. Expected: attach <rank>")
-        try:
-            rank = int(parts[1])
-        except ValueError:
-            raise ValueError(f"Invalid rank {parts[1]}. Expected: int")
-        return cls(rank)
-
-
-class ListCommand(DebugCommand):
-    pass
-
-
-class Quit(DebugCommand):
-    pass
-
-
-class Help(DebugCommand):
-    pass
-
-
-class Continue(DebugCommand):
-    pass
-
-
-@dataclass
-class Cast(DebugCommand):
-    ranks: List[int] | None
-    command: str
-
-    @classmethod
-    def _parse(cls, parts: List[str]) -> "Cast":
-        if len(parts) < 3:
-            raise ValueError(
-                "Invalid cast command. Expected: cast {<r0,r1,...> | *} <command>"
-            )
-        str_ranks = parts[1]
-        command = " ".join(parts[2:])
-        if str_ranks == "*":
-            return cls(None, command)
-        else:
-            str_ranks = str_ranks.split(",")
-            if len(str_ranks) == 0:
-                raise ValueError(
-                    "Invalid rank list for cast. Expected at least one rank."
-                )
-            ranks = []
-            for rank in str_ranks:
-                try:
-                    ranks.append(int(rank))
-                except ValueError:
-                    raise ValueError(f"Invalid rank {rank}. Expected: int")
-            return cls(ranks, command)
-
-
-class DebugClient(Actor):
-    """
-    Single actor for both remote debuggers and users to talk to.
-
-    Handles multiple sessions simultanesouly
-    """
-
-    def __init__(self) -> None:
-        self.sessions = {}  # rank -> DebugSession
-
-    @endpoint
-    async def wait_pending_session(self):
-        while len(self.sessions) == 0:
-            await asyncio.sleep(1)
-
-    @endpoint
-    async def list(self) -> List[Tuple[int, Dict[str, int], str, ActorId, str, int]]:
-        table_data = []
-        for _, session in self.sessions.items():
-            info = session.get_info()
-            table_data.append(
-                (
-                    info.rank,
-                    info.coords,
-                    info.hostname,
-                    info.actor_id,
-                    info.function,
-                    info.lineno,
-                )
-            )
-        table_data = sorted(table_data, key=lambda r: r[0])
-
-        headers = ["Rank", "Coords", "Hostname", "Actor ID", "Function", "Line No."]
-        print(tabulate(table_data, headers=headers, tablefmt="grid"))
-
-        return table_data
-
-    @endpoint
-    async def enter(self) -> None:
-        # pyre-ignore
-        await getattr(self, "list")._method(self)  # noqa
-
-        while True:
-            try:
-                user_input = await _debugger_input("monarch_dbg> ")
-                command = DebugCommand.parse(user_input)
-                if isinstance(command, Help):
-                    print("monarch_dbg commands:")
-                    print("\tattach <rank> - attach to a debug session")
-                    print("\tlist - list all debug sessions")
-                    print("\tquit - exit the debugger, leaving all sessions in place")
-                    print(
-                        "\tcast {<r0,r1,...> | *} <command> - send a command to a comma-separated list of ranks, or all ranks"
-                    )
-                    print(
-                        "\tcontinue - tell all ranks to continue execution, then exit the debugger"
-                    )
-                    print("\thelp - print this help message")
-                elif isinstance(command, Attach):
-                    if command.rank not in self.sessions:
-                        print(f"No debug session for rank {command.rank}")
-                    else:
-                        await self.sessions[command.rank].attach()
-                elif isinstance(command, ListCommand):
-                    await getattr(self, "list")._method(self)  # noqa
-                elif isinstance(command, Continue):
-                    # Make sure all ranks have exited their debug sessions.
-                    # If we sent "quit", it would raise BdbQuit, crashing
-                    # the process, which probably isn't what we want.
-                    while len(self.sessions) > 0:
-                        tasks = []
-                        for rank in self.sessions:
-                            tasks.append(
-                                self.sessions[rank].attach("c", suppress_output=True)
-                            )
-                        await asyncio.gather(*tasks)
-                    return
-                elif isinstance(command, Quit):
-                    return
-                elif isinstance(command, Cast):
-                    if command.ranks is None:
-                        ranks = self.sessions.keys()
-                    else:
-                        ranks = command.ranks
-                    tasks = []
-                    for rank in ranks:
-                        if rank in self.sessions:
-                            tasks.append(
-                                self.sessions[rank].attach(
-                                    command.command,
-                                    suppress_output=True,
-                                )
-                            )
-                        else:
-                            print(f"No debug session for rank {rank}")
-                    await asyncio.gather(*tasks)
-            except Exception as e:
-                print(f"Error processing command: {e}")
-
-    ##########################################################################
-    # Debugger APIs
-    #
-    # These endpoints are called by the remote debuggers to establish sessions
-    # and communicate with them.
-    @endpoint
-    async def debugger_session_start(
-        self, rank: int, coords: Dict[str, int], hostname: str, actor_id: ActorId
-    ) -> None:
-        # Create a session if it doesn't exist
-        if rank not in self.sessions:
-            self.sessions[rank] = DebugSession(rank, coords, hostname, actor_id)
-
-    @endpoint
-    async def debugger_session_end(self, rank: int) -> None:
-        """Detach from the current debug session."""
-        session = self.sessions.pop(rank)
-        await session.detach()
-
-    @endpoint
-    async def debugger_read(self, rank: int, size: int) -> DebuggerWrite | str:
-        """Read from the debug session for the given rank."""
-        session = self.sessions[rank]
-
-        return await session.debugger_read(size)
-
-    @endpoint
-    async def debugger_write(self, rank: int, write: DebuggerWrite) -> None:
-        """Write to the debug session for the given rank."""
-        session = self.sessions[rank]
-        await session.debugger_write(write)
-
-
-async def init_debugging(
-    actor_mesh: ActorMeshRef,
-) -> ActorMeshRef[DebugClient]:
-    debugger_proc_mesh = await local_proc_mesh(gpus=1, hosts=1)
-    debug_client_mesh = await debugger_proc_mesh.spawn("debug_client", DebugClient)
-    await actor_mesh._set_debug_client.call(debug_client_mesh)
-    return debug_client_mesh

monarch/future.py

@@ -1,76 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-import asyncio
-from functools import partial
-from typing import Generator, Generic, Optional, TypeVar
-
-R = TypeVar("R")
-
-
-def _incomplete(impl, self):
-    try:
-        return self._set_result(impl())
-    except Exception as e:
-        self._set_exception(e)
-        raise
-
-
-async def _aincomplete(impl, self):
-    try:
-        return self._set_result(await impl())
-    except Exception as e:
-        self._set_exception(e)
-        raise
-
-
-# TODO: consolidate with monarch.common.future
-class ActorFuture(Generic[R]):
-    def __init__(self, impl, blocking_impl=None):
-        if blocking_impl is None:
-            blocking_impl = partial(asyncio.run, impl())
-        self._get = partial(_incomplete, blocking_impl)
-        self._aget = partial(_aincomplete, impl)
-
-    def get(self, timeout: Optional[float] = None) -> R:
-        if timeout is not None:
-            return asyncio.run(asyncio.wait_for(self._aget(self), timeout))
-        return self._get(self)
-
-    def __await__(self) -> Generator[R, None, R]:
-        return self._aget(self).__await__()
-
-    def _set_result(self, result):
-        def f(self):
-            return result
-
-        async def af(self):
-            return result
-
-        self._get, self._aget = f, af
-        return result
-
-    def _set_exception(self, e):
-        def f(self):
-            raise e
-
-        async def af(self):
-            raise e
-
-        self._get, self._aget = f, af
-
-    # compatibility with old tensor engine Future objects
-    # hopefully we do not need done(), add_callback because
-    # they are harder to implement right.
-    def result(self, timeout: Optional[float] = None) -> R:
-        return self.get(timeout)
-
-    def exception(self, timeout: Optional[float] = None):
-        try:
-            self.get(timeout)
-            return None
-        except Exception as e:
-            return e

monarch/rdma.py

@@ -1,162 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-import ctypes
-
-from dataclasses import dataclass
-from typing import cast, Dict, Optional, Tuple
-
-import torch
-
-from monarch._rust_bindings.monarch_hyperactor.proc import ActorId
-
-from monarch.actor_mesh import (
-    _ActorMeshRefImpl,
-    Actor,
-    ActorMeshRef,
-    endpoint,
-    MonarchContext,
-)
-
-
-@dataclass
-class LocalRDMARecord:
-    data: torch.Tensor
-
-
-_local_buffers: Dict[int, "LocalRDMARecord"] = {}
-
-
-def _get_bytes(storage: torch.Tensor, offset: int, size: int) -> bytearray:
-    """Extracts a bytearray from a 1D, 1byte per item tensor."""
-    if offset + size > storage.numel():
-        raise ValueError(f"Read out of range: {offset + size} > {storage.size()}")
-    addr = storage.data_ptr()
-    if storage.device.type != "cpu":
-        result = bytearray(size)
-        result_tensor = torch.frombuffer(
-            result,
-            dtype=torch.uint8,
-        )
-        source_tensor = storage[offset:]
-        result_tensor.copy_(source_tensor)
-    else:
-        ctypes_array = (ctypes.c_byte * size).from_address(addr)
-        result = bytearray(ctypes_array)
-    return result
-
-
-class RDMAManager(Actor):
-    @staticmethod
-    def on_proc(proc_id: str) -> "RDMAManager":
-        ctx = MonarchContext.get()
-        return cast(
-            RDMAManager,
-            ActorMeshRef(
-                RDMAManager,
-                _ActorMeshRefImpl.from_actor_id(
-                    ctx.mailbox,
-                    ActorId.from_string(f"{proc_id}.rdma_manager[0]"),
-                ),
-                ctx.mailbox,
-            ),
-        )
-
-    @endpoint
-    async def drop(self, addr: int) -> None:
-        if addr in _local_buffers:
-            del _local_buffers[addr]
-
-    @endpoint
-    async def fetch(self, addr: int, offset: int, nbytes: int) -> bytearray:
-        if addr not in _local_buffers:
-            raise ValueError(f"Unknown buffer {addr}")
-        storage = _local_buffers[addr].data
-        return _get_bytes(storage, offset, nbytes)
-
-    @endpoint
-    async def put(self, addr: int, offset: int, bytes: bytearray) -> None:
-        if addr not in _local_buffers:
-            raise ValueError(f"Unknown buffer {addr}")
-        storage = _local_buffers[addr].data
-        storage[offset : offset + len(bytes)] = torch.frombuffer(
-            bytes, dtype=storage.dtype
-        )
-
-
-def _assert_tensor_is_1d_contiguous_uint8(t: torch.Tensor) -> None:
-    if t.ndim != 1:
-        raise ValueError(f"Tensor must be 1D, got {t.ndim}D")
-    if t.dtype != torch.uint8:
-        raise ValueError(f"Tensor must be uint8, got {t.dtype}")
-    if not t.is_contiguous():
-        raise ValueError("Tensor must be contiguous")
-
-
-class RDMABuffer:
-    def __init__(self, data: torch.Tensor) -> None:
-        """
-        RDMABuffer only supports 1D contiguous tensors that are 1 byte per item.
-
-        To create a 1 byte, 1D view, use t.view(torch.uint8).flatten()
-
-        TODO: Create TensorBuffer, which will be main user API supporting non-contiguous , multi-byte-per-elment tensors
-        """
-        _assert_tensor_is_1d_contiguous_uint8(data)
-        assert data.storage_offset() == 0
-        storage = data.untyped_storage()
-        self.addr: int = storage.data_ptr()
-        self.begin = 0
-        self.end: int = storage.size()
-        self.proc_id: str = MonarchContext.get().proc_id
-        self.local_data: object = None
-        _local_buffers[self.addr] = LocalRDMARecord(data)
-
-    def drop(self) -> None:
-        if self.proc_id is None:
-            del _local_buffers[self.addr]
-            return
-        rmda_actor = RDMAManager.on_proc(self.proc_id)
-        # pyre-ignore[16]: Undefined attribute [16]: `Endpoint` has no attribute `cast`.
-        rmda_actor.drop.cast(self.addr)
-
-    def __getstate__(self) -> Tuple[int, int, int, Optional[str]]:
-        proc_id = self.proc_id
-        # locally created RDMABuffer being set remotely,
-        # record its proc_id so we know how to establish connections to it
-        if proc_id is None:
-            proc_id = MonarchContext.get().proc_id
-        return (self.addr, self.begin, self.end, proc_id)
-
-    def __setstate__(self, state: Tuple[int, int, int, str]) -> None:
-        self.local_data = None
-        self.addr, self.begin, self.end, self.proc_id = state
-
-    async def read_into(self, dst: torch.Tensor, offset: int = 0) -> None:
-        """
-        Read data from the RDMABuffer into a destination tensor.
-
-        The destination tensor must be contiguous and 1 byte per item.
-        """
-        _assert_tensor_is_1d_contiguous_uint8(dst)
-        bytes = await RDMAManager.on_proc(self.proc_id).fetch.call_one(
-            self.addr, offset, dst.numel()
-        )
-        dst.copy_(torch.frombuffer(bytes, dtype=torch.uint8))
-
-    async def write(self, src: torch.Tensor, offset: int = 0) -> None:
-        """
-        Write data from a source tensor into the RDMABuffer.
-
-        The source tensor must be contiguous and 1 byte per item.
-        """
-        _assert_tensor_is_1d_contiguous_uint8(src)
-        bytes = _get_bytes(
-            src,
-            cast(int, src.storage_offset()),
-            src.numel(),
-        )
-        await RDMAManager.on_proc(self.proc_id).put.call_one(self.addr, offset, bytes)

torchmonarch_nightly-2025.7.1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-monarch = monarch.tools.cli:main
-monarch_bootstrap = monarch.bootstrap_main:invoke_main