remove performance module tests and refactor utility includes

Author: allnes

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "3rdparty/libenvpp"]
 	path = 3rdparty/libenvpp
 	url = https://github.com/ph3at/libenvpp
+[submodule "3rdparty/benchmark"]
+	path = 3rdparty/benchmark
+	url = https://github.com/google/benchmark

3rdparty/benchmark

@@ -43,6 +43,7 @@ endforeach()
 ######################### External projects #########################
 
 message( STATUS "PPC step: Setup external projects" )
+include(cmake/benchmark.cmake)
 include(cmake/gtest.cmake)
 
 ############################## Modules ##############################

CMakeLists.txt

@@ -0,0 +1,37 @@
+include_guard()
+
+include(ExternalProject)
+
+ExternalProject_Add(
+  ppc_benchmark
+  SOURCE_DIR "${CMAKE_SOURCE_DIR}/3rdparty/benchmark"
+  PREFIX "${CMAKE_CURRENT_BINARY_DIR}/ppc_benchmark"
+  BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/ppc_benchmark/build"
+  INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}/ppc_benchmark/install"
+  CMAKE_ARGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+             -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+             -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
+             -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+             -DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}
+             -DCMAKE_CXX_STANDARD_REQUIRED=${CMAKE_CXX_STANDARD_REQUIRED}
+             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+             -DBENCHMARK_ENABLE_TESTING=OFF
+             -DBENCHMARK_ENABLE_GTEST_TESTS=OFF
+             -DBENCHMARK_ENABLE_INSTALL=ON
+             -DBENCHMARK_ENABLE_LIBPFM=OFF
+  BUILD_COMMAND
+    "${CMAKE_COMMAND}" --build "${CMAKE_CURRENT_BINARY_DIR}/ppc_benchmark/build"
+    --config $<CONFIG> --parallel
+  INSTALL_COMMAND
+    "${CMAKE_COMMAND}" --install
+    "${CMAKE_CURRENT_BINARY_DIR}/ppc_benchmark/build" --config $<CONFIG>
+    --prefix "${CMAKE_CURRENT_BINARY_DIR}/ppc_benchmark/install")
+
+function(ppc_link_benchmark target)
+  target_include_directories(
+    ${target} PUBLIC ${CMAKE_SOURCE_DIR}/3rdparty/benchmark/include)
+  add_dependencies(${target} ppc_benchmark)
+  target_link_directories(${target} PUBLIC
+                          "${CMAKE_BINARY_DIR}/ppc_benchmark/install/lib")
+  target_link_libraries(${target} PUBLIC benchmark)
+endfunction()

cmake/benchmark.cmake

@@ -1,133 +1,5 @@
 #pragma once
 
-#include <cstdint>
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-
-#include "task/include/task.hpp"
-#include "util/include/util.hpp"
-
 namespace ppc::performance {
-
-inline double DefaultTimer() {
-  return -1.0;
-}
-
-struct PerfAttr {
-  /// @brief Number of times the task is run for performance evaluation.
-  uint64_t num_running = 5;
-  /// @brief Timer function returning current time in seconds.
-  /// @cond
-  std::function<double()> current_timer = DefaultTimer;
-  /// @endcond
-};
-
-struct PerfResults {
-  /// @brief Measured execution time in seconds.
-  double time_sec = 0.0;
-  enum class TypeOfRunning : uint8_t {
-    kPipeline,
-    kTaskRun,
-    kNone,
-  };
-  TypeOfRunning type_of_running = TypeOfRunning::kNone;
-  constexpr static double kMaxTime = 10.0;
-};
-
-template <typename InType, typename OutType>
-class Perf {
- public:
-  // Init performance analysis with an initialized task and initialized data
-  explicit Perf(const ppc::task::TaskPtr<InType, OutType> &task_ptr) : task_(task_ptr) {
-    task_ptr->GetStateOfTesting() = ppc::task::StateOfTesting::kPerf;
-  }
-  // Check performance of full task's pipeline:  PreProcessing() ->
-  // Validation() -> Run() -> PostProcessing()
-  void PipelineRun(const PerfAttr &perf_attr) {
-    perf_results_.type_of_running = PerfResults::TypeOfRunning::kPipeline;
-
-    CommonRun(perf_attr, [&] {
-      task_->Validation();
-      task_->PreProcessing();
-      task_->Run();
-      task_->PostProcessing();
-    }, perf_results_);
-  }
-  // Check performance of task's Run() function
-  void TaskRun(const PerfAttr &perf_attr) {
-    perf_results_.type_of_running = PerfResults::TypeOfRunning::kTaskRun;
-
-    task_->Validation();
-    task_->PreProcessing();
-    CommonRun(perf_attr, [&] { task_->Run(); }, perf_results_);
-    task_->PostProcessing();
-
-    task_->Validation();
-    task_->PreProcessing();
-    task_->Run();
-    task_->PostProcessing();
-  }
-  // Print results for automation checkers
-  void PrintPerfStatistic(const std::string &test_id) const {
-    std::string type_test_name;
-    if (perf_results_.type_of_running == PerfResults::TypeOfRunning::kTaskRun) {
-      type_test_name = "task_run";
-    } else if (perf_results_.type_of_running == PerfResults::TypeOfRunning::kPipeline) {
-      type_test_name = "pipeline";
-    } else {
-      std::stringstream err_msg;
-      err_msg << '\n' << "The type of performance check for the task was not selected.\n";
-      throw std::runtime_error(err_msg.str().c_str());
-    }
-
-    auto time_secs = perf_results_.time_sec;
-    const auto max_time = ppc::util::GetPerfMaxTime();
-    std::stringstream perf_res_str;
-    if (time_secs < max_time) {
-      perf_res_str << std::fixed << std::setprecision(10) << time_secs;
-      std::cout << test_id << ":" << type_test_name << ":" << perf_res_str.str() << '\n';
-    } else {
-      std::stringstream err_msg;
-      err_msg << '\n' << "Task execute time need to be: ";
-      err_msg << "time < " << max_time << " secs." << '\n';
-      err_msg << "Original time in secs: " << time_secs << '\n';
-      perf_res_str << std::fixed << std::setprecision(10) << -1.0;
-      std::cout << test_id << ":" << type_test_name << ":" << perf_res_str.str() << '\n';
-      throw std::runtime_error(err_msg.str().c_str());
-    }
-  }
-  /// @brief Retrieves the performance test results.
-  /// @return The latest PerfResults structure.
-  [[nodiscard]] PerfResults GetPerfResults() const {
-    return perf_results_;
-  }
-
- private:
-  PerfResults perf_results_;
-  std::shared_ptr<ppc::task::Task<InType, OutType>> task_;
-  static void CommonRun(const PerfAttr &perf_attr, const std::function<void()> &pipeline, PerfResults &perf_results) {
-    auto begin = perf_attr.current_timer();
-    for (uint64_t i = 0; i < perf_attr.num_running; i++) {
-      pipeline();
-    }
-    auto end = perf_attr.current_timer();
-    perf_results.time_sec = (end - begin) / static_cast<double>(perf_attr.num_running);
-  }
-};
-
-inline std::string GetStringParamName(PerfResults::TypeOfRunning type_of_running) {
-  if (type_of_running == PerfResults::TypeOfRunning::kTaskRun) {
-    return "task_run";
-  }
-  if (type_of_running == PerfResults::TypeOfRunning::kPipeline) {
-    return "pipeline";
-  }
-  return "none";
+inline constexpr const char kTaskRunName[] = "task_run";
 }
-
-}  // namespace ppc::performance