torchada 0.1.0__tar.gz

torchada-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 R0CKSTAR
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

torchada-0.1.0/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: torchada
+Version: 0.1.0
+Summary: Adapter package for torch_musa to act exactly like PyTorch CUDA
+Author: torchada contributors
+License: MIT
+Project-URL: Homepage, https://github.com/yeahdongcn/torchada
+Project-URL: Repository, https://github.com/yeahdongcn/torchada
+Keywords: pytorch,cuda,musa,moore-threads,gpu,adapter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Provides-Extra: musa
+Requires-Dist: torch_musa; extra == "musa"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# torchada
+
+**Adapter package for torch_musa to act exactly like PyTorch CUDA**
+
+torchada provides a unified interface that works transparently on both NVIDIA GPUs (CUDA) and Moore Threads GPUs (MUSA). Write your code once using standard PyTorch CUDA APIs, and it will run on MUSA hardware without any changes.
+
+## Features
+
+- **Zero Code Changes**: Just `import torchada` once, then use standard `torch.cuda.*` APIs
+- **Automatic Platform Detection**: Detects whether you're running on CUDA or MUSA
+- **Transparent Device Mapping**: `tensor.cuda()` and `tensor.to("cuda")` work on MUSA
+- **Extension Building**: Standard `torch.utils.cpp_extension` works on MUSA after importing torchada
+- **Source Code Porting**: Automatic CUDA → MUSA symbol mapping for C++/CUDA extensions
+
+## Installation
+
+```bash
+pip install torchada
+
+# Or install from source
+git clone https://github.com/yeahdongcn/torchada.git
+cd torchada
+pip install -e .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import torchada  # Import once to apply patches - that's it!
+import torch
+
+# Use standard torch.cuda APIs - they work on both CUDA and MUSA:
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+    tensor = torch.randn(10, 10).cuda()
+    model = MyModel().cuda()
+
+    # All torch.cuda.* APIs work transparently
+    print(f"Device count: {torch.cuda.device_count()}")
+    print(f"Device name: {torch.cuda.get_device_name()}")
+    torch.cuda.synchronize()
+```
+
+### Building C++ Extensions
+
+```python
+# setup.py - Use standard torch imports!
+import torchada  # Import first to apply patches
+from setuptools import setup
+from torch.utils.cpp_extension import CUDAExtension, BuildExtension, CUDA_HOME
+
+print(f"Building with CUDA/MUSA home: {CUDA_HOME}")
+
+ext_modules = [
+    CUDAExtension(
+        name="my_extension",
+        sources=[
+            "my_extension.cpp",
+            "my_extension_kernel.cu",
+        ],
+        extra_compile_args={
+            "cxx": ["-O3"],
+            "nvcc": ["-O3"],  # Automatically mapped to mcc on MUSA
+        },
+    ),
+]
+
+setup(
+    name="my_package",
+    ext_modules=ext_modules,
+    cmdclass={"build_ext": BuildExtension.with_options(use_ninja=True)},
+)
+```
+
+### JIT Compilation
+
+```python
+import torchada  # Import first to apply patches
+from torch.utils.cpp_extension import load
+
+# Load extension at runtime (works on both CUDA and MUSA)
+my_extension = load(
+    name="my_extension",
+    sources=["my_extension.cpp", "my_extension_kernel.cu"],
+    verbose=True,
+)
+```
+
+### Mixed Precision Training
+
+```python
+import torchada  # Import first to apply patches
+import torch
+
+model = MyModel().cuda()
+optimizer = torch.optim.Adam(model.parameters())
+scaler = torch.cuda.amp.GradScaler()
+
+for data, target in dataloader:
+    data, target = data.cuda(), target.cuda()
+
+    with torch.cuda.amp.autocast():
+        output = model(data)
+        loss = criterion(output, target)
+
+    scaler.scale(loss).backward()
+    scaler.step(optimizer)
+    scaler.update()
+    optimizer.zero_grad()
+```
+
+### Distributed Training
+
+```python
+import torchada  # Import first to apply patches
+import torch.distributed as dist
+
+# Use 'nccl' backend as usual - torchada maps it to 'mccl' on MUSA
+dist.init_process_group(backend='nccl')
+```
+
+### CUDA Graphs
+
+```python
+import torchada  # Import first to apply patches
+import torch
+
+# Use standard torch.cuda.CUDAGraph - works on MUSA too
+g = torch.cuda.CUDAGraph()
+with torch.cuda.graph(g):
+    y = model(x)
+```
+
+## Platform Detection
+
+torchada automatically detects the platform:
+
+```python
+import torchada
+from torchada import detect_platform, Platform
+
+platform = detect_platform()
+if platform == Platform.MUSA:
+    print("Running on Moore Threads GPU")
+elif platform == Platform.CUDA:
+    print("Running on NVIDIA GPU")
+
+# Or use convenience functions
+if torchada.is_musa_platform():
+    print("MUSA platform detected")
+```
+
+## What Gets Patched
+
+After `import torchada`, the following standard PyTorch APIs work on MUSA:
+
+| Standard Import | Works On MUSA |
+|----------------|---------------|
+| `torch.cuda.*` | ✅ All APIs |
+| `torch.cuda.amp.*` | ✅ autocast, GradScaler |
+| `torch.cuda.CUDAGraph` | ✅ Maps to MUSAGraph |
+| `torch.distributed` (backend='nccl') | ✅ Uses MCCL |
+| `torch.utils.cpp_extension.*` | ✅ CUDAExtension, BuildExtension |
+
+## API Reference
+
+### torchada
+
+| Function | Description |
+|----------|-------------|
+| `detect_platform()` | Returns the detected platform (CUDA, MUSA, or CPU) |
+| `is_musa_platform()` | Check if running on MUSA |
+| `is_cuda_platform()` | Check if running on CUDA |
+| `get_device_name()` | Get device name string ("cuda", "musa", or "cpu") |
+
+### torch.cuda (after importing torchada)
+
+All standard `torch.cuda` APIs work, including:
+- `is_available()`, `device_count()`, `current_device()`, `set_device()`
+- `memory_allocated()`, `memory_reserved()`, `empty_cache()`
+- `synchronize()`, `Stream`, `Event`, `CUDAGraph`
+- `amp.autocast()`, `amp.GradScaler()`
+
+### torch.utils.cpp_extension (after importing torchada)
+
+| Symbol | Description |
+|--------|-------------|
+| `CUDAExtension` | Creates CUDA or MUSA extension based on platform |
+| `CppExtension` | Creates C++ extension (no GPU code) |
+| `BuildExtension` | Build command for extensions |
+| `CUDA_HOME` | Path to CUDA/MUSA installation |
+| `load()` | JIT compile and load extension |
+
+## Symbol Mapping
+
+torchada automatically maps CUDA symbols to MUSA equivalents when building extensions:
+
+| CUDA | MUSA |
+|------|------|
+| `cudaMalloc` | `musaMalloc` |
+| `cudaMemcpy` | `musaMemcpy` |
+| `cudaStream_t` | `musaStream_t` |
+| `cublasHandle_t` | `mublasHandle_t` |
+| `curandState` | `murandState` |
+| `at::cuda` | `at::musa` |
+| `c10::cuda` | `c10::musa` |
+| ... | ... |
+
+See `src/torchada/_mapping.py` for the complete mapping table.
+
+## License
+
+MIT License

