Source code for torch.utils.cpp_extension

from __future__ import absolute_import, division, print_function, unicode_literals
import copy
import glob
import imp
import os
import re
import setuptools
import subprocess
import sys
import sysconfig
import tempfile
import warnings
import collections

import torch
from .file_baton import FileBaton
from ._cpp_extension_versioner import ExtensionVersioner

from setuptools.command.build_ext import build_ext

IS_WINDOWS = sys.platform == 'win32'

BUILD_NAMEDTENSOR = os.getenv('BUILD_NAMEDTENSOR', '').upper() == '1'

def _find_cuda_home():
    '''Finds the CUDA install path.'''
    # Guess #1
    cuda_home = os.environ.get('CUDA_HOME') or os.environ.get('CUDA_PATH')
    if cuda_home is None:
        # Guess #2
            which = 'where' if IS_WINDOWS else 'which'
            nvcc = subprocess.check_output(
                [which, 'nvcc']).decode().rstrip('\r\n')
            cuda_home = os.path.dirname(os.path.dirname(nvcc))
        except Exception:
            # Guess #3
            if IS_WINDOWS:
                cuda_homes = glob.glob(
                    'C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v*.*')
                if len(cuda_homes) == 0:
                    cuda_home = ''
                    cuda_home = cuda_homes[0]
                cuda_home = '/usr/local/cuda'
            if not os.path.exists(cuda_home):
                cuda_home = None
    if cuda_home and not torch.cuda.is_available():
        print("No CUDA runtime is found, using CUDA_HOME='{}'".format(cuda_home))
    return cuda_home

MINIMUM_MSVC_VERSION = (19, 0, 24215)

                               !! WARNING !!

Your compiler ({}) may be ABI-incompatible with PyTorch!
Please use a compiler that is ABI-compatible with GCC 4.9 and above.

for instructions on how to install GCC 4.9 or higher.

                              !! WARNING !!

                               !! WARNING !!

Your compiler ({user_compiler}) is not compatible with the compiler Pytorch was
built with for this platform, which is {pytorch_compiler} on {platform}. Please
use {pytorch_compiler} to to compile your extension. Alternatively, you may
compile PyTorch from source using {user_compiler}, and then you can also use
{user_compiler} to compile your extension.

See for help
with compiling PyTorch from source.

                              !! WARNING !!
CUDA_HOME = _find_cuda_home()
CUDNN_HOME = os.environ.get('CUDNN_HOME') or os.environ.get('CUDNN_PATH')
# PyTorch releases have the version pattern major.minor.patch, whereas when
# PyTorch is built from source, we append the git commit hash, which gives
# it the below pattern.
BUILT_FROM_SOURCE_VERSION_PATTERN = re.compile(r'\d+\.\d+\.\d+\w+\+\w+')

COMMON_MSVC_FLAGS = ['/MD', '/wd4819', '/EHsc']


# See comment in load_inline for more information
# The goal is to be able to call the safe version of the
# function exactly as if it was the original one.
# We need to create a pointer to this new function to give
# it to pybind later.

#include <functional>

