total time per layer

Author: Semyon1104

app/Graph/build.cpp

@@ -1174,6 +1174,7 @@ void print_time_stats(Graph& graph) {
   int sum = std::accumulate(elps_time.begin(), elps_time.end(), 0);
   std::cout << "Elapsed inference time:" << sum << '\n';
   std::cout << "!INFERENCE TIME INFO END!" << '\n';
+  graph.printLayerStats();
 #else
   (void)graph;
 #endif

include/graph/graph.hpp

@@ -14,6 +14,13 @@
 #include "runtime_options.hpp"
 
 namespace it_lab_ai {
+struct LayerTimeStats {
+  std::string layer_name;
+  double total_time = 0.0;
+  int call_count = 0;
+  double min_time = std::numeric_limits<double>::max();
+  double max_time = 0.0;
+};
 
 struct BranchState {
   int ind_layer;
@@ -24,6 +31,8 @@ struct BranchState {
 };
 
 class Graph {
+  std::map<std::string, LayerTimeStats> layer_stats_;
+  bool collect_layer_stats_ = true;
   int BiggestSize_;
   int V_;  // amount of ids
   std::vector<std::shared_ptr<Layer>> layers_;
@@ -372,8 +381,52 @@ class Graph {
       auto end = std::chrono::high_resolution_clock::now();
       auto elapsed =
           std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
-      time_.push_back(static_cast<int>(elapsed.count()));
-      time_layer_.push_back(layers_[current_layer]->getName());
+      int elapsed_ms = static_cast<int>(elapsed.count());
+      time_.push_back(elapsed_ms);
+
+      LayerType layer_type = layers_[current_layer]->getName();
+      time_layer_.push_back(layer_type);
+
+      if (collect_layer_stats_) {
+        // Èñïîëüçóåì òó æå label_map äëÿ êîíâåðòàöèè â ñòðîêó
+        static const std::unordered_map<LayerType, std::string> label_map = {
+            {kInput, "Input"},
+            {kPooling, "Pooling"},
+            {kElementWise, "Element-wise"},
+            {kConvolution, "Convolution"},
+            {kFullyConnected, "Dense"},
+            {kFlatten, "Flatten"},
+            {kConcat, "Concat"},
+            {kDropout, "Dropout"},
+            {kSplit, "Split"},
+            {kBinaryOp, "BinaryOp"},
+            {kTranspose, "Transpose"},
+            {kMatmul, "MatMul"},
+            {kReshape, "Reshape"},
+            {kSoftmax, "Softmax"},
+            {kReduce, "Reduce"},
+            {kBatchNormalization, "Normalization"}};
+
+        auto it = label_map.find(layer_type);
+        std::string layer_name_str =
+            (it != label_map.end()) ? it->second : "Unknown";
+
+        auto& stats = layer_stats_[layer_name_str];
+
+        // Îáíîâëÿåì ñòàòèñòèêó (ïðåäïîëàãàåì, ÷òî stats.total_time - ýòî int
+        // èëè double)
+        stats.total_time += elapsed_ms;
+        stats.call_count++;
+
+        // Îáíîâëÿåì min/max
+        if (stats.call_count == 1) {
+          stats.min_time = elapsed_ms;
+          stats.max_time = elapsed_ms;
+        } else {
+          if (elapsed_ms < stats.min_time) stats.min_time = elapsed_ms;
+          if (elapsed_ms > stats.max_time) stats.max_time = elapsed_ms;
+        }
+      }
 #endif
     }
   }
@@ -449,7 +502,22 @@ class Graph {
 
     return result;
   }
-
+  void printLayerStats() {
+    std::cout << "\n========== LAYER PERFORMANCE STATISTICS ==========\n";
+    std::cout << std::left << std::setw(20) << "Layer Type" << std::right
+              << std::setw(15) << "Total (ms)" << std::setw(12) << "Calls"
+              << std::setw(15) << "Avg (ms)" << std::setw(15) << "Min (ms)"
+              << std::setw(15) << "Max (ms)" << std::endl;
+
+    for (const auto& [name, stats] : layer_stats_) {
+      double avg = stats.total_time / stats.call_count;
+      std::cout << std::left << std::setw(20) << name << std::right
+                << std::fixed << std::setprecision(3) << std::setw(15)
+                << stats.total_time << std::setw(12) << stats.call_count
+                << std::setw(15) << avg << std::setw(15) << stats.min_time
+                << std::setw(15) << stats.max_time << std::endl;
+    }
+  }
   [[nodiscard]] std::vector<int> getTraversalOrder() const {
     auto in_out_degrees = getInOutDegrees();
     std::vector<int> in_degree(V_);

src/Weights_Reader/reader_weights.cpp

@@ -5,6 +5,7 @@
 #include <nlohmann/json.hpp>
 #include <stdexcept>
 #include <vector>
+
 #ifdef _WIN32
 #include <windows.h>
 #else
@@ -20,7 +21,6 @@ using json = nlohmann::json;
 
 json read_json(const std::string& filename) {
 #ifdef _WIN32
-  // Windows implementation
   HANDLE file = CreateFileA(filename.c_str(), GENERIC_READ, FILE_SHARE_READ,
                             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
@@ -33,7 +33,6 @@ json read_json(const std::string& filename) {
   CloseHandle(mapping);
   CloseHandle(file);
 #else
-  // Unix implementation
   int fd = open(filename.c_str(), O_RDONLY);
   struct stat sb;
   fstat(fd, &sb);