torchada-0.1.0/README.md

@@ -0,0 +1,215 @@
+# torchada
+
+**Adapter package for torch_musa to act exactly like PyTorch CUDA**
+
+torchada provides a unified interface that works transparently on both NVIDIA GPUs (CUDA) and Moore Threads GPUs (MUSA). Write your code once using standard PyTorch CUDA APIs, and it will run on MUSA hardware without any changes.
+
+## Features
+
+- **Zero Code Changes**: Just `import torchada` once, then use standard `torch.cuda.*` APIs
+- **Automatic Platform Detection**: Detects whether you're running on CUDA or MUSA
+- **Transparent Device Mapping**: `tensor.cuda()` and `tensor.to("cuda")` work on MUSA
+- **Extension Building**: Standard `torch.utils.cpp_extension` works on MUSA after importing torchada
+- **Source Code Porting**: Automatic CUDA → MUSA symbol mapping for C++/CUDA extensions
+
+## Installation
+
+```bash
+pip install torchada
+
+# Or install from source
+git clone https://github.com/yeahdongcn/torchada.git
+cd torchada
+pip install -e .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import torchada  # Import once to apply patches - that's it!
+import torch
+
+# Use standard torch.cuda APIs - they work on both CUDA and MUSA:
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+    tensor = torch.randn(10, 10).cuda()
+    model = MyModel().cuda()
+
+    # All torch.cuda.* APIs work transparently
+    print(f"Device count: {torch.cuda.device_count()}")
+    print(f"Device name: {torch.cuda.get_device_name()}")
+    torch.cuda.synchronize()
+```
+
+### Building C++ Extensions
+
+```python
+# setup.py - Use standard torch imports!
+import torchada  # Import first to apply patches
+from setuptools import setup
+from torch.utils.cpp_extension import CUDAExtension, BuildExtension, CUDA_HOME
+
+print(f"Building with CUDA/MUSA home: {CUDA_HOME}")
+
+ext_modules = [
+    CUDAExtension(
+        name="my_extension",
+        sources=[
+            "my_extension.cpp",
+            "my_extension_kernel.cu",
+        ],
+        extra_compile_args={
+            "cxx": ["-O3"],
+            "nvcc": ["-O3"],  # Automatically mapped to mcc on MUSA
+        },
+    ),
+]
+
+setup(
+    name="my_package",
+    ext_modules=ext_modules,
+    cmdclass={"build_ext": BuildExtension.with_options(use_ninja=True)},
+)
+```
+
+### JIT Compilation
+
+```python
+import torchada  # Import first to apply patches
+from torch.utils.cpp_extension import load
+
+# Load extension at runtime (works on both CUDA and MUSA)
+my_extension = load(
+    name="my_extension",
+    sources=["my_extension.cpp", "my_extension_kernel.cu"],
+    verbose=True,
+)
+```
+
+### Mixed Precision Training
+
+```python
+import torchada  # Import first to apply patches
+import torch
+
+model = MyModel().cuda()
+optimizer = torch.optim.Adam(model.parameters())
+scaler = torch.cuda.amp.GradScaler()
+
+for data, target in dataloader:
+    data, target = data.cuda(), target.cuda()
+
+    with torch.cuda.amp.autocast():
+        output = model(data)
+        loss = criterion(output, target)
+
+    scaler.scale(loss).backward()
+    scaler.step(optimizer)
+    scaler.update()
+    optimizer.zero_grad()
+```
+
+### Distributed Training
+
+```python
+import torchada  # Import first to apply patches
+import torch.distributed as dist
+
+# Use 'nccl' backend as usual - torchada maps it to 'mccl' on MUSA
+dist.init_process_group(backend='nccl')
+```
+
+### CUDA Graphs
+
+```python
+import torchada  # Import first to apply patches
+import torch
+
+# Use standard torch.cuda.CUDAGraph - works on MUSA too
+g = torch.cuda.CUDAGraph()
+with torch.cuda.graph(g):
+    y = model(x)
+```
+
+## Platform Detection
+
+torchada automatically detects the platform:
+
+```python
+import torchada
+from torchada import detect_platform, Platform
+
+platform = detect_platform()
+if platform == Platform.MUSA:
+    print("Running on Moore Threads GPU")
+elif platform == Platform.CUDA:
+    print("Running on NVIDIA GPU")
+
+# Or use convenience functions
+if torchada.is_musa_platform():
+    print("MUSA platform detected")
+```
+
+## What Gets Patched
+
+After `import torchada`, the following standard PyTorch APIs work on MUSA:
+
+| Standard Import | Works On MUSA |
+|----------------|---------------|
+| `torch.cuda.*` | ✅ All APIs |
+| `torch.cuda.amp.*` | ✅ autocast, GradScaler |
+| `torch.cuda.CUDAGraph` | ✅ Maps to MUSAGraph |
+| `torch.distributed` (backend='nccl') | ✅ Uses MCCL |
+| `torch.utils.cpp_extension.*` | ✅ CUDAExtension, BuildExtension |
+
+## API Reference
+
+### torchada
+
+| Function | Description |
+|----------|-------------|
+| `detect_platform()` | Returns the detected platform (CUDA, MUSA, or CPU) |
+| `is_musa_platform()` | Check if running on MUSA |
+| `is_cuda_platform()` | Check if running on CUDA |
+| `get_device_name()` | Get device name string ("cuda", "musa", or "cpu") |
+
+### torch.cuda (after importing torchada)
+
+All standard `torch.cuda` APIs work, including:
+- `is_available()`, `device_count()`, `current_device()`, `set_device()`
+- `memory_allocated()`, `memory_reserved()`, `empty_cache()`
+- `synchronize()`, `Stream`, `Event`, `CUDAGraph`
+- `amp.autocast()`, `amp.GradScaler()`
+
+### torch.utils.cpp_extension (after importing torchada)
+
+| Symbol | Description |
+|--------|-------------|
+| `CUDAExtension` | Creates CUDA or MUSA extension based on platform |
+| `CppExtension` | Creates C++ extension (no GPU code) |
+| `BuildExtension` | Build command for extensions |
+| `CUDA_HOME` | Path to CUDA/MUSA installation |
+| `load()` | JIT compile and load extension |
+
+## Symbol Mapping
+
+torchada automatically maps CUDA symbols to MUSA equivalents when building extensions:
+
+| CUDA | MUSA |
+|------|------|
+| `cudaMalloc` | `musaMalloc` |
+| `cudaMemcpy` | `musaMemcpy` |
+| `cudaStream_t` | `musaStream_t` |
+| `cublasHandle_t` | `mublasHandle_t` |
+| `curandState` | `murandState` |
+| `at::cuda` | `at::musa` |
+| `c10::cuda` | `c10::musa` |
+| ... | ... |
+
+See `src/torchada/_mapping.py` for the complete mapping table.
+
+## License
+
+MIT License

