Dev

CMakeLists.txt

@@ -57,5 +57,10 @@ install(FILES
 
 enable_testing()
 
+option(ENABLE_BENCH "Set to on in order to compile bench suite, work only in release mode" OFF)
+
 add_subdirectory(simdpp)
 add_subdirectory(test)
+if(ENABLE_BENCH)
+  add_subdirectory(bench)
+endif()  

bench/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(thirdparty)
+add_subdirectory(insn)

bench/insn/CMakeLists.txt

@@ -0,0 +1,51 @@
+include_directories(${libsimdpp_SOURCE_DIR})
+include_directories(${GOOGLE_BENCHMARK_INCLUDE_DIRS})
+
+set(TEST_BENCH_SOURCES
+    main.cc
+    main.h
+)
+
+set(BENCH_INSN_ARCH_SOURCES
+  algorithm/transform_unary.cc
+  algorithm/transform_binary.cc
+  algorithm/reduce_unary.cc
+  algorithm/reduce_binary.cc
+  load_store.cc
+  )
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+foreach(ARCH ${COMPILABLE_ARCHS}})
+  simdpp_get_arch_info(CXX_FLAGS DEFINES_LIST SUFFIX ${ARCH})
+  #message("Create benchmark for arch : ${SUFFIX} with flags: ${CXX_FLAGS} with defines ${DEFINES_LIST}")
+  SET(exename "bench_insn_${SUFFIX}")
+  add_executable(${exename} ${BENCH_INSN_ARCH_SOURCES} ${TEST_BENCH_SOURCES})
+  set_target_properties( ${exename} PROPERTIES COMPILE_FLAGS "${CXX_FLAGS}" )
+  set_target_properties (${exename} PROPERTIES FOLDER bench)
+  if(SIMDPP_MSVC)
+    if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        # enable _vectorcall on i386 builds (only works on MSVC 2013)
+        #set_target_properties(${exename} PROPERTIES COMPILE_FLAGS "/Gv")
+    endif()
+  elseif(SIMDPP_MSVC_INTEL)
+    set_target_properties(${exename} PROPERTIES COMPILE_FLAGS "/Qstd=c++11")
+  else()
+    # Xcode clang linker spends very long time in deduplication pass when
+    # linking the test executable unless -fvisibility-inlines-hidden is passed.
+    set_target_properties(${exename} PROPERTIES COMPILE_FLAGS "-std=c++11 -O2 -Wall -Wextra -fvisibility-inlines-hidden")
+  endif()
+  if(WIN32)
+    target_link_libraries(${exename}
+    PUBLIC benchmark  
+    PUBLIC shlwapi.lib
+    )
+  else()
+   target_link_libraries(${exename}
+     PUBLIC benchmark
+     PUBLIC pthread
+    )
+  add_dependencies(${exename} ${GOOGLE_BENCHMARK})  
+  endif()
+endforeach(ARCH ${${COMPILABLE_ARCHS}})
+
+

bench/insn/algorithm/reduce_binary.cc

