HeCBench/CMakeLists.txt at master · ORNL/HeCBench · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
cmake_minimum_required(VERSION 3.21)

# Enable HIP language if requested
if(DEFINED HECBENCH_ENABLE_HIP AND HECBENCH_ENABLE_HIP)
    project(HeCBench
        LANGUAGES C CXX HIP
        VERSION 1.0.0
        DESCRIPTION "Heterogeneous Computing Benchmark Suite"
    )
else()
    project(HeCBench
        LANGUAGES C CXX
        VERSION 1.0.0
        DESCRIPTION "Heterogeneous Computing Benchmark Suite"
    )
endif()

# Set C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# 3rd party
find_package(Boost)
find_package(MPI)
find_package(GDAL CONFIG)
find_package(GSL)
find_package(BZip2)

# Build options - which programming models to enable
option(HECBENCH_ENABLE_CUDA "Enable CUDA benchmarks" ON)
option(HECBENCH_ENABLE_HIP "Enable HIP benchmarks" ON)
option(HECBENCH_ENABLE_SYCL "Enable SYCL benchmarks" ON)
option(HECBENCH_ENABLE_OPENMP "Enable OpenMP benchmarks" ON)

# Architecture options
set(HECBENCH_CUDA_ARCH "sm_80" CACHE STRING "CUDA architecture (e.g., sm_60, sm_70, sm_80, sm_90)")
set(HECBENCH_HIP_ARCH "gfx90a" CACHE STRING "HIP architecture (e.g., gfx908, gfx90a, gfx942)")

# Build configuration
option(HECBENCH_ENABLE_TESTING "Enable testing" ON)
option(HECBENCH_BUILD_ALL_BENCHMARKS "Build all benchmarks (vs selective)" ON)

# Add cmake module path
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")

# Find programming model compilers/libraries
if(HECBENCH_ENABLE_CUDA)
    enable_language(CUDA)
    find_package(CUDAToolkit REQUIRED)
    find_package(NCCL MODULE)
    message(STATUS "CUDA enabled - Architecture: ${HECBENCH_CUDA_ARCH}")
    set(CMAKE_CUDA_ARCHITECTURES ${HECBENCH_CUDA_ARCH})
endif()

if(HECBENCH_ENABLE_HIP)
    find_package(HIP MODULE)
    if(HIP_FOUND)
        message(STATUS "HIP enabled - Architecture: ${HECBENCH_HIP_ARCH}")
    else()
        message(WARNING "HIP requested but not found - HIP benchmarks will be skipped")
        set(HECBENCH_ENABLE_HIP OFF)
    endif()
endif()

if(HECBENCH_ENABLE_SYCL)
    find_package(SYCL MODULE)
    if(SYCL_FOUND)
        message(STATUS "SYCL enabled - Compiler: ${SYCL_COMPILER}")
    else()
        message(WARNING "SYCL requested but not found - SYCL benchmarks will be skipped")
        set(HECBENCH_ENABLE_SYCL OFF)
    endif()
endif()

if(HECBENCH_ENABLE_OPENMP)
    find_package(OpenMP REQUIRED)
    if(OpenMP_CXX_FOUND)
        message(STATUS "OpenMP enabled")
    else()
        message(WARNING "OpenMP requested but not found - OpenMP benchmarks will be skipped")
        set(HECBENCH_ENABLE_OPENMP OFF)
    endif()
endif()

# Include benchmark macros
include(BenchmarkMacros)

# Enable testing if requested
if(HECBENCH_ENABLE_TESTING)
    enable_testing()
    include(CTest)
    find_package(Python3 REQUIRED COMPONENTS Interpreter)
    message(STATUS "CTest enabled - use 'ctest' to run benchmarks")
    message(STATUS "Python3 for tests: ${Python3_EXECUTABLE}")
endif()

# Add src directory with all benchmarks
add_subdirectory(src)

# Summary
message(STATUS "")
message(STATUS "=== HeCBench Build Configuration ===")
message(STATUS "CUDA:    ${HECBENCH_ENABLE_CUDA}")
if(HECBENCH_ENABLE_CUDA)
    message(STATUS "  Architecture: ${HECBENCH_CUDA_ARCH}")
endif()
message(STATUS "HIP:     ${HECBENCH_ENABLE_HIP}")
if(HECBENCH_ENABLE_HIP)
    message(STATUS "  Architecture: ${HECBENCH_HIP_ARCH}")
endif()
message(STATUS "SYCL:    ${HECBENCH_ENABLE_SYCL}")
message(STATUS "OpenMP:  ${HECBENCH_ENABLE_OPENMP}")
message(STATUS "Testing: ${HECBENCH_ENABLE_TESTING}")
message(STATUS "====================================")
message(STATUS "")