std::inclusive_scan support detection, abstraction and basic testing

Author: ptheywood

cmake/checkcxx/inclusive_scan.cmake

@@ -0,0 +1,33 @@
+# only run this once
+include_guard(GLOBAL)
+
+# CMake function to check if std::inclusive_scan is supported or not by the current CXX compiler
+function(check_inclusive_scan)
+
+    # Ensure c++ is enabled and supported
+    include(CheckLanguage)
+    check_language(CXX)
+
+    # If this has already been checked for the current CMakeCache, don't rerun.
+    if(DEFINED EXATEPP_ABM_check_inclusive_scan_RESULT)
+        return()
+    endif()
+
+    # Try and compile the sample in c++17
+    try_compile(
+        HAS_STD_INCLUSIVE_SCAN
+        "${CMAKE_CURRENT_BINARY_DIR}/try_compile/"
+        "${CMAKE_CURRENT_LIST_DIR}/inclusive_scan.cpp"
+        CXX_STANDARD 17
+        CXX_STANDARD_REQUIRED "ON"
+    )
+
+    # If notsupported, mark store this in the parent cache
+    if (NOT HAS_STD_INCLUSIVE_SCAN) 
+        set(EXATEPP_ABM_check_inclusive_scan_RESULT "NO" PARENT_SCOPE)
+        return()
+    endif()
+    set(EXATEPP_ABM_check_inclusive_scan_RESULT "YES" PARENT_SCOPE)
+endfunction()
+
+check_inclusive_scan()

cmake/checkcxx/inclusive_scan.cpp

@@ -0,0 +1,9 @@
+// Test if std::inclusive_scan is supported or not by the current compiler c++ stdlib.
+#include <numeric>
+#include <vector>
+
+int main(int argc, char * argv[]) {
+    std::vector<float> vec = {{0.f, 1.f, 2.f, 3.f}};
+    std::inclusive_scan(vec.begin(), vec.end(), vec.begin());
+    return 0;
+}

src/CMakeLists.txt

@@ -70,6 +70,15 @@ if(CMAKE_VERSION VERSION_LESS "3.25.0")
     target_compile_options(${LIBRARY_NAME} PUBLIC "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:-Xcudafe --diag_suppress=128>")
 endif()
 
+# Check for std::inclusive_scan, and set a public definition as required
+include(${CMAKE_CURRENT_SOURCE_DIR}/../cmake/checkcxx/inclusive_scan.cmake)
+if (EXATEPP_ABM_check_inclusive_scan_RESULT)
+    target_compile_definitions(${LIBRARY_NAME} PUBLIC "-DEXATEPP_ABM_USE_STD_INCLUSIVE_SCAN=1")
+else()
+    target_compile_definitions(${LIBRARY_NAME} PUBLIC "-DEXATEPP_ABM_USE_STD_INCLUSIVE_SCAN=0")
+endif()
+
+
 # Enable host device constexpr?
 target_compile_options(${LIBRARY_NAME} PUBLIC "$<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>")
 

src/exateppabm/population.cu

@@ -12,6 +12,7 @@
 #include "exateppabm/disease.h"
 #include "exateppabm/person.h"
 #include "exateppabm/input.h"
