Windows benchmark compile fixes

benchmark/benchmark_utils.hpp

@@ -43,11 +43,12 @@
 
 namespace benchmark_utils
 {
+const size_t default_max_random_size = 1024 * 1024;
 
 // get_random_data() generates only part of sequence and replicates it,
 // because benchmarks usually do not need "true" random sequence.
 template<class T>
-inline auto get_random_data(size_t size, T min, T max, size_t max_random_size = 1024 * 1024)
+inline auto get_random_data(size_t size, T min, T max, size_t max_random_size = default_max_random_size)
     -> typename std::enable_if<std::is_integral<T>::value, std::vector<T>>::type
 {
     std::random_device rd;
@@ -66,7 +67,7 @@ inline auto get_random_data(size_t size, T min, T max, size_t max_random_size =
 }
 
 template<class T>
-inline auto get_random_data(size_t size, T min, T max, size_t max_random_size = 1024 * 1024)
+inline auto get_random_data(size_t size, T min, T max, size_t max_random_size = default_max_random_size)
     -> typename std::enable_if<std::is_floating_point<T>::value, std::vector<T>>::type
 {
     std::random_device rd;
@@ -84,8 +85,66 @@ inline auto get_random_data(size_t size, T min, T max, size_t max_random_size =
     return data;
 }
 
+#if defined(_WIN32) && defined(__clang__)
+// get_random_data() generates only part of sequence and replicates it,
+// because benchmarks usually do not need "true" random sequence.
+template<>
+inline std::vector<unsigned char> get_random_data(size_t size, unsigned char min, unsigned char max, size_t max_random_size)
+{
+    std::random_device rd;
+    std::default_random_engine gen(rd());
+    std::uniform_int_distribution<int> distribution(min, max);
+    std::vector<unsigned char> data(size);
+    std::generate(
+        data.begin(), data.begin() + std::min(size, max_random_size),
+        [&]() { return distribution(gen); }
+    );
+    for(size_t i = max_random_size; i < size; i += max_random_size)
+    {
+        std::copy_n(data.begin(), std::min(size - i, max_random_size), data.begin() + i);
+    }
+    return data;
+}
+
+template<>
+inline std::vector<signed char> get_random_data(size_t size, signed char min, signed char max, size_t max_random_size)
+{
+    std::random_device rd;
+    std::default_random_engine gen(rd());
+    std::uniform_int_distribution<int> distribution(min, max);
+    std::vector<signed char> data(size);
+    std::generate(
+        data.begin(), data.begin() + std::min(size, max_random_size),
+        [&]() { return distribution(gen); }
+    );
+    for(size_t i = max_random_size; i < size; i += max_random_size)
+    {
+        std::copy_n(data.begin(), std::min(size - i, max_random_size), data.begin() + i);
+    }
+    return data;
+}
+
+template<>
+inline std::vector<char> get_random_data(size_t size, char min, char max, size_t max_random_size)
+{
+    std::random_device rd;
+    std::default_random_engine gen(rd());
+    std::uniform_int_distribution<int> distribution(min, max);
+    std::vector<char> data(size);
+    std::generate(
+        data.begin(), data.begin() + std::min(size, max_random_size),
+        [&]() { return distribution(gen); }
+    );
+    for(size_t i = max_random_size; i < size; i += max_random_size)
+    {
+        std::copy_n(data.begin(), std::min(size - i, max_random_size), data.begin() + i);
+    }
+    return data;
+}
+#endif
+
 template<class T>
-inline std::vector<T> get_random_data01(size_t size, float p, size_t max_random_size = 1024 * 1024)
+inline std::vector<T> get_random_data01(size_t size, float p, size_t max_random_size = default_max_random_size)
 {
     std::random_device rd;
     std::default_random_engine gen(rd());

benchmark/cmdparser.hpp

@@ -185,6 +185,13 @@ namespace cli {
             return std::stoul(elements[0]);
         }
 
+        static unsigned long long parse(const std::vector<std::string>& elements, const unsigned long long&) {
+            if (elements.size() != 1)
+                throw std::bad_cast();
+
+            return std::stoull(elements[0]);
+        }
+
         static long parse(const std::vector<std::string>& elements, const long&) {
             if (elements.size() != 1)
                 throw std::bad_cast();

benchmark/common_benchmark_header.hpp

@@ -31,6 +31,7 @@
 #include <limits> 
 #include <cmath>
 #include <cstdlib>
+#include <numeric>
 
 // Google Benchmark
 #include "benchmark/benchmark.h"

cmake/Dependencies.cmake

@@ -155,27 +155,38 @@ endif()
 
 # Benchmark dependencies
 if(BUILD_BENCHMARK)
-  # Google Benchmark (https://github.com/google/benchmark.git)
   message(STATUS "Downloading and building Google Benchmark.")
   if(CMAKE_CXX_COMPILER MATCHES ".*/hipcc$|.*/nvcc$")
     # hip-clang cannot compile googlebenchmark for some reason
     set(COMPILER_OVERRIDE "-DCMAKE_CXX_COMPILER=g++")
+  # Google Benchmark (https://github.com/google/benchmark.git)
+  endif()
+  find_package(benchmark QUIET)
+
+  if(NOT benchmark_FOUND)
+    message(STATUS "Google Benchmark not found or force download Google Benchmark on. Downloading and building Google Benchmark.")
+    if(CMAKE_CONFIGURATION_TYPES)
+      message(FATAL_ERROR "DownloadProject.cmake doesn't support multi-configuration generators.")
+    endif()
+    set(GOOGLEBENCHMARK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/deps/googlebenchmark CACHE PATH "")
+    if(CMAKE_CXX_COMPILER MATCHES ".*/hipcc$")
+      # hip-clang cannot compile googlebenchmark for some reason
+      set(COMPILER_OVERRIDE "-DCMAKE_CXX_COMPILER=g++")
+    endif()
+
+    download_project(
+      PROJ           googlebenchmark
+      GIT_REPOSITORY https://github.com/google/benchmark.git
+      GIT_TAG        v1.6.1
+      INSTALL_DIR    ${GOOGLEBENCHMARK_ROOT}
+      CMAKE_ARGS     -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS} -DBENCHMARK_ENABLE_TESTING=OFF -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> -DCMAKE_CXX_STANDARD=14 ${COMPILER_OVERRIDE}
+      LOG_DOWNLOAD   TRUE
+      LOG_CONFIGURE  TRUE
+      LOG_BUILD      TRUE
+      LOG_INSTALL    TRUE
+      BUILD_PROJECT  TRUE
+      ${UPDATE_DISCONNECTED_IF_AVAILABLE}
+    )
   endif()
-  # Download, build and install googlebenchmark library
-  set(GOOGLEBENCHMARK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark CACHE PATH "")
-  download_project(
-    PROJ           googlebenchmark
-    GIT_REPOSITORY https://github.com/google/benchmark.git
-    GIT_TAG        v1.6.1
-    GIT_SHALLOW    TRUE
-    INSTALL_DIR    ${GOOGLEBENCHMARK_ROOT}
-    CMAKE_ARGS     -DCMAKE_BUILD_TYPE=RELEASE -DBENCHMARK_ENABLE_TESTING=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> ${COMPILER_OVERRIDE}
-    LOG_DOWNLOAD   TRUE
-    LOG_CONFIGURE  TRUE
-    LOG_BUILD      TRUE
-    LOG_INSTALL    TRUE
-    BUILD_PROJECT  TRUE
-    ${UPDATE_DISCONNECTED_IF_AVAILABLE}
-  )
   find_package(benchmark REQUIRED CONFIG PATHS ${GOOGLEBENCHMARK_ROOT})
 endif()

rmake.py

@@ -143,7 +143,7 @@ def config_cmd():
         cmake_options.append( f"-DROCM_DISABLE_LDCONFIG=ON" )
 
     if args.build_clients:
-        cmake_options.append( f"-DBUILD_TEST=ON -DBUILD_DIR={build_dir}" )
+        cmake_options.append( f"-DBUILD_TEST=ON -DBUILD_BENCHMARK=ON -DBUILD_DIR={build_dir}" )
 
     cmake_options.append( f"-DAMDGPU_TARGETS={args.gpu_architecture}" )