OilfieldToolsNet/LBPM
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updating CMake to use ENABLE_LANGUAGE( CUDA )

Browse Source
This commit is contained in:
Mark Berrill 2018-04-17 08:38:57 -04:00
parent 7c3b35c109
commit 11b7bc6b1e
9 changed files with 99 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
CMakeLists.txt
View File

@ -1,5 +1,5 @@
# Set some CMake properties
CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
CMAKE_MINIMUM_REQUIRED( VERSION 3.9 )
MESSAGE("====================")
@ -30,6 +30,10 @@ IF ( NOT CXX_STD )
ENDIF()
# Disable Link Time Optimization until we have a chance to test
SET( DISABLE_LTO )
# Set source/install paths
SET( ${PROJ}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" )
SET( ${PROJ}_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}" )
@ -108,10 +112,15 @@ ADD_CUSTOM_TARGET( check COMMAND make test )
ADD_DISTCLEAN( analysis null_timer tests liblbpm-wia.* cpu gpu example common visit IO threadpool )
# Check for CUDA
IF ( USE_CUDA )
ENABLE_LANGUAGE( CUDA )
ENDIF()
# Configure external packages
IF ( NOT ONLY_BUILD_DOCS )
CONFIGURE_MPI() # MPI must be before other libraries
CONFIGURE_CUDA()
CONFIGURE_MIC()
CONFIGURE_NETCDF()
CONFIGURE_SILO()

2
cmake/ctest_script.cmake
View File

@ -222,7 +222,7 @@ IF ( USE_VISIT )
SET( CTEST_OPTIONS "${CTEST_OPTIONS};-DUSE_VISIT:BOOL=true;-DVISIT_ROOT_DIR='${VISIT_ROOT_DIR}'" )
ENDIF()
IF ( USE_CUDA )
SET( CTEST_OPTIONS "${CTEST_OPTIONS};-DUSE_CUDA:BOOL=true;-DCUDA_NVCC_FLAGS='${CUDA_FLAGS}';-DCUDA_HOST_COMPILER=${CUDA_HOST_COMPILER};-DLIB_TYPE=${LIB_TYPE}" )
SET( CTEST_OPTIONS "${CTEST_OPTIONS};-DUSE_CUDA:BOOL=true;-DCMAKE_CUDA_FLAGS='${CUDA_FLAGS}';-DCMAKE_CUDA_HOST_COMPILER=${CUDA_HOST_COMPILER};-DLIB_TYPE=${LIB_TYPE}" )
ELSE()
SET( CTEST_OPTIONS "${CTEST_OPTIONS};-DUSE_CUDA:BOOL=false" )
ENDIF()

43
cmake/libraries.cmake
View File

@ -29,49 +29,6 @@ FUNCTION( CONFIGURE_LINE_COVERAGE )
ENDFUNCTION()
# Macro to configure CUDA
MACRO( CONFIGURE_CUDA )
CHECK_ENABLE_FLAG( USE_CUDA 0 )
IF ( USE_CUDA )
# Include FindCUDA
INCLUDE( FindCUDA )
IF ( NOT CUDA_FOUND )
MESSAGE ( FATAL_ERROR "CUDA not found" )
ENDIF()
# Initialize the cuda flags
IF ( CUDA_FLAGS )
SET( CUDA_NVCC_FLAGS "${CUDA_FLAGS}" )
ENDIF()
IF(NOT CUDA_NVCC_FLAGS)
# Set minimum requirements
SET( CUDA_NVCC_FLAGS "-arch=sm_20" )
ENDIF()
IF( NOT CMAKE_BUILD_TYPE )
MESSAGE(FATAL_ERROR "CMAKE_BUILD_TYPE is not set")
ELSEIF( ${CMAKE_BUILD_TYPE} STREQUAL "Debug" )
SET( CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -g -O0" )
ELSEIF( ${CMAKE_BUILD_TYPE} STREQUAL "Release" )
SET( CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3" )
ENDIF()
SET( CUDA_PROPAGATE_HOST_FLAGS OFF )
SET( CUDA_FIND_QUIETLY )
STRING( REPLACE " " ";" CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} )
ENDIF()
IF ( NOT USE_CUDA )
MESSAGE( "Not using CUDA" )
ELSE ()
INCLUDE_DIRECTORIES ( ${CUDA_INCLUDE_DIRS} )
ADD_DEFINITIONS ( "-D USE_CUDA" )
MESSAGE( "Using CUDA ${CUDA_VERSION}" )
MESSAGE( " CUDA_LIBRARIES = ${CUDA_LIBRARIES}" )
MESSAGE( " CUDA_INCLUDE = ${CUDA_INCLUDE_DIRS}" )
MESSAGE( " CUDA_NVCC_FLAGS = ${CUDA_NVCC_FLAGS}" )
MESSAGE( " CUDA_TOOLKIT_ROOT = ${CUDA_TOOLKIT_ROOT_DIR}" )
SET( EXTERNAL_LIBS ${EXTERNAL_LIBS} ${CUDA_LIBRARIES} )
ENDIF()
ENDMACRO()
# Macro to configure MIC
MACRO( CONFIGURE_MIC )
CHECK_ENABLE_FLAG( USE_MIC 0 )

80
cmake/macros.cmake
View File

@ -3,8 +3,10 @@ INCLUDE(CheckCSourceCompiles)
INCLUDE(CheckCXXCompilerFlag)
INCLUDE(CheckCXXSourceCompiles)
IF ( NOT TEST_FAIL_REGULAR_EXPRESSION )
# SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)|(leaked context IDs detected)|(handles are still allocated)" )
SET( TEST_FAIL_REGULAR_EXPRESSION "FAILED" )
# Note: we cannot check for "handles are still allocated" due to PETSc. See static variable
# Petsc_Reduction_keyval on line 234 of comb.c
#SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)|(leaked context IDs detected)|(handles are still allocated)" )
SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)" )
ENDIF()
@ -21,6 +23,27 @@ IF ( NOT CMAKE_BUILD_TYPE )
ENDIF()
# Enable json
SET( CMAKE_EXPORT_COMPILE_COMMANDS ON )
# Check for link time optimization (LTO)
IF ( ${CMAKE_BUILD_TYPE} STREQUAL "Release" AND ${CMAKE_VERSION} VERSION_GREATER 3.9.4
AND NOT DISABLE_LTO AND NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION )
CMAKE_MINIMUM_REQUIRED(VERSION 3.9)
INCLUDE( CheckIPOSupported )
CHECK_IPO_SUPPORTED(RESULT supported OUTPUT error)
IF( supported )
MESSAGE(STATUS "IPO / LTO enabled")
SET( CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE )
ELSE()
MESSAGE(STATUS "IPO / LTO not supported: <${error}>")
ENDIF()
ELSEIF( NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION )
MESSAGE(STATUS "IPO / LTO disabled")
ENDIF()
# Add some default targets if they do not exist
IF ( NOT TARGET copy-${PROJ}-Data )
ADD_CUSTOM_TARGET( copy-${PROJ}-Data ALL )
@ -200,7 +223,7 @@ MACRO( FIND_FILES_PATH IN_PATH )
SET( CUDASOURCES ${CUDASOURCES} ${T_CUDASOURCES} )
SET( CSOURCES ${CSOURCES} ${T_CSOURCES} )
SET( FSOURCES ${FSOURCES} ${T_FSOURCES} )
SET( SOURCES ${SOURCES} ${T_CXXSOURCES} ${T_CSOURCES} ${T_FSOURCES} )
SET( SOURCES ${SOURCES} ${T_CXXSOURCES} ${T_CSOURCES} ${T_FSOURCES} ${CUDASOURCES} )
ENDMACRO()
@ -245,7 +268,7 @@ MACRO( INSTALL_${PROJ}_TARGET PACKAGE )
ENDFOREACH()
ENDIF()
# Add the library and install the package
IF ( NOT ONLY_BUILD_DOCS AND ( SOURCES OR CUDASOURCES ) )
IF ( NOT ONLY_BUILD_DOCS AND SOURCES )
# Set RPATH variables
IF ( NOT CMAKE_RPATH_VARIABLES_SET )
SET(CMAKE_RPATH_VARIABLES_SET ON)
@ -263,20 +286,9 @@ MACRO( INSTALL_${PROJ}_TARGET PACKAGE )
# Create the library
IF ( ${PROJ}_LIB )
# We are using a single project library
ADD_LIBRARY( ${PACKAGE} OBJECT ${SOURCES} ${CUDASOURCES} )
IF( USE_CUDA )
SET( ${PROJ}_CUDA_SOURCES ${${PROJ}_CUDA_SOURCES} ${CUDASOURCES} CACHE INTERNAL "")
SET( tmp ${${PROJ}_CUDA_SOURCES} )
IF ( tmp )
LIST( REMOVE_DUPLICATES tmp )
ENDIF()
SET( ${PROJ}_CUDA_SOURCES ${tmp} CACHE INTERNAL "")
ENDIF()
ADD_LIBRARY( ${PACKAGE} OBJECT ${SOURCES} )
ELSE()
# We are creating individual libraries
IF( USE_CUDA )
CUDA_COMPILE( CUBINS ${CUDASOURCES} )
ENDIF()
ADD_LIBRARY( ${PACKAGE} ${LIB_TYPE} ${SOURCES} ${CUBINS} )
TARGET_LINK_EXTERNAL_LIBRARIES( ${PACKAGE} )
ENDIF()
@ -308,13 +320,7 @@ MACRO( INSTALL_PROJ_LIB )
FOREACH ( tmp ${${PROJ}_LIBS} )
SET( tmp_link_list ${tmp_link_list} $<TARGET_OBJECTS:${tmp}> )
ENDFOREACH()
IF( USE_CUDA )
SET( ${PROJ}_CUDA_SOURCES ${${PROJ}_CUDA_SOURCES} ${CUDASOURCES} CACHE INTERNAL "")
CUDA_COMPILE( CUBINS ${${PROJ}_CUDA_SOURCES} )
ADD_LIBRARY( ${${PROJ}_LIB} ${CUBINS} ${tmp_link_list} )
ELSE()
ADD_LIBRARY( ${${PROJ}_LIB} ${tmp_link_list} )
ENDIF()
ADD_LIBRARY( ${${PROJ}_LIB} ${tmp_link_list} )
TARGET_LINK_EXTERNAL_LIBRARIES( ${${PROJ}_LIB} LINK_PUBLIC )
INSTALL( TARGETS ${${PROJ}_LIB} DESTINATION ${${PROJ}_INSTALL_DIR}/lib )
ENDMACRO()
@ -385,7 +391,7 @@ MACRO( IDENTIFY_COMPILER )
SET(USING_CLANG TRUE)
ADD_DEFINITIONS( -DUSING_CLANG )
MESSAGE("Using Clang")
ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "XL") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "XL") )
ELSEIF( USING_XL OR (${CMAKE_C_COMPILER_ID} MATCHES "XL") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "XL") )
SET(USING_XL TRUE)
ADD_DEFINITIONS( -DUSING_XL )
MESSAGE("Using XL")
@ -397,7 +403,7 @@ MACRO( IDENTIFY_COMPILER )
MESSAGE(FATAL_ERROR "Unknown C/C++ compiler")
ENDIF()
ENDIF()
# SET the Fortran++ compiler
# SET the Fortran compiler
IF ( CMAKE_Fortran_COMPILER_WORKS )
IF( CMAKE_COMPILER_IS_GNUG77 OR (${CMAKE_Fortran_COMPILER_ID} MATCHES "GNU") )
SET( USING_GFORTRAN TRUE )
@ -741,7 +747,11 @@ MACRO( TARGET_LINK_EXTERNAL_LIBRARIES TARGET_NAME )
FOREACH ( tmp ${BLAS_LAPACK_LIBS} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${CUDA_LIBS} ${CUDA_LIBRARIES} )
FOREACH ( MPI_LIBRARIES )
TARGET_LINK_LIBRARIES( ${EXE} ${ARGN} ${tmp} )
ENDFOREACH()
FOREACH ( tmp ${CMAKE_C_IMPLICIT_LINK_LIBRARIES}
${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES} ${CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES} )
TARGET_LINK_LIBRARIES( ${TARGET_NAME} ${ARGN} ${tmp} )
ENDFOREACH()
ENDMACRO()
@ -793,16 +803,16 @@ MACRO( ADD_PROJ_EXE_DEP EXE )
TARGET_COMPILE_DEFINITIONS( ${EXE} PUBLIC ${COVERAGE_FLAGS} )
ENDIF()
# Link to external libraries
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS} ${LDFLAGS_EXTRA}" )
TARGET_LINK_LIBRARIES( ${EXE} ${LINK_LIBRARIES} )
TARGET_LINK_LIBRARIES( ${EXE} ${CUDA_LIBS} ${CUDA_LIBRARIES} )
TARGET_LINK_EXTERNAL_LIBRARIES( ${EXE} )
IF ( USE_MPI OR USE_EXT_MPI OR HAVE_MPI )
TARGET_LINK_LIBRARIES( ${EXE} ${MPI_LIBRARIES} )
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${MPI_LINK_FLAGS} " )
ENDIF()
TARGET_LINK_LIBRARIES( ${EXE} ${COVERAGE_LIBS} ${LDLIBS} ${LDLIBS_EXTRA} )
TARGET_LINK_LIBRARIES( ${EXE} ${SYSTEM_LIBS} ${SYSTEM_LDFLAGS} )
# Set extra link flags
IF ( USE_MPI OR USE_EXT_MPI OR HAVE_MPI )
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${MPI_LINK_FLAGS} ${LDFLAGS} ${LDFLAGS_EXTRA}" )
ELSE()
SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS} ${LDFLAGS_EXTRA}" )
ENDIF()
ENDMACRO()
@ -1202,8 +1212,8 @@ FUNCTION( CREATE_MATLAB_WRAPPER )
SET( MATLAB_GUI "${CMAKE_CURRENT_BINARY_DIR}/tmp/matlab-gui" )
SET( MATLAB_CMD "${CMAKE_CURRENT_BINARY_DIR}/tmp/matlab-cmd" )
SET( MATLAB_INSTALL_CMD "matlab-cmd" )
FILE( WRITE "${MATLAB_GUI}" "LD_PRELOAD=\"${tmp_libs}\" MATLABPATH=\"${tmp_path}\" \"${MATLAB_EXE2}\" -singleCompThread -nosplash \"$@\"\n")
FILE( WRITE "${MATLAB_CMD}" "LD_PRELOAD=\"${tmp_libs}\" MATLABPATH=\"${tmp_path}\" \"${MATLAB_EXE2}\" -singleCompThread -nosplash -nodisplay -nojvm \"$@\"\n")
FILE( WRITE "${MATLAB_GUI}" "LD_PRELOAD=\"${tmp_libs}\" MKL_NUM_THREADS=1 MATLABPATH=\"${tmp_path}\" \"${MATLAB_EXE2}\" -singleCompThread -nosplash \"$@\"\n")
FILE( WRITE "${MATLAB_CMD}" "LD_PRELOAD=\"${tmp_libs}\" MKL_NUM_THREADS=1 MATLABPATH=\"${tmp_path}\" \"${MATLAB_EXE2}\" -singleCompThread -nosplash -nodisplay -nojvm \"$@\"\n")
ENDIF()
FILE( COPY "${MATLAB_GUI}" DESTINATION "${${PROJ}_INSTALL_DIR}/mex"
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE )
@ -1264,6 +1274,7 @@ MACRO( ADD_DISTCLEAN ${ARGN} )
CMakeCache.txt
CMakeFiles
CMakeTmp
CMakeDoxy*
cmake.check_cache
*.cmake
compile.log
@ -1276,6 +1287,7 @@ MACRO( ADD_DISTCLEAN ${ARGN} )
include
doc
docs
examples
latex_docs
lib
Makefile.config

