def build_extension(self, ext):
#self.debug = True
extdir = os.path.abspath(
os.path.dirname(self.get_ext_fullpath(ext.path)))
# python directories
python_include_dirs = distutils.sysconfig.get_python_inc()
python_lib_dirs = distutils.sysconfig.get_config_var('LIBDIR')
torch_include_dirs = include_paths(True)
torch_library_dirs = library_paths(True)
cxx11abi = str(int(torch._C._GLIBCXX_USE_CXX11_ABI))
cmake_args = [
'-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
'-DBUILD_TESTS=OFF',
'-DBUILD_PYTHON_MODULE=ON',
#'-DPYTHON_EXECUTABLE=' + sys.executable,
#'-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON,
'-DPYTHON_INCLUDE_DIRS=' +
';'.join([python_include_dirs] + include_paths(True)),
'-DPYTHON_LINK_DIRS=' + ';'.join(library_paths(True)),
'-DTORCH_CXX11_ABI=' + cxx11abi,
'-DTORCH_LIBRARIES=c10;c10_cuda;torch;torch_cuda;torch_cpu;torch_python;triton',
'-DLLVM_CONFIG=' + find_llvm()
]
# configuration
cfg = 'Debug' if self.debug else 'Release'
cfg = 'Release'
build_args = ['--config', cfg]
if platform.system() == "Windows":
cmake_args += [
'-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(
cfg.upper(), extdir)
]
if sys.maxsize > 2**32:
cmake_args += ['-A', 'x64']
build_args += ['--', '/m']
else:
cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
build_args += ['--', '-j4']
env = os.environ.copy()
if not os.path.exists(self.build_temp):
os.makedirs(self.build_temp)
sourcedir = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'src'))
subprocess.check_call(['cmake', sourcedir] + cmake_args,
cwd=self.build_temp,
env=env)
subprocess.check_call(['cmake', '--build', '.'] + build_args,
cwd=self.build_temp)
def build_cmake(self, extension: CMakeExtension):
"""
The steps required to build the extension
"""
build_dir = pathlib.Path('.'.join([self.build_temp, extension.name]))
build_dir.mkdir(parents=True, exist_ok=True)
install_dir = TORCH_CCL_PATH
# Now that the necessary directories are created, build
my_env = os.environ.copy()
build_options = {
# The value cannot be easily obtained in CMakeLists.txt.
'PYTHON_INCLUDE_DIRS':
str(distutils.sysconfig.get_python_inc()),
'PYTORCH_INCLUDE_DIRS':
CMakeExtension.convert_cmake_dirs(include_paths()),
'PYTORCH_LIBRARY_DIRS':
CMakeExtension.convert_cmake_dirs(library_paths()),
}
extension.generate(build_options, my_env, build_dir, install_dir)
max_jobs = os.getenv('MAX_JOBS', str(multiprocessing.cpu_count()))
build_args = ['-j', max_jobs]
check_call(['make', 'torch_ccl'] + build_args,
cwd=str(build_dir),
env=my_env)
check_call(['make', 'install'], cwd=str(build_dir), env=my_env)
def get_jittable_extension():
ext_modules = []
extensions_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'brevitas', 'csrc')
sources = glob.glob(os.path.join(extensions_dir, '*.cpp'))
sources = [os.path.join(extensions_dir, s) for s in sources]
include_dirs = [extensions_dir] + include_paths()
define_macros = []
libraries = []
library_dirs = []
extra_compile_args = {}
if sys.platform == 'win32':
define_macros += [('brevitas_EXPORTS', None)]
extra_compile_args.setdefault('cxx', [])
extra_compile_args['cxx'].append('/MP')
library_dirs += library_paths()
libraries.append('c10')
libraries.append('torch')
libraries.append('torch_python')
libraries.append('_C')
jittable_ext = JittableExtension('brevitas._C',
language='c++',
sources=sources,
libraries=libraries,
library_dirs=library_dirs,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args)
ext_modules.append(jittable_ext)
return ext_modules
def main():
extra_compile_args = []
extra_link_args = []
grpc_objects = [
f"{PREFIX}/lib/libgrpc++.a",
f"{PREFIX}/lib/libgrpc.a",
f"{PREFIX}/lib/libgpr.a",
f"{PREFIX}/lib/libaddress_sorting.a",
]
include_dirs = cpp_extension.include_paths() + [
np.get_include(),
f"{PREFIX}/include",
]
libraries = []
if sys.platform == "darwin":
extra_compile_args += ["-stdlib=libc++", "-mmacosx-version-min=10.14"]
extra_link_args += ["-stdlib=libc++", "-mmacosx-version-min=10.14"]
# Relevant only when c-cares is not embedded in grpc, e.g. when
# installing grpc via homebrew.
libraries.append("cares")
elif sys.platform == "linux":
libraries.append("z")
grpc_objects.append(f"{PREFIX}/lib/libprotobuf.a")
libtorchbeast = cpp_extension.CppExtension(
name="libtorchbeast._C",
sources=[
"libtorchbeast/libtorchbeast.cc",
"libtorchbeast/actorpool.cc",
"libtorchbeast/rpcenv.cc",
"libtorchbeast/rpcenv.pb.cc",
"libtorchbeast/rpcenv.grpc.pb.cc",
],
include_dirs=include_dirs,
libraries=libraries,
language="c++",
extra_compile_args=["-std=c++17"] + extra_compile_args,
extra_link_args=extra_link_args,
extra_objects=grpc_objects,
)
setuptools.setup(
name="libtorchbeast",
packages=["libtorchbeast"],
version="0.0.14",
ext_modules=[libtorchbeast],
cmdclass={"build_ext": build_ext},
test_suite="setup.test_suite",
install_requires=[
'setuptools'
], # HACK: any package is ok, but somehow must not be empty
)
def is_torch_cuda(build_ext, include_dirs, extra_compile_args):
try:
from torch.utils.cpp_extension import include_paths
test_compile(build_ext, 'test_torch_cuda', include_dirs=include_dirs + include_paths(cuda=True),
extra_compile_preargs=extra_compile_args, code=textwrap.dedent('''\
#include <THC/THC.h>
void test() {
}
'''))
return True
except (CompileError, LinkError, EnvironmentError):
print('INFO: Above error indicates that this PyTorch installation does not support CUDA.')
return False
def get_python_c_module():
main_compile_args = []
main_libraries = ['torch_ccl']
main_link_args = []
main_sources = ["torch_ccl/csrc/_C.cpp"]
lib_path = os.path.join(TORCH_CCL_PATH, "lib")
library_dirs = [lib_path]
include_path = os.path.join(CWD, "src")
include_dirs = include_paths()
include_dirs.append(include_path)
extra_link_args = []
extra_compile_args = [
'-Wall',
'-Wextra',
'-Wno-strict-overflow',
'-Wno-unused-parameter',
'-Wno-missing-field-initializers',
'-Wno-write-strings',
'-Wno-unknown-pragmas',
# This is required for Python 2 declarations that are deprecated in 3.
'-Wno-deprecated-declarations',
# Python 2.6 requires -fno-strict-aliasing, see
# http://legacy.python.org/dev/peps/pep-3123/
# We also depend on it in our code (even Python 3).
'-fno-strict-aliasing',
# Clang has an unfixed bug leading to spurious missing
# braces warnings, see
# https://bugs.llvm.org/show_bug.cgi?id=21629
'-Wno-missing-braces',
]
def make_relative_rpath(path):
return '-Wl,-rpath,$ORIGIN/' + path
_c_module = Extension("torch_ccl._C",
libraries=main_libraries,
sources=main_sources,
language='c',
extra_compile_args=main_compile_args +
extra_compile_args,
include_dirs=include_dirs,
library_dirs=library_dirs,
extra_link_args=extra_link_args + main_link_args +
[make_relative_rpath('lib')])
return _c_module
def HIPExtension(name, sources, *args, **kwargs):
include_dirs = kwargs.get('include_dirs', [])
include_dirs += include_paths() + [
#non-public includea are needed for using hip+pytroch
#default paths for docker-based pytorch installation
os.getenv("PYTORCH_HIP_INCLUDE", "/pytorch/torch/include/"),
os.getenv("PYTORCH_HIP_INCLUDE2", "/pytorch/aten/src/"),
os.getenv("ROCM_INCLUDE", "/opt/rocm/include/"),
os.getenv("HIPRAND_INCLUDE", "/opt/rocm/hiprand/include/"),
os.getenv("ROCRAND_INCLUDE", "/opt/rocm/rocrand/include/"),
]
kwargs['include_dirs'] = include_dirs
kwargs['language'] = 'c++'
#combine nvcc compile args and cxx compile args, since all source swould be treated as cxx with hipcc compiler
extra_compile_args_dict = kwargs.get('extra_compile_args', {})
extra_compile_args_list = extra_compile_args_dict.get(
'cxx', []) + extra_compile_args_dict.get('nvcc', [])
kwargs['extra_compile_args'] = extra_compile_args_list
return Extension(name, sources, *args, **kwargs)
def __init__(self, name, sourcedir=''):
kwargs = dict()
include_dirs = kwargs.get('include_dirs', [])
include_dirs += include_paths()
kwargs['include_dirs'] = include_dirs
if sys.platform == 'win32':
library_dirs = kwargs.get('library_dirs', [])
library_dirs += library_paths()
kwargs['library_dirs'] = library_dirs
libraries = kwargs.get('libraries', [])
libraries.append('caffe2')
libraries.append('_C')
kwargs['libraries'] = libraries
kwargs['language'] = 'c++'
Extension.__init__(self, name, sources=[], **kwargs)
self.sourcedir = os.path.abspath(sourcedir)
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
import sys
import setuptools
from torch.utils import cpp_extension
print(cpp_extension.include_paths())
__version__ = '0.0.1'
extensions = [
cpp_extension.CppExtension(
'src.qp_fast',
["src/qp_fast.cpp"],
language='c++',
extra_compile_args=['-std=c++17'],
),
]
setup(name='latent_decision_tree',
version=__version__,
author="VZ,MK,VN",
ext_modules=extensions,
setup_requires=['pybind11>=2.5.0'],
cmdclass={'build_ext': cpp_extension.BuildExtension},
zip_safe=False)
def get_extensions():
extensions = []
if os.getenv('MMCV_WITH_TRT', '0') != '0':
ext_name = 'mmcv._ext_trt'
from torch.utils.cpp_extension import include_paths, library_paths
library_dirs = []
libraries = []
include_dirs = []
tensorrt_path = os.getenv('TENSORRT_DIR', '0')
tensorrt_lib_path = glob.glob(
os.path.join(tensorrt_path, 'targets', '*', 'lib'))[0]
library_dirs += [tensorrt_lib_path]
libraries += ['nvinfer', 'nvparsers', 'nvinfer_plugin']
libraries += ['cudart']
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/common/cuda')
include_trt_path = os.path.abspath('./mmcv/ops/csrc/tensorrt')
include_dirs.append(include_path)
include_dirs.append(include_trt_path)
include_dirs.append(os.path.join(tensorrt_path, 'include'))
include_dirs += include_paths(cuda=True)
op_files = glob.glob('./mmcv/ops/csrc/tensorrt/plugins/*')
define_macros += [('MMCV_WITH_CUDA', None)]
define_macros += [('MMCV_WITH_TRT', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
library_dirs += library_paths(cuda=True)
from setuptools import Extension
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
if os.getenv('MMCV_WITH_OPS', '0') == '0':
return extensions
if EXT_TYPE == 'parrots':
ext_name = 'mmcv._ext'
from parrots.utils.build_extension import Extension
# new parrots op impl do not use MMCV_USE_PARROTS
# define_macros = [('MMCV_USE_PARROTS', None)]
define_macros = []
include_dirs = []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cu') +\
glob.glob('./mmcv/ops/csrc/parrots/*.cpp')
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/cuda'))
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args = {
'nvcc': [cuda_args] if cuda_args else [],
'cxx': [],
}
if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
extra_compile_args['nvcc'] += [
'-D__CUDA_NO_HALF_OPERATORS__',
'-D__CUDA_NO_HALF_CONVERSIONS__',
'-D__CUDA_NO_HALF2_OPERATORS__',
]
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
cuda=True,
pytorch=True)
extensions.append(ext_ops)
elif EXT_TYPE == 'pytorch':
ext_name = 'mmcv._ext'
from torch.utils.cpp_extension import CppExtension, CUDAExtension
# prevent ninja from using too many resources
os.environ.setdefault('MAX_JOBS', '4')
define_macros = []
extra_compile_args = {'cxx': []}
include_dirs = []
is_rocm_pytorch = False
try:
from torch.utils.cpp_extension import ROCM_HOME
is_rocm_pytorch = True if ((torch.version.hip is not None) and
(ROCM_HOME is not None)) else False
except ImportError:
pass
project_dir = 'mmcv/ops/csrc/'
if is_rocm_pytorch:
from torch.utils.hipify import hipify_python
hipify_python.hipify(
project_directory=project_dir,
output_directory=project_dir,
includes='mmcv/ops/csrc/*',
show_detailed=True,
is_pytorch_extension=True,
)
define_macros += [('MMCV_WITH_CUDA', None)]
define_macros += [('HIP_DIFF', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/hip/*')
extension = CUDAExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/hip'))
elif torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cu')
extension = CUDAExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/cuda'))
else:
print(f'Compiling {ext_name} without CUDA')
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp')
extension = CppExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
ext_ops = extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args)
extensions.append(ext_ops)
if EXT_TYPE == 'pytorch' and os.getenv('MMCV_WITH_ORT', '0') != '0':
ext_name = 'mmcv._ext_ort'
from torch.utils.cpp_extension import library_paths, include_paths
import onnxruntime
library_dirs = []
libraries = []
include_dirs = []
ort_path = os.getenv('ONNXRUNTIME_DIR', '0')
library_dirs += [os.path.join(ort_path, 'lib')]
libraries.append('onnxruntime')
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/onnxruntime')
include_dirs.append(include_path)
include_dirs.append(os.path.join(ort_path, 'include'))
op_files = glob.glob('./mmcv/ops/csrc/onnxruntime/cpu/*')
if onnxruntime.get_device() == 'GPU' or os.getenv('FORCE_CUDA',
'0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files += glob.glob('./mmcv/ops/csrc/onnxruntime/gpu/*')
include_dirs += include_paths(cuda=True)
library_dirs += library_paths(cuda=True)
else:
include_dirs += include_paths(cuda=False)
library_dirs += library_paths(cuda=False)
from setuptools import Extension
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
return extensions
import pykeops
##########################################################
# Search for Pytorch and a GPU
torch_version_required = '1.0'
# is torch installed ?
import torch
from torch.utils.cpp_extension import include_paths
include_dirs = include_paths()[0:2]
if torch.__version__ < torch_version_required:
raise ImportError('The pytorch version should be >=' +
torch_version_required)
pykeops.gpu_available = torch.cuda.is_available() # use torch to detect gpu
pykeops.torch_found = True
default_dtype = 'float32'
##########################################################
# Import pyKeOps routines
from .generic.generic_red import Genred
from .operations import KernelSolve
from .kernel_product.kernels import Kernel, kernel_product, kernel_formulas
from .generic.generic_ops import generic_sum, generic_logsumexp, generic_argmin, generic_argkmin
from .kernel_product.formula import Formula
from pykeops.common.lazy_tensor import LazyTensor, Vi, Vj, Pm
if compile_test('bzlib.h', 'bz2'):
compile_args.append('-DHAVE_BZLIB')
ext_libs.append('bz2')
if compile_test('lzma.h', 'lzma'):
compile_args.append('-DHAVE_XZLIB')
ext_libs.append('lzma')
third_party_libs = ["kenlm", "openfst-1.6.7/src/include", "ThreadPool", "boost_1_67_0", "utf8"]
compile_args.extend(['-DINCLUDE_KENLM', '-DKENLM_MAX_ORDER=6'])
lib_sources = glob.glob('third_party/kenlm/util/*.cc') + glob.glob('third_party/kenlm/lm/*.cc') + glob.glob(
'third_party/kenlm/util/double-conversion/*.cc') + glob.glob('third_party/openfst-1.6.7/src/lib/*.cc')
lib_sources = [fn for fn in lib_sources if not (fn.endswith('main.cc') or fn.endswith('test.cc'))]
third_party_includes = [os.path.realpath(os.path.join("third_party", lib)) for lib in third_party_libs]
ctc_sources = glob.glob('ctcdecode/src/*.cpp')
extension = CppExtension(
name='ctcdecode._ext.ctc_decode',
package=True,
with_cuda=False,
sources=ctc_sources + lib_sources,
include_dirs=third_party_includes + include_paths(),
libraries=ext_libs,
extra_compile_args=compile_args,
language='c++')
######################################################################
# Copyright 2019. Zhenglin Geng.
# This file is part of PhysBAM whose distribution is governed by the license contained in the accompanying file PHYSBAM_COPYRIGHT.txt.
######################################################################
from setuptools import setup
from torch.utils.cpp_extension import CppExtension, BuildExtension, include_paths
import os
from os.path import join
ecos_dir = '../ecos'
eigen_dir = '../eigen'
cmk_dir = 'build_cmk'
# cmk_dir='build_dbg'
print(include_paths())
print('cmk_dir', cmk_dir)
# setup(name='cvx_opt_cpp',
# ext_modules=[CppExtension('cvx_opt_cpp', ['cvx_opt_py.cpp','cvx_opt_utils.cpp','cvx_opt_forward.cpp','cvx_opt_backward.cpp','ecos_opt.cpp','forward_opt.cpp','backward_opt.cpp'],
# include_dirs=[join(ecos_dir,'include'),join(ecos_dir,'external/ldl/include'),join(ecos_dir,'external/amd/include'),join(ecos_dir,'external/SuiteSparse_config'),eigen_dir],
# libraries=['ecos'],
# library_dirs=[ecos_dir],
# extra_compile_args=['-DLDL_LONG', '-DDLONG'])],
# cmdclass={'build_ext': BuildExtension})
setup(name='cvx_opt_cpp',
ext_modules=[
CppExtension('cvx_opt_cpp', ['cvx_opt_py.cpp'],
include_dirs=[
join(ecos_dir, 'include'),
join(ecos_dir, 'external/ldl/include'),
join(ecos_dir, 'external/amd/include'),
def get_extensions():
extensions = []
if os.getenv('MMCV_WITH_TRT', '0') != '0':
ext_name = 'mmcv._ext_trt'
from torch.utils.cpp_extension import include_paths, library_paths
library_dirs = []
libraries = []
include_dirs = []
tensorrt_path = os.getenv('TENSORRT_DIR', '0')
tensorrt_lib_path = glob.glob(
os.path.join(tensorrt_path, 'targets', '*', 'lib'))[0]
library_dirs += [tensorrt_lib_path]
libraries += ['nvinfer', 'nvparsers', 'nvinfer_plugin']
libraries += ['cudart']
kwargs = {}
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc')
include_trt_path = os.path.abspath('./mmcv/ops/csrc/tensorrt')
include_dirs.append(include_path)
include_dirs.append(include_trt_path)
include_dirs.append(os.path.join(tensorrt_path, 'include'))
include_dirs += include_paths(cuda=True)
op_files = glob.glob('./mmcv/ops/csrc/tensorrt/plugins/*')
define_macros += [('MMCV_WITH_CUDA', None)]
define_macros += [('MMCV_WITH_TRT', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
library_dirs += library_paths(cuda=True)
kwargs['library_dirs'] = library_dirs
kwargs['libraries'] = libraries
from setuptools import Extension
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
if os.getenv('MMCV_WITH_OPS', '0') == '0':
return extensions
if EXT_TYPE == 'parrots':
ext_name = 'mmcv._ext'
from parrots.utils.build_extension import Extension
define_macros = [('MMCV_USE_PARROTS', None)]
op_files = glob.glob('./mmcv/ops/csrc/parrots/*')
include_path = os.path.abspath('./mmcv/ops/csrc')
cuda_args = os.getenv('MMCV_CUDA_ARGS')
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=[include_path],
define_macros=define_macros,
extra_compile_args={
'nvcc': [cuda_args] if cuda_args else [],
'cxx': [],
},
cuda=True)
extensions.append(ext_ops)
elif EXT_TYPE == 'pytorch':
ext_name = 'mmcv._ext'
from torch.utils.cpp_extension import CppExtension, CUDAExtension
# prevent ninja from using too many resources
os.environ.setdefault('MAX_JOBS', '4')
define_macros = []
extra_compile_args = {'cxx': []}
if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*')
extension = CUDAExtension
else:
print(f'Compiling {ext_name} without CUDA')
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp')
extension = CppExtension
include_path = os.path.abspath('./mmcv/ops/csrc')
ext_ops = extension(
name=ext_name,
sources=op_files,
include_dirs=[include_path],
define_macros=define_macros,
extra_compile_args=extra_compile_args)
extensions.append(ext_ops)
if EXT_TYPE == 'pytorch' and os.getenv('MMCV_WITH_ORT', '0') != '0':
ext_name = 'mmcv._ext_ort'
from torch.utils.cpp_extension import library_paths, include_paths
import onnxruntime
library_dirs = []
libraries = []
include_dirs = []
ort_path = os.getenv('ONNXRUNTIME_DIR', '0')
library_dirs += [os.path.join(ort_path, 'lib')]
libraries.append('onnxruntime')
kwargs = {}
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/onnxruntime')
include_dirs.append(include_path)
include_dirs.append(os.path.join(ort_path, 'include'))
include_dirs += include_paths(cuda=True)
op_files = glob.glob('./mmcv/ops/csrc/onnxruntime/cpu/*')
if onnxruntime.get_device() == 'GPU' or os.getenv('FORCE_CUDA',
'0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files += glob.glob('./mmcv/ops/csrc/onnxruntime/gpu/*')
library_dirs += library_paths(cuda=True)
else:
library_dirs += library_paths(cuda=False)
kwargs['library_dirs'] = library_dirs
kwargs['libraries'] = libraries
from setuptools import Extension
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
return extensions
def get_extensions():
extensions = []
if (os.getenv('MMCV_WITH_OPS', '0') == '0'):
return extensions
if (EXT_TYPE == 'parrots'):
ext_name = 'mmcv._ext'
from parrots.utils.build_extension import Extension
define_macros = [('MMCV_USE_PARROTS', None)]
op_files = glob.glob('./mmcv/ops/csrc/parrots/*')
include_path = os.path.abspath('./mmcv/ops/csrc')
cuda_args = os.getenv('MMCV_CUDA_ARGS')
ext_ops = Extension(name=ext_name, sources=op_files, include_dirs=[include_path], define_macros=define_macros, extra_compile_args={
'nvcc': ([cuda_args] if cuda_args else []),
'cxx': [],
}, cuda=True)
extensions.append(ext_ops)
elif (EXT_TYPE == 'pytorch'):
ext_name = 'mmcv._ext'
from torch.utils.cpp_extension import CUDAExtension, CppExtension
os.environ.setdefault('MAX_JOBS', '4')
define_macros = []
extra_compile_args = {
'cxx': [],
}
if (torch.cuda.is_available() or (os.getenv('FORCE_CUDA', '0') == '1')):
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = ([cuda_args] if cuda_args else [])
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*')
extension = CUDAExtension
else:
print(
''.join(['Compiling ', '{}'.format(ext_name), ' without CUDA']))
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp')
extension = CppExtension
include_path = os.path.abspath('./mmcv/ops/csrc')
ext_ops = extension(name=ext_name, sources=op_files, include_dirs=[
include_path], define_macros=define_macros, extra_compile_args=extra_compile_args)
extensions.append(ext_ops)
if ((EXT_TYPE == 'pytorch') and (os.getenv('MMCV_WITH_ORT', '0') != '0')):
ext_name = 'mmcv._ext_ort'
from torch.utils.cpp_extension import library_paths, include_paths
import onnxruntime
library_dirs = []
libraries = []
include_dirs = []
ort_path = os.getenv('ONNXRUNTIME_DIR', '0')
library_dirs += [os.path.join(ort_path, 'lib')]
libraries.append('onnxruntime')
kwargs = {
}
define_macros = []
extra_compile_args = {
'cxx': [],
}
include_path = os.path.abspath('./mmcv/ops/csrc/onnxruntime')
include_dirs.append(include_path)
include_dirs.append(os.path.join(ort_path, 'include'))
include_dirs += include_paths(cuda=True)
op_files = glob.glob('./mmcv/ops/csrc/onnxruntime/cpu/*')
if ((onnxruntime.get_device() == 'GPU') or (os.getenv('FORCE_CUDA', '0') == '1')):
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = ([cuda_args] if cuda_args else [])
op_files += glob.glob('./mmcv/ops/csrc/onnxruntime/gpu/*')
library_dirs += library_paths(cuda=True)
else:
library_dirs += library_paths(cuda=False)
kwargs['library_dirs'] = library_dirs
kwargs['libraries'] = libraries
from setuptools import Extension
ext_ops = Extension(name=ext_name, sources=op_files, include_dirs=include_dirs, define_macros=define_macros,
extra_compile_args=extra_compile_args, language='c++', library_dirs=library_dirs, libraries=libraries)
extensions.append(ext_ops)
return extensions
CTLDIR+'img/singleviewdata.cpp',
CTLDIR+'mat/homography.cpp',
CTLDIR+'mat/matrix_algorithm.cpp',
CTLDIR+'mat/projectionmatrix.cpp',
CTLDIR+'ocl/openclconfig.cpp',
CTLDIR+'ocl/cldirfileloader.cpp',
CTLDIR+'processing/radontransform2d.cpp',
'src/'+'radon2d_kernel.cpp',
'src/'+'parallelsetup.cpp',
'src/'+'simple_backprojector_kernel.cpp',
'src/'+'simplebackprojector.cpp',
'src/'+'pybind_radon.cpp'],
include_dirs=[
'include',
CTLDIR,
] + cpp_extension.include_paths(cuda=True),
language='c++',
libraries=['OpenCL', 'c10', 'caffe2', 'torch', 'torch_python', '_C'],
library_dirs=cpp_extension.library_paths(cuda=True),
define_macros=[('OCL_CONFIG_MODULE_AVAILABLE', None), ('NOQT', None)]
),
]
setup(
name='ctl',
version=__version__,
author='Philipp Ernst',
author_email='*****@*****.**',
description='2D Radon transform using CTL',
ext_modules=ext_modules,
cmdclass={'build_ext': cpp_extension.BuildExtension},
def get_extensions():
extensions = []
import numpy
default_includes=[numpy.get_include()]
from torch.utils.cpp_extension import include_paths, library_paths
default_includes += include_paths(cuda=torch.cuda.is_available())
if os.name == 'nt':
default_includes.append(os.path.join(os.path.dirname(
os.path.dirname(sys.executable)),"include" ))
if os.getenv('MMCV_WITH_TRT', '0') != '0':
# Following strings of text style are from colorama package
bright_style, reset_style = '\x1b[1m', '\x1b[0m'
red_text, blue_text = '\x1b[31m', '\x1b[34m'
white_background = '\x1b[107m'
msg = white_background + bright_style + red_text
msg += 'DeprecationWarning: ' + \
'Custom TensorRT Ops will be deprecated in future. '
msg += blue_text + \
'Welcome to use the unified model deployment toolbox '
msg += 'MMDeploy: https://github.com/open-mmlab/mmdeploy'
msg += reset_style
warnings.warn(msg)
ext_name = 'mmcv._ext_trt'
from torch.utils.cpp_extension import include_paths, library_paths
library_dirs = []
libraries = []
include_dirs = default_includes
tensorrt_path = os.getenv('TENSORRT_DIR', '0')
tensorrt_lib_path = glob.glob(
os.path.join(tensorrt_path, 'targets', '*', 'lib'))[0]
library_dirs += [tensorrt_lib_path]
libraries += ['nvinfer', 'nvparsers', 'nvinfer_plugin']
libraries += ['cudart']
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/common/cuda')
include_trt_path = os.path.abspath('./mmcv/ops/csrc/tensorrt')
include_dirs.append(include_path)
include_dirs.append(include_trt_path)
include_dirs.append(os.path.join(tensorrt_path, 'include'))
include_dirs += include_paths(cuda=True)
op_files = glob.glob('./mmcv/ops/csrc/tensorrt/plugins/*')
define_macros += [('MMCV_WITH_CUDA', None)]
define_macros += [('MMCV_WITH_TRT', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
# prevent cub/thrust conflict with other python library
# More context See issues #1454
extra_compile_args['nvcc'] += ['-Xcompiler=-fno-gnu-unique']
library_dirs += library_paths(cuda=True)
from setuptools import Extension
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
if os.getenv('MMCV_WITH_OPS', '0') == '0':
return extensions
if EXT_TYPE == 'parrots':
ext_name = 'mmcv._ext'
from parrots.utils.build_extension import Extension
# new parrots op impl do not use MMCV_USE_PARROTS
# define_macros = [('MMCV_USE_PARROTS', None)]
define_macros = []
include_dirs = default_includes
op_files = glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cu') +\
glob.glob('./mmcv/ops/csrc/pytorch/cpu/*.cpp') +\
glob.glob('./mmcv/ops/csrc/parrots/*.cpp')
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/cuda'))
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args = {
'nvcc': [cuda_args, '-std=c++14'] if cuda_args else ['-std=c++14'],
'cxx': ['-std=c++14'],
}
if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
extra_compile_args['nvcc'] += [
'-D__CUDA_NO_HALF_OPERATORS__',
'-D__CUDA_NO_HALF_CONVERSIONS__',
'-D__CUDA_NO_HALF2_OPERATORS__',
]
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
cuda=True,
pytorch=True)
extensions.append(ext_ops)
elif EXT_TYPE == 'pytorch':
ext_name = 'mmcv._ext'
from torch.utils.cpp_extension import CppExtension, CUDAExtension
# prevent ninja from using too many resources
try:
import psutil
num_cpu = len(psutil.Process().cpu_affinity())
cpu_use = max(4, num_cpu - 1)
except (ModuleNotFoundError, AttributeError):
cpu_use = 4
os.environ.setdefault('MAX_JOBS', str(cpu_use))
define_macros = []
# Before PyTorch1.8.0, when compiling CUDA code, `cxx` is a
# required key passed to PyTorch. Even if there is no flag passed
# to cxx, users also need to pass an empty list to PyTorch.
# Since PyTorch1.8.0, it has a default value so users do not need
# to pass an empty list anymore.
# More details at https://github.com/pytorch/pytorch/pull/45956
extra_compile_args = {'cxx': []}
# Since the PR (https://github.com/open-mmlab/mmcv/pull/1463) uses
# c++14 features, the argument ['std=c++14'] must be added here.
# However, in the windows environment, some standard libraries
# will depend on c++17 or higher. In fact, for the windows
# environment, the compiler will choose the appropriate compiler
# to compile those cpp files, so there is no need to add the
# argument
if platform.system() != 'Windows':
extra_compile_args['cxx'] = ['-std=c++14']
include_dirs = default_includes
is_rocm_pytorch = False
try:
from torch.utils.cpp_extension import ROCM_HOME
is_rocm_pytorch = True if ((torch.version.hip is not None) and
(ROCM_HOME is not None)) else False
except ImportError:
pass
if os.getenv('FORCE_NO_ROCM', '0') == '1':
is_rocm_pytorch = False
if is_rocm_pytorch or torch.cuda.is_available() or os.getenv(
'FORCE_CUDA', '0') == '1':
if is_rocm_pytorch:
define_macros += [('HIP_DIFF', None)]
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cpu/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cu') + \
glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cpp')
extension = CUDAExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/cuda'))
else:
print(f'Compiling {ext_name} without CUDA')
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cpu/*.cpp')
extension = CppExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
# Since the PR (https://github.com/open-mmlab/mmcv/pull/1463) uses
# c++14 features, the argument ['std=c++14'] must be added here.
# However, in the windows environment, some standard libraries
# will depend on c++17 or higher. In fact, for the windows
# environment, the compiler will choose the appropriate compiler
# to compile those cpp files, so there is no need to add the
# argument
if 'nvcc' in extra_compile_args and platform.system() != 'Windows':
extra_compile_args['nvcc'] += ['-std=c++14']
ext_ops = extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args)
extensions.append(ext_ops)
if EXT_TYPE == 'pytorch' and os.getenv('MMCV_WITH_ORT', '0') != '0':
# Following strings of text style are from colorama package
bright_style, reset_style = '\x1b[1m', '\x1b[0m'
red_text, blue_text = '\x1b[31m', '\x1b[34m'
white_background = '\x1b[107m'
msg = white_background + bright_style + red_text
msg += 'DeprecationWarning: ' + \
'Custom ONNXRuntime Ops will be deprecated in future. '
msg += blue_text + \
'Welcome to use the unified model deployment toolbox '
msg += 'MMDeploy: https://github.com/open-mmlab/mmdeploy'
msg += reset_style
warnings.warn(msg)
ext_name = 'mmcv._ext_ort'
import onnxruntime
from torch.utils.cpp_extension import include_paths, library_paths
library_dirs = []
libraries = []
include_dirs = default_includes
ort_path = os.getenv('ONNXRUNTIME_DIR', '0')
library_dirs += [os.path.join(ort_path, 'lib')]
libraries.append('onnxruntime')
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/onnxruntime')
include_dirs.append(include_path)
include_dirs.append(os.path.join(ort_path, 'include'))
op_files = glob.glob('./mmcv/ops/csrc/onnxruntime/cpu/*')
if onnxruntime.get_device() == 'GPU' or os.getenv('FORCE_CUDA',
'0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files += glob.glob('./mmcv/ops/csrc/onnxruntime/gpu/*')
include_dirs += include_paths(cuda=True)
library_dirs += library_paths(cuda=True)
else:
include_dirs += include_paths(cuda=False)
library_dirs += library_paths(cuda=False)
from setuptools import Extension
ext_ops = Extension(
name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
return extensions
def __init__(self,
halide_root,
name,
*args,
generators=[],
gen_cxx="c++",
gen_cxxflags=None,
extra_sources=[],
**kwargs):
sources = extra_sources
cuda = False
for g in generators:
# Activate cuda in the wrapper whenever we have an op that requires it
cuda = cuda or g.cuda
print("CUDA?", cuda)
compile_args = kwargs.get('extra_compile_args', [])
compile_args += ["-std=c++14", "-g"]
if platform.system() == "Darwin": # on osx libstdc++ causes trouble
compile_args += ["-stdlib=libc++"]
kwargs["extra_compile_args"] = compile_args
include_dirs = kwargs.get('include_dirs', [])
library_dirs = kwargs.get('library_dirs', [])
libraries = kwargs.get('libraries', [])
include_dirs += include_paths(cuda=cuda)
include_dirs.append(os.path.join(halide_root, "include"))
if cuda:
libraries.append('cudart')
libraries.append('cuda')
if platform.system() == 'Windows':
library_dirs += library_paths()
kwargs['library_dirs'] = library_dirs
libraries = kwargs.get('libraries', [])
libraries.append('c10')
if cuda:
libraries.append('c10_cuda')
libraries.append('torch')
libraries.append('torch_python')
libraries.append('_C')
kwargs['libraries'] = libraries
kwargs['language'] = 'c++'
if cuda:
library_dirs += library_paths(cuda=True)
kwargs['include_dirs'] = include_dirs
kwargs['library_dirs'] = library_dirs
kwargs['libraries'] = libraries
super(HalidePyTorchExtension, self).__init__(name, sources, *args,
**kwargs)
# Group generators by source file, so we compile those only once
self.generators = {}
self.cuda = cuda
for g in generators:
if not g.gen_source in self.generators.keys():
self.generators[g.gen_source] = []
self.generators[g.gen_source].append(g)
self.gen_cxx = gen_cxx
self.gen_cxxflags = self._get_gen_cxxflags(gen_cxxflags, halide_root)
self.gen_ldflags = self._get_gen_ldflags(None)
self.gen_hlsyslibs = self._get_hlsyslibs(None)
self.gen_deps = self._get_gen_deps(None, halide_root)
self.get_include = self._get_gen_inc(include_dirs)
def get_extensions():
extensions = []
if os.getenv('MMCV_WITH_TRT', '0') != '0':
ext_name = 'mmcv._ext_trt'
from torch.utils.cpp_extension import include_paths, library_paths
library_dirs = []
libraries = []
include_dirs = []
tensorrt_path = os.getenv('TENSORRT_DIR', '0')
tensorrt_lib_path = glob.glob(
os.path.join(tensorrt_path, 'targets', '*', 'lib'))[0]
library_dirs += [tensorrt_lib_path]
libraries += ['nvinfer', 'nvparsers', 'nvinfer_plugin']
libraries += ['cudart']
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/common/cuda')
include_trt_path = os.path.abspath('./mmcv/ops/csrc/tensorrt')
include_dirs.append(include_path)
include_dirs.append(include_trt_path)
include_dirs.append(os.path.join(tensorrt_path, 'include'))
include_dirs += include_paths(cuda=True)
op_files = glob.glob('./mmcv/ops/csrc/tensorrt/plugins/*')
define_macros += [('MMCV_WITH_CUDA', None)]
define_macros += [('MMCV_WITH_TRT', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
library_dirs += library_paths(cuda=True)
from setuptools import Extension
ext_ops = Extension(name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
if os.getenv('MMCV_WITH_OPS', '0') == '0':
return extensions
if EXT_TYPE == 'parrots':
ext_name = 'mmcv._ext'
from parrots.utils.build_extension import Extension
# new parrots op impl do not use MMCV_USE_PARROTS
# define_macros = [('MMCV_USE_PARROTS', None)]
define_macros = []
include_dirs = []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cu') +\
glob.glob('./mmcv/ops/csrc/parrots/*.cpp')
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/cuda'))
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args = {
'nvcc': [cuda_args] if cuda_args else [],
'cxx': [],
}
if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
extra_compile_args['nvcc'] += [
'-D__CUDA_NO_HALF_OPERATORS__',
'-D__CUDA_NO_HALF_CONVERSIONS__',
'-D__CUDA_NO_HALF2_OPERATORS__',
]
ext_ops = Extension(name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
cuda=True,
pytorch=True)
extensions.append(ext_ops)
elif EXT_TYPE == 'pytorch':
ext_name = 'mmcv._ext'
from torch.utils.cpp_extension import CppExtension, CUDAExtension
# prevent ninja from using too many resources
try:
import psutil
num_cpu = len(psutil.Process().cpu_affinity())
cpu_use = max(4, num_cpu - 1)
except (ModuleNotFoundError, AttributeError):
cpu_use = 4
os.environ.setdefault('MAX_JOBS', str(cpu_use))
define_macros = []
# Before PyTorch1.8.0, when compiling CUDA code, `cxx` is a
# required key passed to PyTorch. Even if there is no flag passed
# to cxx, users also need to pass an empty list to PyTorch.
# Since PyTorch1.8.0, it has a default value so users do not need
# to pass an empty list anymore.
# More details at https://github.com/pytorch/pytorch/pull/45956
extra_compile_args = {'cxx': []}
# Since the PR (https://github.com/open-mmlab/mmcv/pull/1463) uses
# c++14 features, the argument ['std=c++14'] must be added here.
# However, in the windows environment, some standard libraries
# will depend on c++17 or higher. In fact, for the windows
# environment, the compiler will choose the appropriate compiler
# to compile those cpp files, so there is no need to add the
# argument
if platform.system() != 'Windows':
extra_compile_args['cxx'] = ['-std=c++14']
include_dirs = []
is_rocm_pytorch = False
try:
from torch.utils.cpp_extension import ROCM_HOME
is_rocm_pytorch = True if ((torch.version.hip is not None) and
(ROCM_HOME is not None)) else False
except ImportError:
pass
project_dir = 'mmcv/ops/csrc/'
if is_rocm_pytorch:
from torch.utils.hipify import hipify_python
hipify_python.hipify(
project_directory=project_dir,
output_directory=project_dir,
includes='mmcv/ops/csrc/*',
show_detailed=True,
is_pytorch_extension=True,
)
define_macros += [('MMCV_WITH_CUDA', None)]
define_macros += [('HIP_DIFF', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/hip/*') \
+ glob.glob('./mmcv/ops/csrc/pytorch/cpu/hip/*')
extension = CUDAExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/hip'))
elif torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cpu/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cu') + \
glob.glob('./mmcv/ops/csrc/pytorch/cuda/*.cpp')
extension = CUDAExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common/cuda'))
else:
print(f'Compiling {ext_name} without CUDA')
op_files = glob.glob('./mmcv/ops/csrc/pytorch/*.cpp') + \
glob.glob('./mmcv/ops/csrc/pytorch/cpu/*.cpp')
extension = CppExtension
include_dirs.append(os.path.abspath('./mmcv/ops/csrc/common'))
# Since the PR (https://github.com/open-mmlab/mmcv/pull/1463) uses
# c++14 features, the argument ['std=c++14'] must be added here.
# However, in the windows environment, some standard libraries
# will depend on c++17 or higher. In fact, for the windows
# environment, the compiler will choose the appropriate compiler
# to compile those cpp files, so there is no need to add the
# argument
if 'nvcc' in extra_compile_args and platform.system() != 'Windows':
extra_compile_args['nvcc'] += ['-std=c++14']
ext_ops = extension(name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args)
extensions.append(ext_ops)
if EXT_TYPE == 'pytorch' and os.getenv('MMCV_WITH_ORT', '0') != '0':
ext_name = 'mmcv._ext_ort'
from torch.utils.cpp_extension import library_paths, include_paths
import onnxruntime
library_dirs = []
libraries = []
include_dirs = []
ort_path = os.getenv('ONNXRUNTIME_DIR', '0')
library_dirs += [os.path.join(ort_path, 'lib')]
libraries.append('onnxruntime')
define_macros = []
extra_compile_args = {'cxx': []}
include_path = os.path.abspath('./mmcv/ops/csrc/onnxruntime')
include_dirs.append(include_path)
include_dirs.append(os.path.join(ort_path, 'include'))
op_files = glob.glob('./mmcv/ops/csrc/onnxruntime/cpu/*')
if onnxruntime.get_device() == 'GPU' or os.getenv('FORCE_CUDA',
'0') == '1':
define_macros += [('MMCV_WITH_CUDA', None)]
cuda_args = os.getenv('MMCV_CUDA_ARGS')
extra_compile_args['nvcc'] = [cuda_args] if cuda_args else []
op_files += glob.glob('./mmcv/ops/csrc/onnxruntime/gpu/*')
include_dirs += include_paths(cuda=True)
library_dirs += library_paths(cuda=True)
else:
include_dirs += include_paths(cuda=False)
library_dirs += library_paths(cuda=False)
from setuptools import Extension
ext_ops = Extension(name=ext_name,
sources=op_files,
include_dirs=include_dirs,
define_macros=define_macros,
extra_compile_args=extra_compile_args,
language='c++',
library_dirs=library_dirs,
libraries=libraries)
extensions.append(ext_ops)
return extensions
from setuptools import setup, Extension
import sys
import os
from torch.utils import cpp_extension
if __name__ == '__main__':
if sys.platform == "darwin":
args = ["-DAPPLE"]
else:
args = ["-fopenmp"]
if os.environ.get("DEBUG_TRANSDUCER") == "1":
args.append("-DDEBUG")
args.append("-O0")
ext = Extension(name='transducer_cpp',
sources=['transducer.cpp'],
include_dirs=cpp_extension.include_paths(),
extra_compile_args=args,
language='c++')
setup(name='transducer_cpp',
ext_modules=[ext],
cmdclass={'build_ext': cpp_extension.BuildExtension})
'\s*\#define\s*{def_name}\s*\"((\d+\.)*\d+?)"[ \t]*$'.format(
def_name=definition_name), headerfile, re.MULTILINE).group(1)
return version_found
VERSION = get_def('../config.h', 'VERSION')
EXTENSION_NAME = 'nnfc._ext.nnfc_codec'
#CUDA_AVAILABLE = torch.cuda.is_available()
CUDA_AVAILABLE = False # TODO(jremmons) add back support for CUDA functions
cuda_sources = [
'nnfc/src/nnfc_cuda.cc',
] if CUDA_AVAILABLE else []
pytorch_include = []
for lib in include_paths(cuda=CUDA_AVAILABLE):
# HACK newer versions of cstdlib use #include_next<stdlib.h> which will break
# if we add /usr/include here.
if lib != "/usr/include":
pytorch_include += ['-isystem', lib]
print(pytorch_include)
pytorch_libdirs = library_paths(cuda=CUDA_AVAILABLE)
pytorch_libs = ['cudart'] if CUDA_AVAILABLE else []
pytorch_defines = [('_NNFC_CUDA_AVAILABLE', 1)] if CUDA_AVAILABLE else []
module = Extension(
EXTENSION_NAME,
sources=[
'nnfc/src/nnfc_codec.cc', 'nnfc/src/nnfc_encoder.cc',
if not PREFIX:
PREFIX = "/usr/local"
extra_compile_args = []
extra_link_args = []
protoc = f"{PREFIX}/bin/protoc"
grpc_objects = [
f"{PREFIX}/lib/libgrpc++.a",
f"{PREFIX}/lib/libgrpc.a",
f"{PREFIX}/lib/libgpr.a",
f"{PREFIX}/lib/libaddress_sorting.a",
]
include_dirs = cpp_extension.include_paths() + [f"{PREFIX}/include"]
libraries = []
if sys.platform == "darwin":
extra_compile_args += ["-stdlib=libc++", "-mmacosx-version-min=10.14"]
extra_link_args += ["-stdlib=libc++", "-mmacosx-version-min=10.14"]
# Relevant only when c-cares is not embedded in grpc, e.g. when
# installing grpc via homebrew.
libraries.append("cares")
elif sys.platform == "linux":
libraries.append("z")
grpc_objects.append(f"{PREFIX}/lib/libprotobuf.a")
actorpool = cpp_extension.CppExtension(
else:
return s
if torch.__version__.startswith("1.0"):
pytorch_base_include_path_suffix = osp.sep + osp.join("lib", "include")
elif torch.__version__.startswith("1.1"):
pytorch_base_include_path_suffix = osp.sep + osp.join("include")
elif torch.__version__.startswith("1.2"):
pytorch_base_include_path_suffix = osp.sep + osp.join("include")
else:
raise ValueError("unsupported PyTorch version {}".format(
torch.__version__))
pytorch_install_prefix = None
for current_include_path in cpp_extension.include_paths(False):
if ("torch" + pytorch_base_include_path_suffix) in current_include_path:
offset_of_search_string = current_include_path.rfind(
"torch" + pytorch_base_include_path_suffix)
current_include_path = current_include_path[:offset_of_search_string +
len("torch")]
if osp.isdir(osp.join(current_include_path, "share")):
pytorch_install_prefix = current_include_path
break
if pytorch_install_prefix is None:
raise ValueError("could not determine pytorch install prefix")
cmake_args = [
"-DPYTORCH_INCLUDES:PATH=" +
osp.pathsep.join(cpp_extension.include_paths(False)),
