def _compile_cu(self, sources, output_dir=None, macros=None,
include_dirs=None, debug=0, extra_preargs=None,
extra_postargs=None, depends=None):
# Compile CUDA C files, mainly derived from UnixCCompiler._compile().
macros, objects, extra_postargs, pp_opts, _build = \
self._setup_compile(output_dir, macros, include_dirs, sources,
depends, extra_postargs)
compiler_so = build.get_nvcc_path()
cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
cuda_version = build.get_cuda_version()
postargs = _nvcc_gencode_options(cuda_version) + ['-O2']
postargs += ['-Xcompiler', '/MD']
print('NVCC options:', postargs)
for obj in objects:
try:
src, ext = _build[obj]
except KeyError:
continue
try:
self.spawn(compiler_so + cc_args + [src, '-o', obj] + postargs)
except errors.DistutilsExecError as e:
raise errors.CompileError(str(e))
return objects
def _compile_cu(self,
sources,
output_dir=None,
macros=None,
include_dirs=None,
debug=0,
extra_preargs=None,
extra_postargs=None,
depends=None):
# Compile CUDA C files, mainly derived from UnixCCompiler._compile().
macros, objects, extra_postargs, pp_opts, _build = \
self._setup_compile(output_dir, macros, include_dirs, sources,
depends, extra_postargs)
compiler_so = CUDA['nvcc']
cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
post_args = CUDA['post_args']
for obj in objects:
try:
src, _ = _build[obj]
except KeyError:
continue
try:
self.spawn([compiler_so] + cc_args + [src, '-o', obj] +
post_args)
except errors.DistutilsExecError as e:
raise errors.CompileError(str(e))
return objects
def compile_using_nvcc(source, options=None, arch=None, filename='kern.cu'):
options = options or []
if arch is None:
cuda_info = get_cuda_info()
arch = min(
[dev['major'] * 10 + dev['minor'] for dev in cuda_info['devices']])
cc = get_compiler()
settings = get_compiler_setting()
arch = "--generate-code=arch=compute_{a},code=sm_{a}".format(a=arch)
options += ['-cubin']
cupy_path = resource_filename("cupy", pjoin("core", "include"))
settings['include_dirs'].append(cupy_path)
with _tempdir() as tmpdir:
tmpfile = pjoin(tmpdir, filename)
with open(tmpfile, "w") as f:
f.write(source)
try:
stderr_file = pjoin(tmpdir, "stderr.txt")
with stdchannel_redirected(sys.stderr, stderr_file):
objects = cc.compile([tmpfile],
include_dirs=settings['include_dirs'],
macros=settings['define_macros'],
extra_postargs=options)
except errors.CompileError as e:
with open(stderr_file, "r") as f:
errs = f.read()
lines = [
"The following source code",
format_code(source), "",
"created the following compilation errors", "",
errs.strip(),
str(e).strip()
]
ex = errors.CompileError("\n".join(lines))
raise (ex, None, sys.exc_info()[2])
assert len(objects) == 1
mod = cp.cuda.function.Module()
mod.load_file(objects[0])
return mod
def _compile_unix_hipcc(self, obj, src, ext, cc_args, extra_postargs,
pp_opts):
# For CUDA C source files, compile them with HIPCC.
rocm_path = build.get_hipcc_path()
base_opts = build.get_compiler_base_options(rocm_path)
compiler_so = rocm_path
postargs = ['-O2', '-fPIC', '--include', 'hip_runtime.h']
print('HIPCC options:', postargs)
try:
self.spawn(compiler_so + base_opts + cc_args + [src, '-o', obj] +
postargs)
except errors.DistutilsExecError as e:
raise errors.CompileError(str(e))
def test(self):
try:
compiler = ccompiler.new_compiler()
if not isinstance(compiler, ccompiler.CCompiler):
raise errors.CompileError("Compiler is not valid!")
sysconfig.customize_compiler(compiler)
self.preCompilationTest(compiler)
o = compiler.compile([self.src])
self.postCompilationTest(compiler, o)
except errors.CompileError as e:
raise DependencyError('Compilation problems', inner=e)
except Exception as e:
raise DependencyError('General error', inner=e)
def _compile_unix_nvcc(self,
obj, src, ext, cc_args, extra_postargs, pp_opts):
# For CUDA C source files, compile them with NVCC.
nvcc_path = build.get_nvcc_path()
base_opts = build.get_compiler_base_options()
compiler_so = nvcc_path
cuda_version = build.get_cuda_version()
postargs = _nvcc_gencode_options(cuda_version) + [
'-O2', '--compiler-options="-fPIC"', '--std=c++11']
print('NVCC options:', postargs)
try:
self.spawn(compiler_so + base_opts + cc_args + [src, '-o', obj] +
postargs)
except errors.DistutilsExecError as e:
raise errors.CompileError(str(e))
def _compile_cu(self,
sources,
output_dir=None,
macros=None,
include_dirs=None,
debug=0,
extra_preargs=None,
extra_postargs=None,
depends=None):
# Compile CUDA C files, mainly derived from UnixCCompiler._compile().
macros, objects, extra_postargs, pp_opts, _build = \
self._setup_compile(output_dir, macros, include_dirs, sources,
depends, extra_postargs)
compiler_so = build.get_nvcc_path()
cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
cuda_version = build.get_cuda_version()
postargs = _nvcc_gencode_options(cuda_version) + ['-O2']
if cuda_version >= 11020:
# MSVC 14.0 (2015) is deprecated for CUDA 11.2 but we need it
# to build CuPy because some Python versions were built using it.
# REF: https://wiki.python.org/moin/WindowsCompilers
postargs += ['-allow-unsupported-compiler']
postargs += ['-Xcompiler', '/MD']
# This is to compile thrust with MSVC2015
if cuda_version >= 11020:
postargs += ['--std=c++14']
num_threads = int(os.environ.get('CUPY_NUM_NVCC_THREADS', '2'))
postargs += [f'-t{num_threads}']
print('NVCC options:', postargs)
for obj in objects:
try:
src, ext = _build[obj]
except KeyError:
continue
try:
self.spawn(compiler_so + cc_args + [src, '-o', obj] + postargs)
except errors.DistutilsExecError as e:
raise errors.CompileError(str(e))
return objects
def __call__(self):
try:
self._makeSource()
except Exception as e:
raise DependencyError('Cannot create source file', inner=e)
try:
compiler = ccompiler.new_compiler()
if not isinstance(compiler, ccompiler.CCompiler):
raise errors.CompileError("Compiler is not valid!")
sysconfig.customize_compiler(compiler)
self.preCompilationTest(compiler)
o = compiler.compile([self.src])
self.postCompilationTest(compiler, o)
except errors.CompileError as e:
raise DependencyError('Compilation problems', inner=e)
except Exception as e:
raise DependencyError('General error', inner=e)
finally:
self._cleanup()
def _compile_unix_nvcc(self,
obj, src, ext, cc_args, extra_postargs, pp_opts):
# For CUDA C source files, compile them with NVCC.
nvcc_path = build.get_nvcc_path()
base_opts = build.get_compiler_base_options(nvcc_path)
compiler_so = nvcc_path
cuda_version = build.get_cuda_version()
postargs = _nvcc_gencode_options(cuda_version) + [
'-O2', '--compiler-options="-fPIC"']
if cuda_version >= 11020:
postargs += ['--std=c++14']
num_threads = int(os.environ.get('CUPY_NUM_NVCC_THREADS', '2'))
postargs += [f'-t{num_threads}']
else:
postargs += ['--std=c++11']
print('NVCC options:', postargs)
try:
self.spawn(compiler_so + base_opts + cc_args + [src, '-o', obj] +
postargs)
except errors.DistutilsExecError as e:
raise errors.CompileError(str(e))
