CMAKE_MINIMUM_REQUIRED (VERSION 3.2)
PROJECT (DKS)
SET (DKS_VERSION_MAJOR 1)
SET (DKS_VERSION_MINOR 2)
SET (DKS_VERSION_PATCH 0)
set (DKS_VERSION ${DKS_VERSION_MAJOR}.${DKS_VERSION_MINOR}.${DKS_VERSION_PATCH})
SET (PACKAGE \"dks\")
SET (PACKAGE_BUGREPORT \"locans.uldis@psi.ch\")
SET (PACKAGE_NAME \"DKS\")
SET (PACKAGE_TARNAME \"dks\")
SET (DKS_VERSION_STR "\"${DKS_VERSION}\"")
SET (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
if (APPLE)
  SET (CMAKE_MACOSX_RPATH TRUE)
endif (APPLE)

#get compiler name
#STRING (REGEX REPLACE ".*/([A-Za-z]*)$" "\\1" COMPILER_NAME ${CMAKE_CXX_COMPILER})
STRING (REGEX REPLACE ".*/" "" COMPILER_NAME ${CMAKE_CXX_COMPILER})
MESSAGE (STATUS "Your compiler is: ${COMPILER_NAME}")
MESSAGE (STATUS "Your compiler is: ${CMAKE_CXX_COMPILER}")

MESSAGE (STATUS "C compiler: ${CMAKE_C_COMPILER_ID}")
MESSAGE (STATUS "CXX compiler: ${CMAKE_CXX_COMPILER_ID}")

#opencl and cuda kernel files are in the builds include directory
SET (OPENCL_KERNELS -DOPENCL_KERNELS=\\"${CMAKE_INSTALL_PREFIX}/include/\\")
MESSAGE (STATUS "OpenCL kernel files: ${OPENCL_KERNELS}")

#find boost
set (BOOSTROOT $ENV{BOOST_DIR})
SET (Boost_USE_STATIC_LIBS OFF)
SET (Boost_USE_STATIC_RUNTIME OFF)
#FIND_PACKAGE(Boost 1.55 REQUIRED COMPONENTS filesystem system)
FIND_PACKAGE(Boost 1.41 REQUIRED)
IF (Boost_FOUND)
  MESSAGE (STATUS "Boost version: ${Boost_VERSION}")
  MESSAGE (STATUS "Found boost include dir: ${Boost_INCLUDE_DIRS}")
  MESSAGE (STATUS "Found boost library dir: ${Boost_LIBRARY_DIRS}")
  #MESSAGE (STATUS "Found boost libraries: ${Boost_LIBRARIES}")
  INCLUDE_DIRECTORIES (${Boost_INCLUDE_DIRS})
  LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
ENDIF (Boost_FOUND)

#include OPAL, musrfit or pet kernels
OPTION(DKS_FULL "Compile DKS with full library" OFF)
OPTION(ENABLE_OPAL "Compile DKS with OPAL kernels" OFF)
OPTION(ENABLE_MUSR "Compile DKS with musrfit kernels" OFF)
OPTION(ENABLE_PET "Compile DKS with PET reconstruction kernels" OFF)

IF (DKS_FULL)
  SET(ENABLE_OPAL ON)
  SET(ENABLE_MUSR ON)
  SET(ENABLE_PET ON)
ENDIF(DKS_FULL)

#find clFFT
OPTION (ENABLE_AMD "Enable AMD libraries" OFF)
IF (ENABLE_AMD)
  SET (clFFT_USE_STATIC_LIBS OFF)
  FIND_PACKAGE(clFFT REQUIRED HINTS $ENV{CLFFT_PREFIX} $ENV{CLFFT_DIR} $ENV{CLFFT})
  MESSAGE (STATUS "Found clFFT library: ${CLFFT_LIBRARIES}")
  MESSAGE (STATUS "Found clFFT include dir: ${CLFFT_INCLUDE_DIRS}")
  INCLUDE_DIRECTORIES (${CLFFT_INCLUDE_DIRS})
  LINK_DIRECTORIES (${CLFFT_LIBRARIES})

  #find clRNG
  #SET (clRNG_USE_STATIC_LIBS OFF)
  #FIND_PACKAGE(clRng REQUIRED HINTS &ENV{CLRNG_PREFIX} $ENV{CLRNG_DIR} $ENV{CLRNG})
  #MESSAGE (STATUS "Found clRNG library: ${CLRNG_LIBRARIES}")
  #MESSAGE (STATUS "Found clRNG include dir: ${CLRNG_INCLUDE_DIRS}")
  #INCLUDE_DIRECTORIES (${CLFFT_INCLUDE_DIRS})
  #LINK_DIRECTORIES (${CLRNG_LIBRARIES})
  #find_package(PkgConfig)
  #pkg_check_modules(clRng REQUIRED)

  SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDKS_AMD")
ENDIF (ENABLE_AMD)

#enable UQTK
OPTION (USE_UQTK "Use UQTK" OFF)

#intel icpc compiler specific flags
IF (${CMAKE_C_COMPILER_ID} STREQUAL "Intel" OR USE_INTEL)

  #for intel compiler turn on openmp and opencl
  OPTION (USE_OPENCL "Use OpenCL" OFF)
  OPTION (USE_CUDA "Use CUDA" OFF)
  OPTION (USE_MIC "Use intel MIC" ON)
  
  #find xiar and xild and set flags for offload build on mic
  FIND_PROGRAM(XIAR xiar)
  IF(XIAR)
    MESSAGE(STATUS "xiar found: ${XIAR}")
    SET(CMAKE_AR "${XIAR}")
  ENDIF(XIAR)
  MARK_AS_ADVANCED(XIAR)
  SET(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> rcs -qoffload-build <TARGET> <LINK_FLAGS> <OBJECTS>")
  SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> rcs -qoffload-build <TARGET> <LINK_FLAGS> <OBJECTS>")
  
  FIND_PROGRAM(XILD xild)
  IF(XILD)
    SET(CMAKE_LINKER "${XILD}")
  ENDIF(XILD)
  MARK_AS_ADVANCED(XILD)

  #set flags for openmp and opencl
  #TODO: check which opencl to use: nvidia, amd, intel, apple
  SET (CMAKE_CXX_FLAGS "-DDEBUG -O3 -Wall -offload -mkl -openmp -lOpenCL -lpthread -DDKS_MIC -DDKS_OPENCL -qopt-report=5 -qopt-report-phase=vec -std=c++11")

  IF (${COMPILER_NAME} STREQUAL "mpicxx" OR ${COMPILER_NAME} STREQUAL "mpiicpc")
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDKS_MPI")
  ENDIF (${COMPILER_NAME} STREQUAL "mpicxx" OR ${COMPILER_NAME} STREQUAL "mpiicpc")
  
ENDIF (${CMAKE_C_COMPILER_ID} STREQUAL "Intel" OR USE_INTEL)

#gnu copmpiler specific flags
IF ( (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang") AND NOT USE_INTEL)
  
  
  OPTION (USE_OPENCL "Use OpenCL" OFF)
  OPTION (USE_CUDA "Use CUDA" OFF)
  OPTION (USE_MIC "Use intel MIC" OFF)
  OPTION (STATIC_CUDA "Link static cuda libraries" OFF)

  IF (ENABLE_MUSR)
    SET (USE_OPENCL ON)
  ENDIF (ENABLE_MUSR)

  #dont set openmp flag for apple devices
  IF (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -DDEBUG -O3 -Wall -fopenmp -std=c++11 -D__wsu")
  ELSE ($CMAKE_C_COMPILER_ID} STREQUAL "GNU")
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -DDEBUG -O3 -Wall -std=c++11 -D__wsu") 
  ENDIF (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
    

  FIND_PACKAGE(CUDA)
  IF (CUDA_FOUND)
    SET (USE_CUDA ON)
    OPTION(CUDA_USE_STATIC_CUDA_RUNTIME "Use static cuda libraries" OFF)
    INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIRS})
    LINK_DIRECTORIES(${CUDA_TOOLKIT_ROOT_DIR}/lib64)
    LINK_DIRECTORIES(${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs)
    
    MESSAGE (STATUS "cuda include: ${CUDA_INCLUDE_DIRS}")
    MESSAGE (STATUS "cuda libs: ${CUDA_TOOLKIT_ROOT_DIR}/lib64")
    MESSAGE (STATUS "cuda version: ${CUDA_VERSION}")
    SET(CUDA_PROPAGATE_HOST_FLAGS OFF)

#as35: Tesla K40c    SET (CUDA_NVCC_FLAGS "-arch=sm_35;-DDEBUG;-std=c++11;-D__wsu;-fmad=false")    
    SET (CUDA_NVCC_FLAGS "-arch=sm_70; -gencode=arch=compute_70,code=sm_70 -DDEBUG;-std=c++11;-D__wsu;-fmad=false")    
    SET (CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};${OPENCL_KERNELS}")

    IF (NOT STATIC_CUDA)
      SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDKS_CUDA")
      SET (DKS_CUDA_LIBS "-lcudadevrt -lcudart -lcufft -lcublas")
    ELSE (NOT STATIC_CUDA) 
      SET (CUDA_SEPARABLE_COMPILATION ON)
      SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDKS_CUDA -fPIC")
      SET (CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};-rdc=true;-lcufft_static;-lcublas_static;-lcurand_static")
      SET (DKS_CUDA_LIBS "-lcudadevrt -lcudart_static -lcufft_static -lcublas_static -lculibos")
    ENDIF (NOT STATIC_CUDA)

    #if cuda version >= 7.0 add runtime commpilation flags
    IF (NOT CUDA_VERSION VERSION_LESS "7.0" AND ENABLE_MUSR)
      SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lnvrtc -lcuda")
    ENDIF (NOT CUDA_VERSION VERSION_LESS "7.0" AND ENABLE_MUSR)
    
    MESSAGE (STATUS "nvcc flags: ${CUDA_NVCC_FLAGS}")
    
    SET(CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE OFF)
    SET(BUILD_SHARED_LIBS OFF)

  ENDIF (CUDA_FOUND)

  IF (NOT CUDA_FOUND)

    MESSAGE(STATUS "CUDA not found, looking for OpenCL")

    FIND_PACKAGE(OpenCL)
    MESSAGE("after FIND_PACKAGE(OpenCL): version: ${OpenCL_VERSION_STRING}")
    MESSAGE("after FIND_PACKAGE(OpenCL): inc dir: ${OpenCL_INCLUDE_DIR}")
    MESSAGE("after FIND_PACKAGE(OpenCL): lib dir: ${OpenCL_LIBRARY}")
    IF (OpenCL_FOUND)
      MESSAGE(STATUS "OpenCL version : ${OpenCL_VERSION_STRING}")
      MESSAGE(STATUS "OpenCL include dir: ${OpenCL_INCLUDE_DIR}")
      MESSAGE(STATUS "OpenCL library dir: ${OpenCL_LIBRARY}")
      SET(CMAKE_SKIP_RPATH TRUE)
      INCLUDE_DIRECTORIES(${OpenCL_INCLUDE_DIR})
      LINK_DIRECTORIES(${OpenCL_LIBRARY})
    ENDIF (OpenCL_FOUND)

  ENDIF (NOT CUDA_FOUND)

  #if mac OS and no CUDA set apple opencl flags
  IF (APPLE AND NOT CUDA_FOUND)
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -framework opencl -lpthread -DDKS_OPENCL")
  ENDIF(APPLE AND NOT CUDA_FOUND)

  #if cuda found set cuda opencl flags
  IF (CUDA_FOUND AND USE_OPENCL)
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lOpenCL -lpthread -DDKS_OPENCL")
  ENDIF (CUDA_FOUND AND USE_OPENCL)

  #if cuda not found but amd opencl found set opencl flags
  IF (NOT CUDA_FOUND AND OpenCL_FOUND)
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lOpenCL -lpthread -DDKS_OPENCL")
  ENDIF(NOT CUDA_FOUND AND OpenCL_FOUND)

  #if mpi compiler used set mpi flag
  IF (${COMPILER_NAME} STREQUAL "mpicxx")
    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDKS_MPI")
  ENDIF (${COMPILER_NAME} STREQUAL "mpicxx")

ENDIF ( (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang") AND NOT USE_INTEL)

SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCL_KERNELS}")
MESSAGE (STATUS "Compiler flags: ${CMAKE_CXX_FLAGS}")

ADD_SUBDIRECTORY (src)

IF (ENABLE_TESTS)
  ADD_SUBDIRECTORY (test)
ENDIF (ENABLE_TESTS)

ADD_SUBDIRECTORY (auto-tuning)

### write configure files ###
CONFIGURE_FILE ( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${PROJECT_NAME}Config.cmake.in
  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config_install.cmake )

CONFIGURE_FILE (${CMAKE_CURRENT_SOURCE_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake.in
  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion_install.cmake @ONLY)

### install files ###
INSTALL (
  FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config_install.cmake
  DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/cmake/${PROJECT_NAME}"
  RENAME ${PROJECT_NAME}Config.cmake
  )

INSTALL (
  FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion_install.cmake
  DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/cmake/${PROJECT_NAME}"
  RENAME ${PROJECT_NAME}ConfigVersion.cmake
  )