cmake_minimum_required (VERSION 2.8.3 FATAL_ERROR) if(CMAKE_MAJOR_VERSION GREATER 1 AND CMAKE_MINOR_VERSION GREATER 7 AND CMAKE_PATCH_VERSION GREATER 11) cmake_policy(SET CMP0022 OLD) endif() cmake_policy(SET CMP0004 NEW) set(CMAKE_DISABLE_IN_SOURCE_BUILD ON) #=========================================================================== # Project Declaration #=========================================================================== project(SCALFMM C CXX ) # check if compiling into source directories string(COMPARE EQUAL "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" insource) if(insource) message(FATAL_ERROR "${PROJECT_NAME} requires an out of source build. Goto ./Build and tapes cmake ../") endif(insource) list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/) SET(SCALFMM_CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/) # # Adds the CMAKE_DEPENDENT_OPTION command INCLUDE(CMakeDependentOption) #=========================================================================== # Version Number #=========================================================================== # SCALFMM version number. An even minor number corresponds to releases. set(SCALFMM_MAJOR_VERSION 2) set(SCALFMM_MINOR_VERSION 0) set(SCALFMM_PATCH_VERSION rc0) set(SCALFMM_VERSION "${SCALFMM_MAJOR_VERSION}.${SCALFMM_MINOR_VERSION}.${SCALFMM_PATCH_VERSION}" ) SET(CXX_STANDARD_REQUIRED ON) SET(CMAKE_CXX_STANDARD 14) set( MORSE_DISTRIB_DIR "" CACHE PATH "Directory of MORSE distribution") if (MORSE_DISTRIB_DIR OR EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/morse_cmake") # Add extra cmake module path and initialize morse cmake modules # -------------------------------------------------------------- if(MORSE_DISTRIB_DIR) list(APPEND CMAKE_MODULE_PATH ${MORSE_DISTRIB_DIR}/modules) set(MORSE_CMAKE_MODULE_PATH ${MORSE_DISTRIB_DIR}/modules ) elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/morse_cmake") list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/morse_cmake/modules) set(MORSE_CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/morse_cmake/modules ) endif() include(MorseInit) # Set the RPATH config # -------------------- # use, i.e. don't skip the full RPATH for the build tree set(CMAKE_SKIP_BUILD_RPATH FALSE) # when building, don't use the install RPATH already # (but later on when installing) set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) # the RPATH to be used when installing set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") # Build ScalFmm as static or dynamic lib # -------------------------------------- option(BUILD_SHARED_LIBS "Build shared libraries" OFF) # # Options # option( SCALFMM_USE_MPI "Set to ON to build ScaFMM with MPI" OFF ) option( SCALFMM_USE_BLAS "Set to ON to build ScaFMM with BLAS" ON ) option( SCALFMM_USE_FFT "Set to ON to build ScaFMM with FFTW" ON ) option( SCALFMM_BUILD_EXAMPLES "Set to ON to compile examples " ON ) option( SCALFMM_BUILD_TESTS "Set to ON to build functionalities Tests" OFF ) option( SCALFMM_BUILD_UTESTS "Set to ON to build UTests" OFF ) option( SCALFMM_INSTALL_DATA "Set to ON to include the data when proceeding to the installtion " OFF ) option( SCALFMM_BUILD_DOC "Set to ON to build the Doxygen documentation " OFF ) option( SCALFMM_BUILD_DEBUG "Set to ON to build in Debug" OFF ) option( SCALFMM_USE_LOG "Set to ON to print output debug information" OFF ) option( SCALFMM_USE_MEM_STATS "Set to ON to profile memory" OFF ) option( SCALFMM_ATTACHE_SOURCE "Set to ON to compile with -g" OFF ) option( SCALFMM_USE_ADDONS "Set to ON to compile add ons" OFF ) option( SCALFMM_USE_SIGNALS "Set to ON to catch various signal an print backtrace" OFF ) option( SCALFMM_USE_ASSERT "Set to ON to enable safe tests during execution" ON ) option( SCALFMM_USE_MIC_NATIVE "Set to ON to compile in native mode for MIC" OFF ) option( SCALFMM_ONLY_DEVEL "Set to ON to compile Development tools (only scalfmm team)" OFF ) option( SCALFMM_USE_EZTRACE "Set to ON to compile with eztrace framwork" OFF ) option( SCALFMM_USE_STARPU "Set to ON to build SCALFMM with StarPU" OFF ) option( SCALFMM_BUILD_UTILS "Set to ON to build utils Tests" OFF ) if( SCALFMM_ONLY_DEVEL ) if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") option( SCALFMM_USE_OMP4 "Set to ON to disable the gcc/intel omp4" OFF ) else() option( SCALFMM_USE_OMP4 "Set to ON to disable the gcc/intel omp4" ON ) endif() option( SCALFMM_TIME_OMPTASKS "Set to ON to time omp4 tasks and generate output file" OFF ) # SIMGRID and peformance models options option( SCALFMM_SIMGRID_NODATA "Set to ON to avoid the allocation of numerical parts in the group tree" OFF ) option( STARPU_SIMGRID_MLR_MODELS "Set to ON to enable MLR models need for calibration and simulation" OFF ) # OPENMP 4/5 support message(WARNING "OpenMP_VERSION: ${OpenMP_VERSION}") option( OPENMP_SUPPORT_PRIORITY "Set to ON to enable tasks priority (OMP4.x/KSTAR/StarPU compiler only)" OFF ) # STARPU options CMAKE_DEPENDENT_OPTION(OPENMP_SUPPORT_COMMUTE "Set to ON to let tasks commute (KSTAR/StarPU compiler only)" OFF "SCALFMM_USE_STARPU" OFF) CMAKE_DEPENDENT_OPTION(OPENMP_SUPPORT_TASK_NAME "Set to ON to enable a taskname clause for tasks (KSTAR/StarPU compiler only)" OFF "SCALFMM_USE_STARPU" OFF) CMAKE_DEPENDENT_OPTION(SCALFMM_STARPU_USE_COMMUTE "Set to ON to enable commute with StarPU" ON "SCALFMM_USE_STARPU" OFF) CMAKE_DEPENDENT_OPTION(SCALFMM_STARPU_USE_REDUX "Set to ON to enable redux with StarPU" OFF "SCALFMM_USE_STARPU" OFF) CMAKE_DEPENDENT_OPTION(SCALFMM_STARPU_USE_PRIO "Set to ON to enable priority with StarPU" ON "SCALFMM_USE_STARPU" OFF) CMAKE_DEPENDENT_OPTION(SCALFMM_STARPU_FORCE_NO_SCHEDULER "Set to ON to disable heteroprio even if supported" OFF "SCALFMM_USE_STARPU" OFF) CMAKE_DEPENDENT_OPTION(SCALFMM_USE_STARPU_EXTRACT "Set to ON to enable extract with StarPU mpi implicit" ON "SCALFMM_USE_STARPU" OFF) endif() message(STATUS "AVANT ${CMAKE_CXX_COMPILER_ID}" ) # # MPI # if( SCALFMM_USE_MPI ) try_compile(COMPILE_INTEL ${CMAKE_CURRENT_BINARY_DIR} ${SCALFMM_CMAKE_MODULE_PATH}/compileTestIntel.cpp COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS}") if (COMPILE_INTEL) set(CMAKE_CXX_COMPILER_ID "Intel") endif() endif() message(STATUS "CXX ${CMAKE_CXX_COMPILER_ID}" ) # Set scalfmm to default libraries set(SCALFMM_LIBRARIES "") set(SCALFMM_CXX_FLAGS "-fpic -Wall") # set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -I${CMAKE_CURRENT_SOURCE_DIR}/Contribs") # # # Test if openmp is here # find_package (OpenMP) if(OPENMP_FOUND) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}") else(OPENMP_FOUND) message(WARNING "OPENMP NOT FOUND") endif(OPENMP_FOUND) message(STATUS "SCALFMM_BUILD_DEBUG = ${SCALFMM_BUILD_DEBUG}" ) # if(CMAKE_SIZEOF_VOID_P EQUAL 8) set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -m64") endif() ############################################################################## # Inastemp # ############################################################################## set(INASTEMP_JUST_LIB TRUE) set(INASTEMP_DO_INSTALL TRUE) # add the cmakelist directory add_subdirectory(inastemp) # use the filled variables from inastemp INCLUDE_DIRECTORIES( ${INASTEMP_BINARY_DIR}/Src ${INASTEMP_SOURCE_DIR}/Src ${INASTEMP_INCLUDE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/inastemp/Src ) # propagate the flags to be able to compile set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${INASTEMP_CXX_FLAGS}") ############################################################################## # FUSE list # ############################################################################## set(FUSE_LIST "") #set(FUSE_LIST " MPI;BLAS;FFT;STARPU;CUDA;OPENCL;OMP4;SSE;AVX;AVX2;MIC;MPI2") # then do list(APPEND FUSE_LIST "BLAS") to protect from FUSE_BLAS # list(APPEND FUSE_LIST "MPI") ############################################################################## # Debug flags # ############################################################################## # if( SCALFMM_BUILD_DEBUG ) # # Compile Debug flags # set(CMAKE_BUILD_TYPE Debug) ADD_DEFINITIONS(-O0) if( APPLE ) set(SCALFMM_FLAGS_OPTI_DEBUG "-funroll-loops" CACHE STRING "Set your optimization flags for debug mode.") else(APPLE) if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") set(SCALFMM_FLAGS_OPTI_DEBUG "-fp-model strict -funroll-loops" CACHE STRING "Set your optimization flags for debug mode.") else() set(SCALFMM_FLAGS_OPTI_DEBUG "-funroll-loops" CACHE STRING "Set your optimization flags for debug mode.") endif() endif(APPLE) # ADD_DEFINITIONS(${SCALFMM_FLAGS_OPTI_DEBUG}) set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${SCALFMM_FLAGS_OPTI_DEBUG}") set(CMAKE_CXX_FLAGS_TYPE "${CMAKE_CXX_FLAGS_DEBUG}") else() ############################################################################## # Release flags # ############################################################################## set(CMAKE_BUILD_TYPE Release) set(CMAKE_CXX_FLAGS_TYPE "${CMAKE_CXX_FLAGS_RELEASE}") # if compiler is intel add -ip if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -ipo -fstrict-aliasing ")# -no-prec-div -no-prec-sqrt") endif() # Compile optimization if(APPLE) set(SCALFMM_FLAGS_OPTI_RELEASE "-funroll-loops" CACHE STRING "Set your optimization flags for release mode.") else(APPLE) # Not apple system - Check the compiler flags if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") #set(SCALFMM_FLAGS_OPTI_RELEASE "-fp-model precise -fp-model source -fimf-precision=low -funroll-loops -ftree-vectorize" set(SCALFMM_FLAGS_OPTI_RELEASE "-funroll-loops -ftree-vectorize" CACHE STRING "Set your optimization flags for release mode.") # set(SCALFMM_FLAGS_OPTI_RELEASE "-funroll-loops -ftree-vectorize" CACHE STRING # "Set your optimization flags for release mode.") else() set(SCALFMM_FLAGS_OPTI_RELEASE "-ffast-math -funroll-loops -ftree-vectorize" CACHE STRING "Set your optimization flags for release mode.") endif() endif(APPLE) # set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${SCALFMM_FLAGS_OPTI_RELEASE}") endif() MESSAGE(STATUS " %%%%%%%%%% SCALFMM_CXX_FLAGS ${SCALFMM_CXX_FLAGS} %%%%%%%%%%%%%") MESSAGE(STATUS " %%%%%%%%%% CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE} %%%%%%%%%%%%%") # ############################################################################## # Attach source code to exec # ############################################################################## message(STATUS "SCALFMM_ATTACHE_SOURCE = ${SCALFMM_ATTACHE_SOURCE}" ) if( SCALFMM_ATTACHE_SOURCE ) message(STATUS "Option -g is used, the code is attached to the binary." ) set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -g") endif(SCALFMM_ATTACHE_SOURCE) # ############################################################################## # find MPI # ############################################################################## # if( SCALFMM_USE_MPI ) find_package(MPI REQUIRED) if(MPI_FOUND) if (MPI_CXX_FOUND) # message("MPI_CXX is in the place") if (MPI_CXX_INCLUDE_PATH) include_directories( ${MPI_CXX_INCLUDE_PATH} ) endif() if (MPI_CXX_COMPILE_FLAGS) string(REPLACE ";" " " MPI_CXX_COMPILE_FLAGS "${MPI_CXX_COMPILE_FLAGS}") set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${MPI_CXX_COMPILE_FLAGS}") endif() if (MPI_CXX_INCLUDE_PATH) LIST(APPEND SCALFMM_INCLUDES "${SCALFMM_INCLUDES};${MPI_CXX_INCLUDE_PATH}") endif() if (MPI_CXX_LINK_FLAGS) list(APPEND "CMAKE_EXE_LINKER_FLAGS ${MPI_CXX_LINK_FLAGS}") endif() if (MPI_CXX_LIBRARIES) set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${MPI_CXX_LIBRARIES}") endif() else (MPI_CXX_FOUND) message(FATAL_ERROR "MPI_CXX is required but was not found. " "Please provide an MPI compiler in your environment." "Note that you can give the path to your MPI installation " "by setting MPI_DIR cmake variable.") endif (MPI_CXX_FOUND) else(MPI_FOUND) endif(MPI_FOUND) endif( SCALFMM_USE_MPI) list(APPEND FUSE_LIST "MPI") # ############################################################################## # Blas option # ############################################################################## # if( SCALFMM_USE_BLAS ) # if(APPLE) # In order to use QT-creator on macos # list(APPEND CMAKE_REQUIRED_INCLUDES $ENV{MKLROOT}/include) # endif() # include(FortranCInterface) # # Define a Fortran interface file (FCMangle.hpp) # FortranCInterface_HEADER( ${CMAKE_CURRENT_SOURCE_DIR}/Src/FCMangle.hpp # MACRO_NAMESPACE "PM_" # SYMBOL_NAMESPACE "PM_" # SYMBOLS init testPPM:init) message(STATUS "CMAKE_CXX_COMPILER_ID STREQUAL ${CMAKE_CXX_COMPILER_ID}") option( SCALFMM_USE_MKL_AS_BLAS "Set to ON to use MKL BLAS/LAPACK" OFF ) option( SCALFMM_USE_ESSL_AS_BLAS "Set to ON to use ESSL BLAS/LAPACK" OFF ) if( SCALFMM_USE_MKL_AS_BLAS ) set(BLA_VENDOR "Intel10_64lp_seq") find_package(BLAS ) # not REQUIRED unset(LAPACK_LIBRARIES) if (BLAS_LIBRARIES) set(BLASLAPACK_LIBRARIES ${BLAS_LIBRARIES}) endif() elseif(SCALFMM_USE_ESSL_AS_BLAS) set(BLA_VENDOR "IBMESSL") find_package(BLAS QUIET) # not REQUIRED find_package(LAPACK QUIET) # not REQUIRED if (LAPACK_LIBRARIES) set(BLASLAPACK_LIBRARIES "${LAPACK_LIBRARIES}") endif() if (BLAS_LIBRARIES) list(APPEND BLASLAPACK_LIBRARIES ${BLAS_LIBRARIES}) endif() elseif(SCALFMM_USE_EXTERNAL_BLAS) message(STATUS "BLAS SET BY EXTERNAL PROGRAM = ${BLAS_LIBRARIES}") list(APPEND BLASLAPACK_LIBRARIES "${BLAS_LIBRARIES}") else() find_package(BLAS) # not REQUIRED find_package(LAPACK) # not REQUIRED set(BLASLAPACK_LIBRARIES) if (LAPACK_LIBRARIES) set(BLASLAPACK_LIBRARIES "${LAPACK_LIBRARIES}") endif() if (BLAS_LIBRARIES) list(APPEND BLASLAPACK_LIBRARIES "${BLAS_LIBRARIES}") endif() endif() if(BLAS_FOUND) set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${BLASLAPACK_LIBRARIES}") if(BLAS_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${BLAS_LIBRARY_DIRS}") endif() if(LAPACK_FOUND AND LAPACK_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${LAPACK_LIBRARY_DIRS}") endif() message (STATUS "check BLAS Fortran mangling") # add options to let the user be able to force a behavior option( SCALFMM_BLAS_ADD_ "Set to ON to force calls to BLAS Fortran symbols with _ (ex: dgemm_)" ON ) option( SCALFMM_BLAS_UPCASE "Set to ON to force calls to BLAS Fortran symbols in capital (ex: DGEMM)" OFF ) option( SCALFMM_BLAS_NOCHANGE "Set to ON to force calls to BLAS Fortran symbols with no change (ex: dgemm)" OFF ) # if options not changed by user then auto-detection if (NOT SCALFMM_BLAS_ADD_ AND NOT SCALFMM_BLAS_UPCASE AND NOT SCALFMM_BLAS_NOCHANGE) # give blas libraries and check dgemm symbol set(CMAKE_REQUIRED_LIBRARIES "${BLAS_LIBRARIES}") check_function_exists(dgemv_ DGEMV_ADD_) check_function_exists(DGEMV DGEMV_UPCASE) check_function_exists(dgemv DGEMV_NOCHANGE) # here we consider that the first kind of symbol found will be the one used # current order is: ADD_, UPCASE, NOCHANGE if (DGEMV_ADD_) set (SCALFMM_BLAS_ADD_ ON) set (SCALFMM_BLAS_UPCASE OFF) set (SCALFMM_BLAS_NOCHANGE OFF) message (STATUS "BLAS dgemv_ symbol found, SCALFMM_BLAS_ADD_ is ON") else (DGEMV_ADD_) if (DGEMV_UPCASE) set (SCALFMM_BLAS_ADD_ OFF) set (SCALFMM_BLAS_UPCASE ON) set (SCALFMM_BLAS_NOCHANGE OFF) message (STATUS "BLAS DGEMV symbol found, SCALFMM_BLAS_UPCASE is ON") else (DGEMV_UPCASE) if (DGEMV_NOCHANGE) set (SCALFMM_BLAS_ADD_ OFF) set (SCALFMM_BLAS_UPCASE OFF) set (SCALFMM_BLAS_NOCHANGE ON) message (STATUS "BLAS dgemv symbol found, SCALFMM_BLAS_NOCHANGE is ON") endif (DGEMV_NOCHANGE) endif (DGEMV_UPCASE) endif (DGEMV_ADD_) if ( (NOT DGEMV_ADD_) AND (NOT DGEMV_UPCASE) AND (NOT DGEMV_NOCHANGE) ) message(FATAL_ERROR "BLAS Fortran mangling is not properly detected - please check your BLAS libraries") endif () else (NOT SCALFMM_BLAS_ADD_ AND NOT SCALFMM_BLAS_UPCASE AND NOT SCALFMM_BLAS_NOCHANGE) if (SCALFMM_BLAS_ADD_) message (STATUS "SCALFMM_BLAS_ADD_ is set to ON") endif() if (SCALFMM_BLAS_UPCASE) message (STATUS "SCALFMM_BLAS_UPCASE is set to ON") endif() if (SCALFMM_BLAS_NOCHANGE) message (STATUS "SCALFMM_BLAS_NOCHANGE is set to ON") endif() endif (NOT SCALFMM_BLAS_ADD_ AND NOT SCALFMM_BLAS_UPCASE AND NOT SCALFMM_BLAS_NOCHANGE) else() MESSAGE(WARNING "BLAS: ${BLAS-FOUND}") message(WARNING "BLAS has not been found, SCALFMM will continue to compile but some applications will be disabled.") message(WARNING "If you have BLAS set BLAS_LIBDIR, BLAS_INCDIR or BLAS_DIR (CMake variables using -D or environment variables).") set(SCALFMM_USE_BLAS OFF) endif() endif(SCALFMM_USE_BLAS) list(APPEND FUSE_LIST "BLAS") # # FFT option # CMAKE_DEPENDENT_OPTION(SCALFMM_USE_MKL_AS_FFTW "Set to ON to use MKL FFTW" ON "SCALFMM_USE_FFT;SCALFMM_USE_MKL_AS_BLAS" OFF ) CMAKE_DEPENDENT_OPTION(SCALFMM_USE_ESSL_AS_FFTW "Set to ON to use ESSL FFTW" ON "SCALFMM_USE_FFT;SCALFMM_USE_ESSL_AS_BLAS" OFF ) if( SCALFMM_USE_FFT ) message(STATUS "SCALFMM USE FFT Configure:") # The package find_package(FFTW) can be used with the following COMPONENTS: # MKL, ESSL, THREADS|OMP and/or SIMPLE|LONG|QUAD # Default will find the real double precision fftw library version without THREADS|OMP if( SCALFMM_USE_MKL_AS_FFTW ) message(STATUS " SCALFMM USE FFT from MKL") find_package(FFTW COMPONENTS MKL) elseif (SCALFMM_USE_ESSL_AS_FFTW) message(STATUS " SCALFMM USE FFT from ESSL ") find_package(FFTW COMPONENTS ESSL) add_definitions(-DSCALFMM_USE_ESSL_AS_FFTW) else() message(STATUS " SCALFMM USE FFTW") find_package(FFTW COMPONENTS SIMPLE) endif() if(FFTW_FOUND) if (FFTW_LIBRARY_DIRS_DEP) set(FFT_LIBRARIES "-L${FFTW_LIBRARY_DIRS_DEP};" CACHE STRING "Set your MKL flags") endif() if (FFTW_LIBRARIES_DEP) foreach (fft_lib ${FFTW_LIBRARIES_DEP}) set(FFT_LIBRARIES "${FFT_LIBRARIES};${fft_lib};") endforeach() endif() set(FFT_INCLUDES "${FFTW_INCLUDE_DIRS_DEP}" ) if (FFT_LIBRARIES) set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${FFT_LIBRARIES}") endif() if(FFTW_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${FFTW_LIBRARY_DIRS}") endif() if (FFT_INCLUDES) LIST(APPEND SCALFMM_INCLUDES "${FFT_INCLUDES}") endif() else(FFTW_FOUND) message(WARNING "FFTW has not been found, SCALFMM will continue to compile but some applications will be disabled.") message(WARNING "If you have FFTW set FFTW_LIBDIR, FFTW_INCDIR or FFTW_DIR (CMake variables using -D or environment variables).") set(SCALFMM_USE_FFT OFF) endif(FFTW_FOUND) endif(SCALFMM_USE_FFT) message(STATUS "SCALFMM_USE_FFT = ${SCALFMM_USE_FFT}") if (SCALFMM_INCLUDES) list(REMOVE_DUPLICATES SCALFMM_INCLUDES) endif() if (SCALFMM_LIBRARIES) list(REMOVE_DUPLICATES SCALFMM_LIBRARIES) endif() list(APPEND FUSE_LIST "FFT") # # C++ 2011 message( STATUS "CMAKE_SYSTEM: ${CMAKE_SYSTEM} CMAKE_CXX_COMPILER_ID ${CMAKE_CXX_COMPILER_ID} CMAKE_CXX_COMPILER ${NAME}") if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE INTEL_VERSION) message( STATUS "Intel: ${INTEL_VERSION}") set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -Wall") else() # Compile option valid on GCC/G++ set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -Wall -Wshadow -Wpointer-arith -Wcast-qual -Wconversion -Wcast-qual -Wcast-align -Woverloaded-virtual") endif() # ################################################################## # STARPU Section ################################################################## # message( STATUS "SCALFMM_USE_STARPU = ${SCALFMM_USE_STARPU}" ) if( SCALFMM_USE_STARPU ) # CUDA could be used with StarPU enabled option( SCALFMM_USE_CUDA "Set to ON to use CUDA with StarPU" OFF ) if(SCALFMM_USE_CUDA) execute_process(COMMAND nvcc --version ERROR_VARIABLE cuda_error_output OUTPUT_QUIET) if(cuda_error_output) message( FATAL_ERROR "nvcc is needed with CUDA." ) endif() if(NOT DEFINED CUSTOM_CUDA_FLAGS) set( CUSTOM_CUDA_FLAGS "-std=c++11;-arch=sm_20;--ptxas-options=-v;-use_fast_math" CACHE STRING "Set your CUDA flags, for example : -arch=sm_20;--ptxas-options=-v;-use_fast_math") endif() # This is needed to remove backslash after space in ADD_CUSTOM_COMMAND separate_arguments(CUSTOM_CUDA_FLAGS) message( STATUS "CUSTOM_CUDA_FLAGS = ${CUSTOM_CUDA_FLAGS}" ) find_package(CUDA REQUIRED) if (CUDA_INCLUDE_DIRS) include_directories(${CUDA_INCLUDE_DIRS}) endif() if (CUDA_LIBRARIES) set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${CUDA_LIBRARIES}") endif() set(CUDA_NEEDED_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/Src) endif() # Find StarPU with a list of optional components set(SCALFMM_STARPU_VERSION "1.2" CACHE STRING " STARPU version desired") # create list of components in order to make a single call to find_package(starpu...) set(STARPU_COMPONENT_LIST "HWLOC") if(SCALFMM_USE_CUDA) list(APPEND STARPU_COMPONENT_LIST "CUDA") endif() list(APPEND FUSE_LIST "CUDA") if(SCALFMM_USE_MPI) list(APPEND STARPU_COMPONENT_LIST "MPI") endif() # TODO: replace this by a component of find starpu OPTION( SCALFMM_USE_OPENCL "Set to ON to use OPENCL with StarPU" OFF ) if(SCALFMM_USE_OPENCL) list(APPEND STARPU_COMPONENT_LIST "OPENCL") # include_directories($ENV{OPENCL_INC}) # SET(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};-L$ENV{OPENCL_LIB};-lOpenCL") endif() list(APPEND FUSE_LIST "OPENCL") find_package(STARPU ${SCALFMM_STARPU_VERSION} REQUIRED COMPONENTS ${STARPU_COMPONENT_LIST}) if(HWLOC_FOUND AND HWLOC_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${HWLOC_LIBRARY_DIRS}") endif() if(FXT_FOUND AND FXT_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${FXT_LIBRARY_DIRS}") endif() if(STARPU_FOUND AND STARPU_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${STARPU_LIBRARY_DIRS}") # Append list of libraries and include dirs include_directories(${STARPU_INCLUDE_DIRS_DEP}) foreach (starpu_libdir ${STARPU_LIBRARY_DIRS_DEP}) if (${starpu_libdir} MATCHES "^ *-L") set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${starpu_libdir}") else() set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};-L${starpu_libdir}") endif() endforeach() foreach (starpu_lib ${STARPU_LIBRARIES_DEP}) if (EXISTS ${starpu_lib} OR ${starpu_lib} MATCHES "^ *-") set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${starpu_lib}") else() set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};-l${starpu_lib}") endif() endforeach() else() # StarPU not found endif() # TODO: is this very useful? CUDA is already a component of find starpu if (CUDA_LIBRARIES) set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES};${CUDA_LIBRARIES}") endif() # Message if (STARPU_INCLUDE_DIRS) message(STATUS " STARPU_INCLUDES = ${STARPU_INCLUDE_DIRS}") LIST(APPEND SCALFMM_INCLUDES "${STARPU_INCLUDE_DIRS}") endif() # Adding SimGrid includes LIST(APPEND SCALFMM_INCLUDES "$ENV{SIMGRID_INCLUDE}") message(STATUS " Adding SIMGRID = $ENV{SIMGRID_INCLUDE}") endif(SCALFMM_USE_STARPU) list(APPEND FUSE_LIST "STARPU") ################################################################## # FUSE # ################################################################## list(APPEND FUSE_LIST "SSE") list(APPEND FUSE_LIST "AVX") list(APPEND FUSE_LIST "MIC") ################################################################## # # Set EZTRACE # ################################################################## If(SCALFMM_USE_EZTRACE) find_package (PkgConfig) if(PKG_CONFIG_FOUND) set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH "ON") pkg_search_module( EZTrace REQUIRED eztrace) if(EZTrace_FOUND) link_directories(${EZTrace_LIBRARY_DIRS}) link_libraries( ${EZTrace_LIBRARIES}) if (EZTrace_LIBRARY_DIRS) # the RPATH to be used when installing list(APPEND CMAKE_INSTALL_RPATH "${EZTrace_LIBRARY_DIRS}") endif() IF( SCALFMM_USE_MPI ) link_libraries(-leztrace-autostart-mpi) ENDIF(SCALFMM_USE_MPI) include_directories(${EZTrace_INCLUDE_DIRS}) MESSAGE(STATUS "EZTRACE: ${EZTrace_INCLUDE_DIRS} ${EZTrace_LIBRARY_DIRS} ${EZTrace_LIBRARIES}") CMAKE_DEPENDENT_OPTION(SCALFMM_TRACE_ALGO "Set to ON to trace the full algorithm (all operators)" ON "SCALFMM_USE_EZTRACE" OFF ) CMAKE_DEPENDENT_OPTION(SCALFMM_TRACE_P2M "Set to ON to trace P2M operator" OFF "SCALFMM_USE_EZTRACE" OFF ) CMAKE_DEPENDENT_OPTION(SCALFMM_TRACE_M2M "Set to ON to trace M2M operator" OFF "SCALFMM_USE_EZTRACE" OFF ) CMAKE_DEPENDENT_OPTION(SCALFMM_TRACE_M2L "Set to ON to trace M2L operator" OFF "SCALFMM_USE_EZTRACE" OFF ) CMAKE_DEPENDENT_OPTION(SCALFMM_TRACE_L2L "Set to ON to trace L2L operator" OFF "SCALFMM_USE_EZTRACE" OFF ) CMAKE_DEPENDENT_OPTION(SCALFMM_TRACE_P2P "Set to ON to trace P2P operator" OFF "SCALFMM_USE_EZTRACE" OFF ) else(EZTrace_FOUND) MESSAGE(WARNING "Eztrace not found - EZTRACE Is set to OFF") set(SCALFMM_USE_EZTRACE OFF) endif(EZTrace_FOUND) else(PKG_CONFIG_FOUND) MESSAGE(WARNING "PKG-CONFIG not found - EZTRACE Is set to OFF") set(SCALFMM_USE_EZTRACE OFF) endif(PKG_CONFIG_FOUND) endif(SCALFMM_USE_EZTRACE) list(APPEND FUSE_LIST "OMP4") ################################################################## # # To catch signals # ################################################################## if((WIN32 OR (${CMAKE_SYSTEM_NAME} MATCHES "Windows")) AND SCALFMM_USE_SIGNALS) # We are on Windows and we cannot catch signals message( FATAL_ERROR "Catching the signals requieres an UNIX system." ) else() IF( NOT APPLE) SET(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -rdynamic") ENDIF() endif() ################################################################## # # # END SETTING VARIABLES # # # ################################################################## # # Generate ScalFmmConfig.h # set(SCALFMM_COMPILE_FLAGS "${SCALFMM_CXX_FLAGS} ${CMAKE_CXX_FLAGS}") set(CMAKE_CXX_FLAGS "${SCALFMM_COMPILE_FLAGS}") # We need the libraries without spaces (inside the config file) set(SCALFMM_COMPILE_LIBS "") foreach(lib_var ${SCALFMM_LIBRARIES}) string(STRIP ${lib_var} lib_var) LIST(APPEND SCALFMM_COMPILE_LIBS ${lib_var}) endforeach() string(REPLACE " " ";" SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}") string(REPLACE ";;" ";" SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}") # string(REPLACE " " ";" SCALFMM_INCLUDES "${SCALFMM_INCLUDES}") # string(REPLACE ";;" ";" SCALFMM_INCLUDES "${SCALFMM_INCLUDES}") configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/Src/ScalFmmConfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/Src/ScalFmmConfig.h ) # ################################################################## # Build - lib # ################################################################## # MESSAGE(STATUS "FUSE : ${FUSE_LIST} ") add_subdirectory(Contribs) add_subdirectory(Src) # Link with scalfmm lib set(scalfmm_lib scalfmm) # ################################################################## # Remove compilation of the drivers # ################################################################## message(STATUS "SCALFMM_BUILD_EXAMPLES = ${SCALFMM_BUILD_EXAMPLES}" ) if( SCALFMM_BUILD_EXAMPLES ) # Build - Examples and drivers add_subdirectory(Examples) endif() ################################################################## # Build tools (Internal use) # ################################################################## # Build - UTILs if( SCALFMM_ONLY_DEVEL AND SCALFMM_BUILD_UTILS) add_subdirectory(Utils) endif() ################################################################## # Build -Tests to see examples # ################################################################## # Build - Tests message( STATUS "SCALFMM_BUILD_TESTS = ${SCALFMM_BUILD_TESTS}" ) if( SCALFMM_BUILD_TESTS ) add_subdirectory(Tests) endif() ################################################################## # Build - Unitary and numerical Tests # ################################################################## # message( STATUS "SCALFMM_BUILD_UTESTS = ${SCALFMM_BUILD_UTESTS}" ) if( SCALFMM_BUILD_UTESTS ) include(CTest) enable_testing() add_subdirectory(UTests) endif() # ################################################################## # Add - doc # ################################################################## # message(STATUS "SCALFMM_BUILD_DOC = ${SCALFMM_BUILD_DOC}" ) if(SCALFMM_BUILD_DOC) add_subdirectory(Doc) endif() # ################################################################## # Build - Addons # ################################################################## # # SCALFMM_ADDON_CKERNELAPI doesn't works with scalfmm 2.0 # if( SCALFMM_USE_ADDONS ) # file(GLOB all_addons ./Addons/*) # # Options # option( SCALFMM_ADDON_CKERNELAPI "Set to ON to build ScaFMM FMM API interface" OFF ) # foreach(addon_name ${all_addons}) # message(STATUS "Addons += ${addon_name}" ) # add_subdirectory(${addon_name}) # endforeach() # endif() # Add custom clean command if("${CMAKE_GENERATOR}" MATCHES "Make") add_custom_target(reset COMMAND ${CMAKE_MAKE_PROGRAM} clean && rm -r ./CMake* && cmake .. WORKING_DIRECTORY ${CMAKE_CURRENT_DIR} COMMENT "Cleaning Build dir and CMake cache, then do cmake.." ) endif() # ################################################################## # # # Build and export cmake files # # # ################################################################## # message(STATUS "SCALFMM_BINARY_DIR: " ${SCALFMM_BINARY_DIR}) configure_file(${SCALFMM_SOURCE_DIR}/ScalFMMConfig.cmake.in ${SCALFMM_BINARY_DIR}/ScalFMMConfig.cmake @ONLY IMMEDIATE ) # install(FILES ${SCALFMM_BINARY_DIR}/ScalFMMConfig.cmake DESTINATION lib/ ) if( SCALFMM_INSTALL_DATA ) install(FILES ${SCALFMM_SOURCE_DIR}/Data/test20k.fma DESTINATION Data/ ) endif() # ################################################################## # # # build a CPack driven installer package # # # ################################################################## # # Use git commit number as CPACK_PACKAGE_VERSION_PATCH set(CPACK_PACKAGE_VERSION_PATCH 0) execute_process( COMMAND git rev-list HEAD --count OUTPUT_VARIABLE CPACK_PACKAGE_VERSION_PATCH RESULT_VARIABLE RET ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) #string_TRIM(PATCH1 PATCH) set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY "ON") # set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENCE") set(CPACK_PACKAGE_VERSION_MAJOR "${SCALFMM_MAJOR_VERSION}") set(CPACK_PACKAGE_VERSION_MINOR "${SCALFMM_MINOR_VERSION}") # set(PACK_PACKAGE_VERSION "${SCALFMM_MAJOR_VERSION}.${SCALFMM_MINOR_VERSION}-${CPACK_PACKAGE_VERSION_PATCH}") set(CPACK_SOURCE_GENERATOR "TGZ") set(CPACK_SOURCE_PACKAGE_FILE_NAME "SCALFMM-${SCALFMM_MAJOR_VERSION}.${SCALFMM_MINOR_VERSION}-${CPACK_PACKAGE_VERSION_PATCH}") set(CPACK_SOURCE_IGNORE_FILES "\\\\.git;.DS_Store;.*~;/*.aux;/*.idx;/*.log;/*.out;/*.toc;/*.ilg;CMakeLists.txt.user;/.settings/") list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_CURRENT_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/Utils/;/Build*;/Obsolete/") # include(CPack) # # ################################################################## # # # PRINT messages # # # ################################################################## message(STATUS "CPACK_SOURCE_IGNORE_FILES = ${CPACK_SOURCE_IGNORE_FILES}") message(STATUS "CPACK_SOURCE_PACKAGE_FILE_NAME = ${CPACK_SOURCE_PACKAGE_FILE_NAME}") # # Use Mem stats message(STATUS "SCALFMM_USE_MEM_STATS = ${SCALFMM_USE_MEM_STATS}" ) # Use Log message(STATUS "SCALFMM_USE_LOG = ${SCALFMM_USE_LOG}" ) # Use Assert message(STATUS "SCALFMM_USE_ASSERT = ${SCALFMM_USE_ASSERT}" ) # message(STATUS "SCALFMM_USE_MPI = ${SCALFMM_USE_MPI}" ) message(STATUS "SCALFMM_USE_BLAS = ${SCALFMM_USE_BLAS}") message(STATUS "SCALFMM_USE_FFT = ${SCALFMM_USE_FFT}") message(STATUS "SCALFMM_USE_MKL = ${SCALFMM_USE_MKL}") # if(SCALFMM_USE_STARPU) message( STATUS "SCALFMM_USE_STARPU = ${SCALFMM_USE_STARPU}" ) message(STATUS " STARPU_LIBRARIES = ${STARPU_LIBRARIES}") message( STATUS "SCALFMM_USE_CUDA = ${SCALFMM_USE_CUDA}" ) MESSAGE( STATUS "SCALFMM_USE_OPENCL = ${SCALFMM_USE_OPENCL}" ) endif(SCALFMM_USE_STARPU) message(STATUS "CMAKE_CXX_FLAGS_TYPE = ${CMAKE_CXX_FLAGS_TYPE}") message(STATUS "CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}") message(STATUS "SCALFMM_CXX_FLAGS = ${SCALFMM_CXX_FLAGS}") message(STATUS "SCALFMM_LIBRARIES = ${SCALFMM_LIBRARIES}") message(STATUS "SCALFMM_INCLUDES = ${SCALFMM_INCLUDES}") message(STATUS "FUSE_LIST = ${FUSE_LIST}") # ################################################################## # END # ################################################################## # else(MORSE_DISTRIB_DIR OR EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/morse_cmake") message(STATUS "MORSE_DISTRIB_DIR is not set") message(STATUS "Please indicate where is located your MORSE distribution directory." " This is necessary to find cmake_modules.") message(STATUS "If you are a MORSE developer, you normally have access to the svn repository of the MORSE_DISTRIB_DIR: " "svn checkout svn+ssh://yourlogin@scm.gforge.inria.fr/svnroot/morse/trunk/morse_distrib") endif(MORSE_DISTRIB_DIR OR EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/morse_cmake")