+#include "exateppabm/util.h"
 
 namespace exateppabm {
 namespace population {
@@ -22,25 +23,6 @@ namespace {
 
 std::array<std::uint64_t, demographics::AGE_COUNT> infectedPerDemographic = {};
 
-
-/**
- * in-place inclusive scan, for libstdc++ which does not support c++17 (i.e. GCC 8)
- */
-template <typename T>
-void inplace_inclusive_scan(T& container) {
-    // @todo - use cmake to detect which path needs taking
-    // std::inclusive_scan(container.begin(), container.end(), container.begin());
-    // return;
-    // @todo - refactor this into a testable method, in a util namespace?
-    if (container.size() <= 1) {
-        return;
-    }
-    // Naive in-place inclusive scan for libstc++8
-    for (size_t i = 1; i < container.size(); ++i) {
-        container[i] = container[i - 1] + container[i];
-    }
-}
-
 }  // namespace
 
 std::unique_ptr<flamegpu::AgentVector> generate(flamegpu::ModelDescription& model, const exateppabm::input::config config, const bool verbose, const float env_width, const float interactionRadius) {
@@ -85,7 +67,7 @@ std::unique_ptr<flamegpu::AgentVector> generate(flamegpu::ModelDescription& mode
     }};
     // Perform an inclusive scan to convert to cumulative probability
     // Using a local method which supports inclusive scans in old libstc++
-    inplace_inclusive_scan(demographicProbabilties);
+    exateppabm::util::inplace_inclusive_scan(demographicProbabilties);
     // std::inclusive_scan(demographicProbabilties.begin(), demographicProbabilties.end(), demographicProbabilties.begin());
     std::array<demographics::Age, demographics::AGE_COUNT> allDemographics = {{
         demographics::Age::AGE_0_9,

src/exateppabm/util.h

@@ -2,6 +2,7 @@
 
 #include <cstdint>
 #include <string>
+#include <numeric>
 
 namespace exateppabm {
 namespace util {
@@ -54,5 +55,42 @@ bool getSeatbeltsEnabled();
  */
 std::string getCMakeBuildType();
 
+
+/**
+ * Perform an inclusive scan on an interable (i.e. std::array<float>), without using std::inclusive_scan which although part of c++17 is not available in some older stdlib implementations (i.e. gcc 8). 
+ */
+
+/**
+ * In-place inclusive scan, for libstdc++ which does not support c++17 (i.e. GCC 8)
+ * 
+ * equivalent to std::inclusive_scan(container.begin(), container.end(), container.begin());
+ * 
+ * @param container iterable container / something with size() and operator[]
+ */
+template <typename T>
+void naive_inplace_inclusive_scan(T& container) {
+    if (container.size() <= 1) {
+        return;
+    }
+    // Naive in-place inclusive scan for libstc++8
+    for (size_t i = 1; i < container.size(); ++i) {
+        container[i] = container[i - 1] + container[i];
+    }
+}
+
+/**
+ * In-place inclusive scan, using std::inclusive_scan if possible, else a naive implementation.
+ * 
+ * equivalent to std::inclusive_scan(container.begin(), container.end(), container.begin());
+ */
+template <typename T>
+void inplace_inclusive_scan(T& container) {
+#if defined(EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN) && EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN
+    std::inclusive_scan(container.begin(), container.end(), container.begin());
+#else
+    naive_inplace_inclusive_scan(container);
+#endif  // defined(EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN) && EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN
+}
+
 }  // namespace util
 }  // namespace exateppabm

tests/CMakeLists.txt

@@ -32,7 +32,7 @@ include(${FLAMEGPU_ROOT}/cmake/common.cmake)
 # List test source files
 set(TESTS_SRC
     ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cu
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/temp.cu
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/exateppabm/test_util.cu
 )
 
 # Define output location of binary files

tests/src/exateppabm/test_util.cu

@@ -0,0 +1,163 @@
+#include <array>
+#include <numeric>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+#include "fmt/core.h"
+#include "exateppabm/util.h"
+
+/**
+ * Test the naive inplace inclusive_scan implementation for an array of integers
+ */
+TEST(TestUtil, naive_inplace_inclusive_scan_array_int) {
+    constexpr std::uint32_t ELEMENTS = 4;
+    std::array<int, ELEMENTS> inout = {{1, 2, 3, 4}};
+    const std::array<int, ELEMENTS> expected = {{1, 3, 6, 10}};
+
+    exateppabm::util::naive_inplace_inclusive_scan(inout);
+
+    for (std::uint32_t e = 0; e < inout.size(); e++) {
+        EXPECT_EQ(inout[e], expected[e]);
+    }
+}
+
+/**
+ * Test the naive inplace inclusive_scan implementation for a vector of unsigned integers
+ */
+TEST(TestUtil, naive_inplace_inclusive_scan_vec_uint) {
+    std::vector<std::uint32_t> inout = {{1, 2, 3, 4}};
+    const std::vector<std::uint32_t> expected = {{1, 3, 6, 10}};
+
+    exateppabm::util::naive_inplace_inclusive_scan(inout);
+
+    for (std::uint32_t e = 0; e < inout.size(); e++) {
+        EXPECT_EQ(inout[e], expected[e]);
+    }
+}
+
+/**
+ * Test the naive inplace inclusive_scan implementation for a vector of floats, using an arbitrary epsilon value which is good enough for the input values
+ */
+TEST(TestUtil, naive_inplace_inclusive_scan_vec_double) {
+    std::vector<float> inout = {{1.1, 2.2, 3.3, 4.4}};
+    const std::vector<float> expected = {{1.1, 3.3, 6.6, 11.0}};
+
+    exateppabm::util::naive_inplace_inclusive_scan(inout);
+
+    constexpr float EPSILON = 1.0e-6f;
+
+    for (float e = 0; e < inout.size(); e++) {
+        EXPECT_NEAR(inout[e], expected[e], EPSILON);
+    }
+}
+
+/**
+ * Test the naive or std inplace inclusive_scan implementation for an array of integers
+ */
+TEST(TestUtil, inplace_inclusive_scan_array_int) {
+    constexpr std::uint32_t ELEMENTS = 4;
+    std::array<int, ELEMENTS> inout = {{1, 2, 3, 4}};
+    const std::array<int, ELEMENTS> expected = {{1, 3, 6, 10}};
+
+    exateppabm::util::inplace_inclusive_scan(inout);
+
+    for (std::uint32_t e = 0; e < inout.size(); e++) {
+        EXPECT_EQ(inout[e], expected[e]);
+    }
+}
+
+/**
+ * Test the naive or std inplace inclusive_scan implementation for a vector of unsigned integers
+ */
+TEST(TestUtil, inplace_inclusive_scan_vec_uint) {
+    std::vector<std::uint32_t> inout = {{1, 2, 3, 4}};
+    const std::vector<std::uint32_t> expected = {{1, 3, 6, 10}};
+
+    exateppabm::util::inplace_inclusive_scan(inout);
+
+    for (std::uint32_t e = 0; e < inout.size(); e++) {
+        EXPECT_EQ(inout[e], expected[e]);
+    }
+}
+
+/**
+ * Test the naive or std inplace inclusive_scan implementation for a vector of floats, using an arbitrary epsilon value which is good enough for the input values
+ */
+TEST(TestUtil, inplace_inclusive_scan_vec_double) {
+    std::vector<float> inout = {{1.1, 2.2, 3.3, 4.4}};
+    const std::vector<float> expected = {{1.1, 3.3, 6.6, 11.0}};
+
+    exateppabm::util::inplace_inclusive_scan(inout);
+
+    constexpr float EPSILON = 1.0e-6f;
+
+    for (float e = 0; e < inout.size(); e++) {
+        EXPECT_NEAR(inout[e], expected[e], EPSILON);
+    }
+}
+
+
+/**
+ * Test the std inplace inclusive_scan implementation for an array of integers
+ This is just to check the test case behaves too
+ */
+#if defined(EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN) && EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN
+TEST(TestUtil, std_inclusive_scan_array_int) {
+    constexpr std::uint32_t ELEMENTS = 4;
+    std::array<int, ELEMENTS> inout = {{1, 2, 3, 4}};
+    const std::array<int, ELEMENTS> expected = {{1, 3, 6, 10}};
+
+    std::inclusive_scan(inout.begin(), inout.end(), inout.begin());
+
+    for (std::uint32_t e = 0; e < inout.size(); e++) {
+        EXPECT_EQ(inout[e], expected[e]);
+    }
+}
+#else
+TEST(TestUtil, DISABLED_std_inclusive_scan_array_int) {
+}
+#endif
+
+
+/**
+ * Test the std inplace inclusive_scan implementation for a vector of unsigned integers.
+ * This is just to check the test case behaves too
+ */
+#if defined(EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN) && EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN
+TEST(TestUtil, std_inclusive_scan_vec_uint) {
+    std::vector<std::uint32_t> inout = {{1, 2, 3, 4}};
+    const std::vector<std::uint32_t> expected = {{1, 3, 6, 10}};
+
+    std::inclusive_scan(inout.begin(), inout.end(), inout.begin());
+
+    for (std::uint32_t e = 0; e < inout.size(); e++) {
+        EXPECT_EQ(inout[e], expected[e]);
+    }
+}
+#else
+TEST(TestUtil, DISABLED_std_inclusive_scan_vec_uint) {
+}
+#endif
+
+/**
+ * Test the std inplace inclusive_scan implementation for a vector of floats, using an arbitrary epsilon value which is good enough for the input values.
+ * This is just to check the test case behaves too
+ */
+#if defined(EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN) && EXATEPP_ABM_USE_STD_INCLUSIVE_SCAN
+TEST(TestUtil, std_inclusive_scan_vec_double) {
+    std::vector<float> inout = {{1.1, 2.2, 3.3, 4.4}};
+    const std::vector<float> expected = {{1.1, 3.3, 6.6, 11.0}};
+
+    std::inclusive_scan(inout.begin(), inout.end(), inout.begin());
+
+    constexpr float EPSILON = 1.0e-6f;
+
+    for (float e = 0; e < inout.size(); e++) {
+        EXPECT_NEAR(inout[e], expected[e], EPSILON);
+    }
+}
+#else
+TEST(TestUtil, DISABLED_std_inclusive_scan_vec_double) {
+}
+#endif

tests/src/main.cu

@@ -1,5 +1,5 @@
 #include <cstdio>
-// Include google test 
+// Include google test
 #include "gtest/gtest.h"
 // Include flame gpu telemetry header to prevent every test from triggering a telemetry API call.
 #include "flamegpu/io/Telemetry.h"