@@ -0,0 +1,155 @@
+/*  Copyright (C) 2018  Povilas Kanapickas <[email protected]>
+    Copyright (C) 2018  Thomas Retornaz <[email protected]>
+
+    Distributed under the Boost Software License, Version 1.0.
+    (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include "benchmark/benchmark.h"
+#include <vector>
+#include <numeric>
+#include <iterator>
+#include <simdpp/simd.h>
+//algorithm
+#include <simdpp/algorithm/reduce.h>
+
+
+namespace {
+
+template< typename T>
+struct BinaryOpPlus
+{
+public:
+   BinaryOpPlus() {}
+   SIMDPP_INL T operator()(T const &a0, T const &a1) const  SIMDPP_NOEXCEPT
+   {
+      return a0 + a1;
+   }
+
+   template<typename U>
+   SIMDPP_INL U operator()(U const &a0, U const &a1) const  SIMDPP_NOEXCEPT
+   {
+      return a0 + a1;
+   }
+};
+
+template <typename T>
+struct GeneratorConstant
+{
+    GeneratorConstant(T constant) { m_constant = constant; }
+    T operator()() { return m_constant; }
+    T m_constant;
+};
+
+
+template<typename T, class  Generator>
+std::vector<T, simdpp::aligned_allocator<T, simdpp::simd_traits<T>::alignment>> DataGenerator(std::size_t size, Generator gen)
+{
+
+    using vector_aligned_t = std::vector<T, simdpp::aligned_allocator<T, simdpp::simd_traits<T>::alignment>>;
+    vector_aligned_t input(size);
+    std::generate(input.begin(), input.end(), gen);
+    return input;
+}
+
+/*********************UNARY****************************/
+
+template<typename T>
+class ReduceBinaryFixture : public ::benchmark::Fixture {
+public:
+  void SetUp(const ::benchmark::State& st) 
+  {
+      m_inputvect = DataGenerator<T, GeneratorConstant<T>>((size_t)st.range(0), GeneratorConstant<T>(1));
+  }
+  void TearDown(const ::benchmark::State&) 
+  {
+     m_inputvect.clear();
+  }
+  using vector_aligned_t = std::vector<T, simdpp::aligned_allocator<T, simdpp::simd_traits<T>::alignment>>;
+  vector_aligned_t  m_inputvect;
+};
+
+//UINT64_T
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceBinaryFixture, BinaryUNINT64_SIMD_Test, uint64_t)(benchmark::State& st)
+{
+  const auto size= (size_t)st.range(0);
+  uint64_t init = (uint64_t)0;
+  auto opPlus = BinaryOpPlus<uint64_t>();
+  uint64_t neutral = (uint64_t)0;
+  while (st.KeepRunning()) 
+  {
+     benchmark::DoNotOptimize(simdpp::reduce(m_inputvect.data(), m_inputvect.data() + m_inputvect.size(), init, neutral, opPlus));
+  }
+}
+BENCHMARK_REGISTER_F(ReduceBinaryFixture, BinaryUNINT64_SIMD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceBinaryFixture, BinaryUNINT64_STD_Test, uint64_t)(benchmark::State& st)
+{
+  const auto size = (size_t)st.range(0);
+  uint64_t init = (uint64_t)0;
+  auto opPlus = BinaryOpPlus<uint64_t>();
+  while (st.KeepRunning())
+  {
+     benchmark::DoNotOptimize(std::accumulate(m_inputvect.cbegin(), m_inputvect.cend(), init, opPlus));
+  }
+}
+BENCHMARK_REGISTER_F(ReduceBinaryFixture, BinaryUNINT64_STD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+
+//FLOAT
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceBinaryFixture, BinaryFLOAT_SIMD_Test, float)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   float init = (float)0;
+   auto opPlus = BinaryOpPlus<float>();
+   float neutral = (float)0;
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(simdpp::reduce(m_inputvect.data(), m_inputvect.data() + m_inputvect.size(), init, neutral, opPlus));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceBinaryFixture, BinaryFLOAT_SIMD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceBinaryFixture, BinaryFLOAT_STD_Test, float)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   float init = (float)0;
+   auto opPlus = BinaryOpPlus<uint64_t>();
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(std::accumulate(m_inputvect.cbegin(), m_inputvect.cend(), init, opPlus));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceBinaryFixture, BinaryFLOAT_STD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+
+//DOUBLE
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceBinaryFixture, BinaryDOUBLE_SIMD_Test, double)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   double init = (double)0;
+   auto opPlus = BinaryOpPlus<double>();
+   double neutral = (double)0;
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(simdpp::reduce(m_inputvect.data(), m_inputvect.data() + m_inputvect.size(), init, neutral, opPlus));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceBinaryFixture, BinaryDOUBLE_SIMD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceBinaryFixture, BinaryDOUBLE_STD_Test, double)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   double init = (double)0;
+   auto opPlus = BinaryOpPlus<uint64_t>();
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(std::accumulate(m_inputvect.cbegin(), m_inputvect.cend(), init, opPlus));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceBinaryFixture, BinaryDOUBLE_STD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+
+
+}  // namespace

bench/insn/algorithm/reduce_unary.cc

