torchada 0.1.19__tar.gz

torchada-0.1.19/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Moore Threads Technology Co., Ltd ("Moore Threads"). All rights reserved.
+
+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.19/PKG-INFO

@@ -0,0 +1,296 @@
+Metadata-Version: 2.1
+Name: torchada
+Version: 0.1.19
+Summary: Adapter package for torch_musa to act exactly like PyTorch CUDA
+Author: torchada contributors
+License: MIT
+Project-URL: Homepage, https://github.com/MooreThreads/torchada
+Project-URL: Repository, https://github.com/MooreThreads/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"
+
+<div align="center" id="sglangtop">
+<img src="https://raw.githubusercontent.com/MooreThreads/torchada/main/assets/logo.png" alt="logo" width="250" margin="10px"></img>
+</div>
+
+--------------------------------------------------------------------------------
+
+# torchada
+
+English | [中文](README_CN.md)
+
+**Run your CUDA code on Moore Threads GPUs — zero code changes required**
+
+torchada is an adapter that makes [torch_musa](https://github.com/MooreThreads/torch_musa) (Moore Threads GPU support for PyTorch) compatible with standard PyTorch CUDA APIs. Import it once, and your existing `torch.cuda.*` code works on MUSA hardware.
+
+## Why torchada?
+
+Many PyTorch projects are written for NVIDIA GPUs using `torch.cuda.*` APIs. To run these on Moore Threads GPUs, you would normally need to change every `cuda` reference to `musa`. torchada eliminates this by automatically translating CUDA API calls to MUSA equivalents at runtime.
+
+## Prerequisites
+
+- **torch_musa**: You must have [torch_musa](https://github.com/MooreThreads/torch_musa) installed (this provides MUSA support for PyTorch)
+- **Moore Threads GPU**: A Moore Threads GPU with proper driver installed
+
+## Installation
+
+```bash
+pip install torchada
+
+# Or install from source
+git clone https://github.com/MooreThreads/torchada.git
+cd torchada
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import torchada  # ← Add this one line at the top
+import torch
+
+# Your existing CUDA code works unchanged:
+x = torch.randn(10, 10).cuda()
+print(torch.cuda.device_count())
+torch.cuda.synchronize()
+```
+
+That's it! All `torch.cuda.*` APIs are automatically redirected to `torch.musa.*`.
+
+## What Works
+
+| Feature | Example |
+|---------|---------|
+| Device operations | `tensor.cuda()`, `model.cuda()`, `torch.device("cuda")` |
+| Memory management | `torch.cuda.memory_allocated()`, `empty_cache()` |
+| Synchronization | `torch.cuda.synchronize()`, `Stream`, `Event` |
+| Mixed precision | `torch.cuda.amp.autocast()`, `GradScaler()` |
+| CUDA Graphs | `torch.cuda.CUDAGraph`, `torch.cuda.graph()` |
+| Profiler | `ProfilerActivity.CUDA` → uses PrivateUse1 |
+| Custom Ops | `Library.impl(..., "CUDA")` → uses PrivateUse1 |
+| Distributed | `dist.init_process_group(backend='nccl')` → uses MCCL |
+| torch.compile | `torch.compile(model)` with all backends |
+| C++ Extensions | `CUDAExtension`, `BuildExtension`, `load()` |
+
+## Examples
+
+### Mixed Precision Training
+
+```python
+import torchada
+import torch
+
+model = MyModel().cuda()
+scaler = torch.cuda.amp.GradScaler()
+
+with torch.cuda.amp.autocast():
+    output = model(data.cuda())
+    loss = criterion(output, target.cuda())
+
+scaler.scale(loss).backward()
+scaler.step(optimizer)
+scaler.update()
+```
+
+### Distributed Training
+
+```python
+import torchada
+import torch.distributed as dist
+
+# 'nccl' is automatically mapped to 'mccl' on MUSA
+dist.init_process_group(backend='nccl')
+```
+
+### CUDA Graphs
+
+```python
+import torchada
+import torch
+
+g = torch.cuda.CUDAGraph()
+with torch.cuda.graph(cuda_graph=g):  # cuda_graph= keyword works on MUSA
+    y = model(x)
+```
+
+### torch.compile
+
+```python
+import torchada
+import torch
+
+compiled_model = torch.compile(model.cuda(), backend='inductor')
+```
+
+### Building C++ Extensions
+
+```python
+import torchada  # Must import before torch.utils.cpp_extension
+from torch.utils.cpp_extension import CUDAExtension, BuildExtension
+
+# Standard CUDAExtension works — torchada handles CUDA→MUSA translation
+ext = CUDAExtension("my_ext", sources=["kernel.cu"])
+```
+
+### Custom Ops
+
+```python
+import torchada
+import torch
+
+my_lib = torch.library.Library("my_lib", "DEF")
+my_lib.define("my_op(Tensor x) -> Tensor")
+my_lib.impl("my_op", my_func, "CUDA")  # Works on MUSA!
+```
+
+### Profiler
+
+```python
+import torchada
+import torch
+
+# ProfilerActivity.CUDA works on MUSA
+with torch.profiler.profile(
+    activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA]
+) as prof:
+    model(x)
+```
+
+## Platform Detection
+
+```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 torch.version-based detection
+def is_musa():
+    import torch
+    return hasattr(torch.version, 'musa') and torch.version.musa is not None
+```
+
+## Known Limitation
+
+**Device type string comparisons fail on MUSA:**
+
+```python
+device = torch.device("cuda:0")  # On MUSA, this becomes musa:0
+device.type == "cuda"  # Returns False!
+```
+
+**Solution:** Use `torchada.is_gpu_device()`:
+
+```python
+import torchada
+
+if torchada.is_gpu_device(device):  # Works on both CUDA and MUSA
+    ...
+# Or: device.type in ("cuda", "musa")
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `detect_platform()` | Returns `Platform.CUDA`, `Platform.MUSA`, or `Platform.CPU` |
+| `is_musa_platform()` | Returns True if running on MUSA |
+| `is_cuda_platform()` | Returns True if running on CUDA |
+| `is_gpu_device(device)` | Returns True if device is CUDA or MUSA |
+| `CUDA_HOME` | Path to CUDA/MUSA installation |
+
+**Note**: `torch.cuda.is_available()` is intentionally NOT redirected — it returns `False` on MUSA. This allows proper platform detection. Use `torch.musa.is_available()` or `is_musa()` function instead.
+
+## C++ Extension Symbol Mapping
+
+When building C++ extensions, torchada automatically translates CUDA symbols to MUSA:
+
+| CUDA | MUSA |
+|------|------|
+| `cudaMalloc` | `musaMalloc` |
+| `cudaStream_t` | `musaStream_t` |
+| `cublasHandle_t` | `mublasHandle_t` |
+| `at::cuda` | `at::musa` |
+| `c10::cuda` | `c10::musa` |
+| `#include <cuda/*>` | `#include <musa/*>` |
+
+See `src/torchada/_mapping.py` for the complete mapping table (380+ mappings).
+
+## Integrating torchada into Your Project
+
+### Step 1: Add Dependency
+
+```
+# pyproject.toml or requirements.txt
+torchada>=0.1.19
+```
+
+### Step 2: Conditional Import
+
+```python
+# At your application entry point
+def is_musa():
+    import torch
+    return hasattr(torch.version, "musa") and torch.version.musa is not None
+
+if is_musa():
+    import torchada  # noqa: F401
+
+# Rest of your code uses torch.cuda.* as normal
+```
+
+### Step 3: Extend Feature Flags (if applicable)
+
+```python
+# Include MUSA in GPU capability checks
+if is_nvidia() or is_musa():
+    ENABLE_FLASH_ATTENTION = True
+```
+
+### Step 4: Fix Device Type Checks (if applicable)
+
+```python
+# Instead of: device.type == "cuda"
+# Use: device.type in ("cuda", "musa")
+# Or: torchada.is_gpu_device(device)
+```
+
+## Projects Using torchada
+
+| Project | Category | Status |
+|---------|----------|--------|
+| [Xinference](https://github.com/xorbitsai/inference) | Model Serving | ✅ Merged |
+| [LightLLM](https://github.com/ModelTC/LightLLM) | Model Serving | ✅ Merged |
+| [LightX2V](https://github.com/ModelTC/LightX2V) | Image/Video Generation | ✅ Merged |
+| [SGLang](https://github.com/sgl-project/sglang) | Model Serving | In Progress |
+| [ComfyUI](https://github.com/comfyanonymous/ComfyUI) | Image/Video Generation | In Progress |
+
+## License
+
+MIT License

torchada-0.1.19/README.md

@@ -0,0 +1,263 @@
+<div align="center" id="sglangtop">
+<img src="https://raw.githubusercontent.com/MooreThreads/torchada/main/assets/logo.png" alt="logo" width="250" margin="10px"></img>
+</div>
+
+--------------------------------------------------------------------------------
+
+# torchada
+
+English | [中文](README_CN.md)
+
+**Run your CUDA code on Moore Threads GPUs — zero code changes required**
+
+torchada is an adapter that makes [torch_musa](https://github.com/MooreThreads/torch_musa) (Moore Threads GPU support for PyTorch) compatible with standard PyTorch CUDA APIs. Import it once, and your existing `torch.cuda.*` code works on MUSA hardware.
+
+## Why torchada?
+
+Many PyTorch projects are written for NVIDIA GPUs using `torch.cuda.*` APIs. To run these on Moore Threads GPUs, you would normally need to change every `cuda` reference to `musa`. torchada eliminates this by automatically translating CUDA API calls to MUSA equivalents at runtime.
+
+## Prerequisites
+
+- **torch_musa**: You must have [torch_musa](https://github.com/MooreThreads/torch_musa) installed (this provides MUSA support for PyTorch)
+- **Moore Threads GPU**: A Moore Threads GPU with proper driver installed
+
+## Installation
+
+```bash
+pip install torchada
+
+# Or install from source
+git clone https://github.com/MooreThreads/torchada.git
+cd torchada
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import torchada  # ← Add this one line at the top
+import torch
+
+# Your existing CUDA code works unchanged:
+x = torch.randn(10, 10).cuda()
+print(torch.cuda.device_count())
+torch.cuda.synchronize()
+```
+
+That's it! All `torch.cuda.*` APIs are automatically redirected to `torch.musa.*`.
+
+## What Works
+
+| Feature | Example |
+|---------|---------|
+| Device operations | `tensor.cuda()`, `model.cuda()`, `torch.device("cuda")` |
+| Memory management | `torch.cuda.memory_allocated()`, `empty_cache()` |
+| Synchronization | `torch.cuda.synchronize()`, `Stream`, `Event` |
+| Mixed precision | `torch.cuda.amp.autocast()`, `GradScaler()` |
+| CUDA Graphs | `torch.cuda.CUDAGraph`, `torch.cuda.graph()` |
+| Profiler | `ProfilerActivity.CUDA` → uses PrivateUse1 |
+| Custom Ops | `Library.impl(..., "CUDA")` → uses PrivateUse1 |
+| Distributed | `dist.init_process_group(backend='nccl')` → uses MCCL |
+| torch.compile | `torch.compile(model)` with all backends |
+| C++ Extensions | `CUDAExtension`, `BuildExtension`, `load()` |
+
+## Examples
+
+### Mixed Precision Training
+
+```python
+import torchada
+import torch
+
+model = MyModel().cuda()
+scaler = torch.cuda.amp.GradScaler()
+
+with torch.cuda.amp.autocast():
+    output = model(data.cuda())
+    loss = criterion(output, target.cuda())
+
+scaler.scale(loss).backward()
+scaler.step(optimizer)
+scaler.update()
+```
+
+### Distributed Training
+
+```python
+import torchada
+import torch.distributed as dist
+
+# 'nccl' is automatically mapped to 'mccl' on MUSA
+dist.init_process_group(backend='nccl')
+```
+
+### CUDA Graphs
+
+```python
+import torchada
+import torch
+
+g = torch.cuda.CUDAGraph()
+with torch.cuda.graph(cuda_graph=g):  # cuda_graph= keyword works on MUSA
+    y = model(x)
+```
+
+### torch.compile
+
+```python
+import torchada
+import torch
+
+compiled_model = torch.compile(model.cuda(), backend='inductor')
+```
+
+### Building C++ Extensions
+
+```python
+import torchada  # Must import before torch.utils.cpp_extension
+from torch.utils.cpp_extension import CUDAExtension, BuildExtension
+
+# Standard CUDAExtension works — torchada handles CUDA→MUSA translation
+ext = CUDAExtension("my_ext", sources=["kernel.cu"])
+```
+
+### Custom Ops
+
+```python
+import torchada
+import torch
+
+my_lib = torch.library.Library("my_lib", "DEF")
+my_lib.define("my_op(Tensor x) -> Tensor")
+my_lib.impl("my_op", my_func, "CUDA")  # Works on MUSA!
+```
+
+### Profiler
+
+```python
+import torchada
+import torch
+
+# ProfilerActivity.CUDA works on MUSA
+with torch.profiler.profile(
+    activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA]
+) as prof:
+    model(x)
+```
+
+## Platform Detection
+
+```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 torch.version-based detection
+def is_musa():
+    import torch
+    return hasattr(torch.version, 'musa') and torch.version.musa is not None
+```
+
+## Known Limitation
+
+**Device type string comparisons fail on MUSA:**
+
+```python
+device = torch.device("cuda:0")  # On MUSA, this becomes musa:0
+device.type == "cuda"  # Returns False!
+```
+
+**Solution:** Use `torchada.is_gpu_device()`:
+
+```python
+import torchada
+
+if torchada.is_gpu_device(device):  # Works on both CUDA and MUSA
+    ...
+# Or: device.type in ("cuda", "musa")
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `detect_platform()` | Returns `Platform.CUDA`, `Platform.MUSA`, or `Platform.CPU` |
+| `is_musa_platform()` | Returns True if running on MUSA |
+| `is_cuda_platform()` | Returns True if running on CUDA |
+| `is_gpu_device(device)` | Returns True if device is CUDA or MUSA |
+| `CUDA_HOME` | Path to CUDA/MUSA installation |
+
+**Note**: `torch.cuda.is_available()` is intentionally NOT redirected — it returns `False` on MUSA. This allows proper platform detection. Use `torch.musa.is_available()` or `is_musa()` function instead.
+
+## C++ Extension Symbol Mapping
+
+When building C++ extensions, torchada automatically translates CUDA symbols to MUSA:
+
+| CUDA | MUSA |
+|------|------|
+| `cudaMalloc` | `musaMalloc` |
+| `cudaStream_t` | `musaStream_t` |
+| `cublasHandle_t` | `mublasHandle_t` |
+| `at::cuda` | `at::musa` |
+| `c10::cuda` | `c10::musa` |
+| `#include <cuda/*>` | `#include <musa/*>` |
+
+See `src/torchada/_mapping.py` for the complete mapping table (380+ mappings).
+
+## Integrating torchada into Your Project
+
+### Step 1: Add Dependency
+
+```
+# pyproject.toml or requirements.txt
+torchada>=0.1.19
+```
+
+### Step 2: Conditional Import
+
+```python
+# At your application entry point
+def is_musa():
+    import torch
+    return hasattr(torch.version, "musa") and torch.version.musa is not None
+
+if is_musa():
+    import torchada  # noqa: F401
+
+# Rest of your code uses torch.cuda.* as normal
+```
+
+### Step 3: Extend Feature Flags (if applicable)
+
+```python
+# Include MUSA in GPU capability checks
+if is_nvidia() or is_musa():
+    ENABLE_FLASH_ATTENTION = True
+```
+
+### Step 4: Fix Device Type Checks (if applicable)
+
+```python
+# Instead of: device.type == "cuda"
+# Use: device.type in ("cuda", "musa")
+# Or: torchada.is_gpu_device(device)
+```
+
+## Projects Using torchada
+
+| Project | Category | Status |
+|---------|----------|--------|
+| [Xinference](https://github.com/xorbitsai/inference) | Model Serving | ✅ Merged |
+| [LightLLM](https://github.com/ModelTC/LightLLM) | Model Serving | ✅ Merged |
+| [LightX2V](https://github.com/ModelTC/LightX2V) | Image/Video Generation | ✅ Merged |
+| [SGLang](https://github.com/sgl-project/sglang) | Model Serving | In Progress |
+| [ComfyUI](https://github.com/comfyanonymous/ComfyUI) | Image/Video Generation | In Progress |
+
+## License
+
+MIT License

torchada-0.1.19/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=64.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "torchada"
+version = "0.1.19"
+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/MooreThreads/torchada"
+Repository = "https://github.com/MooreThreads/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.19/setup.cfg

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

torchada-0.1.19/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()
+