34
sample_scripts/config_build_titan
View File

@ -12,25 +12,27 @@ rm -rf CMake*
# Configure
cmake \
-D CMAKE_C_COMPILER:PATH=cc \
-D CMAKE_CXX_COMPILER:PATH=CC \
-D CMAKE_CXX_FLAGS="" \
-D MPI_COMPILER:BOOL=TRUE \
-D MPIEXEC=aprun \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
-D CMAKE_BUILD_TYPE:STRING=Release \
-D CXX_STD=11 \
-D CUDA_FLAGS="-arch sm_35" \
-D USE_SILO=1 \
-D SILO_DIRECTORY=/sw/xk6/silo/4.8/sles11.1_gnu4.5.3 \
-D HDF5_DIRECTORY=/opt/cray/hdf5/1.8.16/GNU/4.9 \
-D CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_CUDA=1 \
-D USE_TIMER=0 \
cmake \
-D CMAKE_BUILD_TYPE:STRING=Release \
-D CMAKE_C_COMPILER:PATH=cc \
-D CMAKE_CXX_COMPILER:PATH=CC \
-D CMAKE_CXX_COMPILER:PATH=CC \
-D CXX_STD=11 \
-D USE_CUDA=1 \
-D CMAKE_CUDA_FLAGS="-arch sm_35" \
-D CMAKE_CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_MPI=1 \
-D MPI_COMPILER:BOOL=TRUE \
-D MPIEXEC=aprun \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
-D USE_SILO=1 \
-D SILO_DIRECTORY=/sw/xk6/silo/4.8/sles11.1_gnu4.5.3 \
-D HDF5_DIRECTORY=/opt/cray/hdf5/1.8.16/GNU/4.9 \
-D USE_TIMER=0 \
${HOME}/LBPM-WIA
# Build the code
make install -j 8

