2023-01-21 05:32:57 +08:00
# Copyright (c) 2017 - 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2022-04-24 03:02:38 +08:00
# SPDX-License-Identifier: BSD-3-Clause
2018-05-17 02:44:56 +08:00
#
2022-04-24 03:02:38 +08:00
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
2018-05-17 02:44:56 +08:00
#
2022-04-24 03:02:38 +08:00
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2018-05-17 02:44:56 +08:00
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2023-01-24 09:55:28 +08:00
cmake_minimum_required ( VERSION 3.18 FATAL_ERROR )
2018-05-17 02:44:56 +08:00
2019-11-20 08:55:34 +08:00
if ( cutlass_LOADED )
# If CUTLASS has been previously fetched and loaded, don't do it again.
return ( )
else ( )
set ( cutlass_LOADED ON )
set ( CUTLASS_DIR ${ CMAKE_CURRENT_SOURCE_DIR } CACHE PATH "CUTLASS Repository Directory" )
endif ( )
message ( STATUS "CMake Version: ${CMAKE_VERSION}" )
2023-01-21 05:32:57 +08:00
set ( IMPLICIT_CMAKE_CXX_STANDARD OFF CACHE BOOL "Do not explicitly specify -std=c++11 if set" )
2019-11-20 08:55:34 +08:00
2023-01-24 09:55:28 +08:00
project ( CUTLASS VERSION 3.0.0 LANGUAGES CXX )
2019-11-20 08:55:34 +08:00
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /CUDA.cmake )
2018-05-17 02:44:56 +08:00
2023-01-24 09:55:28 +08:00
if ( CUDA_VERSION VERSION_LESS 11.3 )
message ( WARNING "CUTLASS ${CUTLASS_VERSION} requires CUDA 11.4 or higher, and strongly recommends CUDA 11.8 or higher." )
elseif ( CUDA_VERSION VERSION_LESS 11.4 )
message ( WARNING "CUTLASS ${CUTLASS_VERSION} support for CUDA ${CUDA_VERSION} is deprecated, please use CUDA 11.8 or higher." )
endif ( )
if ( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.5 )
message ( FATAL_ERROR "GCC version must be at least 7.5!" )
endif ( )
if ( CUDA_COMPILER MATCHES "[Cc]lang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0 )
message ( FATAL_ERROR "Clang 7.0+ required for GPU compilation" )
2021-07-23 12:40:53 +08:00
endif ( )
2019-11-20 08:55:34 +08:00
find_package ( Doxygen QUIET )
#
2023-01-24 09:55:28 +08:00
# CUTLASS 3.x requires C++17
2019-11-20 08:55:34 +08:00
#
2023-01-24 09:55:28 +08:00
set ( CMAKE_CXX_STANDARD 17 )
set ( CMAKE_CXX_STANDARD_REQUIRED ON )
set ( CMAKE_CXX_EXTENSIONS OFF )
2019-11-20 08:55:34 +08:00
if ( CUTLASS_NATIVE_CUDA )
2023-01-24 09:55:28 +08:00
set ( CMAKE_CUDA_STANDARD 17 )
2019-11-20 08:55:34 +08:00
set ( CMAKE_CUDA_STANDARD_REQUIRED ON )
2023-01-24 09:55:28 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS --expt-relaxed-constexpr )
2018-05-17 02:44:56 +08:00
else ( )
2023-01-24 09:55:28 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS --std=c++17 )
2019-11-20 08:55:34 +08:00
endif ( )
2023-01-24 09:55:28 +08:00
2019-11-20 08:55:34 +08:00
if ( CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT )
set ( CMAKE_INSTALL_PREFIX install CACHE PATH "Default installation location." FORCE )
2018-05-17 02:44:56 +08:00
endif ( )
2019-11-20 08:55:34 +08:00
message ( STATUS "Default Install Location: ${CMAKE_INSTALL_PREFIX}" )
2018-05-17 02:44:56 +08:00
2020-04-08 04:51:25 +08:00
set ( CUTLASS_ENABLE_HEADERS_ONLY OFF CACHE BOOL "Enable only the header library" )
if ( CUTLASS_ENABLE_HEADERS_ONLY )
set ( CUTLASS_ENABLE_EXAMPLES_INIT OFF )
2021-12-22 01:10:26 +08:00
set ( CUTLASS_ENABLE_TOOLS_INIT ON )
set ( CUTLASS_ENABLE_LIBRARY_INIT OFF )
2019-11-20 08:55:34 +08:00
else ( )
2020-04-08 04:51:25 +08:00
set ( CUTLASS_ENABLE_EXAMPLES_INIT ON )
set ( CUTLASS_ENABLE_TOOLS_INIT ON )
2021-12-22 01:10:26 +08:00
set ( CUTLASS_ENABLE_LIBRARY_INIT ON )
2019-11-20 08:55:34 +08:00
endif ( )
2019-05-03 01:40:05 +08:00
2021-02-26 22:58:26 +08:00
set ( CUTLASS_TEST_UNIT_ENABLE_WARNINGS OFF CACHE BOOL "Enable warnings on waived unit tests." )
2020-04-08 04:51:25 +08:00
set ( CUTLASS_ENABLE_EXAMPLES ${ CUTLASS_ENABLE_EXAMPLES_INIT } CACHE BOOL "Enable CUTLASS Examples" )
set ( CUTLASS_ENABLE_TOOLS ${ CUTLASS_ENABLE_TOOLS_INIT } CACHE BOOL "Enable CUTLASS Tools" )
2021-12-22 01:10:26 +08:00
set ( CUTLASS_ENABLE_LIBRARY ${ CUTLASS_ENABLE_LIBRARY_INIT } CACHE BOOL "Enable CUTLASS Library" )
set ( CUTLASS_ENABLE_PROFILER ${ CUTLASS_ENABLE_LIBRARY } CACHE BOOL "Enable CUTLASS Profiler" )
2022-11-19 22:02:15 +08:00
set ( CUTLASS_ENABLE_PERFORMANCE ${ CUTLASS_ENABLE_PROFILER } CACHE BOOL "Enable CUTLASS Proformance" )
2020-04-08 04:51:25 +08:00
if ( ${ CMAKE_PROJECT_NAME } STREQUAL ${ PROJECT_NAME } )
2022-04-24 03:02:38 +08:00
set ( CUTLASS_ENABLE_TESTS_INIT ${ CUTLASS_ENABLE_LIBRARY } } )
2020-04-08 04:51:25 +08:00
else ( )
set ( CUTLASS_ENABLE_TESTS_INIT OFF )
endif ( )
set ( CUTLASS_ENABLE_TESTS ${ CUTLASS_ENABLE_TESTS_INIT } CACHE BOOL "Enable CUTLASS Tests" )
2019-11-20 08:55:34 +08:00
if ( CUTLASS_ENABLE_TESTS )
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /cmake/googletest.cmake )
endif ( )
set ( CUTLASS_NVCC_ARCHS_SUPPORTED "" )
2023-01-24 09:55:28 +08:00
if ( CUDA_VERSION VERSION_GREATER_EQUAL 11.4 AND NOT CUDA_COMPILER MATCHES "[Cc]lang" )
list ( APPEND CUTLASS_NVCC_ARCHS_SUPPORTED 70 72 75 80 86 87 )
2019-11-20 08:55:34 +08:00
endif ( )
2023-01-24 09:55:28 +08:00
if ( CUDA_VERSION VERSION_GREATER_EQUAL 11.8 AND NOT CUDA_COMPILER MATCHES "[Cc]lang" )
list ( APPEND CUTLASS_NVCC_ARCHS_SUPPORTED 89 90 )
2019-05-03 01:40:05 +08:00
endif ( )
2023-01-24 09:55:28 +08:00
if ( CUDA_VERSION VERSION_GREATER_EQUAL 12.0 AND NOT CUDA_COMPILER MATCHES "[Cc]lang" )
list ( APPEND CUTLASS_NVCC_ARCHS_SUPPORTED 90a )
2022-11-19 22:02:15 +08:00
endif ( )
2019-11-20 08:55:34 +08:00
set ( CUTLASS_NVCC_ARCHS ${ CUTLASS_NVCC_ARCHS_SUPPORTED } CACHE STRING "The SM architectures requested." )
set ( CUTLASS_NVCC_ARCHS_ENABLED ${ CUTLASS_NVCC_ARCHS } CACHE STRING "The SM architectures to build code for." )
# Special policy introduced in CMake 3.13
if ( POLICY CMP0076 )
cmake_policy ( SET CMP0076 NEW )
2020-04-08 04:51:25 +08:00
endif ( )
2019-11-20 08:55:34 +08:00
include ( GNUInstallDirs )
2018-05-17 02:44:56 +08:00
2020-04-08 04:51:25 +08:00
link_directories ( ${ CUDA_TOOLKIT_ROOT_DIR } /lib64/stubs )
2018-09-19 07:58:03 +08:00
###################################################################################################
#
# Configure CMake variables
#
###################################################################################################
2019-11-20 08:55:34 +08:00
message ( STATUS "CUDA Compilation Architectures: ${CUTLASS_NVCC_ARCHS_ENABLED}" )
2018-09-19 07:58:03 +08:00
2018-05-17 02:44:56 +08:00
if ( NOT ( CMAKE_BUILD_TYPE OR CONFIGURATION_TYPES ) )
2020-04-08 04:51:25 +08:00
# By default we want to build in Release mode to ensure that we're getting best performance.
2018-05-17 02:44:56 +08:00
set ( CMAKE_BUILD_TYPE Release CACHE STRING "Choose build level" FORCE )
2018-09-19 07:58:03 +08:00
set_property ( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "RelWithDebInfo" "Release" )
2018-05-17 02:44:56 +08:00
endif ( )
2020-04-08 04:51:25 +08:00
set ( CMAKE_POSITION_INDEPENDENT_CODE ON )
2020-11-20 13:25:25 +08:00
if ( DEFINED CMAKE_DEBUG_POSTFIX )
set ( CUTLASS_LIBRARY_DEBUG_POSTFIX_INIT ${ CMAKE_DEBUG_POSTFIX } )
else ( )
set ( CUTLASS_LIBRARY_DEBUG_POSTFIX_INIT .debug )
endif ( )
set ( CUTLASS_LIBRARY_DEBUG_POSTFIX ${ CUTLASS_LIBRARY_DEBUG_POSTFIX_INIT } CACHE STRING "Default postfix value for debug libraries" )
2020-04-08 04:51:25 +08:00
2018-05-17 02:44:56 +08:00
if ( WIN32 )
# On Windows we link against the shared (DLL) runtime. Change gtest settings to match this.
set ( gtest_force_shared_crt ON CACHE BOOL "Use shared (DLL) run-time lib even when Google Test is built as static lib" FORCE )
endif ( )
if ( WIN32 )
2019-03-21 01:49:17 +08:00
# Enable more warnings and treat as errors
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -Xcompiler=/W3 -Xcompiler=/WX )
2018-05-17 02:44:56 +08:00
2019-03-21 01:49:17 +08:00
# Disable warning on Unicode characters
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -Xcompiler=/wd4819 )
2018-05-17 02:44:56 +08:00
2019-03-21 01:49:17 +08:00
# Disable excess x86 floating point precision that can lead to results being labeled incorrectly
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -Xcompiler=/fp:strict )
2018-05-17 02:44:56 +08:00
endif ( WIN32 )
2019-11-20 08:55:34 +08:00
if ( ${ CUTLASS_NVCC_VERBOSE } )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -v )
2019-03-21 01:49:17 +08:00
endif ( )
2021-09-04 01:26:15 +08:00
#
# CUTLASS NAMESPACE
#
set ( CUTLASS_NAMESPACE "cutlass" CACHE STRING "Top level namespace of CUTLASS" )
2018-09-19 07:58:03 +08:00
set ( CUTLASS_NVCC_EMBED_CUBIN ON CACHE BOOL "Embed compiled CUDA kernel binaries into executables." )
set ( CUTLASS_NVCC_EMBED_PTX ON CACHE BOOL "Embed compiled PTX into executables." )
set ( CUTLASS_NVCC_KEEP OFF CACHE BOOL "Keep intermediate files generated by NVCC." )
2020-06-09 07:17:35 +08:00
set ( CUTLASS_ENABLE_F16C OFF CACHE BOOL "Enable F16C x86 extensions in host code." )
2020-04-08 04:51:25 +08:00
#
# CUTLASS generator cmake configuration
#
set ( CUTLASS_LIBRARY_OPERATIONS "all" CACHE STRING "Comma delimited list of operation name filters. Default '' means all operations are enabled." )
set ( CUTLASS_LIBRARY_KERNELS "" CACHE STRING "Comma delimited list of kernel name filters. If unspecified, only the largest tile size is enabled. If 'all' is specified, all kernels are enabled." )
2020-09-24 05:00:58 +08:00
set ( CUTLASS_LIBRARY_IGNORE_KERNELS "" CACHE STRING "Comma delimited list of kernel names to exclude from build." )
2020-04-08 04:51:25 +08:00
2019-11-20 08:55:34 +08:00
# Test Levels L0, L1, L2
set ( CUTLASS_TEST_LEVEL "0" CACHE STRING "Level of tests to compile." )
2021-09-21 02:02:22 +08:00
set ( CUTLASS_TEST_ENABLE_CACHED_RESULTS ON CACHE BOOL "Enable caching and reuse of test results in unit tests" )
2019-11-20 08:55:34 +08:00
set_property ( CACHE CUTLASS_TEST_LEVEL PROPERTY STRINGS 0 1 2 )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -DCUTLASS_TEST_LEVEL= ${ CUTLASS_TEST_LEVEL } )
2020-09-24 05:00:58 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -DCUTLASS_TEST_LEVEL= ${ CUTLASS_TEST_LEVEL } )
2018-09-19 07:58:03 +08:00
2021-09-21 02:02:22 +08:00
if ( CUTLASS_TEST_ENABLE_CACHED_RESULTS )
2021-12-18 05:04:43 +08:00
message ( STATUS "Enable caching of reference results in conv unit tests" )
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -DCUTLASS_TEST_ENABLE_CACHED_RESULTS=1 )
2021-09-21 02:02:22 +08:00
endif ( )
2021-12-18 05:04:43 +08:00
set ( CUTLASS_CONV_UNIT_TEST_RIGOROUS_SIZE_ENABLED ON CACHE BOOL "Enable/Disable rigorous conv problem sizes in conv unit tests" )
if ( CUTLASS_CONV_UNIT_TEST_RIGOROUS_SIZE_ENABLED )
message ( STATUS "Enable rigorous conv problem sizes in conv unit tests" )
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -DCUTLASS_CONV_UNIT_TEST_RIGOROUS_SIZE_ENABLED=1 )
endif ( )
2019-11-20 08:55:34 +08:00
#
2019-03-21 01:49:17 +08:00
# CUDA 10.1 introduces "mma" in PTX performing collective matrix multiply operations.
2019-11-20 08:55:34 +08:00
#
2019-03-21 01:49:17 +08:00
if ( CUDA_VERSION VERSION_LESS 10.1 )
set ( CUTLASS_ENABLE_TENSOR_CORE_MMA_DEFAULT OFF )
else ( )
set ( CUTLASS_ENABLE_TENSOR_CORE_MMA_DEFAULT ON )
endif ( )
2020-09-24 05:00:58 +08:00
# Trace levels for debugging
set ( CUTLASS_DEBUG_TRACE_LEVEL "0" CACHE STRING "Level of debug tracing to perform." )
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -DCUTLASS_DEBUG_TRACE_LEVEL= ${ CUTLASS_DEBUG_TRACE_LEVEL } )
2020-04-08 04:51:25 +08:00
set ( CUTLASS_ENABLE_TENSOR_CORE_MMA ${ CUTLASS_ENABLE_TENSOR_CORE_MMA_DEFAULT } CACHE BOOL
2019-03-21 01:49:17 +08:00
" E n a b l e P T X m m a i n s t r u c t i o n f o r c o l l e c t i v e m a t r i x m u l t i p l y o p e r a t i o n s . " )
2018-09-19 07:58:03 +08:00
#
# NOTE: running with asan and CUDA requires the following environment variable:
#
# ASAN_OPTIONS=protect_shadow_gap=0:replace_intrin=0:detect_leaks=0
#
# without the above environment setting, an error like the following may be generated:
#
# *** Error: Could not detect active GPU device ID [out of memory]
# ...
# ==9149==ERROR: LeakSanitizer: detected memory leaks
# ...
#
if ( ENABLE_ASAN ) # https://github.com/google/sanitizers/wiki/AddressSanitizer
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS --compiler-options=-fsanitize=address --compiler-options=-fno-omit-frame-pointer )
2018-09-19 07:58:03 +08:00
string ( APPEND CMAKE_EXE_LINKER_FLAGS " -fsanitize=address" )
endif ( )
2018-05-17 02:44:56 +08:00
2018-09-19 07:58:03 +08:00
###################################################################################################
#
# Configure CUDA build options
#
###################################################################################################
2019-05-03 01:40:05 +08:00
if ( CUTLASS_NVCC_EMBED_PTX )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS --cuda-include-ptx=all )
2019-05-03 01:40:05 +08:00
endif ( )
2019-03-21 01:49:17 +08:00
if ( CUTLASS_ENABLE_TENSOR_CORE_MMA )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_FLAGS -DCUTLASS_ENABLE_TENSOR_CORE_MMA=1 )
2019-03-21 01:49:17 +08:00
endif ( )
2023-01-24 09:55:28 +08:00
2019-11-20 08:55:34 +08:00
if ( NOT MSVC AND CUTLASS_NVCC_KEEP )
# MSVC flow handles caching already, but for other generators we handle it here.
set ( CUTLASS_NVCC_KEEP_DIR ${ CMAKE_CURRENT_BINARY_DIR } /tmp CACHE PATH "Location to store NVCC scratch files" )
file ( MAKE_DIRECTORY ${ CUTLASS_NVCC_KEEP_DIR } )
2021-09-21 02:02:22 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS --keep -v ) # --keep-dir may not work with nvcc for some directories.
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -save-temps= ${ CUTLASS_NVCC_KEEP_DIR } )
2019-03-21 01:49:17 +08:00
endif ( )
2020-04-08 04:51:25 +08:00
if ( CUTLASS_ENABLE_F16C AND NOT CMAKE_CROSSCOMPILING )
list ( APPEND CUTLASS_CUDA_FLAGS -DCUTLASS_ENABLE_F16C=1 )
2019-11-20 08:55:34 +08:00
if ( ( CMAKE_CXX_COMPILER_ID MATCHES "GNU" ) OR ( CMAKE_CXX_COMPILER_ID MATCHES "Clang" ) )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -Xcompiler=-mf16c )
2019-11-20 08:55:34 +08:00
elseif ( ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" ) )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -Xcompiler=/arch:AVX2 )
2019-11-20 08:55:34 +08:00
endif ( )
2019-03-21 01:49:17 +08:00
endif ( )
2023-01-24 09:55:28 +08:00
if ( CUTLASS_ENABLE_OPENMP_TESTS )
find_package ( OpenMP )
if ( OpenMP_CXX_FOUND )
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -Xcompiler= ${ OpenMP_CXX_FLAGS } )
else ( )
message ( WARNING "CUTLASS_ENABLE_OPENMP_TESTS set but OpenMP not found." )
endif ( )
endif ( )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS $< $<BOOL:${UNIX} > :-Xcompiler=-Wconversion> )
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS $< $<BOOL:${UNIX} > :-Xcompiler=-fno-strict-aliasing> )
2018-05-17 02:44:56 +08:00
2020-04-08 04:51:25 +08:00
# Don't leak lineinfo in release builds
if ( NOT CMAKE_BUILD_TYPE MATCHES "Release" )
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -gmlt )
list ( APPEND CUTLASS_CUDA_NVCC_FLAGS -lineinfo )
2018-10-27 05:38:46 +08:00
endif ( )
2021-02-26 22:58:26 +08:00
#Report CUDA build flags
if ( CUDA_COMPILER MATCHES "[Cc]lang" )
if ( CUTLASS_CUDA_CLANG_FLAGS )
message ( STATUS "Using CLANG flags: ${CUTLASS_CUDA_CLANG_FLAGS}" )
endif ( )
else ( )
if ( CUTLASS_CUDA_NVCC_FLAGS )
message ( STATUS "Using NVCC flags: ${CUTLASS_CUDA_NVCC_FLAGS}" )
endif ( )
endif ( )
2019-11-20 08:55:34 +08:00
if ( CUDA_COMPILER MATCHES "[Cc]lang" )
2020-04-08 04:51:25 +08:00
if ( NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
message ( FATAL_ERROR "Clang CUDA compilation requires Clang CXX compilation. Currently CMAKE_CXX_COMPILER is ${CMAKE_CXX_COMPILER_ID}" )
endif ( )
2021-07-23 12:40:53 +08:00
# There are numerous Clang versions that can work with each CUDA toolkit and the
# the checks are not very useful so we are turning them off and using testing to
# ensure the various combinations work properly.
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS --cuda-path= ${ CUDA_TOOLKIT_ROOT_DIR } )
2021-07-23 12:40:53 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -D__NV_NO_HOST_COMPILER_CHECK=1 )
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -Wno-unknown-cuda-version )
2020-06-09 07:17:35 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -mllvm -pragma-unroll-threshold=100000 )
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -mllvm -unroll-threshold=5000 )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -Wno-unused-command-line-argument )
2018-05-17 02:44:56 +08:00
2019-11-21 01:52:11 +08:00
string ( REPLACE "." ";" CUDA_VERSION_PARTS ${ CMAKE_CUDA_COMPILER_VERSION } )
list ( GET CUDA_VERSION_PARTS 0 CUDA_VERSION_MAJOR )
list ( GET CUDA_VERSION_PARTS 1 CUDA_VERSION_MINOR )
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -D__CUDACC_VER_MAJOR__= ${ CUDA_VERSION_MAJOR } -D__CUDACC_VER_MINOR__= ${ CUDA_VERSION_MINOR } )
2019-11-21 01:52:11 +08:00
2019-11-20 08:55:34 +08:00
# needed for libcublasLt.so in case it's installed in the same location as libcudart.so
# dynamic linker can find it if linker sets RPATH (forced by --disable-new-tags)
# Otherwise linker uses RUNPATH and that does not propagate to loaded libs.
2020-04-08 04:51:25 +08:00
list ( APPEND CUTLASS_CUDA_CLANG_FLAGS -Wl,--disable-new-dtags )
2018-05-17 02:44:56 +08:00
2019-11-20 08:55:34 +08:00
link_libraries ( nvidia::cudart )
2023-01-24 09:55:28 +08:00
link_libraries ( nvidia::cuda_driver )
2019-11-20 08:55:34 +08:00
endif ( )
2022-04-27 22:02:26 +08:00
# Support for 128-bit integers if using NVIDIA C++ compiler
if ( ${ CMAKE_CXX_COMPILER_ID } MATCHES "PGI" OR ${ CMAKE_CXX_COMPILER_ID } MATCHES "NVHPC" )
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Mint128 " )
endif ( )
2021-07-23 12:40:53 +08:00
if ( CMAKE_VERSION VERSION_GREATER_EQUAL 3.18 )
# CMake 3.18 added support for CUDA_ARCHITECTURES target property. We will use this
# property for CMake 3.18+, so we request the NEW behavior for correct compatibility.
# https://cmake.org/cmake/help/v3.18/policy/CMP0104.html#policy:CMP0104
cmake_policy ( SET CMP0104 NEW )
endif ( )
2020-04-08 04:51:25 +08:00
function ( cutlass_apply_cuda_gencode_flags TARGET )
2023-01-21 05:32:57 +08:00
set ( options )
set ( oneValueArgs )
set ( multiValueArgs SM_ARCHS )
cmake_parse_arguments ( _ "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
if ( __SM_ARCHS )
set ( ARCHS_ENABLED ${ __SM_ARCHS } )
else ( )
set ( ARCHS_ENABLED ${ CUTLASS_NVCC_ARCHS_ENABLED } )
endif ( )
2020-04-08 04:51:25 +08:00
set ( NVCC_FLAGS )
set ( CLANG_FLAGS )
2021-07-23 12:40:53 +08:00
set ( __CMAKE_CUDA_ARCHS )
2023-01-21 05:32:57 +08:00
foreach ( ARCH ${ ARCHS_ENABLED } )
2020-06-09 07:17:35 +08:00
list ( APPEND CLANG_FLAGS --cuda-gpu-arch=sm_ ${ ARCH } )
2020-04-08 04:51:25 +08:00
set ( CODES )
if ( CUTLASS_NVCC_EMBED_CUBIN )
list ( APPEND CODES sm_ ${ ARCH } )
2021-07-23 12:40:53 +08:00
list ( APPEND __CMAKE_CUDA_ARCHS ${ ARCH } -real )
2020-04-08 04:51:25 +08:00
endif ( )
if ( CUTLASS_NVCC_EMBED_PTX )
list ( APPEND CODES compute_ ${ ARCH } )
2021-07-23 12:40:53 +08:00
list ( APPEND __CMAKE_CUDA_ARCHS ${ ARCH } -virtual )
2020-04-08 04:51:25 +08:00
endif ( )
list ( JOIN CODES "," CODES_STR )
list ( APPEND NVCC_FLAGS -gencode=arch=compute_ ${ ARCH } ,code=[ ${ CODES_STR } ] )
endforeach ( )
2023-01-21 05:32:57 +08:00
if ( NOT __SM_ARCHS )
if ( CUDA_COMPILER MATCHES "[Cc]lang" )
target_compile_options (
$ { T A R G E T }
P R I V A T E
$ < $ < C O M P I L E _ L A N G U A G E : C X X > : $ { C L A N G _ F L A G S } >
)
elseif ( CMAKE_VERSION GREATER_EQUAL 3.18 )
set_property ( TARGET ${ TARGET } PROPERTY CUDA_ARCHITECTURES ${ __CMAKE_CUDA_ARCHS } )
else ( )
target_compile_options (
$ { T A R G E T }
P R I V A T E
$ < $ < C O M P I L E _ L A N G U A G E : C U D A > : $ { N V C C _ F L A G S } >
)
endif ( )
2020-04-08 04:51:25 +08:00
else ( )
2023-01-21 05:32:57 +08:00
list ( JOIN CLANG_FLAGS " " CLANG_FLAGS_STR )
list ( JOIN NVCC_FLAGS " " STR_NVCC_FLAGS )
if ( CUDA_COMPILER MATCHES "[Cc]lang" )
if ( ${ TARGET } MATCHES ".*\.cpp" )
set_source_files_properties ( ${ TARGET } PROPERTIES COMPILE_FLAGS ${ CLANG_FLAGS_STR } )
endif ( )
elseif ( CMAKE_VERSION GREATER_EQUAL 3.18 )
set_source_files_properties ( ${ TARGET } PROPERTIES CUDA_ARCHITECTURES ${ STR_NVCC_FLAGS } )
else ( )
if ( ${ TARGET } MATCHES ".*\.cu" )
set_source_files_properties ( ${ TARGET } PROPERTIES COMPILE_FLAGS ${ STR_NVCC_FLAGS } )
endif ( )
endif ( )
2020-04-08 04:51:25 +08:00
endif ( )
endfunction ( )
2021-02-26 22:58:26 +08:00
# Cache the flags so they are available when the function below is called anywhere globally.
set ( __CUTLASS_CUDA_FLAGS ${ CUTLASS_CUDA_FLAGS } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_FLAGS_RELEASE ${ CUTLASS_CUDA_FLAGS_RELEASE } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_FLAGS_RELWITHDEBINFO ${ CUTLASS_CUDA_FLAGS_RELWITHDEBINFO } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_FLAGS_DEBUG ${ CUTLASS_CUDA_FLAGS_DEBUG } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_CLANG_FLAGS ${ CUTLASS_CUDA_CLANG_FLAGS } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_CLANG_FLAGS_RELEASE ${ CUTLASS_CUDA_CLANG_FLAGS_RELEASE } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_CLANG_FLAGS_RELWITHDEBINFO ${ CUTLASS_CUDA_CLANG_FLAGS_RELWITHDEBINFO } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_CLANG_FLAGS_DEBUG ${ CUTLASS_CUDA_CLANG_FLAGS_DEBUG } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_NVCC_FLAGS ${ CUTLASS_CUDA_NVCC_FLAGS } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_NVCC_FLAGS_RELEASE ${ CUTLASS_CUDA_NVCC_FLAGS_RELEASE } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_NVCC_FLAGS_RELWITHDEBINFO ${ CUTLASS_CUDA_NVCC_FLAGS_RELWITHDEBINFO } CACHE INTERNAL "" )
set ( __CUTLASS_CUDA_NVCC_FLAGS_DEBUG ${ CUTLASS_CUDA_NVCC_FLAGS_DEBUG } CACHE INTERNAL "" )
2020-04-08 04:51:25 +08:00
function ( cutlass_apply_standard_compile_options TARGET )
if ( CUDA_COMPILER MATCHES "[Cc]lang" )
set ( CUDA_COMPILE_LANGUAGE CXX )
2021-02-26 22:58:26 +08:00
set ( _FLAGS ${ __CUTLASS_CUDA_FLAGS } ${ __CUTLASS_CUDA_CLANG_FLAGS } )
set ( _FLAGS_RELEASE ${ __CUTLASS_CUDA_FLAGS_RELEASE } ${ __CUTLASS_CUDA_CLANG_FLAGS_RELEASE } )
set ( _FLAGS_RELWITHDEBINFO ${ __CUTLASS_CUDA_FLAGS_RELWITHDEBINFO } ${ __CUTLASS_CUDA_CLANG_FLAGS_RELWITHDEBINFO } )
set ( _FLAGS_DEBUG ${ __CUTLASS_CUDA_FLAGS_DEBUG } ${ __CUTLASS_CUDA_CLANG_FLAGS_DEBUG } )
2020-04-08 04:51:25 +08:00
else ( )
set ( CUDA_COMPILE_LANGUAGE CUDA )
2021-02-26 22:58:26 +08:00
set ( _FLAGS ${ __CUTLASS_CUDA_FLAGS } ${ __CUTLASS_CUDA_NVCC_FLAGS } )
set ( _FLAGS_RELEASE ${ __CUTLASS_CUDA_FLAGS_RELEASE } ${ __CUTLASS_CUDA_NVCC_FLAGS_RELEASE } )
set ( _FLAGS_RELWITHDEBINFO ${ __CUTLASS_CUDA_FLAGS_RELWITHDEBINFO } ${ __CUTLASS_CUDA_NVCC_FLAGS_RELWITHDEBINFO } )
set ( _FLAGS_DEBUG ${ __CUTLASS_CUDA_FLAGS_DEBUG } ${ __CUTLASS_CUDA_NVCC_FLAGS_DEBUG } )
2020-04-08 04:51:25 +08:00
endif ( )
2021-09-04 01:26:15 +08:00
target_link_libraries ( ${ TARGET } PRIVATE CUTLASS )
2020-04-08 04:51:25 +08:00
target_compile_options (
$ { T A R G E T }
P R I V A T E
$ < $ < C O M P I L E _ L A N G U A G E : $ { C U D A _ C O M P I L E _ L A N G U A G E } > : $ { _ F L A G S } >
$ < $ < C O M P I L E _ L A N G U A G E : $ { C U D A _ C O M P I L E _ L A N G U A G E } > : $ < $ < C O N F I G : R E L E A S E > : $ { _ F L A G S _ R E L E A S E } > >
$ < $ < C O M P I L E _ L A N G U A G E : $ { C U D A _ C O M P I L E _ L A N G U A G E } > : $ < $ < C O N F I G : R E L W I T H D E B I N F O > : $ { _ F L A G S _ R E L W I T H D E B I N F O } > >
$ < $ < C O M P I L E _ L A N G U A G E : $ { C U D A _ C O M P I L E _ L A N G U A G E } > : $ < $ < C O N F I G : D E B U G > : $ { _ F L A G S _ D E B U G } > >
)
endfunction ( )
2018-05-17 02:44:56 +08:00
#
# The following items should eventually be pushed into cutlass/CMakeLists.txt
#
# GLOB for CUTLASS header files. Should we use a static list instead?
2019-11-20 08:55:34 +08:00
file ( GLOB_RECURSE CUTLASS_INCLUDE RELATIVE ${ CMAKE_CURRENT_SOURCE_DIR } include/cutlass/*.h )
file ( GLOB_RECURSE CUTLASS_CUTLASS RELATIVE ${ CMAKE_CURRENT_SOURCE_DIR } /include include/cutlass/*.h )
file ( GLOB_RECURSE CUTLASS_NVRTC RELATIVE ${ CMAKE_CURRENT_SOURCE_DIR } /test test/unit/nvrtc/kernel/*.h )
2018-10-27 05:38:46 +08:00
2018-09-19 07:58:03 +08:00
###################################################################################################
#
# Define build targets
#
###################################################################################################
2018-05-17 02:44:56 +08:00
2019-11-20 08:55:34 +08:00
source_group ( TREE ${ CMAKE_CURRENT_SOURCE_DIR } /include REGULAR_EXPRESSION ".*\.h" )
2018-05-17 02:44:56 +08:00
add_library ( CUTLASS INTERFACE )
2019-11-20 08:55:34 +08:00
add_library ( nvidia::cutlass::cutlass ALIAS CUTLASS )
set_target_properties ( CUTLASS PROPERTIES EXPORT_NAME cutlass )
set ( CUTLASS_INCLUDE_DIR ${ CMAKE_CURRENT_SOURCE_DIR } /include CACHE PATH "CUTLASS Header Library" )
2020-09-24 05:00:58 +08:00
set ( CUTLASS_GENERATOR_DIR ${ CMAKE_CURRENT_SOURCE_DIR } /tools/library CACHE INTERNAL "Location of generator scripts" )
2019-11-20 08:55:34 +08:00
# The following utility directory is needed even if the tools build is disabled, so it exists here.
set ( CUTLASS_TOOLS_UTIL_INCLUDE_DIR ${ CMAKE_CURRENT_SOURCE_DIR } /tools/util/include CACHE INTERNAL "" )
include_directories ( ${ CUTLASS_INCLUDE_DIR } )
target_compile_features ( CUTLASS INTERFACE cxx_std_11 )
2023-01-21 05:32:57 +08:00
if ( NOT CUTLASS_NAMESPACE STREQUAL "cutlass" )
target_compile_definitions ( CUTLASS INTERFACE CUTLASS_NAMESPACE= ${ CUTLASS_NAMESPACE } )
endif ( )
2019-11-20 08:55:34 +08:00
if ( NOT DEFINED CUTLASS_REVISION )
find_package ( Git QUIET )
execute_process (
C O M M A N D $ { G I T _ E X E C U T A B L E } r e v - p a r s e - - s h o r t H E A D
R E S U L T _ V A R I A B L E C U T L A S S _ R E V I S I O N _ R E S U L T
O U T P U T _ V A R I A B L E C U T L A S S _ R E V I S I O N
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E
)
if ( CUTLASS_REVISION_RESULT )
message ( STATUS "CUTLASS Revision: Unable to detect, Git returned code ${CUTLASS_REVISION_RESULT}." )
else ( )
message ( STATUS "CUTLASS Revision: ${CUTLASS_REVISION}" )
endif ( )
2019-03-21 01:49:17 +08:00
endif ( )
2019-11-20 08:55:34 +08:00
configure_file (
2020-04-08 04:51:25 +08:00
$ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / c m a k e / v e r s i o n . h . i n
$ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / i n c l u d e / c u t l a s s / v e r s i o n . h
2019-11-20 08:55:34 +08:00
@ O N L Y )
target_include_directories (
C U T L A S S
I N T E R F A C E
$ < I N S T A L L _ I N T E R F A C E : i n c l u d e >
$ < B U I L D _ I N T E R F A C E : $ { C U T L A S S _ I N C L U D E _ D I R } >
$ < B U I L D _ I N T E R F A C E : $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / i n c l u d e >
$ < B U I L D _ I N T E R F A C E : $ { C U D A _ T O O L K I T _ R O O T _ D I R } / i n c l u d e >
2023-01-24 09:55:28 +08:00
$ < B U I L D _ I N T E R F A C E : $ { c u t e _ S O U R C E _ D I R } / i n c l u d e >
$ < B U I L D _ I N T E R F A C E : $ { c u t e _ S O U R C E _ D I R } / e x a m p l e s >
2019-11-20 08:55:34 +08:00
)
install (
2020-04-08 04:51:25 +08:00
D I R E C T O R Y
$ { C U T L A S S _ I N C L U D E _ D I R } /
2019-11-20 08:55:34 +08:00
$ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / i n c l u d e /
D E S T I N A T I O N $ { C M A K E _ I N S T A L L _ I N C L U D E D I R }
)
install (
T A R G E T S C U T L A S S
E X P O R T N v i d i a C u t l a s s
P U B L I C _ H E A D E R D E S T I N A T I O N $ { C M A K E _ I N S T A L L _ I N C L U D E D I R }
)
################################################################################
2018-05-17 02:44:56 +08:00
# Doxygen is available. Generate documentation
if ( DOXYGEN_FOUND )
# DOT is available. Enable graph generation in the documentation
if ( DOXYGEN_DOT_EXECUTABLE )
2018-09-19 07:58:03 +08:00
set ( CUTLASS_ENABLE_DOXYGEN_DOT ON CACHE BOOL "Use dot to generate graphs in the doxygen documentation." )
2018-05-17 02:44:56 +08:00
else ( )
2018-09-19 07:58:03 +08:00
set ( CUTLASS_ENABLE_DOXYGEN_DOT OFF CACHE BOOL "Use dot to generate graphs in the doxygen documentation." FORCE )
2018-05-17 02:44:56 +08:00
endif ( )
if ( CUTLASS_ENABLE_DOXYGEN_DOT )
set ( HAVE_DOT "YES" )
else ( )
set ( HAVE_DOT "NO" )
endif ( )
# Add custom target for Doxygen.
add_custom_target ( cutlass_docs ${ CMAKE_COMMAND } -E env
" D O T _ P A T H = $ { D O X Y G E N _ D O T _ E X E C U T A B L E } "
" H A V E _ D O T = $ { H A V E _ D O T } "
$ { D O X Y G E N _ E X E C U T A B L E } $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / D o x y f i l e
W O R K I N G _ D I R E C T O R Y $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R }
V E R B A T I M
)
endif ( )
2019-11-20 08:55:34 +08:00
if ( NOT WIN32 )
# Add common library search paths so executables and libraries can load and run
# without LD_LIBRARY_PATH being set.
link_libraries (
" - W l , - r p a t h , ' $ O R I G I N ' "
" - W l , - r p a t h , ' $ O R I G I N / . . / l i b 6 4 ' "
" - W l , - r p a t h , ' $ O R I G I N / . . / l i b ' "
" - W l , - r p a t h , ' $ { C U D A _ T O O L K I T _ R O O T _ D I R } / l i b 6 4 ' "
" - W l , - r p a t h , ' $ { C U D A _ T O O L K I T _ R O O T _ D I R } / l i b ' "
)
endif ( )
################################################################################
2020-11-20 13:25:25 +08:00
include ( CTest )
enable_testing ( )
if ( NOT TARGET test_all )
add_custom_target ( test_all )
endif ( )
set ( CUTLASS_INSTALL_TESTS ON CACHE BOOL "Install test executables" )
set ( CUTLASS_TEST_EXECUTION_ENVIRONMENT "" CACHE BOOL "Environment in which to invoke unit test executables" )
set ( CMAKE_TEST_INSTALL_PREFIX test CACHE STRING "Test root install location, relative to CMAKE_INSTALL_PREFIX." )
set ( CUTLASS_TEST_INSTALL_PREFIX ${ CMAKE_TEST_INSTALL_PREFIX } /cutlass CACHE STRING "Test root install location, relative to CMAKE_INSTALL_PREFIX." )
set ( CUTLASS_TEST_INSTALL_BINDIR ${ CUTLASS_TEST_INSTALL_PREFIX } / ${ CMAKE_INSTALL_BINDIR } CACHE STRING "Test root install location, relative to CMAKE_INSTALL_PREFIX." )
set ( CUTLASS_TEST_INSTALL_LIBDIR ${ CUTLASS_TEST_INSTALL_PREFIX } / ${ CMAKE_INSTALL_LIBDIR } CACHE STRING "Test root install location, relative to CMAKE_INSTALL_PREFIX." )
install ( DIRECTORY DESTINATION ${ CUTLASS_TEST_INSTALL_PREFIX } )
install ( DIRECTORY DESTINATION ${ CUTLASS_TEST_INSTALL_BINDIR } )
install ( DIRECTORY DESTINATION ${ CUTLASS_TEST_INSTALL_LIBDIR } )
install ( DIRECTORY DESTINATION ${ CUTLASS_TEST_INSTALL_PREFIX } /ctest )
2021-02-26 22:58:26 +08:00
################################################################################
2022-11-19 22:02:15 +08:00
set ( CUTLASS_ENABLE_CUBLAS OFF CACHE BOOL "cuBLAS usage for tests" )
set ( CUTLASS_ENABLE_CUDNN OFF CACHE BOOL "cuDNN usage for tests" )
2021-02-26 22:58:26 +08:00
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /cuBLAS.cmake )
if ( CUTLASS_ENABLE_CUBLAS )
target_compile_definitions ( CUTLASS INTERFACE CUTLASS_ENABLE_CUBLAS=1 )
endif ( )
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /cuDNN.cmake )
if ( CUTLASS_ENABLE_CUDNN )
target_compile_definitions ( CUTLASS INTERFACE CUTLASS_ENABLE_CUDNN=1 )
endif ( )
################################################################################
2020-11-20 13:25:25 +08:00
set ( CUTLASS_CTEST_TEMPLATE_FILE ${ CMAKE_CURRENT_LIST_DIR } /cmake/CTestTestfile.config.cmake )
set ( CUTLASS_CTEST_GENERATED_FILES "" CACHE INTERNAL "" )
function ( cutlass_add_executable_tests NAME TARGET )
#
# Generates test rules for `make test`, `make test_all`, and `ctest` invoked from either the
# <CMAKE_BINARY_DIR> or the <CMAKE_INSTALL_PREFIX>/<CUTLASS_TEST_INSTALL_PREFIX> after installation.
#
# NAME: The base name for the test. Can be run with `make <NAME>` or `ctest -R 'c<NAME>'`.
# TARGET: The target corresponding to the executable under test.
# DISABLE_EXECUTABLE_INSTALL_RULE: An option, if given, that disables creating an install rule for TARGET.
# DEPENDS: A list of targets or files on which this test is dependent.
# DEPENDEES: A list of targets which should depend on this test.
# TEST_COMMAND_OPTIONS: A list of variables (i.e. by reference params) which contain command line arguments
# to pass to the test executable. A unique test with suffix _0, _1, ... is generated for each set of
# options given. If this option is not used, a single test with no arguments is generated.
2021-09-21 02:02:22 +08:00
# RESULT_CACHE_FILE: A file to be installed alongside the test executable with pre-computed
# test results to speed up test runtime.
2020-11-20 13:25:25 +08:00
#
set ( options DISABLE_EXECUTABLE_INSTALL_RULE )
2021-09-21 02:02:22 +08:00
set ( oneValueArgs DISABLE_TESTS RESULT_CACHE_FILE )
2020-11-20 13:25:25 +08:00
set ( multiValueArgs DEPENDS DEPENDEES TEST_COMMAND_OPTIONS )
cmake_parse_arguments ( _ "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
2021-07-23 12:40:53 +08:00
if ( NOT DEFINED __DISABLE_TESTS )
set ( __DISABLE_TESTS OFF )
endif ( )
2021-09-21 02:02:22 +08:00
if ( __RESULT_CACHE_FILE )
add_custom_command (
T A R G E T $ { T A R G E T }
P O S T _ B U I L D
C O M M A N D $ { C M A K E _ C O M M A N D }
A R G S - E c o p y $ { _ _ R E S U L T _ C A C H E _ F I L E } " $ < T A R G E T _ F I L E _ D I R : $ { T A R G E T } > "
)
endif ( )
2020-11-20 13:25:25 +08:00
if ( NOT __DISABLE_EXECUTABLE_INSTALL_RULE AND CUTLASS_INSTALL_TESTS )
# file(RELATIVE_PATH CMAKE_CURRENT_BINARY_RELATIVE_DIR ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
install (
T A R G E T S $ { T A R G E T }
R U N T I M E D E S T I N A T I O N $ { C U T L A S S _ T E S T _ I N S T A L L _ B I N D I R }
)
2021-09-21 02:02:22 +08:00
if ( __RESULT_CACHE_FILE )
install (
F I L E S $ { _ _ R E S U L T _ C A C H E _ F I L E }
D E S T I N A T I O N $ { C U T L A S S _ T E S T _ I N S T A L L _ B I N D I R } /
)
endif ( )
2020-11-20 13:25:25 +08:00
endif ( )
if ( NOT __TEST_COMMAND_OPTIONS )
set ( __TEST_COMMAND_OPTIONS " " )
endif ( )
list ( LENGTH __TEST_COMMAND_OPTIONS CMD_COUNT )
set ( CMD_IDX 0 )
if ( CMD_COUNT GREATER 1 )
add_custom_target ( ${ NAME } DEPENDS ${ TARGET } ${ __DEPENDS } )
foreach ( DEPENDEE ${ __DEPENDEES } )
add_dependencies ( ${ DEPENDEE } ${ NAME } )
endforeach ( )
endif ( )
foreach ( CMD_OPTIONS ${ __TEST_COMMAND_OPTIONS } )
if ( CMD_COUNT GREATER 1 )
set ( TEST_NAME ${ NAME } _ ${ CMD_IDX } )
else ( )
set ( TEST_NAME ${ NAME } )
endif ( )
# The following rigmarole is needed to deal with spaces and possible quotes in
# command line arguments. The options are passed "by reference" as the actual
# variable names holding the real options. We then expand these in a way that
# preserves any quotes. Note, they have to be in this order for it to work for
# all the use cases below.
set ( CMD_OPTIONS ${ ${CMD_OPTIONS } } )
list ( JOIN CMD_OPTIONS " " TEST_COMMAND_OPTIONS )
separate_arguments ( CMD_OPTIONS )
add_custom_target (
$ { T E S T _ N A M E }
C O M M A N D
$ { C U T L A S S _ T E S T _ E X E C U T I O N _ E N V I R O N M E N T } $ < T A R G E T _ F I L E : $ { T A R G E T } > $ { C M D _ O P T I O N S }
D E P E N D S
$ { T A R G E T }
)
if ( CMD_COUNT GREATER 1 )
add_dependencies ( ${ NAME } ${ TEST_NAME } )
endif ( )
foreach ( DEPENDEE ${ __DEPENDEES } )
add_dependencies ( ${ DEPENDEE } ${ TEST_NAME } )
endforeach ( )
add_test (
N A M E c $ { T E S T _ N A M E }
C O M M A N D $ { C U T L A S S _ T E S T _ E X E C U T I O N _ E N V I R O N M E N T } $ < T A R G E T _ F I L E : $ { T A R G E T } > $ { C M D _ O P T I O N S }
)
2021-07-23 12:40:53 +08:00
set_tests_properties ( c ${ TEST_NAME } PROPERTIES DISABLED ${ __DISABLE_TESTS } )
2020-11-20 13:25:25 +08:00
if ( CUTLASS_INSTALL_TESTS )
# To run the tests from an install package with tests enabled, we need to generate test files
# that don't rely on the current directory structure in build.
set ( TEST_NAME c ${ TEST_NAME } )
set ( TEST_EXE $< TARGET_FILE_NAME:${TARGET} > )
set ( TEST_EXE_WORKING_DIRECTORY ./ ${ CMAKE_INSTALL_BINDIR } )
configure_file ( "${CUTLASS_CTEST_TEMPLATE_FILE}" "${CMAKE_PROJECT_DIR}${CMAKE_CURRENT_BINARY_DIR}/CTestTestfile.${TEST_NAME}.config.cmake" @ONLY )
file ( GENERATE
O U T P U T " $ { C M A K E _ P R O J E C T _ D I R } $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / C T e s t T e s t f i l e . $ { T E S T _ N A M E } . c m a k e "
I N P U T " $ { C M A K E _ P R O J E C T _ D I R } $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / C T e s t T e s t f i l e . $ { T E S T _ N A M E } . c o n f i g . c m a k e "
)
install (
F I L E S " $ { C M A K E _ P R O J E C T _ D I R } $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / C T e s t T e s t f i l e . $ { T E S T _ N A M E } . c m a k e "
D E S T I N A T I O N $ { C U T L A S S _ T E S T _ I N S T A L L _ P R E F I X } / c t e s t /
)
set ( CUTLASS_CTEST_GENERATED_FILES ${ CUTLASS_CTEST_GENERATED_FILES } ;ctest/CTestTestfile. ${ TEST_NAME } .cmake CACHE INTERNAL "" )
endif ( )
math ( EXPR CMD_IDX "${CMD_IDX} + 1" )
endforeach ( )
endfunction ( )
if ( CUTLASS_ENABLE_TOOLS )
2019-11-20 08:55:34 +08:00
add_subdirectory ( tools )
2020-11-20 13:25:25 +08:00
if ( CUTLASS_ENABLE_PROFILER )
add_dependencies ( test_all test_profiler )
2022-11-19 22:02:15 +08:00
endif ( )
2019-11-20 08:55:34 +08:00
endif ( )
2020-11-20 13:25:25 +08:00
if ( CUTLASS_ENABLE_EXAMPLES )
2019-11-20 08:55:34 +08:00
add_subdirectory ( examples )
2020-11-20 13:25:25 +08:00
add_dependencies ( test_all test_examples )
2019-11-20 08:55:34 +08:00
endif ( )
2020-11-20 13:25:25 +08:00
if ( CUTLASS_ENABLE_TESTS )
2019-11-20 08:55:34 +08:00
add_subdirectory ( test )
2020-11-20 13:25:25 +08:00
add_dependencies ( test_all test_unit )
endif ( )
if ( CUTLASS_INSTALL_TESTS )
file ( MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/cmake" )
file ( WRITE "${CMAKE_BINARY_DIR}/cmake/CTestTestfile.cmake" "# Generated File\n" )
foreach ( GENERATED_FILE ${ CUTLASS_CTEST_GENERATED_FILES } )
file ( APPEND "${CMAKE_BINARY_DIR}/cmake/CTestTestfile.cmake" "include(${GENERATED_FILE})\n" )
endforeach ( )
install (
F I L E S " $ { C M A K E _ B I N A R Y _ D I R } / c m a k e / C T e s t T e s t f i l e . c m a k e "
2022-04-24 03:02:38 +08:00
D E S T I N A T I O N " $ { C U T L A S S _ T E S T _ I N S T A L L _ P R E F I X } / "
2020-11-20 13:25:25 +08:00
)
2019-11-20 08:55:34 +08:00
endif ( )
2020-11-20 13:25:25 +08:00
#? install(
#? FILES ${CMAKE_BINARY_DIR}/CTestTestfile.cmake
#? DESTINATION ${CUTLASS_TEST_INSTALL_PREFIX}/
#? )
#?
#? install(
#? DIRECTORY
#? ${CMAKE_BINARY_DIR}/tools
#? ${CMAKE_BINARY_DIR}/test
#? DESTINATION ${CUTLASS_TEST_INSTALL_PREFIX}/
#? FILES_MATCHING PATTERN "CTestTestfile.cmake"
#? )
2019-11-20 08:55:34 +08:00
################################################################################
2023-01-21 05:32:57 +08:00
include ( CMakePackageConfigHelpers )
write_basic_package_version_file (
$ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / N v i d i a C u t l a s s C o n f i g V e r s i o n . c m a k e
C O M P A T I B I L I T Y A n y N e w e r V e r s i o n )
2019-11-20 08:55:34 +08:00
install (
2023-01-21 05:32:57 +08:00
F I L E S
$ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / c m a k e / N v i d i a C u t l a s s C o n f i g . c m a k e
$ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / N v i d i a C u t l a s s C o n f i g V e r s i o n . c m a k e
D E S T I N A T I O N $ { C M A K E _ I N S T A L L _ L I B D I R } / c m a k e / N v i d i a C u t l a s s /
2019-11-20 08:55:34 +08:00
)
install (
E X P O R T N v i d i a C u t l a s s
N A M E S P A C E n v i d i a : : c u t l a s s : :
2023-01-21 05:32:57 +08:00
D E S T I N A T I O N $ { C M A K E _ I N S T A L L _ L I B D I R } / c m a k e / N v i d i a C u t l a s s /
2019-11-20 08:55:34 +08:00
F I L E N v i d i a C u t l a s s T a r g e t s . c m a k e
)
################################################################################
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /cmake/NvidiaCutlassPackageConfig.cmake )
