Merge branch 'main' into Semyon1104/Acc_Parametrized

Author: Semyon1104

app/Graph/build.cpp

@@ -1140,6 +1140,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

app/Graph/graph_build.cpp

@@ -38,6 +38,8 @@ int main(int argc, char* argv[]) {
         options.par_backend = ParBackend::kThreads;
       } else if (backend_str == "omp") {
         options.par_backend = ParBackend::kOmp;
+      } else if (backend_str == "kokkos") {
+        options.par_backend = ParBackend::kKokkos;
       } else {
         std::cerr << "Unknown parallel backend: " << backend_str
                   << ". Using default (Threads)." << '\n';

include/graph/graph.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <algorithm>
 #include <chrono>
+#include <iomanip>
 #include <memory>
 #include <queue>
 #include <stdexcept>
@@ -14,6 +15,31 @@
 #include "runtime_options.hpp"
 
 namespace it_lab_ai {
+static 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"}};
+
+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;
@@ -27,6 +53,7 @@ std::shared_ptr<Layer> layer_based_shared_copy(
     const std::shared_ptr<Layer>& layer, const RuntimeOptions& options);
 
 class Graph {
+  std::map<std::string, LayerTimeStats> layer_stats_;
   int BiggestSize_;
   int V_;  // amount of ids
   std::vector<std::shared_ptr<Layer>> layers_;
@@ -83,34 +110,38 @@ class Graph {
     split_distribution_ = std::move(split_dist);
   }
 
-  [[nodiscard]] int getVertexValue(size_t layerID) const {
-    if (layerID >= arrayV_.size()) {
-      throw std::invalid_argument("ArrayV does not contain this ID.");
-    }
-    return arrayV_[layerID];
-  }
-
-  [[nodiscard]] int getEdgeValue(size_t pos) const {
-    if (pos >= arrayE_.size()) {
-      throw std::invalid_argument("ArrayE does not contain this.");
-    }
-    return arrayE_[pos];
-  }
-
   [[nodiscard]] size_t getInputsSize(size_t layerID) const {
     if (layerID >= in_edges_.size()) {
-      throw std::invalid_argument("Input edges array do not contain this ID.");
+      throw std::invalid_argument(
+          "Input edges array does not contain this ID.");
     }
     return in_edges_[layerID].size();
   }
 
   [[nodiscard]] std::vector<int> getInLayers(size_t layerID) const {
     if (layerID >= in_edges_.size()) {
-      throw std::invalid_argument("Input edges array do not contain this ID.");
+      throw std::invalid_argument(
+          "Input edges array does not contain this ID.");
     }
     return in_edges_[layerID];
   }
 
+  [[nodiscard]] size_t getOutputsSize(size_t layerID) const {
+    if (layerID >= layers_.size()) {
+      throw std::invalid_argument("Layers array does not contain this ID.");
+    }
+    return arrayV_[layerID + 1] - arrayV_[layerID];
+  }
+
+  [[nodiscard]] std::vector<int> getOutLayers(size_t layerID) const {
+    if (layerID >= layers_.size()) {
+      throw std::invalid_argument(
+          "Output edges array does not contain this ID.");
+    }
+    return std::vector<int>(arrayE_.begin() + arrayV_[layerID],
+                            arrayE_.begin() + arrayV_[layerID + 1]);
+  }
+
   [[nodiscard]] int getLayersCount() const { return V_; }
 
   [[nodiscard]] std::shared_ptr<Layer> getLayerFromID(size_t layerID) const {
@@ -237,8 +268,9 @@ class Graph {
     }
     // remove outputs
     int amount_connected = arrayV_[id + 1] - arrayV_[id];
+    std::vector<int> array_e_copy = arrayE_;
     for (int i = 0; i < amount_connected; i++) {
-      removeConnection(id, arrayE_[arrayV_[id] + i]);
+      removeConnection(id, array_e_copy[arrayV_[id] + i]);
     }
     // remove vertex
     in_edges_.erase(in_edges_.begin() + id);
@@ -378,8 +410,27 @@ 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);
+
+      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 += elapsed_ms;
+      stats.call_count++;
+
+      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
     }
   }
@@ -403,25 +454,6 @@ class Graph {
 #ifdef ENABLE_STATISTIC_TIME
   std::vector<std::string> getTimeInfo() {
     std::vector<std::string> res;
-
-    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"}};
-
     for (size_t i = 0; i < time_.size(); i++) {
       auto it = label_map.find(time_layer_[i]);
       std::string layer_name = (it != label_map.end()) ? it->second : "Unknown";
@@ -456,6 +488,23 @@ 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)" << '\n';
+
+    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 << '\n';
+    }
+  }
+
   [[nodiscard]] std::vector<int> getTraversalOrder() const {
     auto in_out_degrees = getInOutDegrees();
     std::vector<int> in_degree(V_);

include/graph_transformations/graph_transformations.hpp

@@ -2,9 +2,26 @@
 #include <vector>
 
 #include "graph/graph.hpp"
+#include "layers/EWLayer.hpp"
 #include "layers/Layer.hpp"
 
 namespace it_lab_ai {
+
+struct IOOrder {
+  std::vector<int> in_order;
+  std::vector<int> out_order;
+  void fill_empty(size_t in_size, size_t out_size) {
+    if (in_order.empty()) {
+      in_order.resize(in_size);
+      std::iota(in_order.begin(), in_order.end(), 0);
+    }
+    if (out_order.empty()) {
+      out_order.resize(out_size);
+      std::iota(out_order.begin(), out_order.end(), 0);
+    }
+  }
+};
+
 std::vector<std::vector<int>> find_subgraphs(const Graph& graph,
                                              const Graph& subgraph);
 bool has_edge(const Graph& graph, int id_from, int id_to);
@@ -13,4 +30,15 @@ bool is_leaf(const Graph& graph, int id);
 bool run_search(const Graph& graph, const Graph& subgraph,
                 std::vector<int>& assignments,
                 std::vector<std::vector<int>>& results);
+
+void change_ids(std::vector<std::vector<int>>& vec, int id);
+bool does_intersect(const std::vector<int>& vec1, const std::vector<int>& vec2);
+void changed_subgraphs(const Graph& graph, const Graph& subgraph_from,
+                       const std::shared_ptr<Layer>& layer_to, Graph& new_graph,
+                       Tensor& out,
+                       const RuntimeOptions& options = RuntimeOptions());
+void changed_subgraphs(const Graph& graph, const Graph& subgraph_from,
+                       const Graph& subgraph_to, Graph& new_graph, Tensor& out,
+                       const RuntimeOptions& options = RuntimeOptions(),
+                       IOOrder order = IOOrder());
 }  // namespace it_lab_ai

include/layers/BinaryOpLayer.hpp

@@ -19,6 +19,8 @@ class BinaryOpLayer : public Layer {
 
   void run(const std::vector<Tensor>& input,
            std::vector<Tensor>& output) override;
+  void run(const std::vector<Tensor>& input, std::vector<Tensor>& output,
+           const RuntimeOptions& options) override;
   static bool is_scalar_tensor(const Tensor& t);
 
 #ifdef ENABLE_STATISTIC_WEIGHTS
@@ -30,6 +32,7 @@ class BinaryOpLayer : public Layer {
 
  private:
   Operation op_;
+  ParBackend parallel_backend_ = ParBackend::kSeq;
 
   template <typename ValueType>
   void run_with_scalar_impl(const Tensor& input, ValueType scalar,

src/Weights_Reader/reader_weights.cpp

@@ -6,24 +6,64 @@
 #include <stdexcept>
 #include <vector>
 
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
 namespace it_lab_ai {
 
 using json = nlohmann::json;
 
 json read_json(const std::string& filename) {
-  std::ifstream ifs(filename);
-  if (!ifs.is_open()) {
-    throw std::runtime_error("Failed to open JSON file: " + filename);
+#ifdef _WIN32
+  HANDLE file = CreateFileA(filename.c_str(), GENERIC_READ, FILE_SHARE_READ,
+                            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+  if (file == INVALID_HANDLE_VALUE) {
+    throw std::runtime_error("Cannot open file: " + filename);
+  }
+
+  DWORD size = GetFileSize(file, NULL);
+  if (size == 0) {
+    CloseHandle(file);
+    return json{};
+  }
+
+  HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
+  char* data = (char*)MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
+
+  json result = json::parse(data, data + size);
+
+  UnmapViewOfFile(data);
+  CloseHandle(mapping);
+  CloseHandle(file);
+  return result;
+
+#else
+  int fd = open(filename.c_str(), O_RDONLY);
+  if (fd == -1) {
+    throw std::runtime_error("Cannot open file: " + filename);
   }
 
-  json model_data;
-  try {
-    ifs >> model_data;
-  } catch (const json::parse_error& e) {
-    throw std::runtime_error("JSON parse error: " + std::string(e.what()));
+  struct stat sb;
+  fstat(fd, &sb);
+
+  if (sb.st_size == 0) {
+    close(fd);
+    return json{};
   }
 
-  return model_data;
+  char* data = (char*)mmap(nullptr, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+  json result = json::parse(data, data + sb.st_size);
+
+  munmap(data, sb.st_size);
+  close(fd);
+  return result;
+#endif
 }
 
 void extract_values_from_json(const json& j, std::vector<float>& values) {

src/graph_transformations/CMakeLists.txt

@@ -1,4 +1,4 @@
 file(GLOB_RECURSE graphT_src *.cpp)
 add_library(graphT_lib STATIC "${GRAPHT_HEADERS}" "${graphT_src}")
-target_link_libraries(graphT_lib PUBLIC TBB_unified)
+target_link_libraries(graphT_lib PUBLIC graph_lib TBB_unified)
 add_dependencies(graphT_lib kokkos_external)