more fixes

Author: aobolensk

.clang-tidy

@@ -9,9 +9,15 @@ Checks: >
   readability-*,
   -google-build-using-namespace,
   -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-  -cppcoreguidelines-narrowing-conversions,
   -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-prefer-member-initializer,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-member-init,
+  -cppcoreguidelines-special-member-functions,
   -google-readability-braces-around-statements,
   -google-readability-namespace-comments,
   -google-runtime-references,

include/layers/Layer.hpp

@@ -78,6 +78,7 @@ class LayerImpl {
   LayerImpl() = default;
   LayerImpl(const Shape& inputShape, const Shape& outputShape)
       : inputShape_(inputShape), outputShape_(outputShape) {}
+  virtual ~LayerImpl() = default;
   LayerImpl(const LayerImpl& c) = default;
   LayerImpl& operator=(const LayerImpl& c) = default;
   [[nodiscard]] virtual std::vector<ValueType> run(

include/layers/PoolingLayer.hpp

@@ -179,18 +179,18 @@ PoolingLayerImpl<ValueType>::PoolingLayerImpl(
 
     size_t effective_kernel_size = (kernel_size - 1) * dilation + 1;
 
-    size_t output_size;
-    if (ceil_mode) {
-      output_size = static_cast<size_t>(
-                        std::ceil((input_size + pad - effective_kernel_size) /
-                                  static_cast<float>(stride))) +
-                    1;
-    } else {
-      output_size = static_cast<size_t>(
-                        std::floor((input_size + pad - effective_kernel_size) /
-                                   static_cast<float>(stride))) +
-                    1;
-    }
+    size_t output_size = [=]() {
+      if (ceil_mode) {
+        return static_cast<size_t>(
+                   std::ceil((input_size + pad - effective_kernel_size) /
+                             static_cast<float>(stride))) +
+               1;
+      }
+      return static_cast<size_t>(
+                 std::floor((input_size + pad - effective_kernel_size) /
+                            static_cast<float>(stride))) +
+             1;
+    }();
 
     this->outputShape_[input_shape.dims() - pooling_shape.dims() + i] =
         output_size;
@@ -321,4 +321,4 @@ std::vector<ValueType> PoolingLayerImpl<ValueType>::run(
   return res;
 }
 
-}  // namespace it_lab_ai
+}  // namespace it_lab_ai

include/perf/benchmarking.hpp

@@ -7,6 +7,7 @@
 #include <cmath>
 #include <numeric>
 #include <stdexcept>
+#include <utility>
 #include <vector>
 
 namespace it_lab_ai {
@@ -16,7 +17,7 @@ template <typename DurationContainerType, typename DurationType, class Function,
 DurationContainerType elapsed_time(Function&& func, Args&&... args) {
   auto duration = std::chrono::duration<DurationContainerType, DurationType>();
   auto start = std::chrono::high_resolution_clock::now();
-  func(args...);
+  std::forward<Function>(func)(std::forward<Args>(args)...);
   auto end = std::chrono::high_resolution_clock::now();
   duration = end - start;
   return duration.count();
@@ -26,7 +27,7 @@ DurationContainerType elapsed_time(Function&& func, Args&&... args) {
 template <class Function, typename... Args>
 double elapsed_time_omp(Function&& func, Args&&... args) {
   double start = omp_get_wtime();
-  func(args...);
+  std::forward<Function>(func)(std::forward<Args>(args)...);
   double end = omp_get_wtime();
   return end - start;
 }
@@ -38,7 +39,7 @@ DurationContainerType elapsed_time_avg(const size_t iters, Function&& func,
   auto duration = std::chrono::duration<DurationContainerType, DurationType>();
   auto start = std::chrono::high_resolution_clock::now();
   for (size_t i = 0; i < iters; i++) {
-    func(args...);
+    std::forward<Function>(func)(std::forward<Args>(args)...);
   }
   auto end = std::chrono::high_resolution_clock::now();
   duration = (end - start) / iters;
@@ -51,7 +52,7 @@ double elapsed_time_omp_avg(const size_t iters, Function&& func,
                             Args&&... args) {
   double start = omp_get_wtime();
   for (size_t i = 0; i < iters; i++) {
-    func(args...);
+    std::forward<Function>(func)(std::forward<Args>(args)...);
   }
   double end = omp_get_wtime();
   return (end - start) / iters;
@@ -61,26 +62,31 @@ template <typename ThroughputContainerType, typename DurationType,
           class Function, typename... Args>
 ThroughputContainerType throughput(Function&& func, Args&&... args) {
   return ThroughputContainerType(1) /
-         elapsed_time<ThroughputContainerType, DurationType>(func, args...);
+         elapsed_time<ThroughputContainerType, DurationType>(
+             std::forward<Function>(func), std::forward<Args>(args)...);
 }
 
 template <class Function, typename... Args>
 double throughput_omp(Function&& func, Args&&... args) {
-  return 1 / elapsed_time_omp(func, args...);
+  return 1 /
+         elapsed_time_omp(std::forward<Function>(func),
+                          std::forward<Args>(args)...);
 }
 
 template <typename ThroughputContainerType, typename DurationType,
           class Function, typename... Args>
 ThroughputContainerType throughput_avg(const size_t iters, Function&& func,
                                        Args&&... args) {
   return ThroughputContainerType(1) /
-         elapsed_time_avg<ThroughputContainerType, DurationType>(iters, func,
-                                                                 args...);
+         elapsed_time_avg<ThroughputContainerType, DurationType>(
+             iters, std::forward<Function>(func), std::forward<Args>(args)...);
 }
 
 template <class Function, typename... Args>
 double throughput_omp_avg(const size_t iters, Function&& func, Args&&... args) {
-  return 1 / elapsed_time_omp_avg(iters, func, args...);
+  return 1 /
+         elapsed_time_omp_avg(iters, std::forward<Function>(func),
+                              std::forward<Args>(args)...);
 }
 
 // as "Manhattan" norm of error-vector