template <typename Ret, typename ...Args>
auto _get_safe_version(Ret (*f)(Args...)) -> std::function<Ret(Args...)> {{
    return [f](Args&& ...args) -> Ret {{
        return f(std::forward<Args>(args)...);


JIT_EXTENSION_VERSIONER = ExtensionVersioner()

def _is_binary_build():
    return not BUILT_FROM_SOURCE_VERSION_PATTERN.match(torch.version.__version__)

def _accepted_compilers_for_platform():
    # gnu-c++ and gnu-cc are the conda gcc compilers
    return ['clang++', 'clang'] if sys.platform.startswith('darwin') else ['g++', 'gcc', 'gnu-c++', 'gnu-cc']

def get_default_build_root():
    Returns the path to the root folder under which extensions will built.

    For each extension module built, there will be one folder underneath the
    folder returned by this function. For example, if ``p`` is the path
    returned by this function and ``ext`` the name of an extension, the build
    folder for the extension will be ``p/ext``.
    # tempfile.gettempdir() will be /tmp on UNIX and \TEMP on Windows.
    return os.path.realpath(os.path.join(tempfile.gettempdir(), 'torch_extensions'))

def check_compiler_ok_for_platform(compiler):
    Verifies that the compiler is the expected one for the current platform.

        compiler (str): The compiler executable to check.

        True if the compiler is gcc/g++ on Linux or clang/clang++ on macOS,
        and always True for Windows.
    if IS_WINDOWS:
        return True
    which = subprocess.check_output(['which', compiler], stderr=subprocess.STDOUT)
    # Use os.path.realpath to resolve any symlinks, in particular from 'c++' to e.g. 'g++'.
    compiler_path = os.path.realpath(which.decode().strip())
    return any(name in compiler_path for name in _accepted_compilers_for_platform())

[docs]def check_compiler_abi_compatibility(compiler): ''' Verifies that the given compiler is ABI-compatible with PyTorch. Arguments: compiler (str): The compiler executable name to check (e.g. ``g++``). Must be executable in a shell process. Returns: False if the compiler is (likely) ABI-incompatible with PyTorch, else True. ''' if not _is_binary_build(): return True if os.environ.get('TORCH_DONT_CHECK_COMPILER_ABI') in ['ON', '1', 'YES', 'TRUE', 'Y']: return True # First check if the compiler is one of the expected ones for the particular platform. if not check_compiler_ok_for_platform(compiler): warnings.warn(WRONG_COMPILER_WARNING.format( user_compiler=compiler, pytorch_compiler=_accepted_compilers_for_platform()[0], platform=sys.platform)) return False if sys.platform.startswith('darwin'): # There is no particular minimum version we need for clang, so we're good here. return True try: if sys.platform.startswith('linux'): minimum_required_version = MINIMUM_GCC_VERSION version = subprocess.check_output([compiler, '-dumpfullversion', '-dumpversion']) version = version.decode().strip().split('.') else: minimum_required_version = MINIMUM_MSVC_VERSION compiler_info = subprocess.check_output(compiler, stderr=subprocess.STDOUT) match ='(\d+)\.(\d+)\.(\d+)', compiler_info.decode().strip()) version = (0, 0, 0) if match is None else match.groups() except Exception: _, error, _ = sys.exc_info() warnings.warn('Error checking compiler version for {}: {}'.format(compiler, error)) return False if tuple(map(int, version)) >= minimum_required_version: return True compiler = '{} {}'.format(compiler, ".".join(version)) warnings.warn(ABI_INCOMPATIBILITY_WARNING.format(compiler)) return False
# See below for why we inherit BuildExtension from object. #
[docs]class BuildExtension(build_ext, object): ''' A custom :mod:`setuptools` build extension . This :class:`setuptools.build_ext` subclass takes care of passing the minimum required compiler flags (e.g. ``-std=c++11``) as well as mixed C++/CUDA compilation (and support for CUDA files in general). When using :class:`BuildExtension`, it is allowed to supply a dictionary for ``extra_compile_args`` (rather than the usual list) that maps from languages (``cxx`` or ``nvcc``) to a list of additional compiler flags to supply to the compiler. This makes it possible to supply different flags to the C++ and CUDA compiler during mixed compilation. ''' @classmethod def with_options(cls, **options): ''' Returns an alternative constructor that extends any original keyword arguments to the original constructor with the given options. ''' def init_with_options(*args, **kwargs): kwargs = kwargs.copy() kwargs.update(options) return cls(*args, **kwargs) return init_with_options def __init__(self, *args, **kwargs): super(BuildExtension, self).__init__(*args, **kwargs) self.no_python_abi_suffix = kwargs.get("no_python_abi_suffix", False) def build_extensions(self): self._check_abi() for extension in self.extensions: self._add_compile_flag(extension, '-DTORCH_API_INCLUDE_EXTENSION_H') if BUILD_NAMEDTENSOR: self._add_compile_flag(extension, '-DBUILD_NAMEDTENSOR') self._define_torch_extension_name(extension) self._add_gnu_cpp_abi_flag(extension) # Register .cu and .cuh as valid source extensions. self.compiler.src_extensions += ['.cu', '.cuh'] # Save the original _compile method for later. if self.compiler.compiler_type == 'msvc': self.compiler._cpp_extensions += ['.cu', '.cuh'] original_compile = self.compiler.compile original_spawn = self.compiler.spawn else: original_compile = self.compiler._compile def unix_wrap_compile(obj, src, ext, cc_args, extra_postargs, pp_opts): # Copy before we make any modifications. cflags = copy.deepcopy(extra_postargs) try: original_compiler = self.compiler.compiler_so if _is_cuda_file(src): nvcc = _join_cuda_home('bin', 'nvcc') if not isinstance(nvcc, list): nvcc = [nvcc] self.compiler.set_executable('compiler_so', nvcc) if isinstance(cflags, dict): cflags = cflags['nvcc'] cflags = COMMON_NVCC_FLAGS + ['--compiler-options', "'-fPIC'"] + cflags + _get_cuda_arch_flags(cflags) elif isinstance(cflags, dict): cflags = cflags['cxx'] # NVCC does not allow multiple -std to be passed, so we avoid # overriding the option if the user explicitly passed it. if not any(flag.startswith('-std=') for flag in cflags): cflags.append('-std=c++11') original_compile(obj, src, ext, cc_args, cflags, pp_opts) finally: # Put the original compiler back in place. self.compiler.set_executable('compiler_so', original_compiler) def win_wrap_compile(sources, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None): self.cflags = copy.deepcopy(extra_postargs) extra_postargs = None def spawn(cmd): # Using regex to match src, obj and include files src_regex = re.compile('/T(p|c)(.*)') src_list = [ for m in (src_regex.match(elem) for elem in cmd) if m ] obj_regex = re.compile('/Fo(.*)') obj_list = [ for m in (obj_regex.match(elem) for elem in cmd) if m ] include_regex = re.compile(r'((\-|\/)I.*)') include_list = [ for m in (include_regex.match(elem) for elem in cmd) if m ] if len(src_list) >= 1 and len(obj_list) >= 1: src = src_list[0] obj = obj_list[0] if _is_cuda_file(src): nvcc = _join_cuda_home('bin', 'nvcc') if isinstance(self.cflags, dict): cflags = self.cflags['nvcc'] elif isinstance(self.cflags, list): cflags = self.cflags else: cflags = [] cflags = COMMON_NVCC_FLAGS + cflags + _get_cuda_arch_flags(cflags) for flag in COMMON_MSVC_FLAGS: cflags = ['-Xcompiler', flag] + cflags cmd = [nvcc, '-c', src, '-o', obj] + include_list + cflags elif isinstance(self.cflags, dict): cflags = COMMON_MSVC_FLAGS + self.cflags['cxx'] cmd += cflags elif isinstance(self.cflags, list): cflags = COMMON_MSVC_FLAGS + self.cflags cmd += cflags return original_spawn(cmd) try: self.compiler.spawn = spawn return original_compile(sources, output_dir, macros, include_dirs, debug, extra_preargs, extra_postargs, depends) finally: self.compiler.spawn = original_spawn # Monkey-patch the _compile method. if self.compiler.compiler_type == 'msvc': self.compiler.compile = win_wrap_compile else: self.compiler._compile = unix_wrap_compile build_ext.build_extensions(self) def get_ext_filename(self, ext_name): # Get the original shared library name. For Python 3, this name will be # suffixed with "<SOABI>.so", where <SOABI> will be something like # cpython-37m-x86_64-linux-gnu. On Python 2, there is no such ABI name. # The final extension, .so, would be .lib/.dll on Windows of course. ext_filename = super(BuildExtension, self).get_ext_filename(ext_name) # If `no_python_abi_suffix` is `True`, we omit the Python 3 ABI # component. This makes building shared libraries with setuptools that # aren't Python modules nicer. if self.no_python_abi_suffix and sys.version_info >= (3, 0): # The parts will be e.g. ["my_extension", "cpython-37m-x86_64-linux-gnu", "so"]. ext_filename_parts = ext_filename.split('.') # Omit the second to last element. without_abi = ext_filename_parts[:-2] + ext_filename_parts[-1:] ext_filename = '.'.join(without_abi) return ext_filename def _check_abi(self): # On some platforms, like Windows, compiler_cxx is not available. if hasattr(self.compiler, 'compiler_cxx'): compiler = self.compiler.compiler_cxx[0] elif IS_WINDOWS: compiler = os.environ.get('CXX', 'cl') else: compiler = os.environ.get('CXX', 'c++') check_compiler_abi_compatibility(compiler) def _add_compile_flag(self, extension, flag): extension.extra_compile_args = copy.deepcopy(extension.extra_compile_args) if isinstance(extension.extra_compile_args, dict): for args in extension.extra_compile_args.values(): args.append(flag) else: extension.extra_compile_args.append(flag) def _define_torch_extension_name(self, extension): # pybind11 doesn't support dots in the names # so in order to support extensions in the packages # like torch._C, we take the last part of the string # as the library name names ='.') name = names[-1] define = '-DTORCH_EXTENSION_NAME={}'.format(name) self._add_compile_flag(extension, define) def _add_gnu_cpp_abi_flag(self, extension): # use the same CXX ABI as what PyTorch was compiled with self._add_compile_flag(extension, '-D_GLIBCXX_USE_CXX11_ABI=' + str(int(torch._C._GLIBCXX_USE_CXX11_ABI)))
[docs]def CppExtension(name, sources, *args, **kwargs): ''' Creates a :class:`setuptools.Extension` for C++. Convenience method that creates a :class:`setuptools.Extension` with the bare minimum (but often sufficient) arguments to build a C++ extension. All arguments are forwarded to the :class:`setuptools.Extension` constructor. Example: >>> from setuptools import setup >>> from torch.utils.cpp_extension import BuildExtension, CppExtension >>> setup( name='extension', ext_modules=[ CppExtension( name='extension', sources=['extension.cpp'], extra_compile_args=['-g']), ], cmdclass={ 'build_ext': BuildExtension }) ''' include_dirs = kwargs.get('include_dirs', []) include_dirs += include_paths() kwargs['include_dirs'] = include_dirs if IS_WINDOWS: library_dirs = kwargs.get('library_dirs', []) library_dirs += library_paths() kwargs['library_dirs'] = library_dirs libraries = kwargs.get('libraries', []) libraries.append('c10') libraries.append('torch') libraries.append('torch_python') libraries.append('_C') kwargs['libraries'] = libraries kwargs['language'] = 'c++' return setuptools.Extension(name, sources, *args, **kwargs)
[docs]def CUDAExtension(name, sources, *args, **kwargs): ''' Creates a :class:`setuptools.Extension` for CUDA/C++. Convenience method that creates a :class:`setuptools.Extension` with the bare minimum (but often sufficient) arguments to build a CUDA/C++ extension. This includes the CUDA include path, library path and runtime library. All arguments are forwarded to the :class:`setuptools.Extension` constructor. Example: >>> from setuptools import setup >>> from torch.utils.cpp_extension import BuildExtension, CUDAExtension >>> setup( name='cuda_extension', ext_modules=[ CUDAExtension( name='cuda_extension', sources=['extension.cpp', ''], extra_compile_args={'cxx': ['-g'], 'nvcc': ['-O2']}) ], cmdclass={ 'build_ext': BuildExtension }) ''' library_dirs = kwargs.get('library_dirs', []) library_dirs += library_paths(cuda=True) kwargs['library_dirs'] = library_dirs libraries = kwargs.get('libraries', []) libraries.append('cudart') if IS_WINDOWS: libraries.append('c10') libraries.append('c10_cuda') libraries.append('torch') libraries.append('torch_python') libraries.append('_C') kwargs['libraries'] = libraries include_dirs = kwargs.get('include_dirs', []) include_dirs += include_paths(cuda=True) kwargs['include_dirs'] = include_dirs kwargs['language'] = 'c++' return setuptools.Extension(name, sources, *args, **kwargs)
[docs]def include_paths(cuda=False): ''' Get the include paths required to build a C++ or CUDA extension. Args: cuda: If `True`, includes CUDA-specific include paths. Returns: A list of include path strings. ''' here = os.path.abspath(__file__) torch_path = os.path.dirname(os.path.dirname(here)) lib_include = os.path.join(torch_path, 'include') paths = [ lib_include, # Remove this once torch/torch.h is officially no longer supported for C++ extensions. os.path.join(lib_include, 'torch', 'csrc', 'api', 'include'), # Some internal (old) Torch headers don't properly prefix their includes, # so we need to pass -Itorch/lib/include/TH as well. os.path.join(lib_include, 'TH'), os.path.join(lib_include, 'THC') ] if cuda: cuda_home_include = _join_cuda_home('include') # if we have the Debian/Ubuntu packages for cuda, we get /usr as cuda home. # but gcc dosn't like having /usr/include passed explicitly if cuda_home_include != '/usr/include': paths.append(cuda_home_include) if CUDNN_HOME is not None: paths.append(os.path.join(CUDNN_HOME, 'include')) return paths
def library_paths(cuda=False): ''' Get the library paths required to build a C++ or CUDA extension. Args: cuda: If `True`, includes CUDA-specific library paths. Returns: A list of library path strings. ''' paths = [] if IS_WINDOWS: here = os.path.abspath(__file__) torch_path = os.path.dirname(os.path.dirname(here)) lib_path = os.path.join(torch_path, 'lib') paths.append(lib_path) if cuda: if IS_WINDOWS: lib_dir = 'lib/x64' else: lib_dir = 'lib64' if (not os.path.exists(_join_cuda_home(lib_dir)) and os.path.exists(_join_cuda_home('lib'))): # 64-bit CUDA may be installed in 'lib' (see e.g. gh-16955) # Note that it's also possible both don't exist (see # _find_cuda_home) - in that case we stay with 'lib64'. lib_dir = 'lib' paths.append(_join_cuda_home(lib_dir)) if CUDNN_HOME is not None: paths.append(os.path.join(CUDNN_HOME, lib_dir)) return paths
[docs]def load(name, sources, extra_cflags=None, extra_cuda_cflags=None, extra_ldflags=None, extra_include_paths=None, build_directory=None, verbose=False, with_cuda=None, is_python_module=True): ''' Loads a PyTorch C++ extension just-in-time (JIT). To load an extension, a Ninja build file is emitted, which is used to compile the given sources into a dynamic library. This library is subsequently loaded into the current Python process as a module and returned from this function, ready for use. By default, the directory to which the build file is emitted and the resulting library compiled to is ``<tmp>/torch_extensions/<name>``, where ``<tmp>`` is the temporary folder on the current platform and ``<name>`` the name of the extension. This location can be overridden in two ways. First, if the ``TORCH_EXTENSIONS_DIR`` environment variable is set, it replaces ``<tmp>/torch_extensions`` and all extensions will be compiled into subfolders of this directory. Second, if the ``build_directory`` argument to this function is supplied, it overrides the entire path, i.e. the library will be compiled into that folder directly. To compile the sources, the default system compiler (``c++``) is used, which can be overridden by setting the ``CXX`` environment variable. To pass additional arguments to the compilation process, ``extra_cflags`` or ``extra_ldflags`` can be provided. For example, to compile your extension with optimizations, pass ``extra_cflags=['-O3']``. You can also use ``extra_cflags`` to pass further include directories. CUDA support with mixed compilation is provided. Simply pass CUDA source files (``.cu`` or ``.cuh``) along with other sources. Such files will be detected and compiled with nvcc rather than the C++ compiler. This includes passing the CUDA lib64 directory as a library directory, and linking ``cudart``. You can pass additional flags to nvcc via ``extra_cuda_cflags``, just like with ``extra_cflags`` for C++. Various heuristics for finding the CUDA install directory are used, which usually work fine. If not, setting the ``CUDA_HOME`` environment variable is the safest option. Args: name: The name of the extension to build. This MUST be the same as the name of the pybind11 module! sources: A list of relative or absolute paths to C++ source files. extra_cflags: optional list of compiler flags to forward to the build. extra_cuda_cflags: optional list of compiler flags to forward to nvcc when building CUDA sources. extra_ldflags: optional list of linker flags to forward to the build. extra_include_paths: optional list of include directories to forward to the build. build_directory: optional path to use as build workspace. verbose: If ``True``, turns on verbose logging of load steps. with_cuda: Determines whether CUDA headers and libraries are added to the build. If set to ``None`` (default), this value is automatically determined based on the existence of ``.cu`` or ``.cuh`` in ``sources``. Set it to `True`` to force CUDA headers and libraries to be included. is_python_module: If ``True`` (default), imports the produced shared library as a Python module. If ``False``, loads it into the process as a plain dynamic library. Returns: If ``is_python_module`` is ``True``, returns the loaded PyTorch extension as a Python module. If ``is_python_module`` is ``False`` returns nothing (the shared library is loaded into the process as a side effect). Example: >>> from torch.utils.cpp_extension import load >>> module = load( name='extension', sources=['extension.cpp', ''], extra_cflags=['-O2'], verbose=True) ''' return _jit_compile( name, [sources] if isinstance(sources, str) else sources, extra_cflags, extra_cuda_cflags, extra_ldflags, extra_include_paths, build_directory or _get_build_directory(name, verbose), verbose, with_cuda, is_python_module)
[docs]def load_inline(name, cpp_sources, cuda_sources=None, functions=None, extra_cflags=None, extra_cuda_cflags=None, extra_ldflags=None, extra_include_paths=None, build_directory=None, verbose=False, with_cuda=None, is_python_module=True, with_pytorch_error_handling=True): ''' Loads a PyTorch C++ extension just-in-time (JIT) from string sources. This function behaves exactly like :func:`load`, but takes its sources as strings rather than filenames. These strings are stored to files in the build directory, after which the behavior of :func:`load_inline` is identical to :func:`load`. See `the tests <>`_ for good examples of using this function. Sources may omit two required parts of a typical non-inline C++ extension: the necessary header includes, as well as the (pybind11) binding code. More precisely, strings passed to ``cpp_sources`` are first concatenated into a single ``.cpp`` file. This file is then prepended with ``#include <torch/extension.h>``. Furthermore, if the ``functions`` argument is supplied, bindings will be automatically generated for each function specified. ``functions`` can either be a list of function names, or a dictionary mapping from function names to docstrings. If a list is given, the name of each function is used as its docstring. The sources in ``cuda_sources`` are concatenated into a separate ``.cu`` file and prepended with ``torch/types.h``, ``cuda.h`` and ``cuda_runtime.h`` includes. The ``.cpp`` and ``.cu`` files are compiled separately, but ultimately linked into a single library. Note that no bindings are generated for functions in ``cuda_sources`` per se. To bind to a CUDA kernel, you must create a C++ function that calls it, and either declare or define this C++ function in one of the ``cpp_sources`` (and include its name in ``functions``). See :func:`load` for a description of arguments omitted below. Args: cpp_sources: A string, or list of strings, containing C++ source code. cuda_sources: A string, or list of strings, containing CUDA source code. functions: A list of function names for which to generate function bindings. If a dictionary is given, it should map function names to docstrings (which are otherwise just the function names). with_cuda: Determines whether CUDA headers and libraries are added to the build. If set to ``None`` (default), this value is automatically determined based on whether ``cuda_sources`` is provided. Set it to ``True`` to force CUDA headers and libraries to be included. with_pytorch_error_handling: Determines whether pytorch error and warning macros are handled by pytorch instead of pybind. To do this, each function ``foo`` is called via an intermediary ``_safe_foo`` function. This redirection might cause issues in obscure cases of cpp. This flag should be set to ``False`` when this redirect causes issues. Example: >>> from torch.utils.cpp_extension import load_inline >>> source = \'\'\' at::Tensor sin_add(at::Tensor x, at::Tensor y) { return x.sin() + y.sin(); } \'\'\' >>> module = load_inline(name='inline_extension', cpp_sources=[source], functions=['sin_add']) ''' build_directory = build_directory or _get_build_directory(name, verbose) if isinstance(cpp_sources, str): cpp_sources = [cpp_sources] cuda_sources = cuda_sources or [] if isinstance(cuda_sources, str): cuda_sources = [cuda_sources] cpp_sources.insert(0, '#include <torch/extension.h>') # Adds a new `_get_safe_version(foo)` function that returns a new function # that performs the same operation as `foo` but with pytorch error handling # macros. cpp_sources.append(SAFE_FUNCTION_DEFINITION) # If `functions` is supplied, we create the pybind11 bindings for the user. # Here, `functions` is (or becomes, after some processing) a map from # function names to function docstrings. if functions is not None: module_def = [] module_def.append('PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {') if isinstance(functions, str): functions = [functions] if isinstance(functions, list): # Make the function docstring the same as the function name. functions = dict((f, f) for f in functions) elif not isinstance(functions, dict): raise ValueError( "Expected 'functions' to be a list or dict, but was {}".format( type(functions))) for function_name, docstring in functions.items(): if with_pytorch_error_handling: module_def.append('m.def("{0}", _get_safe_version({0}), "{1}");'.format( function_name, docstring)) else: module_def.append('m.def("{0}", {0}, "{1}");'.format(function_name, docstring)) module_def.append('}') cpp_sources += module_def cpp_source_path = os.path.join(build_directory, 'main.cpp') with open(cpp_source_path, 'w') as cpp_source_file: cpp_source_file.write('\n'.join(cpp_sources)) sources = [cpp_source_path] if cuda_sources: cuda_sources.insert(0, '#include <torch/types.h>') cuda_sources.insert(1, '#include <cuda.h>') cuda_sources.insert(2, '#include <cuda_runtime.h>') cuda_source_path = os.path.join(build_directory, '') with open(cuda_source_path, 'w') as cuda_source_file: cuda_source_file.write('\n'.join(cuda_sources)) sources.append(cuda_source_path) return _jit_compile( name, sources, extra_cflags, extra_cuda_cflags, extra_ldflags, extra_include_paths, build_directory, verbose, with_cuda, is_python_module)
def _jit_compile(name, sources, extra_cflags, extra_cuda_cflags, extra_ldflags, extra_include_paths, build_directory, verbose, with_cuda, is_python_module): old_version = JIT_EXTENSION_VERSIONER.get_version(name) version = JIT_EXTENSION_VERSIONER.bump_version_if_changed( name, sources, build_arguments=[extra_cflags, extra_cuda_cflags, extra_ldflags, extra_include_paths], build_directory=build_directory, with_cuda=with_cuda ) if version > 0: if version != old_version and verbose: print('The input conditions for extension module {} have changed. '.format(name) + 'Bumping to version {0} and re-building as {1}_v{0}...'.format(version, name)) name = '{}_v{}'.format(name, version) if version != old_version: baton = FileBaton(os.path.join(build_directory, 'lock')) if baton.try_acquire(): try: _write_ninja_file_and_build( name=name, sources=sources, extra_cflags=extra_cflags or [], extra_cuda_cflags=extra_cuda_cflags or [], extra_ldflags=extra_ldflags or [], extra_include_paths=extra_include_paths or [], build_directory=build_directory, verbose=verbose, with_cuda=with_cuda) finally: baton.release() else: baton.wait() elif verbose: print('No modifications detected for re-loaded extension ' 'module {}, skipping build step...'.format(name)) if verbose: print('Loading extension module {}...'.format(name)) return _import_module_from_library(name, build_directory, is_python_module) def _write_ninja_file_and_build(name, sources, extra_cflags, extra_cuda_cflags, extra_ldflags, extra_include_paths, build_directory, verbose, with_cuda): verify_ninja_availability() if IS_WINDOWS: compiler = os.environ.get('CXX', 'cl') else: compiler = os.environ.get('CXX', 'c++') check_compiler_abi_compatibility(compiler) if with_cuda is None: with_cuda = any(map(_is_cuda_file, sources)) extra_ldflags = _prepare_ldflags( extra_ldflags or [], with_cuda, verbose) build_file_path = os.path.join(build_directory, '') if verbose: print( 'Emitting ninja build file {}...'.format(build_file_path)) # NOTE: Emitting a new ninja build file does not cause re-compilation if # the sources did not change, so it's ok to re-emit (and it's fast). _write_ninja_file( path=build_file_path, name=name, sources=sources, extra_cflags=extra_cflags or [], extra_cuda_cflags=extra_cuda_cflags or [], extra_ldflags=extra_ldflags or [], extra_include_paths=extra_include_paths or [], with_cuda=with_cuda) if verbose: print('Building extension module {}...'.format(name)) _build_extension_module(name, build_directory, verbose)
[docs]def verify_ninja_availability(): ''' Returns ``True`` if the `ninja <>`_ build system is available on the system. ''' with open(os.devnull, 'wb') as devnull: try: subprocess.check_call('ninja --version'.split(), stdout=devnull) except OSError: raise RuntimeError("Ninja is required to load C++ extensions") else: return True
def _prepare_ldflags(extra_ldflags, with_cuda, verbose): if IS_WINDOWS: python_path = os.path.dirname(sys.executable) python_lib_path = os.path.join(python_path, 'libs') here = os.path.abspath(__file__) torch_path = os.path.dirname(os.path.dirname(here)) lib_path = os.path.join(torch_path, 'lib') extra_ldflags.append('c10.lib') extra_ldflags.append('torch.lib') extra_ldflags.append('torch_python.lib') extra_ldflags.append('_C.lib') extra_ldflags.append('/LIBPATH:{}'.format(python_lib_path)) extra_ldflags.append('/LIBPATH:{}'.format(lib_path)) if with_cuda: if verbose: print('Detected CUDA files, patching ldflags') if IS_WINDOWS: extra_ldflags.append('/LIBPATH:{}'.format( _join_cuda_home('lib/x64'))) extra_ldflags.append('cudart.lib') if CUDNN_HOME is not None: extra_ldflags.append(os.path.join(CUDNN_HOME, 'lib/x64')) else: extra_ldflags.append('-L{}'.format(_join_cuda_home('lib64'))) extra_ldflags.append('-lcudart') if CUDNN_HOME is not None: extra_ldflags.append('-L{}'.format(os.path.join(CUDNN_HOME, 'lib64'))) return extra_ldflags def _get_cuda_arch_flags(cflags=None): ''' Determine CUDA arch flags to use. For an arch, say "6.1", the added compile flag will be ``-gencode=arch=compute_61,code=sm_61``. For an added "+PTX", an additional ``-gencode=arch=compute_xx,code=compute_xx`` is added. See select_compute_arch.cmake for corresponding named and supported arches when building with CMake. ''' # If cflags is given, there may already be user-provided arch flags in it # (from `extra_compile_args`) if cflags is not None: for flag in cflags: if 'arch' in flag: return [] # Note: keep combined names ("arch1+arch2") above single names, otherwise # string replacement may not do the right thing named_arches = collections.OrderedDict([ ('Kepler+Tesla', '3.7'), ('Kepler', '3.5+PTX'), ('Maxwell+Tegra', '5.3'), ('Maxwell', '5.0;5.2+PTX'), ('Pascal', '6.0;6.1+PTX'), ('Volta', '7.0+PTX'), ('Turing', '7.5+PTX'), ]) supported_arches = ['3.5', '3.7', '5.0', '5.2', '5.3', '6.0', '6.1', '6.2', '7.0', '7.2', '7.5'] valid_arch_strings = supported_arches + [s + "+PTX" for s in supported_arches] # The default is sm_30 for CUDA 9.x and 10.x # First check for an env var (same as used by the main # Can be one or more architectures, e.g. "6.1" or "3.5;5.2;6.0;6.1;7.0+PTX" # See cmake/Modules_CUDA_fix/upstream/FindCUDA/select_compute_arch.cmake arch_list = os.environ.get('TORCH_CUDA_ARCH_LIST', None) # If not given, determine what's needed for the GPU that can be found if not arch_list: capability = torch.cuda.get_device_capability() arch_list = ['{}.{}'.format(capability[0], capability[1])] else: # Deal with lists that are ' ' separated (only deal with ';' after) arch_list = arch_list.replace(' ', ';') # Expand named arches for named_arch, archval in named_arches.items(): arch_list = arch_list.replace(named_arch, archval) arch_list = arch_list.split(';') flags = [] for arch in arch_list: if arch not in valid_arch_strings: raise ValueError("Unknown CUDA arch ({}) or GPU not supported".format(arch)) else: num = arch[0] + arch[2] flags.append('-gencode=arch=compute_{},code=sm_{}'.format(num, num)) if arch.endswith('+PTX'): flags.append('-gencode=arch=compute_{},code=compute_{}'.format(num, num)) return list(set(flags)) def _get_build_directory(name, verbose): root_extensions_directory = os.environ.get('TORCH_EXTENSIONS_DIR') if root_extensions_directory is None: root_extensions_directory = get_default_build_root() if verbose: print('Using {} as PyTorch extensions root...'.format( root_extensions_directory)) build_directory = os.path.join(root_extensions_directory, name) if not os.path.exists(build_directory): if verbose: print('Creating extension directory {}...'.format(build_directory)) # This is like mkdir -p, i.e. will also create parent directories. os.makedirs(build_directory) return build_directory def _build_extension_module(name, build_directory, verbose): try: sys.stdout.flush() sys.stderr.flush() if sys.version_info >= (3, 5): ['ninja', '-v'], stdout=None if verbose else subprocess.PIPE, stderr=subprocess.STDOUT, cwd=build_directory, check=True) else: subprocess.check_output( ['ninja', '-v'], stderr=subprocess.STDOUT, cwd=build_directory) except subprocess.CalledProcessError: # Python 2 and 3 compatible way of getting the error object. _, error, _ = sys.exc_info() # error.output contains the stdout and stderr of the build attempt. message = "Error building extension '{}'".format(name) if hasattr(error, 'output') and error.output: message += ": {}".format(error.output.decode()) raise RuntimeError(message) def _import_module_from_library(module_name, path, is_python_module): # file, path, description = imp.find_module(module_name, [path]) # Close the .so file after load. with file: if is_python_module: return imp.load_module(module_name, file, path, description) else: torch.ops.load_library(path) def _write_ninja_file(path, name, sources, extra_cflags, extra_cuda_cflags, extra_ldflags, extra_include_paths, with_cuda): extra_cflags = [flag.strip() for flag in extra_cflags] extra_cuda_cflags = [flag.strip() for flag in extra_cuda_cflags] extra_ldflags = [flag.strip() for flag in extra_ldflags] extra_include_paths = [flag.strip() for flag in extra_include_paths] if IS_WINDOWS: compiler = os.environ.get('CXX', 'cl') else: compiler = os.environ.get('CXX', 'c++') # Version 1.3 is required for the `deps` directive. config = ['ninja_required_version = 1.3'] config.append('cxx = {}'.format(compiler)) if with_cuda: config.append('nvcc = {}'.format(_join_cuda_home('bin', 'nvcc'))) # Turn into absolute paths so we can emit them into the ninja build # file wherever it is. sources = [os.path.abspath(file) for file in sources] user_includes = [os.path.abspath(file) for file in extra_include_paths] # include_paths() gives us the location of torch/extension.h system_includes = include_paths(with_cuda) # sysconfig.get_paths()['include'] gives us the location of Python.h system_includes.append(sysconfig.get_paths()['include']) # Windows does not understand `-isystem`. if IS_WINDOWS: user_includes += system_includes system_includes.clear() common_cflags = ['-DTORCH_EXTENSION_NAME={}'.format(name)] common_cflags.append('-DTORCH_API_INCLUDE_EXTENSION_H') if BUILD_NAMEDTENSOR: common_cflags.append('-DBUILD_NAMEDTENSOR') common_cflags += ['-I{}'.format(include) for include in user_includes] common_cflags += ['-isystem {}'.format(include) for include in system_includes] common_cflags += ['-D_GLIBCXX_USE_CXX11_ABI=' + str(int(torch._C._GLIBCXX_USE_CXX11_ABI))] if IS_WINDOWS: cflags = common_cflags + COMMON_MSVC_FLAGS + extra_cflags from distutils.spawn import _nt_quote_args cflags = _nt_quote_args(cflags) else: cflags = common_cflags + ['-fPIC', '-std=c++11'] + extra_cflags flags = ['cflags = {}'.format(' '.join(cflags))] if with_cuda: cuda_flags = common_cflags + COMMON_NVCC_FLAGS + _get_cuda_arch_flags() if IS_WINDOWS: for flag in COMMON_MSVC_FLAGS: cuda_flags = ['-Xcompiler', flag] + cuda_flags cuda_flags = _nt_quote_args(cuda_flags) cuda_flags += _nt_quote_args(extra_cuda_cflags) else: cuda_flags += ['--compiler-options', "'-fPIC'"] cuda_flags += extra_cuda_cflags if not any(flag.startswith('-std=') for flag in cuda_flags): cuda_flags.append('-std=c++11') flags.append('cuda_flags = {}'.format(' '.join(cuda_flags))) if IS_WINDOWS: ldflags = ['/DLL'] + extra_ldflags else: ldflags = ['-shared'] + extra_ldflags # The darwin linker needs explicit consent to ignore unresolved symbols. if sys.platform.startswith('darwin'): ldflags.append('-undefined dynamic_lookup') elif IS_WINDOWS: ldflags = _nt_quote_args(ldflags) flags.append('ldflags = {}'.format(' '.join(ldflags))) # See for reference. compile_rule = ['rule compile'] if IS_WINDOWS: compile_rule.append( ' command = cl /showIncludes $cflags -c $in /Fo$out') compile_rule.append(' deps = msvc') else: compile_rule.append( ' command = $cxx -MMD -MF $out.d $cflags -c $in -o $out') compile_rule.append(' depfile = $out.d') compile_rule.append(' deps = gcc') if with_cuda: cuda_compile_rule = ['rule cuda_compile'] cuda_compile_rule.append( ' command = $nvcc $cuda_flags -c $in -o $out') link_rule = ['rule link'] if IS_WINDOWS: cl_paths = subprocess.check_output(['where', 'cl']).decode().split('\r\n') if len(cl_paths) >= 1: cl_path = os.path.dirname(cl_paths[0]).replace(':', '$:') else: raise RuntimeError("MSVC is required to load C++ extensions") link_rule.append( ' command = "{}/link.exe" $in /nologo $ldflags /out:$out'.format( cl_path)) else: link_rule.append(' command = $cxx $in $ldflags -o $out') # Emit one build rule per source to enable incremental build. object_files = [] build = [] for source_file in sources: # '/path/to/file.cpp' -> 'file' file_name = os.path.splitext(os.path.basename(source_file))[0] if _is_cuda_file(source_file) and with_cuda: rule = 'cuda_compile' # Use a different object filename in case a C++ and CUDA file have # the same filename but different extension (.cpp vs. .cu). target = '{}.cuda.o'.format(file_name) else: rule = 'compile' target = '{}.o'.format(file_name) object_files.append(target) if IS_WINDOWS: source_file = source_file.replace(':', '$:') source_file = source_file.replace(" ", "$ ") build.append('build {}: {} {}'.format(target, rule, source_file)) ext = 'pyd' if IS_WINDOWS else 'so' library_target = '{}.{}'.format(name, ext) link = ['build {}: link {}'.format(library_target, ' '.join(object_files))] default = ['default {}'.format(library_target)] # 'Blocks' should be separated by newlines, for visual benefit. blocks = [config, flags, compile_rule] if with_cuda: blocks.append(cuda_compile_rule) blocks += [link_rule, build, link, default] with open(path, 'w') as build_file: for block in blocks: lines = '\n'.join(block) build_file.write('{}\n\n'.format(lines)) def _join_cuda_home(*paths): ''' Joins paths with CUDA_HOME, or raises an error if it CUDA_HOME is not set. This is basically a lazy way of raising an error for missing $CUDA_HOME only once we need to get any CUDA-specific path. ''' if CUDA_HOME is None: raise EnvironmentError('CUDA_HOME environment variable is not set. ' 'Please set it to your CUDA install root.') return os.path.join(CUDA_HOME, *paths) def _is_cuda_file(path): return os.path.splitext(path)[1] in ['.cu', '.cuh']


Access comprehensive developer documentation for PyTorch

View Docs


Get in-depth tutorials for beginners and advanced developers

View Tutorials


Find development resources and get your questions answered

View Resources