forked from lijiext/lammps
1327 lines
53 KiB
Makefile
1327 lines
53 KiB
Makefile
# Default settings common options.
|
|
|
|
#LAMMPS specific settings:
|
|
ifndef KOKKOS_PATH
|
|
KOKKOS_PATH=../../lib/kokkos
|
|
endif
|
|
CXXFLAGS=$(CCFLAGS)
|
|
|
|
KOKKOS_VERSION_MAJOR = 3
|
|
KOKKOS_VERSION_MINOR = 1
|
|
KOKKOS_VERSION_PATCH = 1
|
|
KOKKOS_VERSION = $(shell echo $(KOKKOS_VERSION_MAJOR)*10000+$(KOKKOS_VERSION_MINOR)*100+$(KOKKOS_VERSION_PATCH) | bc)
|
|
|
|
# Options: Cuda,HIP,ROCm,OpenMP,Pthread,Serial
|
|
KOKKOS_DEVICES ?= "OpenMP"
|
|
#KOKKOS_DEVICES ?= "Pthread"
|
|
# Options:
|
|
# Intel: KNC,KNL,SNB,HSW,BDW,SKX
|
|
# NVIDIA: Kepler,Kepler30,Kepler32,Kepler35,Kepler37,Maxwell,Maxwell50,Maxwell52,Maxwell53,Pascal60,Pascal61,Volta70,Volta72,Turing75
|
|
# ARM: ARMv80,ARMv81,ARMv8-ThunderX,ARMv8-TX2
|
|
# IBM: BGQ,Power7,Power8,Power9
|
|
# AMD-GPUS: Vega900,Vega906
|
|
# AMD-CPUS: AMDAVX,Ryzen,EPYC
|
|
KOKKOS_ARCH ?= ""
|
|
# Options: yes,no
|
|
KOKKOS_DEBUG ?= "no"
|
|
# Options: hwloc,librt,experimental_memkind
|
|
KOKKOS_USE_TPLS ?= ""
|
|
# Options: c++11,c++14,c++1y,c++17,c++1z,c++2a
|
|
KOKKOS_CXX_STANDARD ?= "c++11"
|
|
# Options: aggressive_vectorization,disable_profiling,enable_deprecated_code,disable_deprecated_code,enable_large_mem_tests,disable_complex_align
|
|
KOKKOS_OPTIONS ?= ""
|
|
# Option for setting ETI path
|
|
KOKKOS_ETI_PATH ?= ${KOKKOS_PATH}/core/src/eti
|
|
KOKKOS_CMAKE ?= "no"
|
|
KOKKOS_TRIBITS ?= "no"
|
|
KOKKOS_STANDALONE_CMAKE ?= "no"
|
|
|
|
# Default settings specific options.
|
|
# Options: force_uvm,use_ldg,rdc,enable_lambda,enable_constexpr
|
|
KOKKOS_CUDA_OPTIONS ?= "enable_lambda"
|
|
|
|
# Options: rdc
|
|
KOKKOS_HIP_OPTIONS ?= ""
|
|
|
|
# Default settings specific options.
|
|
# Options: enable_async_dispatch
|
|
KOKKOS_HPX_OPTIONS ?= ""
|
|
|
|
# Return a 1 if a string contains a substring and 0 if not
|
|
# Note the search string should be without '"'
|
|
# Example: $(call kokkos_has_string,"hwloc,librt",hwloc)
|
|
# Will return a 1
|
|
kokkos_has_string=$(if $(findstring $2,$1),1,0)
|
|
# Returns 1 if the path exists, 0 otherwise
|
|
# Example: $(call kokkos_path_exists,/path/to/file)
|
|
# Will return a 1 if /path/to/file exists
|
|
kokkos_path_exists=$(if $(wildcard $1),1,0)
|
|
|
|
# Check for general settings
|
|
|
|
KOKKOS_INTERNAL_ENABLE_DEBUG := $(call kokkos_has_string,$(KOKKOS_DEBUG),yes)
|
|
KOKKOS_INTERNAL_ENABLE_CXX11 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++11)
|
|
KOKKOS_INTERNAL_ENABLE_CXX14 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++14)
|
|
KOKKOS_INTERNAL_ENABLE_CXX1Y := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++1y)
|
|
KOKKOS_INTERNAL_ENABLE_CXX17 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++17)
|
|
KOKKOS_INTERNAL_ENABLE_CXX1Z := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++1z)
|
|
KOKKOS_INTERNAL_ENABLE_CXX2A := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++2a)
|
|
|
|
# Check for external libraries.
|
|
KOKKOS_INTERNAL_USE_HWLOC := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),hwloc)
|
|
KOKKOS_INTERNAL_USE_LIBRT := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),librt)
|
|
KOKKOS_INTERNAL_USE_MEMKIND := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),experimental_memkind)
|
|
|
|
# Check for advanced settings.
|
|
KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),compiler_warnings)
|
|
KOKKOS_INTERNAL_OPT_RANGE_AGGRESSIVE_VECTORIZATION := $(call kokkos_has_string,$(KOKKOS_OPTIONS),aggressive_vectorization)
|
|
KOKKOS_INTERNAL_DISABLE_PROFILING := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_profiling)
|
|
KOKKOS_INTERNAL_DISABLE_DEPRECATED_CODE := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_deprecated_code)
|
|
KOKKOS_INTERNAL_ENABLE_DEPRECATED_CODE := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_deprecated_code)
|
|
KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_complex_align)
|
|
KOKKOS_INTERNAL_DISABLE_DUALVIEW_MODIFY_CHECK := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_dualview_modify_check)
|
|
KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_profile_load_print)
|
|
KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_large_mem_tests)
|
|
KOKKOS_INTERNAL_CUDA_USE_LDG := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),use_ldg)
|
|
KOKKOS_INTERNAL_CUDA_USE_UVM := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),force_uvm)
|
|
KOKKOS_INTERNAL_CUDA_USE_RELOC := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),rdc)
|
|
KOKKOS_INTERNAL_CUDA_USE_LAMBDA := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_lambda)
|
|
KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_constexpr)
|
|
KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH := $(call kokkos_has_string,$(KOKKOS_HPX_OPTIONS),enable_async_dispatch)
|
|
KOKKOS_INTERNAL_ENABLE_ETI := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_eti)
|
|
|
|
KOKKOS_INTERNAL_HIP_USE_RELOC := $(call kokkos_has_string,$(KOKKOS_HIP_OPTIONS),rdc)
|
|
|
|
# Check for Kokkos Host Execution Spaces one of which must be on.
|
|
KOKKOS_INTERNAL_USE_OPENMP := $(call kokkos_has_string,$(subst OpenMPTarget,,$(KOKKOS_DEVICES)),OpenMP)
|
|
KOKKOS_INTERNAL_USE_PTHREADS := $(call kokkos_has_string,$(KOKKOS_DEVICES),Pthread)
|
|
KOKKOS_INTERNAL_USE_HPX := $(call kokkos_has_string,$(KOKKOS_DEVICES),HPX)
|
|
KOKKOS_INTERNAL_USE_SERIAL := $(call kokkos_has_string,$(KOKKOS_DEVICES),Serial)
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 0)
|
|
ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 0)
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 0)
|
|
KOKKOS_INTERNAL_USE_SERIAL := 1
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Check for other Execution Spaces.
|
|
KOKKOS_INTERNAL_USE_CUDA := $(call kokkos_has_string,$(KOKKOS_DEVICES),Cuda)
|
|
KOKKOS_INTERNAL_USE_HIP := $(call kokkos_has_string,$(KOKKOS_DEVICES),HIP)
|
|
KOKKOS_INTERNAL_USE_OPENMPTARGET := $(call kokkos_has_string,$(KOKKOS_DEVICES),OpenMPTarget)
|
|
|
|
KOKKOS_DEVICELIST =
|
|
ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
|
|
KOKKOS_DEVICELIST += Serial
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
|
|
KOKKOS_DEVICELIST += OpenMP
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
|
|
KOKKOS_DEVICELIST += Threads
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
|
|
KOKKOS_DEVICELIST += HPX
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
KOKKOS_DEVICELIST += Cuda
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
|
|
KOKKOS_DEVICELIST += HIP
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
|
|
KOKKOS_DEVICELIST += OPENMPTARGET
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc)
|
|
ifeq ($(origin CUDA_PATH), undefined)
|
|
CUDA_PATH = $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=)
|
|
endif
|
|
ifeq ($(CUDA_PATH),)
|
|
CUDA_PATH = $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=)
|
|
endif
|
|
KOKKOS_INTERNAL_COMPILER_NVCC_VERSION := $(shell nvcc --version 2>&1 | grep release | cut -d' ' -f5 | cut -d',' -f1 | tr -d .)
|
|
endif
|
|
|
|
# Check OS.
|
|
KOKKOS_OS := $(strip $(shell uname -s))
|
|
KOKKOS_INTERNAL_OS_CYGWIN := $(call kokkos_has_string,$(KOKKOS_OS),CYGWIN)
|
|
KOKKOS_INTERNAL_OS_LINUX := $(call kokkos_has_string,$(KOKKOS_OS),Linux)
|
|
KOKKOS_INTERNAL_OS_DARWIN := $(call kokkos_has_string,$(KOKKOS_OS),Darwin)
|
|
|
|
# Check compiler.
|
|
KOKKOS_CXX_VERSION := $(strip $(shell $(CXX) --version 2>&1))
|
|
KOKKOS_INTERNAL_COMPILER_INTEL := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),Intel Corporation)
|
|
KOKKOS_INTERNAL_COMPILER_PGI := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),PGI)
|
|
KOKKOS_INTERNAL_COMPILER_XL := $(strip $(shell $(CXX) -qversion 2>&1 | grep XL | wc -l))
|
|
KOKKOS_INTERNAL_COMPILER_CRAY := $(strip $(shell $(CXX) -craype-verbose 2>&1 | grep "CC-" | wc -l))
|
|
KOKKOS_INTERNAL_COMPILER_NVCC := $(strip $(shell echo "$(shell export OMPI_CXX=$(OMPI_CXX); export MPICH_CXX=$(MPICH_CXX); $(CXX) --version 2>&1 | grep nvcc | wc -l)>0" | bc))
|
|
KOKKOS_INTERNAL_COMPILER_CLANG := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),clang)
|
|
KOKKOS_INTERNAL_COMPILER_APPLE_CLANG := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),Apple LLVM)
|
|
KOKKOS_INTERNAL_COMPILER_HCC := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),HCC)
|
|
KOKKOS_INTERNAL_COMPILER_GCC := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),GCC)
|
|
|
|
# Check Host Compiler if using NVCC through nvcc_wrapper
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
KOKKOS_INTERNAL_COMPILER_NVCC_WRAPPER := $(strip $(shell echo $(CXX) | grep nvcc_wrapper | wc -l))
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC_WRAPPER), 1)
|
|
|
|
KOKKOS_CXX_HOST_VERSION := $(strip $(shell $(CXX) $(CXXFLAGS) --host-version 2>&1))
|
|
KOKKOS_INTERNAL_COMPILER_PGI := $(call kokkos_has_string,$(KOKKOS_CXX_HOST_VERSION),PGI)
|
|
KOKKOS_INTERNAL_COMPILER_INTEL := $(call kokkos_has_string,$(KOKKOS_CXX_HOST_VERSION),Intel Corporation)
|
|
KOKKOS_INTERNAL_COMPILER_CLANG := $(call kokkos_has_string,$(KOKKOS_CXX_HOST_VERSION),clang)
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 2)
|
|
KOKKOS_INTERNAL_COMPILER_CLANG = 1
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 2)
|
|
KOKKOS_INTERNAL_COMPILER_XL = 1
|
|
endif
|
|
|
|
# Apple Clang passes both clang and apple clang tests, so turn off clang.
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_APPLE_CLANG), 1)
|
|
KOKKOS_INTERNAL_COMPILER_CLANG = 0
|
|
endif
|
|
# AMD HCC passes both clang and hcc test so turn off clang
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_HCC), 1)
|
|
KOKKOS_INTENAL_COMPILER_CLANG = 0
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_COMPILER_CLANG_VERSION := $(shell $(CXX) --version | grep version | cut -d ' ' -f3 | tr -d '.')
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_CLANG_VERSION) -lt 400; echo $$?),0)
|
|
$(error Compiling Cuda code directly with Clang requires version 4.0.0 or higher)
|
|
endif
|
|
|
|
KOKKOS_INTERNAL_CUDA_USE_LAMBDA := 1
|
|
endif
|
|
endif
|
|
|
|
# Set compiler warnings flags.
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
# TODO check if PGI accepts GNU style warnings
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS =
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wuninitialized
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_APPLE_CLANG), 1)
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wuninitialized
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wuninitialized
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
# TODO check if cray accepts GNU style warnings
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS =
|
|
else
|
|
#gcc
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wignored-qualifiers -Wempty-body -Wclobbered -Wuninitialized
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
else
|
|
KOKKOS_INTERNAL_COMPILER_WARNINGS =
|
|
endif
|
|
|
|
# Set OpenMP flags.
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_INTERNAL_OPENMP_FLAG := -mp
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp=libomp
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_APPLE_CLANG), 1)
|
|
KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp=libomp
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
|
|
KOKKOS_INTERNAL_OPENMP_FLAG := -qsmp=omp
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
# OpenMP is turned on by default in Cray compiler environment.
|
|
KOKKOS_INTERNAL_OPENMP_FLAG :=
|
|
else
|
|
KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
|
|
KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_IBM_XL_OMP45_WORKAROUND -qsmp=omp -qoffload -qnoeh
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
#KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_BUG_WORKAROUND_IBM_CLANG_OMP45_VIEW_INIT -fopenmp-implicit-declare-target -fopenmp-targets=nvptx64-nvidia-cuda -fopenmp -fopenmp=libomp
|
|
KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_WORKAROUND_OPENMPTARGET_CLANG -fopenmp -fopenmp=libomp
|
|
KOKKOS_INTERNAL_OPENMPTARGET_LIB := -lomptarget
|
|
else
|
|
#Assume GCC
|
|
KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -fopenmp -foffload=nvptx-none
|
|
endif
|
|
endif
|
|
|
|
# Set C++11 flags.
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_INTERNAL_CXX11_FLAG := --c++11
|
|
KOKKOS_INTERNAL_CXX14_FLAG := --c++14
|
|
#KOKKOS_INTERNAL_CXX17_FLAG := --c++17
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
|
|
KOKKOS_INTERNAL_CXX11_FLAG := -std=c++11
|
|
KOKKOS_INTERNAL_CXX14_FLAG := -std=c++14
|
|
KOKKOS_INTERNAL_CXX1Y_FLAG := -std=c++1y
|
|
#KOKKOS_INTERNAL_CXX17_FLAG := -std=c++17
|
|
#KOKKOS_INTERNAL_CXX1Z_FLAG := -std=c++1Z
|
|
#KOKKOS_INTERNAL_CXX2A_FLAG := -std=c++2a
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
KOKKOS_INTERNAL_CXX11_FLAG := -hstd=c++11
|
|
KOKKOS_INTERNAL_CXX14_FLAG := -hstd=c++14
|
|
#KOKKOS_INTERNAL_CXX1Y_FLAG := -hstd=c++1y
|
|
#KOKKOS_INTERNAL_CXX17_FLAG := -hstd=c++17
|
|
#KOKKOS_INTERNAL_CXX1Z_FLAG := -hstd=c++1z
|
|
#KOKKOS_INTERNAL_CXX2A_FLAG := -hstd=c++2a
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_HCC), 1)
|
|
KOKKOS_INTERNAL_CXX11_FLAG :=
|
|
else
|
|
KOKKOS_INTERNAL_CXX11_FLAG := --std=c++11
|
|
KOKKOS_INTERNAL_CXX14_FLAG := --std=c++14
|
|
KOKKOS_INTERNAL_CXX1Y_FLAG := --std=c++1y
|
|
KOKKOS_INTERNAL_CXX17_FLAG := --std=c++17
|
|
KOKKOS_INTERNAL_CXX1Z_FLAG := --std=c++1z
|
|
KOKKOS_INTERNAL_CXX2A_FLAG := --std=c++2a
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Check for Kokkos Architecture settings.
|
|
|
|
# Intel based.
|
|
KOKKOS_INTERNAL_USE_ARCH_KNC := $(call kokkos_has_string,$(KOKKOS_ARCH),KNC)
|
|
KOKKOS_INTERNAL_USE_ARCH_WSM := $(call kokkos_has_string,$(KOKKOS_ARCH),WSM)
|
|
KOKKOS_INTERNAL_USE_ARCH_SNB := $(call kokkos_has_string,$(KOKKOS_ARCH),SNB)
|
|
KOKKOS_INTERNAL_USE_ARCH_HSW := $(call kokkos_has_string,$(KOKKOS_ARCH),HSW)
|
|
KOKKOS_INTERNAL_USE_ARCH_BDW := $(call kokkos_has_string,$(KOKKOS_ARCH),BDW)
|
|
KOKKOS_INTERNAL_USE_ARCH_SKX := $(call kokkos_has_string,$(KOKKOS_ARCH),SKX)
|
|
KOKKOS_INTERNAL_USE_ARCH_KNL := $(call kokkos_has_string,$(KOKKOS_ARCH),KNL)
|
|
|
|
# NVIDIA based.
|
|
NVCC_WRAPPER := $(KOKKOS_PATH)/bin/nvcc_wrapper
|
|
KOKKOS_INTERNAL_USE_ARCH_KEPLER30 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler30)
|
|
KOKKOS_INTERNAL_USE_ARCH_KEPLER32 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler32)
|
|
KOKKOS_INTERNAL_USE_ARCH_KEPLER35 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler35)
|
|
KOKKOS_INTERNAL_USE_ARCH_KEPLER37 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler37)
|
|
KOKKOS_INTERNAL_USE_ARCH_MAXWELL50 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell50)
|
|
KOKKOS_INTERNAL_USE_ARCH_MAXWELL52 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell52)
|
|
KOKKOS_INTERNAL_USE_ARCH_MAXWELL53 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell53)
|
|
KOKKOS_INTERNAL_USE_ARCH_PASCAL61 := $(call kokkos_has_string,$(KOKKOS_ARCH),Pascal61)
|
|
KOKKOS_INTERNAL_USE_ARCH_PASCAL60 := $(call kokkos_has_string,$(KOKKOS_ARCH),Pascal60)
|
|
KOKKOS_INTERNAL_USE_ARCH_VOLTA70 := $(call kokkos_has_string,$(KOKKOS_ARCH),Volta70)
|
|
KOKKOS_INTERNAL_USE_ARCH_VOLTA72 := $(call kokkos_has_string,$(KOKKOS_ARCH),Volta72)
|
|
KOKKOS_INTERNAL_USE_ARCH_TURING75 := $(call kokkos_has_string,$(KOKKOS_ARCH),Turing75)
|
|
KOKKOS_INTERNAL_USE_ARCH_NVIDIA := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KEPLER30) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_KEPLER32) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_KEPLER35) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_KEPLER37) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_PASCAL61) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_PASCAL60) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_VOLTA70) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_VOLTA72) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_TURING75) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53))
|
|
|
|
#SEK: This seems like a bug to me
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 0)
|
|
KOKKOS_INTERNAL_USE_ARCH_MAXWELL50 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell)
|
|
KOKKOS_INTERNAL_USE_ARCH_KEPLER35 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler)
|
|
KOKKOS_INTERNAL_USE_ARCH_NVIDIA := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KEPLER30) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_KEPLER32) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_KEPLER35) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_KEPLER37) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_PASCAL61) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_PASCAL60) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_VOLTA70) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_VOLTA72) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_TURING75) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52) \
|
|
+ $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53))
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc)
|
|
CUDA_PATH ?= $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=)
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
|
|
KOKKOS_INTERNAL_OPENMPTARGET_FLAG := $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG) --cuda-path=$(CUDA_PATH)
|
|
endif
|
|
endif
|
|
endif
|
|
# ARM based.
|
|
KOKKOS_INTERNAL_USE_ARCH_ARMV80 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv80)
|
|
KOKKOS_INTERNAL_USE_ARCH_ARMV81 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv81)
|
|
KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8-ThunderX)
|
|
KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8-TX2)
|
|
KOKKOS_INTERNAL_USE_ARCH_ARM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_ARMV80)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV81)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2) | bc))
|
|
|
|
# IBM based.
|
|
KOKKOS_INTERNAL_USE_ARCH_BGQ := $(call kokkos_has_string,$(KOKKOS_ARCH),BGQ)
|
|
KOKKOS_INTERNAL_USE_ARCH_POWER7 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power7)
|
|
KOKKOS_INTERNAL_USE_ARCH_POWER8 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power8)
|
|
KOKKOS_INTERNAL_USE_ARCH_POWER9 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power9)
|
|
KOKKOS_INTERNAL_USE_ARCH_IBM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_BGQ)+$(KOKKOS_INTERNAL_USE_ARCH_POWER7)+$(KOKKOS_INTERNAL_USE_ARCH_POWER8)+$(KOKKOS_INTERNAL_USE_ARCH_POWER9) | bc))
|
|
|
|
# AMD based.
|
|
KOKKOS_INTERNAL_USE_ARCH_AMDAVX := $(call kokkos_has_string,$(KOKKOS_ARCH),AMDAVX)
|
|
KOKKOS_INTERNAL_USE_ARCH_RYZEN := $(call kokkos_has_string,$(KOKKOS_ARCH),Ryzen)
|
|
KOKKOS_INTERNAL_USE_ARCH_EPYC := $(call kokkos_has_string,$(KOKKOS_ARCH),EPYC)
|
|
KOKKOS_INTERNAL_USE_ARCH_VEGA900 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega900)
|
|
KOKKOS_INTERNAL_USE_ARCH_VEGA906 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega906)
|
|
|
|
# Any AVX?
|
|
KOKKOS_INTERNAL_USE_ARCH_SSE42 := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_WSM))
|
|
KOKKOS_INTERNAL_USE_ARCH_AVX := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_SNB) + $(KOKKOS_INTERNAL_USE_ARCH_AMDAVX))
|
|
KOKKOS_INTERNAL_USE_ARCH_AVX2 := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_HSW) + $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_EPYC))
|
|
KOKKOS_INTERNAL_USE_ARCH_AVX512MIC := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KNL))
|
|
KOKKOS_INTERNAL_USE_ARCH_AVX512XEON := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_SKX))
|
|
|
|
# Decide what ISA level we are able to support.
|
|
KOKKOS_INTERNAL_USE_ISA_X86_64 := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_WSM) + $(KOKKOS_INTERNAL_USE_ARCH_SNB) + $(KOKKOS_INTERNAL_USE_ARCH_HSW) + $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_KNL) + $(KOKKOS_INTERNAL_USE_ARCH_SKX) + $(KOKKOS_INTERNAL_USE_ARCH_EPYC))
|
|
KOKKOS_INTERNAL_USE_ISA_KNC := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KNC))
|
|
KOKKOS_INTERNAL_USE_ISA_POWERPCLE := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_POWER8) + $(KOKKOS_INTERNAL_USE_ARCH_POWER9))
|
|
KOKKOS_INTERNAL_USE_ISA_POWERPCBE := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_POWER7))
|
|
|
|
# Decide whether we can support transactional memory
|
|
KOKKOS_INTERNAL_USE_TM := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_SKX))
|
|
|
|
# Incompatible flags?
|
|
KOKKOS_INTERNAL_USE_ARCH_MULTIHOST := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_SSE42)+$(KOKKOS_INTERNAL_USE_ARCH_AVX)+$(KOKKOS_INTERNAL_USE_ARCH_AVX2)+$(KOKKOS_INTERNAL_USE_ARCH_AVX512MIC)+$(KOKKOS_INTERNAL_USE_ARCH_AVX512XEON)+$(KOKKOS_INTERNAL_USE_ARCH_KNC)+$(KOKKOS_INTERNAL_USE_ARCH_IBM)+$(KOKKOS_INTERNAL_USE_ARCH_ARM)>1" | bc ))
|
|
KOKKOS_INTERNAL_USE_ARCH_MULTIGPU := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_NVIDIA)>1" | bc))
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MULTIHOST), 1)
|
|
$(error Defined Multiple Host architectures: KOKKOS_ARCH=$(KOKKOS_ARCH) )
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MULTIGPU), 1)
|
|
$(error Defined Multiple GPU architectures: KOKKOS_ARCH=$(KOKKOS_ARCH) )
|
|
endif
|
|
|
|
# Generating the list of Flags.
|
|
|
|
KOKKOS_CPPFLAGS =
|
|
KOKKOS_LIBDIRS =
|
|
ifneq ($(KOKKOS_CMAKE), yes)
|
|
KOKKOS_CPPFLAGS = -I./ -I$(KOKKOS_PATH)/core/src -I$(KOKKOS_PATH)/containers/src -I$(KOKKOS_PATH)/algorithms/src -I$(KOKKOS_ETI_PATH)
|
|
endif
|
|
KOKKOS_TPL_INCLUDE_DIRS =
|
|
KOKKOS_TPL_LIBRARY_DIRS =
|
|
KOKKOS_TPL_LIBRARY_NAMES =
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS), 1)
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_COMPILER_WARNINGS)
|
|
endif
|
|
|
|
KOKKOS_LIBS = -ldl
|
|
KOKKOS_TPL_LIBRARY_NAMES += dl
|
|
ifneq ($(KOKKOS_CMAKE), yes)
|
|
KOKKOS_LIBDIRS = -L$(shell pwd)
|
|
# CXXLDFLAGS is used together with CXXFLAGS in a combined compile/link command
|
|
KOKKOS_CXXLDFLAGS = -L$(shell pwd)
|
|
endif
|
|
KOKKOS_LINK_FLAGS =
|
|
KOKKOS_SRC =
|
|
KOKKOS_HEADERS =
|
|
|
|
# Generating the KokkosCore_config.h file.
|
|
|
|
KOKKOS_INTERNAL_CONFIG_TMP=KokkosCore_config.tmp
|
|
KOKKOS_CONFIG_HEADER=KokkosCore_config.h
|
|
# Functions for generating config header file
|
|
kokkos_append_header = $(shell echo $1 >> $(KOKKOS_INTERNAL_CONFIG_TMP))
|
|
|
|
# Do not append first line
|
|
tmp := $(shell echo "/* ---------------------------------------------" > KokkosCore_config.tmp)
|
|
tmp := $(call kokkos_append_header,"Makefile constructed configuration:")
|
|
tmp := $(call kokkos_append_header,"$(shell date)")
|
|
tmp := $(call kokkos_append_header,"----------------------------------------------*/")
|
|
|
|
tmp := $(call kokkos_append_header,'\#if !defined(KOKKOS_MACROS_HPP) || defined(KOKKOS_CORE_CONFIG_H)')
|
|
tmp := $(call kokkos_append_header,'\#error "Do not include $(KOKKOS_CONFIG_HEADER) directly; include Kokkos_Macros.hpp instead."')
|
|
tmp := $(call kokkos_append_header,'\#else')
|
|
tmp := $(call kokkos_append_header,'\#define KOKKOS_CORE_CONFIG_H')
|
|
tmp := $(call kokkos_append_header,'\#endif')
|
|
|
|
tmp := $(call kokkos_append_header,"")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_VERSION $(KOKKOS_VERSION)")
|
|
tmp := $(call kokkos_append_header,"")
|
|
|
|
tmp := $(call kokkos_append_header,"/* Execution Spaces */")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_COMPILER_CUDA_VERSION $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION)")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ROCM), 1)
|
|
tmp := $(call kokkos_append_header,'\#define KOKKOS_ENABLE_ROCM')
|
|
tmp := $(call kokkos_append_header,'\#define KOKKOS_IMPL_ROCM_CLANG_WORKAROUND 1')
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
|
|
tmp := $(call kokkos_append_header,'\#define KOKKOS_ENABLE_HIP')
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
|
|
tmp := $(call kokkos_append_header,'\#define KOKKOS_ENABLE_OPENMPTARGET')
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_GCC), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_WORKAROUND_OPENMPTARGET_GCC")
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
|
|
tmp := $(call kokkos_append_header,'\#define KOKKOS_ENABLE_OPENMP')
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_THREADS")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HPX")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_SERIAL")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_TM), 1)
|
|
tmp := $(call kokkos_append_header,"\#ifndef __CUDA_ARCH__")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_TM")
|
|
tmp := $(call kokkos_append_header,"\#endif")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ISA_X86_64), 1)
|
|
tmp := $(call kokkos_append_header,"\#ifndef __CUDA_ARCH__")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_USE_ISA_X86_64")
|
|
tmp := $(call kokkos_append_header,"\#endif")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ISA_KNC), 1)
|
|
tmp := $(call kokkos_append_header,"\#ifndef __CUDA_ARCH__")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_USE_ISA_KNC")
|
|
tmp := $(call kokkos_append_header,"\#endif")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ISA_POWERPCLE), 1)
|
|
tmp := $(call kokkos_append_header,"\#ifndef __CUDA_ARCH__")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_USE_ISA_POWERPCLE")
|
|
tmp := $(call kokkos_append_header,"\#endif")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ISA_POWERPCBE), 1)
|
|
tmp := $(call kokkos_append_header,"\#ifndef __CUDA_ARCH__")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_USE_ISA_POWERPCBE")
|
|
tmp := $(call kokkos_append_header,"\#endif")
|
|
endif
|
|
|
|
#only add the c++ standard flags if this is not CMake
|
|
tmp := $(call kokkos_append_header,"/* General Settings */")
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX11), 1)
|
|
ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX11_FLAG)
|
|
endif
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX11")
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX14), 1)
|
|
ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX14_FLAG)
|
|
endif
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX14")
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX1Y), 1)
|
|
#I cannot make CMake add this in a good way - so add it here
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX1Y_FLAG)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX14")
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX17), 1)
|
|
ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX17_FLAG)
|
|
endif
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX17")
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX1Z), 1)
|
|
#I cannot make CMake add this in a good way - so add it here
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX1Z_FLAG)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX17")
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX2A), 1)
|
|
#I cannot make CMake add this in a good way - so add it here
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX2A_FLAG)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX20")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
KOKKOS_CXXFLAGS += -lineinfo
|
|
endif
|
|
|
|
KOKKOS_CXXFLAGS += -g
|
|
KOKKOS_LDFLAGS += -g
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEBUG")
|
|
ifeq ($(KOKKOS_INTERNAL_DISABLE_DUALVIEW_MODIFY_CHECK), 0)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK")
|
|
endif
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN), 0)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_COMPLEX_ALIGN")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_PROFILING_LOAD_PRINT")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HWLOC), 1)
|
|
ifneq ($(KOKKOS_CMAKE), yes)
|
|
ifneq ($(HWLOC_PATH),)
|
|
KOKKOS_CPPFLAGS += -I$(HWLOC_PATH)/include
|
|
KOKKOS_LIBDIRS += -L$(HWLOC_PATH)/lib
|
|
KOKKOS_CXXLDFLAGS += -L$(HWLOC_PATH)/lib
|
|
KOKKOS_TPL_INCLUDE_DIRS += $(HWLOC_PATH)/include
|
|
KOKKOS_TPL_LIBRARY_DIRS += $(HWLOC_PATH)/lib
|
|
endif
|
|
KOKKOS_LIBS += -lhwloc
|
|
KOKKOS_TPL_LIBRARY_NAMES += hwloc
|
|
endif
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HWLOC")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_LIBRT), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_USE_LIBRT")
|
|
KOKKOS_LIBS += -lrt
|
|
KOKKOS_TPL_LIBRARY_NAMES += rt
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
|
|
ifneq ($(KOKKOS_CMAKE), yes)
|
|
ifneq ($(MEMKIND_PATH),)
|
|
KOKKOS_CPPFLAGS += -I$(MEMKIND_PATH)/include
|
|
KOKKOS_LIBDIRS += -L$(MEMKIND_PATH)/lib
|
|
KOKKOS_CXXLDFLAGS += -L$(MEMKIND_PATH)/lib
|
|
KOKKOS_TPL_INCLUDE_DIRS += $(MEMKIND_PATH)/include
|
|
KOKKOS_TPL_LIBRARY_DIRS += $(MEMKIND_PATH)/lib
|
|
endif
|
|
KOKKOS_LIBS += -lmemkind -lnuma
|
|
KOKKOS_TPL_LIBRARY_NAMES += memkind numa
|
|
endif
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HBWSPACE")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_DISABLE_PROFILING), 0)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_PROFILING")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 0)
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_DEPRECATED_CODE), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEPRECATED_CODE")
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_ETI")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_LARGE_MEM_TESTS")
|
|
endif
|
|
|
|
tmp := $(call kokkos_append_header,"/* Optimization Settings */")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_OPT_RANGE_AGGRESSIVE_VECTORIZATION), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION")
|
|
endif
|
|
|
|
tmp := $(call kokkos_append_header,"/* Cuda Settings */")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_CUDA_USE_LDG), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC")
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC")
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_CUDA_USE_UVM), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_UVM")
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_CUDA_USE_RELOC), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE")
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_CXXFLAGS += -fcuda-rdc
|
|
KOKKOS_LDFLAGS += -fcuda-rdc
|
|
else
|
|
KOKKOS_CXXFLAGS += --relocatable-device-code=true
|
|
KOKKOS_LDFLAGS += --relocatable-device-code=true
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -ge 90; echo $$?),0)
|
|
# This diagnostic is just plain wrong in CUDA 9
|
|
# See https://github.com/kokkos/kokkos/issues/1470
|
|
KOKKOS_CXXFLAGS += -Xcudafe --diag_suppress=esa_on_defaulted_function_ignored
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_CUDA_USE_LAMBDA), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -gt 70; echo $$?),0)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_LAMBDA")
|
|
KOKKOS_CXXFLAGS += -expt-extended-lambda
|
|
else
|
|
$(warning Warning: Cuda Lambda support was requested but NVCC version is too low. This requires NVCC for Cuda version 7.5 or higher. Disabling Lambda support now.)
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_LAMBDA")
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -ge 80; echo $$?),0)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_CONSTEXPR")
|
|
KOKKOS_CXXFLAGS += -expt-relaxed-constexpr
|
|
else
|
|
$(warning Warning: Cuda relaxed constexpr support was requested but NVCC version is too low. This requires NVCC for Cuda version 8.0 or higher. Disabling relaxed constexpr support now.)
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_CONSTEXPR")
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_IMPL_CUDA_CLANG_WORKAROUND")
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HPX_ASYNC_DISPATCH")
|
|
endif
|
|
endif
|
|
|
|
# Add Architecture flags.
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV80), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_ARMV80")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
KOKKOS_CXXFLAGS += -march=armv8-a
|
|
KOKKOS_LDFLAGS += -march=armv8-a
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV81), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_ARMV81")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
KOKKOS_CXXFLAGS += -march=armv8.1-a
|
|
KOKKOS_LDFLAGS += -march=armv8.1-a
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_EPYC), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AMD_EPYC")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AMD_AVX2")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -mavx2
|
|
KOKKOS_LDFLAGS += -mavx2
|
|
else
|
|
KOKKOS_CXXFLAGS += -march=znver1 -mtune=znver1
|
|
KOKKOS_LDFLAGS += -march=znver1 -mtune=znver1
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_ARMV80")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_ARMV8_THUNDERX")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
KOKKOS_CXXFLAGS += -march=armv8-a -mtune=thunderx
|
|
KOKKOS_LDFLAGS += -march=armv8-a -mtune=thunderx
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_ARMV81")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_ARMV8_THUNDERX2")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS +=
|
|
KOKKOS_LDFLAGS +=
|
|
else
|
|
KOKKOS_CXXFLAGS += -mtune=thunderx2t99 -mcpu=thunderx2t99
|
|
KOKKOS_LDFLAGS += -mtune=thunderx2t99 -mcpu=thunderx2t99
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_SSE42), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_SSE42")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -xSSE4.2
|
|
KOKKOS_LDFLAGS += -xSSE4.2
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS += -tp=nehalem
|
|
KOKKOS_LDFLAGS += -tp=nehalem
|
|
else
|
|
# Assume that this is a really a GNU compiler.
|
|
KOKKOS_CXXFLAGS += -msse4.2
|
|
KOKKOS_LDFLAGS += -msse4.2
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AVX")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -mavx
|
|
KOKKOS_LDFLAGS += -mavx
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS += -tp=sandybridge
|
|
KOKKOS_LDFLAGS += -tp=sandybridge
|
|
else
|
|
# Assume that this is a really a GNU compiler.
|
|
KOKKOS_CXXFLAGS += -mavx
|
|
KOKKOS_LDFLAGS += -mavx
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_POWER7), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_POWER7")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
|
|
else
|
|
# Assume that this is a really a GNU compiler or it could be XL on P8.
|
|
KOKKOS_CXXFLAGS += -mcpu=power7 -mtune=power7
|
|
KOKKOS_LDFLAGS += -mcpu=power7 -mtune=power7
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_POWER8), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_POWER8")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
|
|
KOKKOS_CXXFLAGS += -mcpu=power8 -mtune=power8
|
|
KOKKOS_LDFLAGS += -mcpu=power8 -mtune=power8
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
|
|
else
|
|
# Assume that this is a really a GNU compiler on P8.
|
|
KOKKOS_CXXFLAGS += -mcpu=power8 -mtune=power8
|
|
KOKKOS_LDFLAGS += -mcpu=power8 -mtune=power8
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_POWER9), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_POWER9")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
|
|
KOKKOS_CXXFLAGS += -mcpu=power9 -mtune=power9
|
|
KOKKOS_LDFLAGS += -mcpu=power9 -mtune=power9
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
|
|
else
|
|
# Assume that this is a really a GNU compiler on P9
|
|
KOKKOS_CXXFLAGS += -mcpu=power9 -mtune=power9
|
|
KOKKOS_LDFLAGS += -mcpu=power9 -mtune=power9
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_HSW), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AVX2")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -xCORE-AVX2
|
|
KOKKOS_LDFLAGS += -xCORE-AVX2
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS += -tp=haswell
|
|
KOKKOS_LDFLAGS += -tp=haswell
|
|
else
|
|
# Assume that this is a really a GNU compiler.
|
|
KOKKOS_CXXFLAGS += -march=core-avx2 -mtune=core-avx2
|
|
KOKKOS_LDFLAGS += -march=core-avx2 -mtune=core-avx2
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_BDW), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AVX2")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -xCORE-AVX2
|
|
KOKKOS_LDFLAGS += -xCORE-AVX2
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
KOKKOS_CXXFLAGS += -tp=haswell
|
|
KOKKOS_LDFLAGS += -tp=haswell
|
|
else
|
|
# Assume that this is a really a GNU compiler.
|
|
KOKKOS_CXXFLAGS += -march=core-avx2 -mtune=core-avx2 -mrtm
|
|
KOKKOS_LDFLAGS += -march=core-avx2 -mtune=core-avx2 -mrtm
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX512MIC), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AVX512MIC")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -xMIC-AVX512
|
|
KOKKOS_LDFLAGS += -xMIC-AVX512
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
|
|
else
|
|
# Asssume that this is really a GNU compiler.
|
|
KOKKOS_CXXFLAGS += -march=knl -mtune=knl
|
|
KOKKOS_LDFLAGS += -march=knl -mtune=knl
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX512XEON), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_AVX512XEON")
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
|
|
KOKKOS_CXXFLAGS += -xCORE-AVX512
|
|
KOKKOS_LDFLAGS += -xCORE-AVX512
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
|
|
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
|
|
|
|
else
|
|
# Nothing here yet.
|
|
KOKKOS_CXXFLAGS += -march=skylake-avx512 -mtune=skylake-avx512 -mrtm
|
|
KOKKOS_LDFLAGS += -march=skylake-avx512 -mtune=skylake-avx512 -mrtm
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KNC), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KNC")
|
|
KOKKOS_CXXFLAGS += -mmic
|
|
KOKKOS_LDFLAGS += -mmic
|
|
endif
|
|
|
|
# Figure out the architecture flag for Cuda.
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
KOKKOS_INTERNAL_USE_CUDA_ARCH=1
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
KOKKOS_INTERNAL_USE_CUDA_ARCH=1
|
|
endif
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA_ARCH), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-arch
|
|
else ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG=--cuda-gpu-arch
|
|
KOKKOS_CXXFLAGS += -x cuda
|
|
else
|
|
$(error Makefile.kokkos: CUDA is enabled but the compiler is neither NVCC nor Clang (got version string $(KOKKOS_CXX_VERSION)) )
|
|
endif
|
|
KOKKOS_INTERNAL_USE_CUDA_ARCH = 1
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-fopenmp-targets=nvptx64-nvidia-cuda -Xopenmp-target -march
|
|
endif
|
|
KOKKOS_INTERNAL_USE_CUDA_ARCH = 1
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA_ARCH), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER30), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER30")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_30
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER32), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER32")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_32
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER35), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER35")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_35
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER37), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_KEPLER37")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_37
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_MAXWELL")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_MAXWELL50")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_50
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_MAXWELL")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_MAXWELL52")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_52
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_MAXWELL")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_MAXWELL53")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_53
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL60), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_PASCAL")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_PASCAL60")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_60
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL61), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_PASCAL")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_PASCAL61")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_61
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA70), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_VOLTA")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_VOLTA70")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_70
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA72), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_VOLTA")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_VOLTA72")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_72
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_TURING75), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_TURING")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_TURING75")
|
|
KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_75
|
|
endif
|
|
|
|
ifneq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 0)
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
|
|
KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
|
|
endif
|
|
endif
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
|
|
KOKKOS_CXXFLAGS += --expt-extended-lambda
|
|
endif
|
|
endif
|
|
|
|
|
|
# Figure out the architecture flag for ROCm.
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
|
|
# Lets start with adding architecture defines
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA900), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_HIP 900")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_VEGA900")
|
|
KOKKOS_INTERNAL_HIP_ARCH_FLAG := --amdgpu-target=gfx900
|
|
endif
|
|
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA906), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_HIP 906")
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ARCH_VEGA906")
|
|
KOKKOS_INTERNAL_HIP_ARCH_FLAG := --amdgpu-target=gfx906
|
|
endif
|
|
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/HIP/*.cpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/HIP/*.hpp)
|
|
|
|
KOKKOS_CXXFLAGS+=$(KOKKOS_INTERNAL_HIP_ARCH_FLAG)
|
|
KOKKOS_LDFLAGS+=$(KOKKOS_INTERNAL_HIP_ARCH_FLAG)
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_HIP_USE_RELOC), 1)
|
|
tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE")
|
|
KOKKOS_CXXFLAGS+=-fgpu-rdc
|
|
KOKKOS_LDFLAGS+=-fgpu-rdc
|
|
else
|
|
KOKKOS_CXXFLAGS+=-fno-gpu-rdc
|
|
KOKKOS_LDFLAGS+=-fno-gpu-rdc
|
|
endif
|
|
endif
|
|
|
|
|
|
KOKKOS_INTERNAL_LS_CONFIG := $(shell ls KokkosCore_config.h 2>&1)
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_LS_CONFIG), KokkosCore_config.h)
|
|
KOKKOS_INTERNAL_NEW_CONFIG := $(strip $(shell diff KokkosCore_config.h KokkosCore_config.tmp | grep define | wc -l))
|
|
else
|
|
KOKKOS_INTERNAL_NEW_CONFIG := 1
|
|
endif
|
|
|
|
ifneq ($(KOKKOS_INTERNAL_NEW_CONFIG), 0)
|
|
tmp := $(shell cp KokkosCore_config.tmp KokkosCore_config.h)
|
|
endif
|
|
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/*.hpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/impl/*.hpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/containers/src/*.hpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/containers/src/impl/*.hpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/algorithms/src/*.hpp)
|
|
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/impl/*.cpp)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/containers/src/impl/*.cpp)
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.cpp)
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_ETI_PATH)/Cuda/*.cpp)
|
|
endif
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.hpp)
|
|
ifneq ($(CUDA_PATH),)
|
|
KOKKOS_CPPLAGS += -I$(CUDA_PATH)/include
|
|
ifeq ($(call kokkos_path_exists,$(CUDA_PATH)/lib64), 1)
|
|
KOKKOS_LIBDIRS += -L$(CUDA_PATH)/lib64
|
|
KOKKOS_CXXLDFLAGS += -L$(CUDA_PATH)/lib64
|
|
KOKKOS_TPL_LIBRARY_DIRS += $(CUDA_PATH)/lib64
|
|
else ifeq ($(call kokkos_path_exists,$(CUDA_PATH)/lib), 1)
|
|
KOKKOS_LIBDIRS += -L$(CUDA_PATH)/lib
|
|
KOKKOS_CXXLDFLAGS += -L$(CUDA_PATH)/lib
|
|
KOKKOS_TPL_LIBRARY_DIRS += $(CUDA_PATH)/lib
|
|
else
|
|
$(error Can't find CUDA library directory: no lib64 or lib directory in $(CUDA_PATH))
|
|
endif
|
|
KOKKOS_TPL_INCLUDE_DIRS += $(CUDA_PATH)/include
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_CXXFLAGS += --cuda-path=$(CUDA_PATH)
|
|
endif
|
|
endif
|
|
KOKKOS_LIBS += -lcudart -lcuda
|
|
KOKKOS_TPL_LIBRARY_NAMES += cudart cuda
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/OpenMPTarget/*.cpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/OpenMPTarget/*.hpp)
|
|
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
|
|
KOKKOS_CXXFLAGS += -Xcompiler $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG)
|
|
else
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG)
|
|
endif
|
|
KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG)
|
|
KOKKOS_LIBS += $(KOKKOS_INTERNAL_OPENMPTARGET_LIB)
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/OpenMP/*.cpp)
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_ETI_PATH)/OpenMP/*.cpp)
|
|
endif
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/OpenMP/*.hpp)
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
|
|
KOKKOS_CXXFLAGS += -Xcompiler $(KOKKOS_INTERNAL_OPENMP_FLAG)
|
|
else
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_OPENMP_FLAG)
|
|
endif
|
|
|
|
KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_OPENMP_FLAG)
|
|
KOKKOS_LINK_FLAGS += $(KOKKOS_INTERNAL_OPENMP_FLAG)
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/Threads/*.cpp)
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_ETI_PATH)/Threads/*.cpp)
|
|
endif
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Threads/*.hpp)
|
|
KOKKOS_LIBS += -lpthread
|
|
KOKKOS_TPL_LIBRARY_NAMES += pthread
|
|
endif
|
|
|
|
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/HPX/*.cpp)
|
|
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/HPX/*.hpp)
|
|
ifneq ($(HPX_PATH),)
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
|
|
KOKKOS_CXXFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --cflags hpx_application_debug)
|
|
KOKKOS_CXXLDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
|
|
KOKKOS_LIBS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
|
|
else
|
|
KOKKOS_CXXFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --cflags hpx_application)
|
|
KOKKOS_CXXLDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
|
|
KOKKOS_LIBS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
|
|
endif
|
|
else
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
|
|
KOKKOS_CXXFLAGS += $(shell pkg-config --cflags hpx_application_debug)
|
|
KOKKOS_CXXLDFLAGS += $(shell pkg-config --libs hpx_application_debug)
|
|
KOKKOS_LIBS += $(shell pkg-config --libs hpx_application_debug)
|
|
else
|
|
KOKKOS_CXXFLAGS += $(shell pkg-config --cflags hpx_application)
|
|
KOKKOS_CXXLDFLAGS += $(shell pkg-config --libs hpx_application)
|
|
KOKKOS_LIBS += $(shell pkg-config --libs hpx_application)
|
|
endif
|
|
endif
|
|
KOKKOS_TPL_LIBRARY_NAMES += hpx
|
|
endif
|
|
|
|
# Explicitly set the GCC Toolchain for Clang.
|
|
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
|
|
KOKKOS_INTERNAL_GCC_PATH = $(shell which g++)
|
|
KOKKOS_INTERNAL_GCC_TOOLCHAIN = $(KOKKOS_INTERNAL_GCC_PATH:/bin/g++=)
|
|
KOKKOS_CXXFLAGS += --gcc-toolchain=$(KOKKOS_INTERNAL_GCC_TOOLCHAIN)
|
|
KOKKOS_LDFLAGS += --gcc-toolchain=$(KOKKOS_INTERNAL_GCC_TOOLCHAIN)
|
|
endif
|
|
|
|
# Don't include Kokkos_HBWSpace.cpp if not using MEMKIND to avoid a link warning.
|
|
ifneq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
|
|
KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_HBWSpace.cpp,$(KOKKOS_SRC))
|
|
endif
|
|
|
|
# Don't include Kokkos_Serial.cpp or Kokkos_Serial_Task.cpp if not using Serial
|
|
# device to avoid a link warning.
|
|
ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
|
|
ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
|
|
KOKKOS_SRC += $(wildcard $(KOKKOS_ETI_PATH)/Serial/*.cpp)
|
|
endif
|
|
endif
|
|
ifneq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
|
|
KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_Serial.cpp,$(KOKKOS_SRC))
|
|
KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_Serial_Task.cpp,$(KOKKOS_SRC))
|
|
endif
|
|
|
|
# With Cygwin functions such as fdopen and fileno are not defined
|
|
# when strict ansi is enabled. strict ansi gets enabled with --std=c++11
|
|
# though. So we hard undefine it here. Not sure if that has any bad side effects
|
|
# This is needed for gtest actually, not for Kokkos itself!
|
|
ifeq ($(KOKKOS_INTERNAL_OS_CYGWIN), 1)
|
|
KOKKOS_CXXFLAGS += -U__STRICT_ANSI__
|
|
endif
|
|
|
|
# Set KokkosExtraLibs and add -lkokkos to link line
|
|
KOKKOS_EXTRA_LIBS := ${KOKKOS_LIBS}
|
|
KOKKOS_LIBS := -lkokkos ${KOKKOS_LIBS}
|
|
|
|
# Setting up dependencies.
|
|
|
|
KokkosCore_config.h:
|
|
|
|
KOKKOS_CPP_DEPENDS := KokkosCore_config.h $(KOKKOS_HEADERS)
|
|
|
|
KOKKOS_OBJ = $(KOKKOS_SRC:.cpp=.o)
|
|
KOKKOS_OBJ_LINK = $(notdir $(KOKKOS_OBJ))
|
|
|
|
include $(KOKKOS_PATH)/Makefile.targets
|
|
|
|
kokkos-clean:
|
|
rm -f $(KOKKOS_OBJ_LINK) KokkosCore_config.h KokkosCore_config.tmp libkokkos.a
|
|
|
|
libkokkos.a: $(KOKKOS_OBJ_LINK) $(KOKKOS_SRC) $(KOKKOS_HEADERS)
|
|
ar cr libkokkos.a $(KOKKOS_OBJ_LINK)
|
|
ranlib libkokkos.a
|
|
|
|
print-cxx-flags:
|
|
echo "$(KOKKOS_CXXFLAGS)"
|
|
|
|
KOKKOS_LINK_DEPENDS=libkokkos.a
|
|
|
|
#we have carefully separated LDFLAGS from LIBS and LIBDIRS
|
|
#we have also separated CPPFLAGS from CXXFLAGS
|
|
#if this is not cmake, for backwards compatibility
|
|
#we just jam everything together into the CXXFLAGS and LDFLAGS
|
|
ifneq ($(KOKKOS_CMAKE), yes)
|
|
KOKKOS_CXXFLAGS += $(KOKKOS_CPPFLAGS)
|
|
KOKKOS_LDFLAGS += $(KOKKOS_LIBDIRS)
|
|
endif
|