15
sample_scripts/config_titan
View File

@ -1,15 +1,16 @@
cmake \
-D CMAKE_BUILD_TYPE:STRING=Debug \
-D CMAKE_C_COMPILER:PATH=cc \
-D CMAKE_CXX_COMPILER:PATH=CC \
-D CMAKE_CXX_COMPILER:PATH=CC \
-D CMAKE_C_FLAGS="-DCBUB" \
-D CMAKE_CXX_FLAGS="-DCBUB" \
-D MPI_COMPILER:BOOL=TRUE \
-D MPIEXEC=aprun \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
-D CMAKE_BUILD_TYPE:STRING=Debug \
-D CUDA_FLAGS="-arch sm_35" \
-D CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_CUDA=1 \
-D USE_CUDA=1 \
-D CMAKE_CUDA_FLAGS="-arch sm_35" \
-D CMAKE_CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_MPI=1 \
-D MPI_COMPILER:BOOL=TRUE \
-D MPIEXEC=aprun \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
${HOME}/LBPM-WIA

30
sample_scripts/configure_summit
View File

@ -7,22 +7,22 @@ module load cuda
# configure
rm -rf CMake*
cmake \
cmake \
-D CMAKE_BUILD_TYPE:STRING=Release \
-D CMAKE_C_COMPILER:PATH=mpicc \
-D CMAKE_CXX_COMPILER:PATH=mpicxx \
-D CMAKE_C_FLAGS="" \
-D CMAKE_CXX_FLAGS="" \
-D CMAKE_CXX_STANDARD=11 \
-D MPI_COMPILER:BOOL=TRUE \
-D USE_MPI=1 \
-D MPIEXEC=mpirun \
-D USE_DOXYGEN:BOOL=false \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
-D CMAKE_BUILD_TYPE:STRING=Release \
-D CUDA_FLAGS="-arch sm_70 -Xptxas=-v -Xptxas -dlcm=cg" \
-D CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_CUDA=1 \
-D USE_TIMER=0 \
-D CMAKE_CXX_COMPILER:PATH=mpicxx \
-D CMAKE_C_FLAGS="" \
-D CMAKE_CXX_FLAGS="" \
-D CMAKE_CXX_STANDARD=11 \
-D USE_CUDA=1 \
-D CMAKE_CUDA_FLAGS="-arch sm_70 -Xptxas=-v -Xptxas -dlcm=cg" \
-D CMAKE_CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_MPI=1 \
-D MPI_COMPILER:BOOL=TRUE \
-D MPIEXEC=mpirun \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
-D USE_DOXYGEN:BOOL=false \
-D USE_TIMER=0 \
~/LBPM-WIA
#make VERBOSE=1 -j1 && make install