torchada-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=64.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "torchada"
+version = "0.1.0"
+description = "Adapter package for torch_musa to act exactly like PyTorch CUDA"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "torchada contributors"}
+]
+keywords = ["pytorch", "cuda", "musa", "moore-threads", "gpu", "adapter"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "torch",
+]
+
+[project.optional-dependencies]
+musa = ["torch_musa"]
+dev = ["pytest", "pytest-cov", "black", "isort", "mypy"]
+
+[project.urls]
+Homepage = "https://github.com/yeahdongcn/torchada"
+Repository = "https://github.com/yeahdongcn/torchada"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 100
+target-version = ["py38", "py39", "py310", "py311", "py312"]
+
+[tool.isort]
+profile = "black"
+line_length = 100
+

torchada-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

torchada-0.1.0/setup.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""
+Setup script for torchada.
+
+This is a shim for editable installs. The actual configuration is in pyproject.toml.
+"""
+
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()
+

torchada-0.1.0/src/torchada/__init__.py

@@ -0,0 +1,88 @@
+"""
+torchada - Adapter package for torch_musa to act exactly like PyTorch CUDA.
+
+torchada provides a unified interface that works transparently on both
+NVIDIA GPUs (CUDA) and Moore Threads GPUs (MUSA).
+
+Usage:
+    Just import torchada at the top of your script, then use standard
+    torch.cuda.* and torch.utils.cpp_extension APIs as you normally would.
+    torchada patches PyTorch to transparently redirect to MUSA on
+    Moore Threads hardware.
+
+    # Add this at the top of your script:
+    import torchada  # noqa: F401
+
+    # Then use standard torch APIs - they work on MUSA too!
+    import torch
+    torch.cuda.is_available()
+    x = torch.randn(3, 3).cuda()
+    from torch.cuda.amp import autocast, GradScaler
+    from torch.utils.cpp_extension import CUDAExtension, BuildExtension, CUDA_HOME
+"""
+
+__version__ = "0.1.0"
+
+from . import cuda
+from . import utils
+from ._platform import (
+    Platform,
+    detect_platform,
+    is_musa_platform,
+    is_cuda_platform,
+    is_cpu_platform,
+    get_device_name,
+    get_torch_device_module,
+)
+from ._patch import apply_patches, is_patched, get_original_init_process_group
+from .utils.cpp_extension import CUDA_HOME
+
+
+# Automatically apply patches on import
+apply_patches()
+
+
+def get_version() -> str:
+    """Return the version of torchada."""
+    return __version__
+
+
+def get_platform() -> Platform:
+    """Return the detected platform."""
+    return detect_platform()
+
+
+def get_backend():
+    """
+    Get the underlying torch device module (torch.cuda or torch.musa).
+
+    Returns:
+        The torch.cuda or torch.musa module.
+    """
+    return get_torch_device_module()
+
+
+__all__ = [
+    # Version
+    "__version__",
+    "get_version",
+    # Modules
+    "cuda",
+    "utils",
+    # Platform detection
+    "Platform",
+    "detect_platform",
+    "is_musa_platform",
+    "is_cuda_platform",
+    "is_cpu_platform",
+    "get_device_name",
+    "get_platform",
+    "get_backend",
+    # Patching
+    "apply_patches",
+    "is_patched",
+    "get_original_init_process_group",
+    # C++ Extension building
+    "CUDA_HOME",
+]
+