From c8d4eafe6673c0a318119b294311abcd290a949d Mon Sep 17 00:00:00 2001 From: Arseniy Obolenskiy Date: Sat, 7 Mar 2026 19:14:24 +0100 Subject: [PATCH 1/3] Address 'cppcoreguidelines-*' clang-tidy remarks --- .clang-tidy | 8 ++ src/Weights_Reader/reader_weights.cpp | 5 +- src/graph/graph.cpp | 96 +++++++------------ .../graph_transformations.cpp | 20 ++-- src/layers/FCLayer.cpp | 24 +++-- src/layers/FlattenLayer.cpp | 5 +- src/layers/Shape.cpp | 6 +- src/layers_oneDNN/BinaryOpLayer.cpp | 28 ++++-- src/layers_oneDNN/ConvLayer.cpp | 87 ++++++++--------- src/layers_oneDNN/EWLayer.cpp | 7 +- src/layers_oneDNN/PoolingLayer.cpp | 34 +++---- src/layers_oneDNN/ReduceLayer.cpp | 7 +- 12 files changed, 153 insertions(+), 174 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index d36779f1..bd28b2a7 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -1,12 +1,20 @@ Checks: > bugprone-*, google-*, + cppcoreguidelines-*, modernize-*, misc-*, performance-*, portability-*, readability-*, -google-build-using-namespace, + -cppcoreguidelines-avoid-magic-numbers, + -cppcoreguidelines-pro-bounds-pointer-arithmetic, + -cppcoreguidelines-narrowing-conversions, + -cppcoreguidelines-avoid-non-const-global-variables, + -google-readability-braces-around-statements, + -google-readability-namespace-comments, + -google-runtime-references, -misc-non-private-member-variables-in-classes, -misc-const-correctness, -misc-include-cleaner, diff --git a/src/Weights_Reader/reader_weights.cpp b/src/Weights_Reader/reader_weights.cpp index 47b4503b..a72ffdff 100644 --- a/src/Weights_Reader/reader_weights.cpp +++ b/src/Weights_Reader/reader_weights.cpp @@ -44,12 +44,13 @@ json read_json(const std::string& filename) { return result; #else - int fd = open(filename.c_str(), O_RDONLY); + int fd = open(filename.c_str(), + O_RDONLY); // NOLINT(cppcoreguidelines-pro-type-vararg) if (fd == -1) { throw std::runtime_error("Cannot open file: " + filename); } - struct stat sb; + struct stat sb {}; fstat(fd, &sb); if (sb.st_size == 0) { diff --git a/src/graph/graph.cpp b/src/graph/graph.cpp index 56789722..9d4b2e31 100644 --- a/src/graph/graph.cpp +++ b/src/graph/graph.cpp @@ -26,6 +26,18 @@ namespace it_lab_ai { +namespace { +template +std::shared_ptr clone_layer_checked( + const std::shared_ptr& layer) { + const auto* casted = dynamic_cast(layer.get()); + if (casted == nullptr) { + throw std::invalid_argument("Layer type mismatch while cloning"); + } + return std::make_shared(*casted); +} +} // namespace + void Graph::clone(Graph& result, Tensor& out, const RuntimeOptions& options) const { result.arrayE_ = this->arrayE_; @@ -61,110 +73,70 @@ std::shared_ptr layer_based_shared_copy( const std::shared_ptr& layer, const RuntimeOptions& options) { switch (layer->getName()) { case it_lab_ai::kInput: { - auto* tmp_layer = new InputLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kPooling: { if (options.backend == Backend::kOneDnn) { - auto* tmp_layer = new PoolingLayerOneDnn( - *dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } - auto* tmp_layer = - new PoolingLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kElementWise: { if (options.backend == Backend::kOneDnn) { - auto* tmp_layer = - new EwLayerOneDnn(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } - auto* tmp_layer = new EWLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kConvolution: { if (options.backend == Backend::kOneDnn) { - auto* tmp_layer = - new ConvLayerOneDnn(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } - auto* tmp_layer = new ConvolutionalLayer( - *dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kFullyConnected: { - auto* tmp_layer = new FCLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kFlatten: { - auto* tmp_layer = - new FlattenLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kConcat: { - auto* tmp_layer = - new ConcatLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kDropout: { - auto* tmp_layer = - new DropOutLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kSplit: { - auto* tmp_layer = new SplitLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kBinaryOp: { if (options.backend == Backend::kOneDnn) { - auto* tmp_layer = new BinaryOpLayerOneDnn( - *dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } - auto* tmp_layer = - new BinaryOpLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kTranspose: { - auto* tmp_layer = - new TransposeLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kMatmul: { - auto* tmp_layer = - new MatmulLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kReshape: { - auto* tmp_layer = - new ReshapeLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kSoftmax: { - auto* tmp_layer = - new SoftmaxLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kReduce: { if (options.backend == Backend::kOneDnn) { - auto* tmp_layer = new ReduceLayerOneDnn( - *dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } - auto* tmp_layer = - new ReduceLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kBatchNormalization: { - auto* tmp_layer = new BatchNormalizationLayer( - *dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } case it_lab_ai::kOutput: { - auto* tmp_layer = - new OutputLayer(*dynamic_cast(layer.get())); - return std::shared_ptr(tmp_layer); + return clone_layer_checked(layer); } default: { throw std::invalid_argument("No such layer type"); diff --git a/src/graph_transformations/graph_transformations.cpp b/src/graph_transformations/graph_transformations.cpp index 6d86d5f8..936b1d50 100644 --- a/src/graph_transformations/graph_transformations.cpp +++ b/src/graph_transformations/graph_transformations.cpp @@ -137,8 +137,6 @@ void changed_subgraphs(const Graph& graph, const Graph& subgraph_from, std::vector leaves; std::vector roots_inps_final; std::vector leaves_outs_final; - size_t amount_connected; - size_t amount_connected_s; for (int v = 0; v < subgraph_from.getLayersCount(); v++) { if (is_root(subgraph_from, v)) { roots.push_back(v); @@ -175,8 +173,9 @@ void changed_subgraphs(const Graph& graph, const Graph& subgraph_from, } } // recognize transformations we can apply with roots - amount_connected = new_graph.getOutputsSize(subs[i][roots[j]]); - amount_connected_s = subgraph_from.getOutputsSize(roots[j]); + const size_t amount_connected = + new_graph.getOutputsSize(subs[i][roots[j]]); + const size_t amount_connected_s = subgraph_from.getOutputsSize(roots[j]); if (amount_connected == amount_connected_s) { continue; } @@ -189,7 +188,7 @@ void changed_subgraphs(const Graph& graph, const Graph& subgraph_from, } } for (int leaf : leaves) { - amount_connected = new_graph.getOutputsSize(subs[i][leaf]); + const size_t amount_connected = new_graph.getOutputsSize(subs[i][leaf]); for (size_t k = 0; k < amount_connected; k++) { int id = new_graph.getOutLayers(subs[i][leaf])[k]; auto it = @@ -242,8 +241,6 @@ void changed_subgraphs(const Graph& graph, const Graph& subgraph_from, std::vector leaves_to; std::vector> roots_inps_final; std::vector> leaves_outs_final; - size_t amount_connected; - size_t amount_connected_s; for (int v = 0; v < subgraph_from.getLayersCount(); v++) { if (is_root(subgraph_from, v)) { roots_from.push_back(v); @@ -296,8 +293,10 @@ void changed_subgraphs(const Graph& graph, const Graph& subgraph_from, for (size_t j = 0; j < roots_from.size(); j++) { roots_inps_final[j] = new_graph.getInLayers(subs[i][roots_from[j]]); // recognize transformations we can apply with roots - amount_connected = new_graph.getOutputsSize(subs[i][roots_from[j]]); - amount_connected_s = subgraph_from.getOutputsSize(roots_from[j]); + const size_t amount_connected = + new_graph.getOutputsSize(subs[i][roots_from[j]]); + const size_t amount_connected_s = + subgraph_from.getOutputsSize(roots_from[j]); if (amount_connected == amount_connected_s) { continue; } @@ -310,7 +309,8 @@ void changed_subgraphs(const Graph& graph, const Graph& subgraph_from, } } for (size_t j = 0; j < leaves_from.size(); j++) { - amount_connected = new_graph.getOutputsSize(subs[i][leaves_from[j]]); + const size_t amount_connected = + new_graph.getOutputsSize(subs[i][leaves_from[j]]); for (size_t k = 0; k < amount_connected; k++) { int id = new_graph.getOutLayers(subs[i][leaves_from[j]])[k]; leaves_outs_final[j].push_back(id); diff --git a/src/layers/FCLayer.cpp b/src/layers/FCLayer.cpp index 5401db63..52767f3c 100644 --- a/src/layers/FCLayer.cpp +++ b/src/layers/FCLayer.cpp @@ -17,20 +17,18 @@ void FCLayer::run(const std::vector& input, throw std::invalid_argument("Bias and weights data type aren't same"); } - size_t batch_size; - size_t output_size = bias_->get_shape()[0]; - if (input[0].get_shape().dims() == 1) { - size_t total_elements = input[0].get_shape()[0]; - size_t expected_input_size = weights_->get_shape()[0]; - - if (total_elements % expected_input_size == 0) { - batch_size = total_elements / expected_input_size; - } else { - batch_size = 1; + const size_t batch_size = [&]() -> size_t { + if (input[0].get_shape().dims() == 1) { + const size_t total_elements = input[0].get_shape()[0]; + const size_t expected_input_size = weights_->get_shape()[0]; + if (total_elements % expected_input_size == 0) { + return total_elements / expected_input_size; + } + return 1; } - } else { - batch_size = input[0].get_shape()[0]; - } + return input[0].get_shape()[0]; + }(); + size_t output_size = bias_->get_shape()[0]; switch (input[0].get_type()) { case Type::kInt: { diff --git a/src/layers/FlattenLayer.cpp b/src/layers/FlattenLayer.cpp index bb5c2b85..870f38f9 100644 --- a/src/layers/FlattenLayer.cpp +++ b/src/layers/FlattenLayer.cpp @@ -4,9 +4,8 @@ namespace it_lab_ai { std::vector reorder(std::vector order_vec, std::vector order) { - size_t min_ind; - for (size_t i = 0; i < order.size() - 1; i++) { - min_ind = i; + for (size_t i = 0; i + 1 < order.size(); i++) { + size_t min_ind = i; for (size_t j = i + 1; j < order.size(); j++) { if (order[j] < order[min_ind]) { min_ind = j; diff --git a/src/layers/Shape.cpp b/src/layers/Shape.cpp index f42fe7a1..92b9d773 100644 --- a/src/layers/Shape.cpp +++ b/src/layers/Shape.cpp @@ -7,11 +7,11 @@ size_t Shape::get_index(const std::vector& coords) const { throw std::invalid_argument("Invalid index vector"); } size_t res = 0; - size_t mulbuf; for (size_t i = 0; i < coords.size(); i++) { // to get to the i line - mulbuf = std::accumulate(dims_.begin() + (i + 1), dims_.end(), - static_cast(1), std::multiplies<>()); + const size_t mulbuf = + std::accumulate(dims_.cbegin() + (i + 1), dims_.cend(), + static_cast(1), std::multiplies<>()); if (coords[i] >= dims_[i]) { throw std::out_of_range("Out of range"); } diff --git a/src/layers_oneDNN/BinaryOpLayer.cpp b/src/layers_oneDNN/BinaryOpLayer.cpp index f70ba572..9b7bd481 100644 --- a/src/layers_oneDNN/BinaryOpLayer.cpp +++ b/src/layers_oneDNN/BinaryOpLayer.cpp @@ -30,10 +30,16 @@ void BinaryOpLayerOneDnn::run(const std::vector& input, const auto& src1_data = *b.as(); std::vector dst_data(output_shape_.count()); - dnnl::memory src0_mem(src0_md_, *engine_, - const_cast(src0_data.data())); - dnnl::memory src1_mem(src1_md_, *engine_, - const_cast(src1_data.data())); + dnnl::memory src0_mem( + src0_md_, *engine_, + const_cast( + src0_data + .data())); // NOLINT(cppcoreguidelines-pro-type-const-cast) + dnnl::memory src1_mem( + src1_md_, *engine_, + const_cast( + src1_data + .data())); // NOLINT(cppcoreguidelines-pro-type-const-cast) dnnl::memory dst_mem(dst_md_, *engine_, dst_data.data()); binary_prim_->execute(*stream_, {{DNNL_ARG_SRC_0, src0_mem}, @@ -47,10 +53,16 @@ void BinaryOpLayerOneDnn::run(const std::vector& input, const auto& src1_data = *b.as(); std::vector dst_data(output_shape_.count()); - dnnl::memory src0_mem(src0_md_, *engine_, - const_cast(src0_data.data())); - dnnl::memory src1_mem(src1_md_, *engine_, - const_cast(src1_data.data())); + dnnl::memory src0_mem( + src0_md_, *engine_, + const_cast( + src0_data + .data())); // NOLINT(cppcoreguidelines-pro-type-const-cast) + dnnl::memory src1_mem( + src1_md_, *engine_, + const_cast( + src1_data + .data())); // NOLINT(cppcoreguidelines-pro-type-const-cast) dnnl::memory dst_mem(dst_md_, *engine_, dst_data.data()); binary_prim_->execute(*stream_, {{DNNL_ARG_SRC_0, src0_mem}, diff --git a/src/layers_oneDNN/ConvLayer.cpp b/src/layers_oneDNN/ConvLayer.cpp index b56e4f2e..178ae8b8 100644 --- a/src/layers_oneDNN/ConvLayer.cpp +++ b/src/layers_oneDNN/ConvLayer.cpp @@ -5,6 +5,8 @@ #include #include #include +#include +#include namespace it_lab_ai { @@ -73,18 +75,15 @@ void ConvLayerOneDnn::create_output_tensor(Tensor& output_tensor, Type data_type, dnnl::memory& dst_memory) { size_t output_size = output_shape.count(); + auto* dst_data = static_cast(dst_memory.get_data_handle()); if (data_type == Type::kFloat) { std::vector output_data(output_size); - std::copy(static_cast(dst_memory.get_data_handle()), - static_cast(dst_memory.get_data_handle()) + output_size, - output_data.begin()); + std::copy_n(dst_data, output_size, output_data.begin()); output_tensor = make_tensor(output_data, output_shape); } else if (data_type == Type::kInt) { std::vector float_output(output_size); - std::copy(static_cast(dst_memory.get_data_handle()), - static_cast(dst_memory.get_data_handle()) + output_size, - float_output.begin()); + std::copy_n(dst_data, output_size, float_output.begin()); std::vector int_output(output_size); std::transform(float_output.begin(), float_output.end(), int_output.begin(), @@ -194,29 +193,30 @@ void ConvLayerOneDnn::initialize_convolution(const Shape& input_shape, auto dst_md = dnnl::memory::desc(dst_dims, dnnl_data_type, dnnl::memory::format_tag::any); - dnnl::memory::dims kernel_dims; - dnnl::memory::format_tag weights_format; - if (is_depthwise) { - kernel_dims = {static_cast(group_), 1, 1, - static_cast(kernel_->get_shape()[2]), - static_cast(kernel_->get_shape()[3])}; - weights_format = dnnl::memory::format_tag::goihw; - } else if (group_ > 1) { - kernel_dims = { - static_cast(group_), - static_cast(kernel_->get_shape()[0] / group_), - static_cast(kernel_->get_shape()[1]), - static_cast(kernel_->get_shape()[2]), - static_cast(kernel_->get_shape()[3])}; - weights_format = dnnl::memory::format_tag::goihw; - } else { + const auto [kernel_dims, weights_format] = + [&]() -> std::pair { + if (is_depthwise) { + return {{static_cast(group_), 1, 1, + static_cast(kernel_->get_shape()[2]), + static_cast(kernel_->get_shape()[3])}, + dnnl::memory::format_tag::goihw}; + } + if (group_ > 1) { + return { + {static_cast(group_), + static_cast(kernel_->get_shape()[0] / group_), + static_cast(kernel_->get_shape()[1]), + static_cast(kernel_->get_shape()[2]), + static_cast(kernel_->get_shape()[3])}, + dnnl::memory::format_tag::goihw}; + } const auto& k_shape = kernel_->get_shape(); - kernel_dims = {static_cast(k_shape[0]), - static_cast(k_shape[1]), - static_cast(k_shape[2]), - static_cast(k_shape[3])}; - weights_format = dnnl::memory::format_tag::oihw; - } + return {{static_cast(k_shape[0]), + static_cast(k_shape[1]), + static_cast(k_shape[2]), + static_cast(k_shape[3])}, + dnnl::memory::format_tag::oihw}; + }(); auto weights_md = dnnl::memory::desc(kernel_dims, dnnl_data_type, weights_format); @@ -224,12 +224,9 @@ void ConvLayerOneDnn::initialize_convolution(const Shape& input_shape, dnnl::memory::desc bias_md; bool has_bias = !bias_->empty(); if (!bias_->empty()) { - size_t bias_size; - if (is_depthwise || group_ == 1) { - bias_size = kernel_dims[0]; - } else { - bias_size = kernel_->get_shape()[0]; - } + const size_t bias_size = (is_depthwise || group_ == 1) + ? static_cast(kernel_dims[0]) + : kernel_->get_shape()[0]; bias_md = dnnl::memory::desc({static_cast(bias_size)}, @@ -303,20 +300,14 @@ dnnl::memory::dims ConvLayerOneDnn::get_kernel_dims() const { Shape ConvLayerOneDnn::get_output_shape(const Shape& input_shape) const { const Shape& kernel_shape = kernel_->get_shape(); - size_t kernel_out_channels; - size_t kernel_height; - size_t kernel_width; - - if (use_legacy_ || - (kernel_shape.dims() == 4 && kernel_shape[3] > kernel_shape[2])) { - kernel_height = kernel_shape[0]; - kernel_width = kernel_shape[1]; - kernel_out_channels = kernel_shape[3]; - } else { - kernel_out_channels = kernel_shape[0]; - kernel_height = kernel_shape[2]; - kernel_width = kernel_shape[3]; - } + const auto [kernel_out_channels, kernel_height, + kernel_width] = [&]() -> std::tuple { + if (use_legacy_ || + (kernel_shape.dims() == 4 && kernel_shape[3] > kernel_shape[2])) { + return {kernel_shape[3], kernel_shape[0], kernel_shape[1]}; + } + return {kernel_shape[0], kernel_shape[2], kernel_shape[3]}; + }(); size_t batch_size = input_shape[0]; size_t input_height = input_shape[2]; diff --git a/src/layers_oneDNN/EWLayer.cpp b/src/layers_oneDNN/EWLayer.cpp index 7f9375d4..dd7cde43 100644 --- a/src/layers_oneDNN/EWLayer.cpp +++ b/src/layers_oneDNN/EWLayer.cpp @@ -21,10 +21,10 @@ void EwLayerOneDnn::run(const std::vector& input, if (type == Type::kFloat) { const auto& src = *in.as(); + std::vector src_copy(src.begin(), src.end()); std::vector dst(src.size()); - dnnl::memory src_mem(memory_desc_, *engine_, - const_cast(src.data())); + dnnl::memory src_mem(memory_desc_, *engine_, src_copy.data()); dnnl::memory dst_mem(memory_desc_, *engine_, dst.data()); eltwise_prim_->execute(*stream_, @@ -34,9 +34,10 @@ void EwLayerOneDnn::run(const std::vector& input, output[0] = make_tensor(dst, in.get_shape()); } else if (type == Type::kInt) { const auto& src = *in.as(); + std::vector src_copy(src.begin(), src.end()); std::vector dst(src.size()); - dnnl::memory src_mem(memory_desc_, *engine_, const_cast(src.data())); + dnnl::memory src_mem(memory_desc_, *engine_, src_copy.data()); dnnl::memory dst_mem(memory_desc_, *engine_, dst.data()); eltwise_prim_->execute(*stream_, diff --git a/src/layers_oneDNN/PoolingLayer.cpp b/src/layers_oneDNN/PoolingLayer.cpp index 088e2a78..6226f161 100644 --- a/src/layers_oneDNN/PoolingLayer.cpp +++ b/src/layers_oneDNN/PoolingLayer.cpp @@ -22,10 +22,10 @@ void PoolingLayerOneDnn::run(const std::vector& input, if (type == Type::kFloat) { const auto& src = *in.as(); + std::vector src_copy(src.begin(), src.end()); std::vector dst(output_shape_.count()); - dnnl::memory src_mem(src_memory_desc_, *engine_, - const_cast(src.data())); + dnnl::memory src_mem(src_memory_desc_, *engine_, src_copy.data()); dnnl::memory dst_mem(dst_memory_desc_, *engine_, dst.data()); pool_prim_->execute(*stream_, @@ -35,10 +35,10 @@ void PoolingLayerOneDnn::run(const std::vector& input, output[0] = make_tensor(dst, output_shape_); } else if (type == Type::kInt) { const auto& src = *in.as(); + std::vector src_copy(src.begin(), src.end()); std::vector dst(output_shape_.count()); - dnnl::memory src_mem(src_memory_desc_, *engine_, - const_cast(src.data())); + dnnl::memory src_mem(src_memory_desc_, *engine_, src_copy.data()); dnnl::memory dst_mem(dst_memory_desc_, *engine_, dst.data()); pool_prim_->execute(*stream_, @@ -91,20 +91,16 @@ Shape PoolingLayerOneDnn::calculate_output_shape( size_t effective_kernel_size = (kernel_size - 1) * dilation + 1; - size_t output_size; - if (ceil_mode_) { - output_size = static_cast(std::ceil( - static_cast(input_size + pad_front + pad_back - - effective_kernel_size) / - static_cast(stride))) + - 1; - } else { - output_size = static_cast(std::floor( - static_cast(input_size + pad_front + pad_back - - effective_kernel_size) / - static_cast(stride))) + - 1; - } + const size_t output_size = [&]() -> size_t { + const auto output_raw = + static_cast(input_size + pad_front + pad_back - + effective_kernel_size) / + static_cast(stride); + if (ceil_mode_) { + return static_cast(std::ceil(output_raw)) + 1; + } + return static_cast(std::floor(output_raw)) + 1; + }(); output_shape[input_idx] = output_size; } @@ -234,4 +230,4 @@ dnnl::algorithm PoolingLayerOneDnn::get_PoolType() const { poolingType_); } -} // namespace it_lab_ai \ No newline at end of file +} // namespace it_lab_ai diff --git a/src/layers_oneDNN/ReduceLayer.cpp b/src/layers_oneDNN/ReduceLayer.cpp index 5e9923f1..3df2d69a 100644 --- a/src/layers_oneDNN/ReduceLayer.cpp +++ b/src/layers_oneDNN/ReduceLayer.cpp @@ -54,10 +54,10 @@ void ReduceLayerOneDnn::run(const std::vector& input, if (type == Type::kFloat) { const auto& src_data = *in.as(); + std::vector src_copy(src_data.begin(), src_data.end()); std::vector dst_data(one_dnn_output_shape.count()); - dnnl::memory src_mem(src_md_, *engine_, - const_cast(src_data.data())); + dnnl::memory src_mem(src_md_, *engine_, src_copy.data()); dnnl::memory dst_mem(dst_md_, *engine_, dst_data.data()); reduction_prim_->execute( @@ -85,9 +85,10 @@ void ReduceLayerOneDnn::run(const std::vector& input, } else if (type == Type::kInt) { const auto& src_data = *in.as(); + std::vector src_copy(src_data.begin(), src_data.end()); std::vector dst_data(one_dnn_output_shape.count()); - dnnl::memory src_mem(src_md_, *engine_, const_cast(src_data.data())); + dnnl::memory src_mem(src_md_, *engine_, src_copy.data()); dnnl::memory dst_mem(dst_md_, *engine_, dst_data.data()); reduction_prim_->execute( From 26e2bc388e15026b430a343a3016d20ba25cd582 Mon Sep 17 00:00:00 2001 From: Arseniy Obolenskiy Date: Thu, 12 Mar 2026 16:29:35 +0100 Subject: [PATCH 2/3] more fixes --- .clang-tidy | 10 ++++++++-- include/layers/Layer.hpp | 1 + include/layers/PoolingLayer.hpp | 26 +++++++++++++------------- include/perf/benchmarking.hpp | 24 +++++++++++++++--------- 4 files changed, 37 insertions(+), 24 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index bd28b2a7..05f1ba75 100644 --- a/.clang-tidy +++ b/.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, diff --git a/include/layers/Layer.hpp b/include/layers/Layer.hpp index 0139912f..b8c05304 100644 --- a/include/layers/Layer.hpp +++ b/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 run( diff --git a/include/layers/PoolingLayer.hpp b/include/layers/PoolingLayer.hpp index adb7223f..6a19f104 100644 --- a/include/layers/PoolingLayer.hpp +++ b/include/layers/PoolingLayer.hpp @@ -179,18 +179,18 @@ PoolingLayerImpl::PoolingLayerImpl( size_t effective_kernel_size = (kernel_size - 1) * dilation + 1; - size_t output_size; - if (ceil_mode) { - output_size = static_cast( - std::ceil((input_size + pad - effective_kernel_size) / - static_cast(stride))) + - 1; - } else { - output_size = static_cast( - std::floor((input_size + pad - effective_kernel_size) / - static_cast(stride))) + - 1; - } + size_t output_size = [=]() { + if (ceil_mode) { + return static_cast( + std::ceil((input_size + pad - effective_kernel_size) / + static_cast(stride))) + + 1; + } + return static_cast( + std::floor((input_size + pad - effective_kernel_size) / + static_cast(stride))) + + 1; + }(); this->outputShape_[input_shape.dims() - pooling_shape.dims() + i] = output_size; @@ -321,4 +321,4 @@ std::vector PoolingLayerImpl::run( return res; } -} // namespace it_lab_ai \ No newline at end of file +} // namespace it_lab_ai diff --git a/include/perf/benchmarking.hpp b/include/perf/benchmarking.hpp index c0ee374d..36f9368b 100644 --- a/include/perf/benchmarking.hpp +++ b/include/perf/benchmarking.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include namespace it_lab_ai { @@ -16,7 +17,7 @@ template (); auto start = std::chrono::high_resolution_clock::now(); - func(args...); + std::forward(func)(std::forward(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 double elapsed_time_omp(Function&& func, Args&&... args) { double start = omp_get_wtime(); - func(args...); + std::forward(func)(std::forward(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(); auto start = std::chrono::high_resolution_clock::now(); for (size_t i = 0; i < iters; i++) { - func(args...); + std::forward(func)(std::forward(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(func)(std::forward(args)...); } double end = omp_get_wtime(); return (end - start) / iters; @@ -61,12 +62,15 @@ template ThroughputContainerType throughput(Function&& func, Args&&... args) { return ThroughputContainerType(1) / - elapsed_time(func, args...); + elapsed_time( + std::forward(func), std::forward(args)...); } template double throughput_omp(Function&& func, Args&&... args) { - return 1 / elapsed_time_omp(func, args...); + return 1 / + elapsed_time_omp(std::forward(func), + std::forward(args)...); } template (iters, func, - args...); + elapsed_time_avg( + iters, std::forward(func), std::forward(args)...); } template 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(func), + std::forward(args)...); } // as "Manhattan" norm of error-vector From a7dd6360d89570a394434d9358b40f2db3cfebf2 Mon Sep 17 00:00:00 2001 From: Arseniy Obolenskiy Date: Thu, 12 Mar 2026 17:02:36 +0100 Subject: [PATCH 3/3] fmt --- include/perf/benchmarking.hpp | 10 ++++------ src/Weights_Reader/reader_weights.cpp | 4 ++-- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/include/perf/benchmarking.hpp b/include/perf/benchmarking.hpp index 36f9368b..e63b57c6 100644 --- a/include/perf/benchmarking.hpp +++ b/include/perf/benchmarking.hpp @@ -68,9 +68,8 @@ ThroughputContainerType throughput(Function&& func, Args&&... args) { template double throughput_omp(Function&& func, Args&&... args) { - return 1 / - elapsed_time_omp(std::forward(func), - std::forward(args)...); + return 1 / elapsed_time_omp(std::forward(func), + std::forward(args)...); } template double throughput_omp_avg(const size_t iters, Function&& func, Args&&... args) { - return 1 / - elapsed_time_omp_avg(iters, std::forward(func), - std::forward(args)...); + return 1 / elapsed_time_omp_avg(iters, std::forward(func), + std::forward(args)...); } // as "Manhattan" norm of error-vector diff --git a/src/Weights_Reader/reader_weights.cpp b/src/Weights_Reader/reader_weights.cpp index a72ffdff..4f8e2439 100644 --- a/src/Weights_Reader/reader_weights.cpp +++ b/src/Weights_Reader/reader_weights.cpp @@ -44,8 +44,8 @@ json read_json(const std::string& filename) { return result; #else - int fd = open(filename.c_str(), - O_RDONLY); // NOLINT(cppcoreguidelines-pro-type-vararg) + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) + int fd = open(filename.c_str(), O_RDONLY); if (fd == -1) { throw std::runtime_error("Cannot open file: " + filename); }