def get_rdma_dirs(build_ext):
rdma_include_dirs = []
rdma_lib_dirs = []
rdma_link_flags = []
rdma_lib = []
rdma_home = os.environ.get('T_RING_RDMA_HOME')
if rdma_home:
rdma_include_dirs += ['%s/include' % rdma_home]
rdma_lib_dirs += ['%s/lib' % rdma_home, '%s/lib64' % rdma_home]
rdma_include = os.environ.get('T_RING_RDMA_INCLUDE')
if rdma_include:
rdma_include_dirs += [rdma_include]
rdma_lib = os.environ.get('T_RING_CUDA_LIB')
if rdma_lib:
rdma_lib_dirs += [rdma_lib]
else:
rdma_lib = []
if not rdma_include_dirs and not rdma_lib_dirs:
# default to /usr/local/cuda
rdma_include_dirs += ['/usr/src/mlnx-ofed-kernel-4.1/include']
rdma_lib_dirs += [
'/usr/src/mlnx-ofed-kernel-4.1/lib',
'/usr/src/mlnx-ofed-kernel-4.1/lib64'
]
rdma_lib += ['rdmacm', 'ibverbs']
try:
test_compile(build_ext,
'test_rdma',
include_dirs=rdma_include_dirs,
library_dirs=rdma_lib_dirs,
libraries=rdma_lib,
code=textwrap.dedent('''\
#include <rdma/rdma_cma.h>
void test()
{
char *buffer =NULL;
struct ibv_pd * pd = NULL;
rdma_create_event_channel();
ibv_reg_mr(
pd,
buffer,
1024,
IBV_ACCESS_REMOTE_WRITE);
}
'''))
except (CompileError, LinkError):
raise DistutilsPlatformError(
'RDMA library was not found (see error above).\n'
'Please specify correct RDMA location with the BCUBE_RDMA_HOME '
'environment variable or combination of BCUBE_RDMA_INCLUDE and '
'BCUBE_RDMA_LIB environment variables.\n\n'
'BCUBE_RDMA_HOME - path where RDMA include and lib directories can be found\n'
'BCUBE_RDMA_INCLUDE - path to RDMA include directory\n'
'BCUBE_RDMA_LIB - path to RDMA lib directory')
for lib in rdma_lib:
rdma_link_flags.append('-l%s' % lib)
return rdma_include_dirs, rdma_lib_dirs, rdma_link_flags
def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):
"""Run another program, specified as a command list 'cmd', in a new process.
'cmd' is just the argument list for the new process, ie.
cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
There is no way to run a program with a name different from that of its
executable.
If 'search_path' is true (the default), the system's executable
search path will be used to find the program; otherwise, cmd[0]
must be the exact path to the executable. If 'dry_run' is true,
the command will not actually be run.
Raise DistutilsExecError if running the program fails in any way; just
return on success.
"""
# cmd is documented as a list, but just in case some code passes a tuple
# in, protect our %-formatting code against horrible death
cmd = list(cmd)
log.info(subprocess.list2cmdline(cmd))
if dry_run:
return
if search_path:
executable = find_executable(cmd[0])
if executable is not None:
cmd[0] = executable
env = env if env is not None else dict(os.environ)
if sys.platform == 'darwin':
global _cfg_target, _cfg_target_split
if _cfg_target is None:
from distutils import sysconfig
_cfg_target = sysconfig.get_config_var(
'MACOSX_DEPLOYMENT_TARGET') or ''
if _cfg_target:
_cfg_target_split = [int(x) for x in _cfg_target.split('.')]
if _cfg_target:
# Ensure that the deployment target of the build process is not
# less than 10.3 if the interpreter was built for 10.3 or later.
# This ensures extension modules are built with correct
# compatibility values, specifically LDSHARED which can use
# '-undefined dynamic_lookup' which only works on >= 10.3.
cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
cur_target_split = [int(x) for x in cur_target.split('.')]
if _cfg_target_split[:2] >= [10, 3] and cur_target_split[:2] < [10, 3]:
my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
'now "%s" but "%s" during configure;'
'must use 10.3 or later'
% (cur_target, _cfg_target))
raise DistutilsPlatformError(my_msg)
env.update(MACOSX_DEPLOYMENT_TARGET=cur_target)
try:
proc = subprocess.Popen(cmd, env=env)
proc.wait()
exitcode = proc.returncode
except OSError as exc:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError(
"command %r failed: %s" % (cmd, exc.args[-1])) from exc
if exitcode:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError(
"command %r failed with exit code %s" % (cmd, exitcode))
def initialize(self, plat_name=None):
if not not self.initialized:
raise AssertionError("don't init multiple times")
if plat_name is None:
plat_name = get_platform()
ok_plats = ('win32', 'win-amd64', 'win-ia64')
if plat_name not in ok_plats:
raise DistutilsPlatformError('--plat-name must be one of %s' %
(ok_plats, ))
if 'DISTUTILS_USE_SDK' in os.environ and 'MSSdk' in os.environ and self.find_exe(
'cl.exe'):
self.cc = 'cl.exe'
self.linker = 'link.exe'
self.lib = 'lib.exe'
self.rc = 'rc.exe'
self.mc = 'mc.exe'
else:
if plat_name == get_platform() or plat_name == 'win32':
plat_spec = PLAT_TO_VCVARS[plat_name]
else:
plat_spec = PLAT_TO_VCVARS[
get_platform()] + '_' + PLAT_TO_VCVARS[plat_name]
vc_env = query_vcvarsall(VERSION, plat_spec)
self.__paths = vc_env['path'].encode('mbcs').split(os.pathsep)
os.environ['lib'] = vc_env['lib'].encode('mbcs')
os.environ['include'] = vc_env['include'].encode('mbcs')
if len(self.__paths) == 0:
raise DistutilsPlatformError(
"Python was built with %s, and extensions need to be built with the same version of the compiler, but it isn't installed."
% self.__product)
self.cc = self.find_exe('cl.exe')
self.linker = self.find_exe('link.exe')
self.lib = self.find_exe('lib.exe')
self.rc = self.find_exe('rc.exe')
self.mc = self.find_exe('mc.exe')
try:
for p in os.environ['path'].split(';'):
self.__paths.append(p)
except KeyError:
pass
self.__paths = normalize_and_reduce_paths(self.__paths)
os.environ['path'] = ';'.join(self.__paths)
self.preprocess_options = None
if self.__arch == 'x86':
self.compile_options = [
'/nologo', '/Ox', '/MD', '/W3', '/DNDEBUG'
]
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/W3', '/Z7', '/D_DEBUG'
]
else:
self.compile_options = [
'/nologo', '/Ox', '/MD', '/W3', '/GS-', '/DNDEBUG'
]
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/W3', '/GS-', '/Z7', '/D_DEBUG'
]
self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
self.ldflags_shared_debug = self.__version >= 7 and [
'/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG', '/pdb:None'
]
self.ldflags_static = ['/nologo']
self.initialized = True
return
def check_torch_import():
try:
import torch
except ImportError:
raise DistutilsPlatformError(
'import torch failed, is it installed?\n\n%s' % traceback.format_exc())
def initialize(self):
self.__paths = []
if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe(
"cl.exe"):
# Assume that the SDK set up everything alright; don't try to be
# smarter
self.cc = "cl.exe"
self.linker = "link.exe"
self.lib = "lib.exe"
self.rc = "rc.exe"
self.mc = "mc.exe"
else:
self.__paths = self.get_msvc_paths("path")
if len(self.__paths) == 0:
raise DistutilsPlatformError(
"Python was built with %s, "
"and extensions need to be built with the same "
"version of the compiler, but it isn't installed." %
self.__product)
self.cc = self.find_exe("cl.exe")
self.linker = self.find_exe("link.exe")
self.lib = self.find_exe("lib.exe")
self.rc = self.find_exe("rc.exe") # resource compiler
self.mc = self.find_exe("mc.exe") # message compiler
self.set_path_env_var('lib')
self.set_path_env_var('include')
# extend the MSVC path with the current path
try:
for p in os.environ['path'].split(';'):
self.__paths.append(p)
except KeyError:
pass
self.__paths = normalize_and_reduce_paths(self.__paths)
os.environ['path'] = ";".join(self.__paths)
self.preprocess_options = None
if self.__arch == "Intel":
self.compile_options = [
'/nologo', '/Ox', '/MD', '/W3', '/GX', '/DNDEBUG'
]
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/W3', '/GX', '/Z7', '/D_DEBUG'
]
else:
# Win64
self.compile_options = [
'/nologo', '/Ox', '/MD', '/W3', '/GS-', '/DNDEBUG'
]
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/W3', '/GS-', '/Z7', '/D_DEBUG'
]
self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
if self.__version >= 7:
self.ldflags_shared_debug = [
'/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
]
else:
self.ldflags_shared_debug = [
'/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
]
self.ldflags_static = ['/nologo']
self.initialized = True
my_msg = "invalid Python installation: unable to open %s" % filename
if hasattr(msg, "strerror"):
my_msg = my_msg + " (%s)" % msg.strerror
raise DistutilsPlatformError(my_msg)
# load the installed pyconfig.h:
try:
filename = get_config_h_filename()
parse_config_h(file(filename), g)
except IOError, msg:
my_msg = "invalid Python installation: unable to open %s" % filename
if hasattr(msg, "strerror"):
my_msg = my_msg + " (%s)" % msg.strerror
raise DistutilsPlatformError(my_msg)
# On MacOSX we need to check the setting of the environment variable
# MACOSX_DEPLOYMENT_TARGET: configure bases some choices on it so
# it needs to be compatible.
# If it isn't set we set it to the configure-time value
if sys.platform == 'darwin' and g.has_key('MACOSX_DEPLOYMENT_TARGET'):
cfg_target = g['MACOSX_DEPLOYMENT_TARGET']
cur_target = os.getenv('MACOSX_DEPLOYMENT_TARGET', '')
if cur_target == '':
cur_target = cfg_target
os.putenv('MACOSX_DEPLOYMENT_TARGET', cfg_target)
elif map(int, cfg_target.split('.')) > map(int, cur_target.split('.')):
my_msg = (
'$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configure'
% (cur_target, cfg_target))
def initialize(self, plat_name=None):
# multi-init means we would need to check platform same each time...
assert not self.initialized, "don't init multiple times"
if plat_name is None:
plat_name = get_platform()
# sanity check for platforms to prevent obscure errors later.
if plat_name not in PLAT_TO_VCVARS:
raise DistutilsPlatformError("--plat-name must be one of {}"
.format(tuple(PLAT_TO_VCVARS)))
# Get the vcvarsall.bat spec for the requested platform.
plat_spec = PLAT_TO_VCVARS[plat_name]
vc_env = _get_vc_env(plat_spec)
if not vc_env:
raise DistutilsPlatformError("Unable to find a compatible "
"Visual Studio installation.")
self._paths = vc_env.get('path', '')
paths = self._paths.split(os.pathsep)
self.cc = _find_exe("cl.exe", paths)
self.linker = _find_exe("link.exe", paths)
self.lib = _find_exe("lib.exe", paths)
self.rc = _find_exe("rc.exe", paths) # resource compiler
self.mc = _find_exe("mc.exe", paths) # message compiler
self.mt = _find_exe("mt.exe", paths) # message compiler
self._vcruntime_redist = vc_env.get('py_vcruntime_redist', '')
for dir in vc_env.get('include', '').split(os.pathsep):
if dir:
self.add_include_dir(dir)
for dir in vc_env.get('lib', '').split(os.pathsep):
if dir:
self.add_library_dir(dir)
self.preprocess_options = None
# If vcruntime_redist is available, link against it dynamically. Otherwise,
# use /MT[d] to build statically, then switch from libucrt[d].lib to ucrt[d].lib
# later to dynamically link to ucrtbase but not vcruntime.
self.compile_options = [
'/nologo', '/Ox', '/W3', '/GL', '/DNDEBUG'
]
self.compile_options.append('/MD' if self._vcruntime_redist else '/MT')
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/Zi', '/W3', '/D_DEBUG'
]
ldflags = [
'/nologo', '/INCREMENTAL:NO', '/LTCG'
]
if not self._vcruntime_redist:
ldflags.extend(('/nodefaultlib:libucrt.lib', 'ucrt.lib'))
ldflags_debug = [
'/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL'
]
self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
self.ldflags_shared = [*ldflags, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
self.ldflags_shared_debug = [*ldflags_debug, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
self.ldflags_static = [*ldflags]
self.ldflags_static_debug = [*ldflags_debug]
self._ldflags = {
(CCompiler.EXECUTABLE, None): self.ldflags_exe,
(CCompiler.EXECUTABLE, False): self.ldflags_exe,
(CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
(CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
(CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
(CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
(CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
(CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
(CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
}
self.initialized = True
result[key] = removeDuplicates(value)
finally:
popen.stdout.close()
popen.stderr.close()
if len(result) != len(interesting):
raise ValueError(str(list(result.keys())))
return result
# More globals
VERSION = get_build_version()
if VERSION < 8.0:
raise DistutilsPlatformError("VC %0.1f is not supported by this module" %
VERSION)
# MACROS = MacroExpander(VERSION)
class MSVCCompiler(CCompiler):
"""Concrete class that implements an interface to Microsoft Visual C++,
as defined by the CCompiler abstract class."""
compiler_type = 'msvc'
# Just set this so CCompiler's constructor doesn't barf. We currently
# don't use the 'set_executables()' bureaucracy provided by CCompiler,
# as it really isn't necessary for this sort of single-compiler class.
# Would be nice to have a consistent interface with UnixCCompiler,
# though, so it's worth thinking about.
executables = {}
def run(self):
if sys.platform != 'win32':
raise DistutilsPlatformError("InnoSetup distributions must be"
" created on a Windows platform")
# Locate information about Inno Setup from the registry
from _winreg import OpenKeyEx, QueryValueEx, HKEY_LOCAL_MACHINE
try:
key = OpenKeyEx(
HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows'
r'\CurrentVersion\Uninstall'
r'\Inno Setup 5_is1')
inno_version = QueryValueEx(key, 'DisplayVersion')[0]
inno_path = QueryValueEx(key, 'InstallLocation')[0]
except WindowsError:
raise DistutilsPlatformError(
'Inno Setup version %s to %s is required to build the'
' installer, but was not found on this system.' %
(INNO_MIN_VERSION, INNO_MAX_VERSION))
if inno_version < INNO_MIN_VERSION or inno_version > INNO_MAX_VERSION:
raise DistutilsPlatformError(
'Inno Setup version %s to %s is required to build the'
' installer, but version %s was found on this system.' %
(INNO_MIN_VERSION, INNO_MAX_VERSION, inno_version))
iss_compiler = os.path.join(inno_path, 'iscc.exe')
if not self.skip_build:
self.run_command('build')
self.mkpath(self.bdist_dir)
config = self.reinitialize_command('config')
config.cache_filename = None
config.prefix = 'PREFIX'
config.ensure_finalized()
install = self.reinitialize_command('install')
install.root = self.bdist_dir
install.skip_build = self.skip_build
# Always include "compiled" py-files
install.compile = install.optimize = self.byte_compile
# don't warn about installing into a directory not in sys.path
install.warn_dir = False
# always include documentation
install.with_docs = True
self.announce("installing to %s" % self.bdist_dir, 2)
install.ensure_finalized()
install.run()
if self.license_file:
self.copy_file(self.license_file, self.bdist_dir)
# create the InnoSetup script
iss_file = self.build_iss_file()
iss_path = os.path.join(self.bdist_dir,
'%s.iss' % self.distribution.get_name())
self.announce("writing %r" % iss_path)
if not self.dry_run:
f = open(iss_path, "w")
f.write(iss_file)
f.close()
# build distribution using the Inno Setup 5 Command-Line Compiler
self.announce("creating Inno Setup installer", 2) # log.info
self.spawn([iss_compiler, iss_path])
# Add an empty ZIP file to the installer executable to allow for
# uploading to PyPI (it checks for the bdist_wininst format).
dist_filename = self.get_installer_filename()
if os.path.exists(dist_filename) and not self.dry_run:
install_egg_info = self.get_finalized_command('install_egg_info')
install_dir = install_egg_info.install_dir
zip_dir = 'PLATLIB'
if install_dir.endswith(os.sep):
zip_dir += os.sep
zip_file = zipfile.ZipFile(dist_filename, 'a')
for filename in install_egg_info.get_outputs():
arcname = filename.replace(install_dir, zip_dir, 1)
zip_file.write(filename, arcname)
zip_file.close()
# Add to 'Distribution.dist_files' so that the "upload" command works
if hasattr(self.distribution, 'dist_files'):
target_version = self.target_version or 'any'
spec = ('bdist_wininst', target_version, dist_filename)
self.distribution.dist_files.append(spec)
if not self.keep_temp:
remove_tree(self.bdist_dir, self.verbose, self.dry_run)
return
def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):
"""Run another program, specified as a command list 'cmd', in a new process.
'cmd' is just the argument list for the new process, ie.
cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
There is no way to run a program with a name different from that of its
executable.
If 'search_path' is true (the default), the system's executable
search path will be used to find the program; otherwise, cmd[0]
must be the exact path to the executable. If 'dry_run' is true,
the command will not actually be run.
Raise DistutilsExecError if running the program fails in any way; just
return on success.
"""
# cmd is documented as a list, but just in case some code passes a tuple
# in, protect our %-formatting code against horrible death
cmd = list(cmd)
log.info(" ".join(cmd))
if dry_run:
return
if search_path:
executable = find_executable(cmd[0])
if executable is not None:
cmd[0] = executable
env = env if env is not None else dict(os.environ)
if sys.platform == "darwin":
global _cfg_target, _cfg_target_split
if _cfg_target is None:
from distutils import sysconfig
_cfg_target = sysconfig.get_config_var(
"MACOSX_DEPLOYMENT_TARGET") or ""
if _cfg_target:
_cfg_target_split = [int(x) for x in _cfg_target.split(".")]
if _cfg_target:
# ensure that the deployment target of build process is not less
# than that used when the interpreter was built. This ensures
# extension modules are built with correct compatibility values
cur_target = os.environ.get("MACOSX_DEPLOYMENT_TARGET",
_cfg_target)
if _cfg_target_split > [int(x) for x in cur_target.split(".")]:
my_msg = ("$MACOSX_DEPLOYMENT_TARGET mismatch: "
'now "%s" but "%s" during configure' %
(cur_target, _cfg_target))
raise DistutilsPlatformError(my_msg)
env.update(MACOSX_DEPLOYMENT_TARGET=cur_target)
try:
proc = subprocess.Popen(cmd, env=env)
proc.wait()
exitcode = proc.returncode
except OSError as exc:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError("command %r failed: %s" %
(cmd, exc.args[-1])) from exc
if exitcode:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError("command %r failed with exit code %s" %
(cmd, exitcode))
def get_config_h_filename():
"""Return full pathname of installed pyconfig.h file."""
raise DistutilsPlatformError(
"There are no Python header files on Pythonista")
def get_makefile_filename():
"""Return full pathname of installed Makefile from the Python build."""
raise DistutilsPlatformError("There is no Python Makefile on Pythonista")
def compile(
self, sources,
output_dir=None, macros=None, include_dirs=None, debug=0,
extra_preargs=None, extra_postargs=None, depends=None
):
macros = macros or []
include_dirs = include_dirs or []
extra_preargs = extra_preargs or []
extra_postargs = extra_postargs or []
pythonVersionOpts = self.versionOpts()
if not os.path.exists(output_dir):
os.makedirs(output_dir)
binpath = _qp(self._binpath)
if self.build_exe:
compileOpts = self._exeCompileOpts
else:
compileOpts = self._compileOpts
outputOpts = self._outputOpts
includePathOpts = []
# All object files will be placed in one of three directories:
# infra - All of the infrastructure's object files.
# project - The project's own object files.
# outside - Any source files specified by the project which are not
# contained in the project's own directory.
orig_sources = sources
sources = []
for source in orig_sources:
if os.path.abspath(source).startswith(os.getcwd()):
sources.append((winpath(source,self.winonly), 'project'))
else:
sources.append((winpath(source, self.winonly), 'outside'))
if self.with_pyd:
for file in _pydFiles:
filePath = os.path.join(_infraDir, 'pyd', file)
if not os.path.isfile(filePath):
raise DistutilsPlatformError("Required Pyd source file '%s' is"
" missing." % filePath
)
sources.append((winpath(filePath,self.winonly), 'infra'))
for file in _utilFiles:
filePath = os.path.join(_infraDir, 'util', file)
if not os.path.isfile(filePath):
raise DistutilsPlatformError("Required util source file '%s' is"
" missing." % filePath
)
sources.append((winpath(filePath,self.winonly), 'infra'))
if self.build_deimos:
for file in _deimosFiles:
filePath = os.path.join(_infraDir, 'deimos', 'python', file)
if not os.path.isfile(filePath):
raise DistutilsPlatformError("Required deimos header "
"file '%s' is missing." % filePath
)
sources.append((winpath(filePath,self.winonly), 'infra'))
# If using PydMain, parse the template file
if self.build_exe:
pass
elif self.with_main:
name = self.proj_name
# Store the finished pydmain.d file alongside the object files
infra_output_dir = winpath(os.path.join(output_dir, 'infra'), self.winonly)
if not os.path.exists(infra_output_dir):
os.makedirs(infra_output_dir)
mainFilename = os.path.join(infra_output_dir, 'pydmain.d')
make_pydmain(mainFilename, name)
sources.append((winpath(mainFilename,self.winonly), 'infra'))
# Add the infraDir to the include path for pyd and utils.
includePathOpts += self._includeOpts
includePathOpts[-1] = includePathOpts[-1] % winpath(os.path.join(_infraDir), self.winonly)
for include_dir in include_dirs:
includePathOpts += self._includeOpts
includePathOpts[-1] %= winpath(include_dir, self.winonly)
if self.build_exe:
pass
else:
# Add DLL/SO boilerplate code file.
if _isPlatWin:
boilerplatePath = os.path.join(_infraDir, 'd',
'python_dll_windows_boilerplate.d'
)
else:
boilerplatePath = os.path.join(_infraDir, 'd',
'python_so_linux_boilerplate.d'
)
if not os.path.isfile(boilerplatePath):
raise DistutilsFileError('Required supporting code file "%s"'
' is missing.' % boilerplatePath
)
sources.append((winpath(boilerplatePath,self.winonly), 'infra'))
for imp in self.string_imports_from_ext:
if not (os.path.isfile(imp) or os.path.isdir(imp)):
raise DistutilsFileError('String import file "%s" does not exist' %
imp)
userVersionAndDebugOpts = (
[self._versionOpt % v for v in self.version_flags_from_ext] +
[self._debugOpt % v for v in self.debug_flags_from_ext]
)
# Optimization opts
if debug:
optimizationOpts = self._debugOptimizeOpts
elif self.optimize:
optimizationOpts = self._releaseOptimizeOpts
else:
optimizationOpts = self._defaultOptimizeOpts
unittestOpt = []
if self.unittest_from_ext:
unittestOpt.append(self._unittestOpt)
if self.property_from_ext:
unittestOpt.append(self._propertyOpt)
if self.string_imports_from_ext:
imps = set()
for imp in self.string_imports_from_ext:
if os.path.isfile(imp):
imps.add(os.path.dirname(os.path.abspath(imp)))
else:
imps.add(os.path.abspath(imp))
unittestOpt.extend([self._stringImportOpt % (imp,)
for imp in imps])
objFiles = []
if self.lump:
objName = self._make_object_name(output_dir, 'infra', 'temp')
outOpts = outputOpts[:]
outOpts[-1] = outOpts[-1] % objName
cmdElements = (
[binpath] + extra_preargs + unittestOpt + compileOpts +
pythonVersionOpts + optimizationOpts +
includePathOpts + outOpts + userVersionAndDebugOpts +
[_qp(source[0]) for source in sources] + extra_postargs
)
cmdElements = [el for el in cmdElements if el]
wrapped_spawn(self,cmdElements, 'pyd_compile')
return [objName]
else:
for source, source_type in sources:
outOpts = outputOpts[:]
objFilename = os.path.splitext(source)[0]
if source_type == 'project':
objName = self._make_object_name(output_dir, 'project', objFilename)
elif source_type == 'outside':
objName = self._make_object_name(output_dir, 'outside', os.path.basename(objFilename))
else: # infra
objName = self._make_object_name(output_dir, 'infra', os.path.basename(objFilename))
objFiles.append(objName)
outOpts[-1] = outOpts[-1] % objName
cmdElements = (
[binpath] + extra_preargs + unittestOpt + compileOpts +
pythonVersionOpts + optimizationOpts +
includePathOpts + outOpts + userVersionAndDebugOpts +
[_qp(source)] + extra_postargs
)
cmdElements = [el for el in cmdElements if el]
spawn0(self,cmdElements)
return objFiles
def initialize(self, plat_name=None):
# multi-init means we would need to check platform same each time...
assert not self.initialized, "don't init multiple times"
if plat_name is None:
plat_name = get_platform()
# sanity check for platforms to prevent obscure errors later.
if plat_name not in PLAT_TO_VCVARS:
raise DistutilsPlatformError(
"--plat-name must be one of {}".format(tuple(PLAT_TO_VCVARS)))
# Get the vcvarsall.bat spec for the requested platform.
plat_spec = PLAT_TO_VCVARS[plat_name]
vc_env = _get_vc_env(plat_spec)
if not vc_env:
raise DistutilsPlatformError("Unable to find a compatible "
"Visual Studio installation.")
self._paths = vc_env.get('path', '')
paths = self._paths.split(os.pathsep)
self.cc = _find_exe("cl.exe", paths)
self.linker = _find_exe("link.exe", paths)
self.lib = _find_exe("lib.exe", paths)
self.rc = _find_exe("rc.exe", paths) # resource compiler
self.mc = _find_exe("mc.exe", paths) # message compiler
self.mt = _find_exe("mt.exe", paths) # message compiler
for dir in vc_env.get('include', '').split(os.pathsep):
if dir:
self.add_include_dir(dir.rstrip(os.sep))
for dir in vc_env.get('lib', '').split(os.pathsep):
if dir:
self.add_library_dir(dir.rstrip(os.sep))
self.preprocess_options = None
# bpo-38597: Always compile with dynamic linking
# Future releases of Python 3.x will include all past
# versions of vcruntime*.dll for compatibility.
self.compile_options = [
'/nologo', '/Ox', '/W3', '/GL', '/DNDEBUG', '/MD'
]
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/Zi', '/W3', '/D_DEBUG'
]
ldflags = ['/nologo', '/INCREMENTAL:NO', '/LTCG']
ldflags_debug = ['/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL']
self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
self.ldflags_shared = [
*ldflags, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO'
]
self.ldflags_shared_debug = [
*ldflags_debug, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO'
]
self.ldflags_static = [*ldflags]
self.ldflags_static_debug = [*ldflags_debug]
self._ldflags = {
(CCompiler.EXECUTABLE, None): self.ldflags_exe,
(CCompiler.EXECUTABLE, False): self.ldflags_exe,
(CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
(CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
(CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
(CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
(CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
(CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
(CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
}
self.initialized = True
def link(self,
target_desc,
objects,
output_filename,
output_dir=None,
libraries=None,
library_dirs=None,
runtime_library_dirs=None,
export_symbols=None,
debug=0,
extra_preargs=None,
extra_postargs=None,
build_temp=None,
target_lang=None):
# First fixup.
(objects, output_dir) = self._fix_object_args(objects, output_dir)
(libraries, library_dirs, runtime_library_dirs) = \
self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)
# First examine a couple of options for things that aren't implemented yet
if not target_desc in (self.SHARED_LIBRARY, self.SHARED_OBJECT):
raise DistutilsPlatformError(
'Can only make SHARED_LIBRARY or SHARED_OBJECT targets on the Mac'
)
if runtime_library_dirs:
raise DistutilsPlatformError(
'Runtime library dirs not implemented yet')
if extra_preargs or extra_postargs:
raise DistutilsPlatformError(
'Runtime library dirs not implemented yet')
if len(export_symbols) != 1:
raise DistutilsPlatformError('Need exactly one export symbol')
# Next there are various things for which we need absolute pathnames.
# This is because we (usually) create the project in a subdirectory of
# where we are now, and keeping the paths relative is too much work right
# now.
sources = [self._filename_to_abs(s) for s in self.__sources]
include_dirs = [self._filename_to_abs(d) for d in self.__include_dirs]
if objects:
objects = [self._filename_to_abs(o) for o in objects]
else:
objects = []
if build_temp:
build_temp = self._filename_to_abs(build_temp)
else:
build_temp = os.curdir()
if output_dir:
output_filename = os.path.join(output_dir, output_filename)
# The output filename needs special handling: splitting it into dir and
# filename part. Actually I'm not sure this is really needed, but it
# can't hurt.
output_filename = self._filename_to_abs(output_filename)
output_dir, output_filename = os.path.split(output_filename)
# Now we need the short names of a couple of things for putting them
# into the project.
if output_filename[-8:] == '.ppc.slb':
basename = output_filename[:-8]
elif output_filename[-11:] == '.carbon.slb':
basename = output_filename[:-11]
else:
basename = os.path.strip(output_filename)[0]
projectname = basename + '.mcp'
targetname = basename
xmlname = basename + '.xml'
exportname = basename + '.mcp.exp'
prefixname = 'mwerks_%s_config.h' % basename
# Create the directories we need
distutils.dir_util.mkpath(build_temp, dry_run=self.dry_run)
distutils.dir_util.mkpath(output_dir, dry_run=self.dry_run)
# And on to filling in the parameters for the project builder
settings = {}
settings['mac_exportname'] = exportname
settings['mac_outputdir'] = output_dir
settings['mac_dllname'] = output_filename
settings['mac_targetname'] = targetname
settings['sysprefix'] = sys.prefix
settings['mac_sysprefixtype'] = 'Absolute'
sourcefilenames = []
sourcefiledirs = []
for filename in sources + objects:
dirname, filename = os.path.split(filename)
sourcefilenames.append(filename)
if not dirname in sourcefiledirs:
sourcefiledirs.append(dirname)
settings['sources'] = sourcefilenames
settings['libraries'] = libraries
settings[
'extrasearchdirs'] = sourcefiledirs + include_dirs + library_dirs
if self.dry_run:
print('CALLING LINKER IN', os.getcwd())
for key, value in settings.items():
print('%20.20s %s' % (key, value))
return
# Build the export file
exportfilename = os.path.join(build_temp, exportname)
log.debug("\tCreate export file %s", exportfilename)
fp = open(exportfilename, 'w')
fp.write('%s\n' % export_symbols[0])
fp.close()
# Generate the prefix file, if needed, and put it in the settings
if self.__macros:
prefixfilename = os.path.join(os.getcwd(),
os.path.join(build_temp, prefixname))
fp = open(prefixfilename, 'w')
fp.write('#include "mwerks_shcarbon_config.h"\n')
for name, value in self.__macros:
if value is None:
fp.write('#define %s\n' % name)
else:
fp.write('#define %s %s\n' % (name, value))
fp.close()
settings['prefixname'] = prefixname
# Build the XML file. We need the full pathname (only lateron, really)
# because we pass this pathname to CodeWarrior in an AppleEvent, and CW
# doesn't have a clue about our working directory.
xmlfilename = os.path.join(os.getcwd(),
os.path.join(build_temp, xmlname))
log.debug("\tCreate XML file %s", xmlfilename)
import mkcwproject
xmlbuilder = mkcwproject.cwxmlgen.ProjectBuilder(settings)
xmlbuilder.generate()
xmldata = settings['tmp_projectxmldata']
fp = open(xmlfilename, 'w')
fp.write(xmldata)
fp.close()
# Generate the project. Again a full pathname.
projectfilename = os.path.join(os.getcwd(),
os.path.join(build_temp, projectname))
log.debug('\tCreate project file %s', projectfilename)
mkcwproject.makeproject(xmlfilename, projectfilename)
# And build it
log.debug('\tBuild project')
mkcwproject.buildproject(projectfilename)
def cython_sources(self, sources, extension):
"""
Walk the list of source files in 'sources', looking for Cython
source files (.pyx and .py). Run Cython on all that are
found, and return a modified 'sources' list with Cython source
files replaced by the generated C (or C++) files.
"""
try:
from Cython.Compiler.Main \
import CompilationOptions, \
default_options as cython_default_options, \
compile as cython_compile
from Cython.Compiler.Errors import PyrexError
except ImportError:
e = sys.exc_info()[1]
print("failed to import Cython: %s" % e)
raise DistutilsPlatformError(
"Cython does not appear to be installed")
new_sources = []
cython_sources = []
cython_targets = {}
# Setup create_list and cplus from the extension options if
# Cython.Distutils.extension.Extension is used, otherwise just
# use what was parsed from the command-line or the configuration file.
# cplus will also be set to true is extension.language is equal to
# 'C++' or 'c++'.
#try:
# create_listing = self.cython_create_listing or \
# extension.cython_create_listing
# cplus = self.cython_cplus or \
# extension.cython_cplus or \
# (extension.language != None and \
# extension.language.lower() == 'c++')
#except AttributeError:
# create_listing = self.cython_create_listing
# cplus = self.cython_cplus or \
# (extension.language != None and \
# extension.language.lower() == 'c++')
create_listing = self.cython_create_listing or \
getattr(extension, 'cython_create_listing', 0)
line_directives = self.cython_line_directives or \
getattr(extension, 'cython_line_directives', 0)
no_c_in_traceback = self.no_c_in_traceback or \
getattr(extension, 'no_c_in_traceback', 0)
cplus = self.cython_cplus or getattr(extension, 'cython_cplus', 0) or \
(extension.language and extension.language.lower() == 'c++')
cython_gen_pxi = self.cython_gen_pxi or getattr(
extension, 'cython_gen_pxi', 0)
cython_gdb = self.cython_gdb or getattr(extension, 'cython_gdb', False)
cython_compile_time_env = self.cython_compile_time_env or \
getattr(extension, 'cython_compile_time_env', None)
# Set up the include_path for the Cython compiler:
# 1. Start with the command line option.
# 2. Add in any (unique) paths from the extension
# cython_include_dirs (if Cython.Distutils.extension is used).
# 3. Add in any (unique) paths from the extension include_dirs
includes = self.cython_include_dirs
try:
for i in extension.cython_include_dirs:
if not i in includes:
includes.append(i)
except AttributeError:
pass
# In case extension.include_dirs is a generator, evaluate it and keep
# result
extension.include_dirs = list(extension.include_dirs)
for i in extension.include_dirs:
if not i in includes:
includes.append(i)
# Set up Cython compiler directives:
# 1. Start with the command line option.
# 2. Add in any (unique) entries from the extension
# cython_directives (if Cython.Distutils.extension is used).
directives = self.cython_directives
if hasattr(extension, "cython_directives"):
directives.update(extension.cython_directives)
# Set the target_ext to '.c'. Cython will change this to '.cpp' if
# needed.
if cplus:
target_ext = '.cpp'
else:
target_ext = '.c'
# Decide whether to drop the generated C files into the temp dir
# or the source tree.
if not self.inplace and (self.cython_c_in_temp
or getattr(extension, 'cython_c_in_temp', 0)):
target_dir = os.path.join(self.build_temp, "pyrex")
for package_name in extension.name.split('.')[:-1]:
target_dir = os.path.join(target_dir, package_name)
else:
target_dir = None
newest_dependency = None
for source in sources:
(base, ext) = os.path.splitext(os.path.basename(source))
if ext == ".py":
# FIXME: we might want to special case this some more
ext = '.pyx'
if ext == ".pyx": # Cython source file
output_dir = target_dir or os.path.dirname(source)
new_sources.append(os.path.join(output_dir, base + target_ext))
cython_sources.append(source)
cython_targets[source] = new_sources[-1]
elif ext == '.pxi' or ext == '.pxd':
if newest_dependency is None \
or newer(source, newest_dependency):
newest_dependency = source
else:
new_sources.append(source)
if not cython_sources:
return new_sources
module_name = extension.name
for source in cython_sources:
target = cython_targets[source]
depends = [source] + list(extension.depends or ())
if (source[-4:].lower() == ".pyx"
and os.path.isfile(source[:-3] + "pxd")):
depends += [source[:-3] + "pxd"]
rebuild = self.force or newer_group(depends, target, 'newer')
if not rebuild and newest_dependency is not None:
rebuild = newer(newest_dependency, target)
if rebuild:
log.info("cythoning %s to %s", source, target)
self.mkpath(os.path.dirname(target))
if self.inplace:
output_dir = os.curdir
else:
output_dir = self.build_lib
options = CompilationOptions(
cython_default_options,
use_listing_file=create_listing,
include_path=includes,
compiler_directives=directives,
output_file=target,
cplus=cplus,
emit_linenums=line_directives,
c_line_in_traceback=not no_c_in_traceback,
generate_pxi=cython_gen_pxi,
output_dir=output_dir,
gdb_debug=cython_gdb,
compile_time_env=cython_compile_time_env)
result = cython_compile(source,
options=options,
full_module_name=module_name)
else:
log.info("skipping '%s' Cython extension (up-to-date)", target)
return new_sources
def build_java_ext(self, ext):
"""Run command."""
java = self.distribution.enable_build_jar
javac = "javac"
try:
if os.path.exists(
os.path.join(os.environ['JAVA_HOME'], 'bin', 'javac')):
javac = '"%s"' % os.path.join(os.environ['JAVA_HOME'], 'bin',
'javac')
except KeyError:
pass
jar = "jar"
try:
if os.path.exists(
os.path.join(os.environ['JAVA_HOME'], 'bin', 'jar')):
jar = '"%s"' % os.path.join(os.environ['JAVA_HOME'], 'bin',
'jar')
except KeyError:
pass
# Try to use the cache if we are not requested build
if not java:
src = os.path.join('native', 'jars')
dest = os.path.join('build', 'lib')
if os.path.exists(src):
distutils.log.info("Using Jar cache")
copy_tree(src, dest)
return
classpath = "."
if ext.libraries:
classpath = os.path.pathsep.join(ext.libraries)
distutils.log.info(
"Jar cache is missing, using --enable-build-jar to recreate it.")
coverage = self.distribution.enable_coverage
target_version = "1.8"
# build the jar
try:
dirname = os.path.dirname(self.get_ext_fullpath("JAVA"))
jarFile = os.path.join(dirname, ext.name + ".jar")
build_dir = os.path.join(self.build_temp, ext.name, "classes")
os.makedirs(build_dir, exist_ok=True)
os.makedirs(dirname, exist_ok=True)
cmd1 = shlex.split(
'%s -cp "%s" -d "%s" -g:none -source %s -target %s' %
(javac, classpath, build_dir, target_version, target_version))
cmd1.extend(ext.sources)
debug = "-g:none"
if coverage:
debug = "-g:lines,vars,source"
os.makedirs("build/classes", exist_ok=True)
self.announce(" %s" % " ".join(cmd1), level=distutils.log.INFO)
subprocess.check_call(cmd1)
try:
for file in glob.iglob("native/java/**/*.*", recursive=True):
if file.endswith(".java") or os.path.isdir(file):
continue
p = os.path.join(build_dir,
os.path.relpath(file, "native/java"))
print("Copy file", file, p)
shutil.copyfile(file, p)
except Exception as ex:
print("FAIL", ex)
pass
cmd3 = shlex.split('%s cvf "%s" -C "%s" .' %
(jar, jarFile, build_dir))
self.announce(" %s" % " ".join(cmd3), level=distutils.log.INFO)
subprocess.check_call(cmd3)
except subprocess.CalledProcessError as exc:
distutils.log.error(exc.output)
raise DistutilsPlatformError("Error executing {}".format(exc.cmd))
def initialize(self, plat_name=None):
# multi-init means we would need to check platform same each time...
assert not self.initialized, "don't init multiple times"
if plat_name is None:
plat_name = get_platform()
# sanity check for platforms to prevent obscure errors later.
ok_plats = 'win32', 'win-amd64', 'win-ia64'
if plat_name not in ok_plats:
raise DistutilsPlatformError("--plat-name must be one of %s" %
(ok_plats, ))
if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe(
"cl.exe"):
# Assume that the SDK set up everything alright; don't try to be
# smarter
self.cc = "cl.exe"
self.linker = "link.exe"
self.lib = "lib.exe"
self.rc = "rc.exe"
self.mc = "mc.exe"
else:
# On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
# to cross compile, you use 'x86_amd64'.
# On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
# compile use 'x86' (ie, it runs the x86 compiler directly)
# No idea how itanium handles this, if at all.
if plat_name == get_platform() or plat_name == 'win32':
# native build or cross-compile to win32
plat_spec = PLAT_TO_VCVARS[plat_name]
else:
# cross compile from win32 -> some 64bit
plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
PLAT_TO_VCVARS[plat_name]
vc_env = query_vcvarsall(VERSION, plat_spec)
self.__paths = vc_env['path'].split(os.pathsep)
os.environ['lib'] = vc_env['lib']
os.environ['include'] = vc_env['include']
if len(self.__paths) == 0:
raise DistutilsPlatformError(
"Python was built with %s, "
"and extensions need to be built with the same "
"version of the compiler, but it isn't installed." %
self.__product)
self.cc = self.find_exe("cl.exe")
self.linker = self.find_exe("link.exe")
self.lib = self.find_exe("lib.exe")
self.rc = self.find_exe("rc.exe") # resource compiler
self.mc = self.find_exe("mc.exe") # message compiler
#self.set_path_env_var('lib')
#self.set_path_env_var('include')
# extend the MSVC path with the current path
try:
for p in os.environ['path'].split(';'):
self.__paths.append(p)
except KeyError:
pass
self.__paths = normalize_and_reduce_paths(self.__paths)
os.environ['path'] = ";".join(self.__paths)
self.preprocess_options = None
if self.__arch == "x86":
self.compile_options = ['/nologo', '/Ox', '/MD', '/W3', '/DNDEBUG']
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/W3', '/Z7', '/D_DEBUG'
]
else:
# Win64
self.compile_options = [
'/nologo', '/Ox', '/MD', '/W3', '/GS-', '/DNDEBUG'
]
self.compile_options_debug = [
'/nologo', '/Od', '/MDd', '/W3', '/GS-', '/Z7', '/D_DEBUG'
]
self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
if self.__version >= 7:
self.ldflags_shared_debug = [
'/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
]
self.ldflags_static = ['/nologo']
self.initialized = True
def run(self):
raise DistutilsPlatformError("bdist_wininst is not supported "
"in this Python distribution")
def runtime_library_dir_option(self, dir):
raise DistutilsPlatformError(
"don't know how to set runtime library search path for MSVC++")
def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
log.info(' '.join(cmd))
if dry_run:
return
executable = cmd[0]
exec_fn = search_path and os.execvp or os.execv
env = None
if sys.platform == 'darwin':
global _cfg_target, _cfg_target_split
if _cfg_target is None:
_cfg_target = sysconfig.get_config_var(
'MACOSX_DEPLOYMENT_TARGET') or ''
if _cfg_target:
_cfg_target_split = [int(x) for x in _cfg_target.split('.')]
if _cfg_target:
# ensure that the deployment target of build process is not less
# than that used when the interpreter was built. This ensures
# extension modules are built with correct compatibility values
cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET',
_cfg_target)
if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
'now "%s" but "%s" during configure' %
(cur_target, _cfg_target))
raise DistutilsPlatformError(my_msg)
env = dict(os.environ, MACOSX_DEPLOYMENT_TARGET=cur_target)
exec_fn = search_path and os.execvpe or os.execve
pid = os.fork()
if pid == 0: # in the child
try:
if env is None:
exec_fn(executable, cmd)
else:
exec_fn(executable, cmd, env)
except OSError as e:
if not DEBUG:
cmd = executable
sys.stderr.write("unable to execute %r: %s\n" % (cmd, e.strerror))
os._exit(1)
if not DEBUG:
cmd = executable
sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
os._exit(1)
else: # in the parent
# Loop until the child either exits or is terminated by a signal
# (ie. keep waiting if it's merely stopped)
while True:
try:
pid, status = os.waitpid(pid, 0)
except OSError as exc:
import errno
if exc.errno == errno.EINTR:
continue
if not DEBUG:
cmd = executable
raise DistutilsExecError("command %r failed: %s" %
(cmd, exc.args[-1]))
if os.WIFSIGNALED(status):
if not DEBUG:
cmd = executable
raise DistutilsExecError("command %r terminated by signal %d" %
(cmd, os.WTERMSIG(status)))
elif os.WIFEXITED(status):
exit_status = os.WEXITSTATUS(status)
if exit_status == 0:
return # hey, it succeeded!
else:
if not DEBUG:
cmd = executable
raise DistutilsExecError(
"command %r failed with exit status %d" %
(cmd, exit_status))
elif os.WIFSTOPPED(status):
continue
else:
if not DEBUG:
cmd = executable
raise DistutilsExecError(
"unknown error executing %r: termination status %d" %
(cmd, status))
def run(self):
raise DistutilsPlatformError(msg)
def configure_mpi(ext, config_cmd):
from textwrap import dedent
from distutils import log
from distutils.errors import DistutilsPlatformError
headers = ['stdlib.h', 'mpi.h']
#
log.info("checking for MPI compile and link ...")
ConfigTest = dedent("""\
int main(int argc, char **argv)
{
(void)MPI_Init(&argc, &argv);
(void)MPI_Finalize();
return 0;
}
""")
errmsg = "Cannot %s MPI programs. Check your configuration!!!"
ok = config_cmd.try_compile(ConfigTest, headers=headers)
if not ok: raise DistutilsPlatformError(errmsg % "compile")
ok = config_cmd.try_link(ConfigTest, headers=headers)
if not ok: raise DistutilsPlatformError(errmsg % "link")
#
log.info("checking for missing MPI functions/symbols ...")
tests = ["defined(%s)" % macro for macro in
("OPEN_MPI", "MSMPI_VER",)]
tests += ["(defined(MPICH_NAME)&&(MPICH_NAME==3))"]
tests += ["(defined(MPICH_NAME)&&(MPICH_NAME==2))"]
ConfigTest = dedent("""\
#if !(%s)
#error "Unknown MPI implementation"
#endif
""") % "||".join(tests)
ok = config_cmd.try_compile(ConfigTest, headers=headers)
if not ok:
from mpidistutils import ConfigureMPI
configure = ConfigureMPI(config_cmd)
results = configure.run()
configure.dump(results)
ext.define_macros += [('HAVE_CONFIG_H', 1)]
else:
for function, arglist in (
('MPI_Type_create_f90_integer', '0,(MPI_Datatype*)0'),
('MPI_Type_create_f90_real', '0,0,(MPI_Datatype*)0'),
('MPI_Type_create_f90_complex', '0,0,(MPI_Datatype*)0'),
('MPI_Status_c2f', '(MPI_Status*)0,(MPI_Fint*)0'),
('MPI_Status_f2c', '(MPI_Fint*)0,(MPI_Status*)0'),
):
ok = config_cmd.check_function_call(
function, arglist, headers=headers)
if not ok:
macro = 'PyMPI_MISSING_' + function
ext.define_macros += [(macro, 1)]
for symbol, stype in (
('MPI_LB', 'MPI_Datatype'),
('MPI_UB', 'MPI_Datatype'),
):
ok = config_cmd.check_symbol(
symbol, type=stype, headers=headers)
if not ok:
macro = 'PyMPI_MISSING_' + symbol
ext.define_macros += [(macro, 1)]
#
if os.name == 'posix':
configure_dl(ext, config_cmd)
