Import test for CUDA project

include/fmt/core.h

@@ -132,13 +132,21 @@
 #    endif
 #  endif
 #endif
+
 // Workaround broken [[deprecated]] in the Intel compiler.
 #ifdef __INTEL_COMPILER
 #  define FMT_DEPRECATED_ALIAS
 #else
 #  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
 #endif
 
+// Workaround broken [[deprecated]] for the NVCC (CUDA with C++14)
+#if defined(__NVCC__) || defined(__CUDACC__)
+#  define FMT_DEPRECATED_ALIAS
+#else
+#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
+#endif
+
 #ifndef FMT_BEGIN_NAMESPACE
 #  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
       FMT_MSC_VER >= 1900

test/CMakeLists.txt

@@ -225,3 +225,22 @@ if (FMT_PEDANTIC AND NOT WIN32)
     "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
     "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
 endif ()
+
+#
+# Activate CUDA related tests if we can find CUDA from CMake. This is optional.
+# For version selection, see https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
+#
+find_package(CUDA 9.0)
+if(CUDA_FOUND)
+  add_test(cuda-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/cuda-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/cuda-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+      "-DFMT_DIR=${PROJECT_BINARY_DIR}"
+      "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
+  )
+endif()

test/cuda-test/CMakeLists.txt

@@ -0,0 +1,112 @@
+
+#
+# We can find some usecases which follows the guide of CMake.
+# The way replaces 'find_package(CUDA)' to 'enable_language(CUDA)'.
+# And let the CMake built-in functions to use NVCC.
+#
+# See: https://cmake.org/cmake/help/latest/module/FindCUDA.html#replacement
+#
+# However, such CMake versions are pretty high (3.10 or later).
+# And we can't sure most of the CUDA projects are using those latest
+# because the latest C++ standard for NVCC is C++ 14 at this moment.
+#
+# In conclusion, 
+# this test should follow the version of the Root CMakeLists.txt 
+# and rely on 'find_package(CUDA)'. 
+#
+
+#
+# This part is for future update
+#
+# cmake_minimum_required(VERSION 3.10)
+# project(fmt-cuda-test LANGUAGES CXX CUDA) # see 'enable_language(CUDA)'
+#
+
+# Follow the Root CMakeLists.txt
+cmake_minimum_required(VERSION 3.1) 
+project(fmt-cuda-test LANGUAGES CXX)
+
+# See 'test/CMakeLists.txt'. It's using ${PROJECT_BINARY_DIR}
+find_package(FMT    REQUIRED) 
+
+# The environment variables (CUDA_BIN_PATH & CUDA_PATH) must be specified
+find_package(CUDA   REQUIRED)
+
+#
+# Update these when NVCC becomes ready for C++ 17 features
+# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
+#
+set(CMAKE_CUDA_STANDARD 14)
+set(CMAKE_CUDA_STANDARD_REQUIRED 14)
+
+list(APPEND CUDA_NVCC_FLAGS "-std=c++14")
+if(MSVC)
+    # this is the solution of pytorch
+    #   https://github.com/pytorch/pytorch/pull/7118
+    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/std:c++14")
+    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/Zc:__cplusplus")
+    # for the reason of this -Xcompiler options, see below ...
+endif()
+
+#
+# In this test, we will assume that 
+# the user is going to compile CUDA source codes with some libraries.
+# Of course, it's 'fmt' in this case.
+#
+# In addition to that, 
+# this test will invoke both C++ Host compiler and NVCC by providing 
+# another (non-CUDA) C++ source code
+#
+cuda_add_executable(fmt-in-cuda-test
+    cuda-cpp14.cu
+    cpp14.cc
+)
+
+#
+# https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html
+#
+set_target_properties(fmt-in-cuda-test
+PROPERTIES
+    CXX_STANDARD 14 # Notice this is for C++ code
+)
+target_compile_features(fmt-in-cuda-test
+PRIVATE
+    cxx_std_14 # just make sure of the property
+)
+
+get_target_property(cuda_standard 
+    fmt-in-cuda-test CUDA_STANDARD
+)
+message(STATUS "cuda_standard:          ${cuda_standard}")
+
+get_target_property(cuda_standard_required
+    fmt-in-cuda-test CUDA_STANDARD_REQUIRED
+)
+message(STATUS "cuda_standard_required: ${cuda_standard_required}")
+
+#
+# https://cmake.org/cmake/help/latest/module/FindCUDA.html
+#
+# From the document, you can see "The default is to use no keyword"
+#
+target_link_libraries(fmt-in-cuda-test
+# PUBLIC
+    fmt::fmt
+)
+
+if(MSVC)
+    #
+    # This part is for (non-CUDA) C++ code.
+    # MSVC can define incorrect '__cplusplus' macro. 
+    # Fix for the issue is to use additional compiler flag. 
+    #
+    # See Also:
+    # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
+    # https://github.com/Microsoft/vscode-cpptools/issues/2595
+    #
+    target_compile_options(fmt-in-cuda-test
+    PRIVATE
+        /Zc:__cplusplus
+        /permissive-
+    )
+endif()

test/cuda-test/cpp14.cc

@@ -0,0 +1,14 @@
+
+#include <fmt/core.h>
+
+//
+// The purpose of this part is to ensure NVCC's host compiler also supports
+// the standard version. See 'cuda-cpp14.cu'.
+//
+// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+//
+static_assert(__cplusplus >= 201402L, "expect C++ 2014 for host compiler");
+
+auto make_message_cpp() -> std::string {
+  return fmt::format("host compiler \t: __cplusplus == {}", __cplusplus);
+}

test/cuda-test/cuda-cpp14.cu

@@ -0,0 +1,49 @@
+
+//
+//  Direct NVCC command line example:
+//
+//  nvcc.exe ./cuda-cpp14.cu -x cu -I"../include" -l"fmtd" -L"../build/Debug"  \
+//          -std=c++14 -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus
+//
+
+//
+// Ensure that we are using the latest C++ standard for NVCC
+// The version is C++14
+//
+// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#c-cplusplus-language-support
+// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+//
+static_assert(__cplusplus >= 201402L, "expect C++ 2014 for nvcc");
+
+//
+// https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#nvcc-identification-macro
+//
+// __NVCC__ is for NVCC compiler
+// __CUDACC__ is for CUDA(.cu) source code
+//
+// Since we don't know the actual case in this header, checking both macro
+// will prevent possible pitfalls ...
+//
+// --- this check is moved into the <fmt/core.h> ---
+//
+// #if defined(__NVCC__) || defined(__CUDACC__)
+// #  define FMT_DEPRECATED // suppress [[deprecated]] attribute
+// #endif
+#include <fmt/core.h>
+
+#include <cuda.h>
+#include <iostream>
+
+using namespace std;
+
+extern auto make_message_cpp() -> std::string;
+extern auto make_message_cuda() -> std::string;
+
+int main(int, char*[]) {
+  cout << make_message_cuda() << endl;
+  cout << make_message_cpp() << endl;
+}
+
+auto make_message_cuda() -> std::string {
+  return fmt::format("nvcc compiler \t: __cplusplus == {}", __cplusplus);
+}