Homec4science
Diffusion tamaas (features/declarative) Browse

tamaas/SConstruct
0158bc7fc227features/declarative

Last Change
Raw File

SConstruct
View Options

# ------------------------------------------------------------------------------
# Imports
# ------------------------------------------------------------------------------
from __future__ import print_function
import os
from os.path import join, abspath, basename
from version import write_info_file
# ------------------------------------------------------------------------------
EnsurePythonVersion(2, 7)
EnsureSConsVersion(2, 4)
# ------------------------------------------------------------------------------
# Helper functions
# ------------------------------------------------------------------------------
def detect_fftw(env):
"""Detect fftw on clusters"""
fftw_include = ""
fftw_library = ""
# If FFTW is provided by module system (on clusters)
if 'FFTW_ROOT' in env['ENV']:
fftw_include = join(env['ENV']['FFTW_ROOT'], 'include')
fftw_library = join(env['ENV']['FFTW_ROOT'], 'lib')
# Setting up FFTW
env['FFTW_LIBRARY_WISH'] = ['main', 'omp']
env['FFTW_INCLUDE_DIR'] = fftw_include
env['FFTW_LIBRARY_DIR'] = fftw_library
env.Tool(fftw)
# ------------------------------------------------------------------------------
def detect_cuda(env):
"""Detect cuda on clusters"""
if 'CUDA_ROOT' in env['ENV']:
env['CUDA_TOOLKIT_PATH'] = env['ENV']['CUDA_ROOT']
else:
env['CUDA_TOOLKIT_PATH'] = '/opt/cuda'
env['CUDA_COMPONENTS'] = ['cufft']
env['CUDA_ARCH_FLAG'] = '-arch=sm_60'
colors = env['COLOR_DICT']
if not env['verbose']:
env['NVCCCOMSTR'] = env['SHCXXCOMSTR']
env['SHLINKCOMSTR'] = u'{0}[Linking (cuda)] {1}$TARGET{2}'.format(colors['purple'],
colors['blue'],
colors['end'])
env.AppendUnique(CXXFLAGS="-expt-extended-lambda") # experimental lambda support
env.AppendUnique(CXXFLAGS="-expt-relaxed-constexpr") # experimental lambda support
if env['build_type'] == 'debug':
env.AppendUnique(CXXFLAGS="-G")
env.Tool('nvcc')
# ------------------------------------------------------------------------------
def detect_boost(env):
"""Detect boost on clusters"""
if 'BOOST_ROOT' in env['ENV']:
env['BOOST_INCLUDE_DIR'] = join(env['ENV']['BOOST_ROOT'], 'include')
env.Tool(boost)
# ------------------------------------------------------------------------------
def detect_thrust(env):
"""Detect cuda on clusters"""
if 'CUDA_ROOT' in env['ENV']:
env['THRUST_INCLUDE_DIR'] = join(env['ENV']['CUDA_ROOT'], 'include')
else:
env['THRUST_INCLUDE_DIR'] = '/opt/cuda/include'
if basename(env['CXX']) == "clang++":
env.AppendUnique(CXXFLAGS=["-Wno-unused-local-typedef"])
env.Tool(thrust)
# ------------------------------------------------------------------------------
def detect_dependencies(env):
"""Detect all dependencies"""
detect_fftw(env)
detect_boost(env)
detect_thrust(env)
# Activate cuda if needed
if env['backend'] == 'cuda':
detect_cuda(env)
# ------------------------------------------------------------------------------
def gen_print(action_string, color_string, env):
"""Generic function for creating pretty compile output"""
if env['verbose']:
return None
def print_fun(command, target, source, env):
colors = env['COLOR_DICT']
print("{}[{}] {}{}".format(colors[color_string],
action_string,
colors['end'],
target[0]))
return print_fun
# ------------------------------------------------------------------------------
# Main compilation
# ------------------------------------------------------------------------------
# Compilation colors
colors = {
'cyan': '\033[96m',
'purple': '\033[95m',
'blue': '\033[94m',
'green': '\033[92m',
'yellow': '\033[93m',
'red': '\033[91m',
'end': '\033[0m'
}
# Inherit all environment variables (for CXX detection, etc.)
main_env = Environment(ENV=os.environ)
main_env['COLOR_DICT'] = colors
# Compiler detection
compiler_default = 'g++'
if 'CXX' in os.environ:
compiler_default = os.environ['CXX']
print("Detected default compiler {} from environment".format(compiler_default))
# Build variables
vars = Variables('build-setup.conf')
vars.Add(EnumVariable('build_type', 'Build type', 'release',
allowed_values=('release', 'profiling', 'debug'),
ignorecase=2))
vars.Add(EnumVariable('backend', 'Thrust backend', 'omp',
allowed_values=('omp', 'cuda'),
ignorecase=2))
vars.Add(EnumVariable('sanitizer', 'Sanitizer type', 'none',
allowed_values=('none', 'memory', 'leaks', 'address'),
ignorecase=2))
vars.Add('prefix', 'Prefix where to install', '/usr/local')
vars.Add('CXX', 'Compiler', compiler_default)
vars.Add('py_exec', 'Python executable', 'python')
# Cosmetic
vars.Add(BoolVariable('verbose', 'Activate verbosity', False))
vars.Add(BoolVariable('color', 'Color the non-verbose compilation output', False))
# Tamaas components
vars.Add(BoolVariable('build_doc', 'Build documentation', False))
vars.Add(BoolVariable('build_tests', 'Build test suite', False))
vars.Add(BoolVariable('build_python', 'Build python wrapper', False))
# Dependencies
vars.Add(BoolVariable('use_googletest', 'Build tests using GTest', False))
vars.Update(main_env)
Help(vars.GenerateHelpText(main_env))
# Save all options, not just those that differ from default
with open('build-setup.conf', 'w') as setup:
for key in vars.keys():
setup.write("{} = '{}'\n".format(key, main_env[key]))
main_env['should_configure'] = not main_env.GetOption('clean') and not main_env.GetOption('help')
build_type = main_env['build_type']
build_dir = 'build-' + main_env['build_type']
if main_env['should_configure']:
print("Building in " + build_dir)
verbose = main_env['verbose']
# Remove colors if not set
if not main_env['color']:
for key in colors:
colors[key] = ''
# Setting object suffix
main_env['SHOBJSUFFIX'] = '.o'
if not verbose:
main_env['SHCXXCOMSTR'] = u'{0}[Compiling ($SHCXX)] {1}$SOURCE'.format(colors['green'],
colors['end'])
main_env['SHLINKCOMSTR'] = u'{0}[Linking] {1}$TARGET'.format(colors['purple'],
colors['end'])
# Include paths
main_env.AppendUnique(CPPPATH=['#/src',
'#/src/core',
'#/src/bem',
'#/src/surface',
'#/src/python',
'#/src/percolation',
'#/src/model',
'#/src/solvers',
'#/src/gpu',
'#/python'])
# Changing the shared object extension
main_env['SHOBJSUFFIX'] = '.o'
# Back to gcc if cuda is activated
if main_env['backend'] == "cuda":
main_env['CXX'] = "g++"
# OpenMP flags - compiler dependent
omp_libs = {
"g++": ["gomp"],
"c++": ["gomp"],
"clang++": [],
"icpc": []
}
omp_flags = {
"g++": ["-fopenmp"],
"c++": ["-fopenmp"],
"clang++": ["-fopenmp=libomp"],
"icpc": ["-qopenmp"]
}
omp_lib = omp_libs[main_env['CXX']]
omp_flag = omp_flags[main_env['CXX']]
main_env.AppendUnique(LIBS=omp_lib)
main_env.AppendUnique(LINKFLAGS=omp_flag)
# Flags and options
main_env.AppendUnique(CXXFLAGS=['-std=c++11',
'-Wall',
omp_flag])
if main_env['backend'] == 'omp':
main_env.AppendUnique(CPPDEFINES=["THRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_OMP"])
elif main_env['backend'] == 'cuda':
main_env.AppendUnique(CPPDEFINES=["THRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_CUDA"])
main_env.AppendUnique(CPPDEFINES=['USE_CUDA'])
# Adding compile flags defined in evironment
if 'CXXFLAGS' in os.environ:
main_env.AppendUnique(CXXFLAGS=Split(os.environ['CXXFLAGS']))
if build_type == 'debug':
main_env.AppendUnique(CPPDEFINES=['TAMAAS_DEBUG'])
# Compilation flags
cxxflags_dict = {
"debug": Split("-g -O0"),
"profiling": Split("-g -pg -O2 -fno-omit-frame-pointer"),
"release": Split("-O3")
}
# Link flags for shared libs
shlinkflags_dict = {
"debug": Split(""),
"profiling": ['-pg'],
"release": []
}
if main_env['sanitizer'] != 'none':
if main_env['backend'] == 'cuda':
print("Sanitizers with cuda are not yet supported!")
Exit(1)
cxxflags_dict[build_type].append('-fsanitize={}'.format(main_env['sanitizer']))
shlinkflags_dict[build_type].append('-fsanitize={}'.format(main_env['sanitizer']))
main_env.AppendUnique(CXXFLAGS=cxxflags_dict[build_type])
main_env.AppendUnique(SHLINKFLAGS=shlinkflags_dict[build_type])
main_env.AppendUnique(LINKFLAGS=shlinkflags_dict[build_type])
main_env['LIBPATH'] = [abspath(join(build_dir, 'src'))]
main_env['RPATH'] = "$LIBPATH"
if main_env['should_configure']:
detect_dependencies(main_env)
# Writing information file
write_info_file("src/tamaas_info.cpp")
# Saving the env file
env_content = """export PYTHONPATH=$PYTHONPATH:{0}/python
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{0}/src
"""
def write_env_file(target, source, env):
"""Builder to write content to file"""
with open(str(target[0]), 'w') as env_file:
env_file.write(env_content.format(abspath(build_dir)))
main_env['gen_print'] = gen_print
env_file_env = main_env.Clone(PRINT_CMD_LINE_FUNC=gen_print("Writing", "cyan", main_env))
# Need to have a command and manage tamaas_environement.sh as target because
# the build directory does not always exist
env_file_env.Command(join(build_dir, 'tamaas_environement.sh'), None, write_env_file)
Export('main_env')
# Building subdirs
def subdir(dir):
return SConscript(join(dir, 'SConscript'),
variant_dir=join(build_dir, dir),
duplicate=True)
# Building Tamaas library
subdir('src')
# Building Tamaas extra components
for dir in ['python', 'tests', 'doc']:
if main_env['build_{}'.format(dir)] and not main_env.GetOption('help'):
subdir(dir)
c4science · Help