mirror of
https://github.com/pytorch/pytorch.git
synced 2025-10-21 05:34:18 +08:00
c254901bdb
The original PR #122396 used the CPU device since at that point in time there was no actual Triton CPU backend. After #133408, this is no longer the case, so we now have multiple backends getting registered for the CPU. The test still works in OSS but fails internally due to different test runners initializing the backends in a different order. This PR doesn't actually end up fixing the test internally because cpp_extension -- needed to implement the privateuseone device -- isn't supported there, so we simply skip it instead. However, it still makes the OSS test independent of initialization order, which is good. Differential Revision: [D63838169](https://our.internmc.facebook.com/intern/diff/D63838169/) Pull Request resolved: https://github.com/pytorch/pytorch/pull/137611 Approved by: https://github.com/henrylhtsang
382 lines
12 KiB
Python
382 lines
12 KiB
Python
# mypy: allow-untyped-defs
|
|
import time
|
|
from dataclasses import dataclass
|
|
from typing import Any, Callable, Dict, Iterable, Optional, Tuple, Type, Union
|
|
|
|
import torch
|
|
|
|
|
|
get_cuda_stream: Optional[Callable[[int], int]]
|
|
if torch.cuda._is_compiled():
|
|
from torch._C import _cuda_getCurrentRawStream as get_cuda_stream
|
|
else:
|
|
get_cuda_stream = None
|
|
|
|
_device_t = Union[torch.device, str, int, None]
|
|
|
|
# Recording the device properties in the main process but used in worker process.
|
|
caching_worker_device_properties: Dict[str, Any] = {}
|
|
caching_worker_current_devices: Dict[str, int] = {}
|
|
|
|
|
|
class DeviceInterface:
|
|
"""
|
|
This is a simple device runtime interface for Inductor. It enables custom
|
|
backends to be integrated with Inductor in a device-agnostic semantic.
|
|
"""
|
|
|
|
class device:
|
|
def __new__(cls, device: _device_t):
|
|
raise NotImplementedError
|
|
|
|
class Event:
|
|
def __new__(cls, *args, **kwargs):
|
|
raise NotImplementedError(
|
|
"Event should be inherited from torch.Event, otherwise, it couldn't be captured by dynamo."
|
|
)
|
|
|
|
class Stream:
|
|
def __new__(cls, *args, **kwargs):
|
|
raise NotImplementedError(
|
|
"Stream should be inherited from torch.Stream, otherwise, it couldn't be captured by dynamo."
|
|
)
|
|
|
|
class Worker:
|
|
"""
|
|
Worker API to query device properties that will work in multi processing
|
|
workers that cannot use the GPU APIs (due to processing fork() and
|
|
initialization time issues). Properties are recorded in the main process
|
|
before we fork the workers.
|
|
"""
|
|
|
|
@staticmethod
|
|
def set_device(device: int):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def current_device() -> int:
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def get_device_properties(device: _device_t = None):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def current_device():
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def set_device(device: _device_t):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def maybe_exchange_device(device: int) -> int:
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def exchange_device(device: int) -> int:
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def device_count():
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def is_available() -> bool:
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def stream(stream: torch.Stream):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def current_stream():
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def set_stream(stream: torch.Stream):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def _set_stream_by_id(stream_id: int, device_index: int, device_type: int):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def get_raw_stream(device_idx: int) -> int:
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def synchronize(device: _device_t = None):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def get_device_properties(device: _device_t = None):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def get_compute_capability(device: _device_t = None):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def is_bf16_supported(including_emulation: bool = False):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def memory_allocated(device: _device_t = None) -> int:
|
|
raise NotImplementedError
|
|
|
|
|
|
class DeviceGuard:
|
|
"""
|
|
This class provides a context manager for device switching. This is a stripped
|
|
down version of torch.{device_name}.device.
|
|
|
|
The context manager changes the current device to the given device index
|
|
on entering the context and restores the original device on exiting.
|
|
The device is switched using the provided device interface.
|
|
"""
|
|
|
|
def __init__(
|
|
self, device_interface: Type[DeviceInterface], index: Optional[int]
|
|
) -> None:
|
|
self.device_interface = device_interface
|
|
self.idx = index
|
|
self.prev_idx = -1
|
|
|
|
def __enter__(self):
|
|
if self.idx is not None:
|
|
self.prev_idx = self.device_interface.exchange_device(self.idx)
|
|
|
|
def __exit__(self, type: Any, value: Any, traceback: Any):
|
|
if self.idx is not None:
|
|
self.idx = self.device_interface.maybe_exchange_device(self.prev_idx)
|
|
return False
|
|
|
|
|
|
class CudaInterface(DeviceInterface):
|
|
device = torch.cuda.device
|
|
|
|
# register Event and Stream class into the backend interface
|
|
# make sure Event and Stream are implemented and inherited from the torch.Event and torch.Stream
|
|
Event = torch.cuda.Event
|
|
Stream = torch.cuda.Stream
|
|
|
|
class Worker:
|
|
@staticmethod
|
|
def set_device(device: int):
|
|
caching_worker_current_devices["cuda"] = device
|
|
|
|
@staticmethod
|
|
def current_device() -> int:
|
|
if "cuda" in caching_worker_current_devices:
|
|
return caching_worker_current_devices["cuda"]
|
|
return torch.cuda.current_device()
|
|
|
|
@staticmethod
|
|
def get_device_properties(device: _device_t = None):
|
|
if device is not None:
|
|
if isinstance(device, str):
|
|
device = torch.device(device)
|
|
assert device.type == "cuda"
|
|
if isinstance(device, torch.device):
|
|
device = device.index
|
|
if device is None:
|
|
device = CudaInterface.Worker.current_device()
|
|
|
|
if "cuda" not in caching_worker_device_properties:
|
|
device_prop = [
|
|
torch.cuda.get_device_properties(i)
|
|
for i in range(torch.cuda.device_count())
|
|
]
|
|
caching_worker_device_properties["cuda"] = device_prop
|
|
|
|
return caching_worker_device_properties["cuda"][device]
|
|
|
|
current_device = staticmethod(torch.cuda.current_device)
|
|
set_device = staticmethod(torch.cuda.set_device)
|
|
device_count = staticmethod(torch.cuda.device_count)
|
|
stream = staticmethod(torch.cuda.stream) # type: ignore[assignment]
|
|
current_stream = staticmethod(torch.cuda.current_stream)
|
|
set_stream = staticmethod(torch.cuda.set_stream) # type: ignore[assignment]
|
|
_set_stream_by_id = staticmethod(torch.cuda._set_stream_by_id) # type: ignore[assignment]
|
|
synchronize = staticmethod(torch.cuda.synchronize)
|
|
get_device_properties = staticmethod(torch.cuda.get_device_properties) # type: ignore[assignment]
|
|
get_raw_stream = staticmethod(get_cuda_stream) # type: ignore[assignment, arg-type]
|
|
exchange_device = staticmethod(torch.cuda._exchange_device) # type: ignore[arg-type]
|
|
maybe_exchange_device = staticmethod(torch.cuda._maybe_exchange_device) # type: ignore[arg-type]
|
|
memory_allocated = staticmethod(torch.cuda.memory_allocated)
|
|
is_bf16_supported = staticmethod(torch.cuda.is_bf16_supported) # type: ignore[arg-type]
|
|
|
|
# Can be mock patched by @patch decorator.
|
|
@staticmethod
|
|
def is_available() -> bool:
|
|
return torch.cuda.is_available()
|
|
|
|
@staticmethod
|
|
def get_compute_capability(device: _device_t = None):
|
|
if torch.version.hip is None:
|
|
major, min = torch.cuda.get_device_capability(device)
|
|
return major * 10 + min
|
|
else:
|
|
return torch.cuda.get_device_properties(device).gcnArchName.split(":", 1)[0]
|
|
|
|
|
|
get_xpu_stream: Optional[Callable[[int], int]]
|
|
if torch.xpu._is_compiled():
|
|
from torch._C import _xpu_getCurrentRawStream as get_xpu_stream
|
|
else:
|
|
get_xpu_stream = None
|
|
|
|
|
|
class XpuInterface(DeviceInterface):
|
|
device = torch.xpu.device
|
|
Event = torch.xpu.Event
|
|
Stream = torch.xpu.Stream
|
|
|
|
class Worker:
|
|
@staticmethod
|
|
def set_device(device: int):
|
|
caching_worker_current_devices["xpu"] = device
|
|
|
|
@staticmethod
|
|
def current_device() -> int:
|
|
if "xpu" in caching_worker_current_devices:
|
|
return caching_worker_current_devices["xpu"]
|
|
return torch.xpu.current_device()
|
|
|
|
@staticmethod
|
|
def get_device_properties(device: _device_t = None):
|
|
if device is not None:
|
|
if isinstance(device, str):
|
|
device = torch.device(device)
|
|
assert device.type == "xpu"
|
|
if isinstance(device, torch.device):
|
|
device = device.index
|
|
if device is None:
|
|
device = XpuInterface.Worker.current_device()
|
|
|
|
if "xpu" not in caching_worker_device_properties:
|
|
device_prop = [
|
|
torch.xpu.get_device_properties(i)
|
|
for i in range(torch.xpu.device_count())
|
|
]
|
|
caching_worker_device_properties["xpu"] = device_prop
|
|
|
|
return caching_worker_device_properties["xpu"][device]
|
|
|
|
current_device = staticmethod(torch.xpu.current_device)
|
|
set_device = staticmethod(torch.xpu.set_device)
|
|
device_count = staticmethod(torch.xpu.device_count)
|
|
stream = staticmethod(torch.xpu.stream) # type: ignore[assignment]
|
|
current_stream = staticmethod(torch.xpu.current_stream)
|
|
set_stream = staticmethod(torch.xpu.set_stream) # type: ignore[assignment]
|
|
_set_stream_by_id = staticmethod(torch.xpu._set_stream_by_id) # type: ignore[assignment]
|
|
synchronize = staticmethod(torch.xpu.synchronize)
|
|
get_device_properties = staticmethod(torch.xpu.get_device_properties) # type: ignore[assignment]
|
|
get_raw_stream = staticmethod(get_xpu_stream) # type: ignore[assignment, arg-type]
|
|
exchange_device = staticmethod(torch.xpu._exchange_device) # type: ignore[arg-type]
|
|
maybe_exchange_device = staticmethod(torch.xpu._maybe_exchange_device) # type: ignore[arg-type]
|
|
memory_allocated = staticmethod(torch.xpu.memory_allocated)
|
|
|
|
# Can be mock patched by @patch decorator.
|
|
@staticmethod
|
|
def is_available() -> bool:
|
|
return torch.xpu.is_available()
|
|
|
|
@staticmethod
|
|
def get_compute_capability(device: _device_t = None):
|
|
cc = torch.xpu.get_device_capability(device)
|
|
return cc
|
|
|
|
@staticmethod
|
|
def is_bf16_supported(including_emulation: bool = False) -> bool:
|
|
return torch.xpu.is_bf16_supported()
|
|
|
|
|
|
@dataclass
|
|
class CpuDeviceProperties:
|
|
multi_processor_count: int
|
|
|
|
|
|
class CpuInterface(DeviceInterface):
|
|
class Event(torch.Event):
|
|
def __init__(self, enable_timing=True):
|
|
self.time = 0.0
|
|
|
|
def elapsed_time(self, end_event) -> float:
|
|
return (end_event.time - self.time) * 1000
|
|
|
|
def record(self, stream=None):
|
|
self.time = time.perf_counter()
|
|
|
|
@staticmethod
|
|
def is_available() -> bool:
|
|
return True
|
|
|
|
@staticmethod
|
|
def get_compute_capability(device: _device_t = None) -> str:
|
|
return ""
|
|
|
|
@staticmethod
|
|
def get_raw_stream(device_idx) -> int:
|
|
return 0
|
|
|
|
@staticmethod
|
|
def current_device():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def synchronize(device: _device_t = None):
|
|
pass
|
|
|
|
class Worker:
|
|
@staticmethod
|
|
def get_device_properties(device: _device_t = None):
|
|
import multiprocessing
|
|
|
|
cpu_count = multiprocessing.cpu_count()
|
|
return CpuDeviceProperties(cpu_count)
|
|
|
|
|
|
device_interfaces: Dict[str, Type[DeviceInterface]] = {}
|
|
_device_initialized = False
|
|
|
|
|
|
def register_interface_for_device(
|
|
device: Union[str, torch.device], device_interface: Type[DeviceInterface]
|
|
):
|
|
if isinstance(device, torch.device):
|
|
device = device.type
|
|
device_interfaces[device] = device_interface
|
|
|
|
|
|
def get_interface_for_device(device: Union[str, torch.device]) -> Type[DeviceInterface]:
|
|
if isinstance(device, torch.device):
|
|
device = device.type
|
|
if not _device_initialized:
|
|
init_device_reg()
|
|
if device in device_interfaces:
|
|
return device_interfaces[device]
|
|
raise NotImplementedError(f"No interface for device {device}")
|
|
|
|
|
|
def get_registered_device_interfaces() -> Iterable[Tuple[str, Type[DeviceInterface]]]:
|
|
if not _device_initialized:
|
|
init_device_reg()
|
|
return device_interfaces.items()
|
|
|
|
|
|
def init_device_reg():
|
|
global _device_initialized
|
|
register_interface_for_device("cuda", CudaInterface)
|
|
for i in range(torch.cuda.device_count()):
|
|
register_interface_for_device(f"cuda:{i}", CudaInterface)
|
|
|
|
register_interface_for_device("xpu", XpuInterface)
|
|
for i in range(torch.xpu.device_count()):
|
|
register_interface_for_device(f"xpu:{i}", XpuInterface)
|
|
|
|
register_interface_for_device("cpu", CpuInterface)
|
|
|
|
_device_initialized = True
|