@@ -0,0 +1,122 @@
+/*  Copyright (C) 2018  Povilas Kanapickas <[email protected]>
+    Copyright (C) 2018  Thomas Retornaz <[email protected]>
+
+    Distributed under the Boost Software License, Version 1.0.
+    (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include "benchmark/benchmark.h"
+#include <vector>
+#include <numeric>
+#include <iterator>
+#include <simdpp/simd.h>
+//algorithm
+#include <simdpp/algorithm/reduce.h>
+
+
+namespace {
+
+template <typename T>
+struct GeneratorConstant
+{
+    GeneratorConstant(T constant) { m_constant = constant; }
+    T operator()() { return m_constant; }
+    T m_constant;
+};
+
+
+template<typename T, class  Generator>
+std::vector<T, simdpp::aligned_allocator<T, simdpp::simd_traits<T>::alignment>> DataGenerator(std::size_t size, Generator gen)
+{
+
+    using vector_aligned_t = std::vector<T, simdpp::aligned_allocator<T, simdpp::simd_traits<T>::alignment>>;
+    vector_aligned_t input(size);
+    std::generate(input.begin(), input.end(), gen);
+    return input;
+}
+
+/*********************UNARY****************************/
+
+template<typename T>
+class ReduceUnaryFixture : public ::benchmark::Fixture {
+public:
+  void SetUp(const ::benchmark::State& st) 
+  {
+      m_inputvect = DataGenerator<T, GeneratorConstant<T>>((size_t)st.range(0), GeneratorConstant<T>(1));
+  }
+  void TearDown(const ::benchmark::State&) 
+  {
+     m_inputvect.clear();
+  }
+  using vector_aligned_t = std::vector<T, simdpp::aligned_allocator<T, simdpp::simd_traits<T>::alignment>>;
+  vector_aligned_t  m_inputvect;
+};
+
+//UINT64_T
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceUnaryFixture, UnaryUNINT64_SIMD_Test, uint64_t)(benchmark::State& st)
+{
+  const auto size= (size_t)st.range(0);
+  while (st.KeepRunning()) 
+  {
+     benchmark::DoNotOptimize(simdpp::reduce(m_inputvect.data(), m_inputvect.data() + m_inputvect.size(),(uint64_t)0));
+  }
+}
+BENCHMARK_REGISTER_F(ReduceUnaryFixture, UnaryUNINT64_SIMD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceUnaryFixture, UnaryUNINT64_STD_Test, uint64_t)(benchmark::State& st)
+{
+  const auto size = (size_t)st.range(0);
+  while (st.KeepRunning())
+  {
+     benchmark::DoNotOptimize(std::accumulate(m_inputvect.begin(), m_inputvect.end(), (uint64_t)0));
+  }
+}
+BENCHMARK_REGISTER_F(ReduceUnaryFixture, UnaryUNINT64_STD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+
+//FLOAT
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceUnaryFixture, UnaryFLOAT_SIMD_Test, float)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(simdpp::reduce(m_inputvect.data(), m_inputvect.data() + m_inputvect.size(), (float)0));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceUnaryFixture, UnaryFLOAT_SIMD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceUnaryFixture, UnaryFLOAT_STD_Test, float)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(std::accumulate(m_inputvect.begin(), m_inputvect.end(), (float)0));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceUnaryFixture, UnaryFLOAT_STD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+//DOUBLE
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceUnaryFixture, UnaryDOUBLE_SIMD_Test, double)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(simdpp::reduce(m_inputvect.data(), m_inputvect.data() + m_inputvect.size(), (double)0));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceUnaryFixture, UnaryDOUBLE_SIMD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+BENCHMARK_TEMPLATE_DEFINE_F(ReduceUnaryFixture, UnaryDOUBLE_STD_Test, double)(benchmark::State& st)
+{
+   const auto size = (size_t)st.range(0);
+   while (st.KeepRunning())
+   {
+      benchmark::DoNotOptimize(std::accumulate(m_inputvect.begin(), m_inputvect.end(), (double)0));
+   }
+}
+BENCHMARK_REGISTER_F(ReduceUnaryFixture, UnaryDOUBLE_STD_Test)->Arg(1)->Arg(10)->Arg(32)->Arg(100)->Arg(1000)->Arg(10000);
+
+
+
+}  // namespace