mirror of
https://github.com/zebrajr/pytorch.git
synced 2025-12-06 12:20:52 +01:00
9157a748a6
For compute capabilitiy (which is an empty string, same as CPU) And for multicore count return 8, as this is smallest number of GPU cores on Apple silicon Pull Request resolved: https://github.com/pytorch/pytorch/pull/144509 Approved by: https://github.com/jansel
424 lines
14 KiB
Python
424 lines
14 KiB
Python
# mypy: allow-untyped-defs
|
|
import time
|
|
from dataclasses import dataclass
|
|
from typing import Any, Callable, Dict, Iterable, Optional, 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
|
|
|
|
@classmethod
|
|
def get_device_properties(cls, device: _device_t = None):
|
|
return cls.Worker.get_device_properties(device)
|
|
|
|
@staticmethod
|
|
def get_compute_capability(device: _device_t = None):
|
|
raise NotImplementedError
|
|
|
|
@staticmethod
|
|
def is_bf16_supported(including_emulation: bool = False):
|
|
raise NotImplementedError
|
|
|
|
@classmethod
|
|
def is_dtype_supported(
|
|
cls, dtype: torch.dtype, including_emulation: bool = False
|
|
) -> bool:
|
|
return dtype != torch.bfloat16 or cls.is_bf16_supported(including_emulation)
|
|
|
|
@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)
|
|
|
|
|
|
class MpsInterface(DeviceInterface):
|
|
@staticmethod
|
|
def is_bf16_supported(including_emulation: bool = False) -> bool:
|
|
return torch.backends.mps.is_macos_or_newer(14, 0)
|
|
|
|
@classmethod
|
|
def is_dtype_supported(
|
|
cls, dtype: torch.dtype, including_emulation: bool = False
|
|
) -> bool:
|
|
if dtype == torch.float64:
|
|
return False
|
|
return dtype != torch.bfloat16 or cls.is_bf16_supported(including_emulation)
|
|
|
|
@staticmethod
|
|
def is_available() -> bool:
|
|
return torch.backends.mps.is_available()
|
|
|
|
@staticmethod
|
|
def current_device():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def get_compute_capability(device: _device_t = None) -> str:
|
|
return ""
|
|
|
|
@staticmethod
|
|
def synchronize(device: _device_t = None):
|
|
torch.mps.synchronize()
|
|
|
|
class Worker:
|
|
@staticmethod
|
|
def get_device_properties(device: _device_t = None):
|
|
return {}
|
|
|
|
|
|
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)
|
|
register_interface_for_device("mps", MpsInterface)
|
|
|
|
_device_initialized = True
|