38
sample_scripts/configure_titan_mbt
View File

@ -1,38 +0,0 @@
# Set the modules and enviornmental variables
source $MODULESHOME/init/bash
module load cudatoolkit
module load cmake
export MPICH_RDMA_ENABLED_CUDA=1
module swap cray-mpich2 cray-mpich2/5.6.3
# Remove CMake files from previous configures
rm -rf CMake*
# Configure
cmake \
-D CMAKE_C_COMPILER:PATH=cc \
-D CMAKE_CXX_COMPILER:PATH=CC \
-D CMAKE_C_FLAGS="-DCBUB" \
-D CMAKE_CXX_FLAGS="-DCBUB -tp=bulldozer" \
-D MPI_COMPILER:BOOL=TRUE \
-D MPIEXEC=aprun \
-D USE_EXT_MPI_FOR_SERIAL_TESTS:BOOL=TRUE \
-D CMAKE_BUILD_TYPE:STRING=Debug \
-D CUDA_FLAGS="-arch sm_35" \
-D CUDA_HOST_COMPILER="/usr/bin/gcc" \
-D USE_CUDA=1 \
../../LBPM-WIA
# Build the code
# make install -j 8
# Run the fast tests
# ctest -E WEEKLY
# Run the slow tests
# ctest -R WEEKLY -VV

16
sample_scripts/load_modules_mbt
View File

@ -1,16 +0,0 @@
# Clear all modules (except modules)
for var in ${LOADEDMODULES//:/ }; do if [ " ${var///*/}" != " modules" ]; then module unload " ${var///*/}" > /dev/null 2>&1; fi; done
# Load basic enviornment/compilers
module load PrgEnv-gnu
module unload cray-libsci
# module load PrgEnv-pgi
# Load repos
module load cray-mpich ugni xpmem udreg
module load moab torque
module load mercurial
module load cmake
# module load libsci_acc
module load acml