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 cythonize(extensions, arg_options): directive_keys = ('linetrace', 'profile') directives = {key: arg_options[key] for key in directive_keys} # Embed signatures for Sphinx documentation. directives['embedsignature'] = True cythonize_option_keys = ('annotate',) cythonize_options = {key: arg_options[key] for key in cythonize_option_keys} # Compile-time constants to be used in Cython code compile_time_env = cythonize_options.get('compile_time_env') if compile_time_env is None: compile_time_env = {} cythonize_options['compile_time_env'] = compile_time_env compile_time_env['use_hip'] = arg_options['use_hip'] compile_time_env['CUPY_CUFFT_STATIC'] = False compile_time_env['cython_version'] = str(cython_version) if use_hip or arg_options['no_cuda']: compile_time_env['CUDA_VERSION'] = 0 else: compile_time_env['CUDA_VERSION'] = build.get_cuda_version() return Cython.Build.cythonize( extensions, verbose=True, language_level=3, compiler_directives=directives, **cythonize_options)
def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): # For sources other than CUDA C ones, just call the super class method. if os.path.splitext(src)[1] != '.cu': return unixccompiler.UnixCCompiler._compile( self, obj, src, ext, cc_args, extra_postargs, pp_opts) if use_hip: return self._comiple_unix_hipcc(obj, src, ext, cc_args, extra_postargs, pp_opts) # For CUDA C source files, compile them with NVCC. _compiler_so = self.compiler_so try: nvcc_path = build.get_nvcc_path() base_opts = build.get_compiler_base_options() self.set_executable('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) return unixccompiler.UnixCCompiler._compile( self, obj, src, ext, base_opts + cc_args, postargs, pp_opts) finally: self.compiler_so = _compiler_so
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 cythonize(extensions, arg_options): # Delay importing Cython as it may be installed via setup_requires if # the user does not have Cython installed. import Cython import Cython.Build cython_version = pkg_resources.parse_version(Cython.__version__) if (cython_version < required_cython_version or cython_version in ignore_cython_versions): raise AssertionError( 'Unsupported Cython version: {}'.format(cython_version)) directive_keys = ('linetrace', 'profile') directives = {key: arg_options[key] for key in directive_keys} # Embed signatures for Sphinx documentation. directives['embedsignature'] = True cythonize_option_keys = ('annotate', ) cythonize_options = { key: arg_options[key] for key in cythonize_option_keys } # Compile-time constants to be used in Cython code compile_time_env = cythonize_options.get('compile_time_env') if compile_time_env is None: compile_time_env = {} cythonize_options['compile_time_env'] = compile_time_env compile_time_env['CUPY_CUFFT_STATIC'] = False compile_time_env['cython_version'] = str(cython_version) if arg_options['no_cuda']: # on RTD compile_time_env['CUDA_VERSION'] = 0 compile_time_env['HIP_VERSION'] = 0 elif use_hip: # on ROCm/HIP compile_time_env['CUDA_VERSION'] = 0 compile_time_env['HIP_VERSION'] = build.get_hip_version() else: # on CUDA compile_time_env['CUDA_VERSION'] = build.get_cuda_version() compile_time_env['HIP_VERSION'] = 0 return Cython.Build.cythonize(extensions, verbose=True, language_level=3, compiler_directives=directives, **cythonize_options)
def _comiple_unix_nvcc(self, obj, src, ext, cc_args, extra_postargs, pp_opts): # For CUDA C source files, compile them with NVCC. _compiler_so = self.compiler_so try: nvcc_path = build.get_nvcc_path() base_opts = build.get_compiler_base_options() self.set_executable('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) return unixccompiler.UnixCCompiler._compile( self, obj, src, ext, base_opts + cc_args, postargs, pp_opts) finally: self.compiler_so = _compiler_so
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 _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))
def preconfigure_modules(compiler, settings): """Returns a list of modules buildable in given environment and settings. For each module in MODULES list, this function checks if the module can be built in the current environment and reports it. Returns a list of module names available. """ nvcc_path = build.get_nvcc_path() hipcc_path = build.get_hipcc_path() summary = [ '', '************************************************************', '* CuPy Configuration Summary *', '************************************************************', '', 'Build Environment:', ' Include directories: {}'.format(str(settings['include_dirs'])), ' Library directories: {}'.format(str(settings['library_dirs'])), ' nvcc command : {}'.format( nvcc_path if nvcc_path else '(not found)'), ' hipcc command : {}'.format( hipcc_path if hipcc_path else '(not found)'), '', 'Environment Variables:', ] for key in [ 'CFLAGS', 'LDFLAGS', 'LIBRARY_PATH', 'CUDA_PATH', 'NVTOOLSEXT_PATH', 'NVCC', 'HIPCC', 'ROCM_HOME' ]: summary += [' {:<16}: {}'.format(key, os.environ.get(key, '(none)'))] summary += [ '', 'Modules:', ] ret = [] for module in MODULES: installed = False status = 'No' errmsg = [] if module['name'] == 'cutensor': cutensor_path = os.environ.get('CUTENSOR_PATH', '') inc_path = os.path.join(cutensor_path, 'include') if os.path.exists(inc_path): settings['include_dirs'].append(inc_path) cuda_version = build.get_cuda_version() cuda_major = str(cuda_version // 1000) cuda_major_minor = cuda_major + '.' + \ str((cuda_version // 10) % 100) for cuda_ver in (cuda_major_minor, cuda_major): lib_path = os.path.join(cutensor_path, 'lib', cuda_ver) if os.path.exists(lib_path): settings['library_dirs'].append(lib_path) break print('') print('-------- Configuring Module: {} --------'.format( module['name'])) sys.stdout.flush() if not check_library( compiler, includes=module['include'], include_dirs=settings['include_dirs'], define_macros=settings['define_macros'], extra_compile_args=settings['extra_compile_args']): errmsg = [ 'Include files not found: %s' % module['include'], 'Check your CFLAGS environment variable.' ] elif not check_library( compiler, libraries=module['libraries'], library_dirs=settings['library_dirs'], define_macros=settings['define_macros'], extra_compile_args=settings['extra_compile_args']): errmsg = [ 'Cannot link libraries: %s' % module['libraries'], 'Check your LDFLAGS environment variable.' ] elif ('check_method' in module and not module['check_method'](compiler, settings)): # Fail on per-library condition check (version requirements etc.) installed = True errmsg = ['The library is installed but not supported.'] elif (module['name'] in ('thrust', 'cub', 'random') and (nvcc_path is None and hipcc_path is None)): installed = True cmd = 'nvcc' if not use_hip else 'hipcc' errmsg = [ '{} command could not be found in PATH.'.format(cmd), 'Check your PATH environment variable.' ] else: installed = True status = 'Yes' ret.append(module['name']) if installed and 'version_method' in module: status += ' (version {})'.format(module['version_method'](True)) summary += [' {:<10}: {}'.format(module['name'], status)] # If error message exists... if len(errmsg) != 0: summary += [' -> {}'.format(m) for m in errmsg] # Skip checking other modules when CUDA is unavailable. if module['name'] == 'cuda': break # Get a list of the CC of the devices connected to this node if not use_hip: build.check_compute_capabilities(compiler, settings) if len(ret) != len(MODULES): if 'cuda' in ret: lines = [ 'WARNING: Some modules could not be configured.', 'CuPy will be installed without these modules.', ] else: lines = [ 'ERROR: CUDA could not be found on your system.', ] summary += [ '', ] + lines + [ 'Please refer to the Installation Guide for details:', 'https://docs.cupy.dev/en/stable/install.html', '', ] summary += [ '************************************************************', '', ] print('\n'.join(summary)) return ret, settings
def test_check_cuda_version(self): with self.assertRaises(RuntimeError): build.get_cuda_version() assert build.check_cuda_version(self.compiler, self.settings) assert isinstance(build.get_cuda_version(), int) assert isinstance(build.get_cuda_version(True), str)