add parallel kinds

Author: Semyon1104

app/Graph/graph_build.cpp

@@ -16,8 +16,39 @@ int main(int argc, char* argv[]) {
       model_name = argv[++i];
     } else if (std::string(argv[i]) == "--onednn") {
       options.backend = Backend::kOneDnn;
-    } else if (std::string(argv[i]) == "--parallel") {
+      if (options.parallel) {
+        std::cout << "Warning: oneDNN backend is not compatible with parallel "
+                     "execution. Disabling parallelism."
+                  << std::endl;
+        options.parallel = false;
+        options.parallel_backend = ParallelBackend::kNone;
+      }
+    } else if (std::string(argv[i]) == "--parallel" && i + 1 < argc) {
+      if (options.backend == Backend::kOneDnn) {
+        std::cout << "Warning: Parallel execution is not compatible with "
+                     "oneDNN backend. Ignoring --parallel option."
+                  << std::endl;
+        i++;
+        continue;
+      }
+
       options.parallel = true;
+      std::string backend_str = argv[++i];
+      if (backend_str == "tbb") {
+        options.parallel_backend = ParallelBackend::kTBB;
+      } else if (backend_str == "stl") {
+        options.parallel_backend = ParallelBackend::kSTL;
+      } else if (backend_str == "omp") {
+        options.parallel_backend = ParallelBackend::kOMP;
+      } else if (backend_str == "kokkos") {
+        options.parallel_backend = ParallelBackend::kKokkos;
+      } else if (backend_str == "sycl") {
+        options.parallel_backend = ParallelBackend::kSycl;
+      } else {
+        std::cerr << "Unknown parallel backend: " << backend_str
+                  << ". Using default (TBB)." << std::endl;
+        options.parallel_backend = ParallelBackend::kTBB;
+      }
     } else if (std::string(argv[i]) == "--threads" && i + 1 < argc) {
       options.threads = std::stoi(argv[++i]);
     }

include/graph/runtime_options.hpp

@@ -2,9 +2,18 @@
 #include <cstdint>
 
 enum class Backend : uint8_t { kNaive, kOneDnn };
+enum class ParallelBackend : uint8_t {
+  kNone,
+  kTBB,
+  kSTL,
+  kOMP,
+  kKokkos,
+  kSycl
+};
 
 struct RuntimeOptions {
   Backend backend{Backend::kNaive};
+  ParallelBackend parallel_backend{ParallelBackend::kNone};
   int threads{0};
   bool parallel{false};
 };

include/layers/ConvLayer.hpp

@@ -50,9 +50,10 @@ class ConvolutionalLayer : public Layer {
     implType_ = implType;
     useLegacyImpl_ = useLegacyImpl;
   }
-
   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);
 #ifdef ENABLE_STATISTIC_WEIGHTS
   Tensor get_weights() override { return kernel_; }
 #endif

src/layers/ConvLayer.cpp

@@ -4,6 +4,13 @@ namespace it_lab_ai {
 
 void ConvolutionalLayer::run(const std::vector<Tensor>& input,
                              std::vector<Tensor>& output) {
+  RuntimeOptions default_options;
+  run(input, output, default_options);
+}
+
+void ConvolutionalLayer::run(const std::vector<Tensor>& input,
+                             std::vector<Tensor>& output,
+                             const RuntimeOptions& options) {
   if (input.size() != 1) {
     throw std::runtime_error("ConvolutionalLayer: Input tensors not 1");
   }
@@ -28,6 +35,29 @@ void ConvolutionalLayer::run(const std::vector<Tensor>& input,
       return;
     }
   }
+  if (options.parallel) {
+    switch (options.parallel_backend) {
+      case ParallelBackend::kTBB:
+        implType_ = kTBB;
+        break;
+      case ParallelBackend::kSTL:
+        implType_ = kSTL;
+        break;
+      // case ParallelBackend::kOMP:
+      //   implType = kOMP;
+      //   break;
+      // case ParallelBackend::kKokkos:
+      //   implType = kKokkos;
+      //   break;
+      // case ParallelBackend::kSycl:
+      //   implType = kSycl;
+      //   break;
+      case ParallelBackend::kNone:
+      default:
+        implType_ = kDefault;
+        break;
+    }
+  }
   switch (input[0].get_type()) {
     case Type::kInt: {
       if (kernel_.get_shape().dims() == 2) {
@@ -84,6 +114,11 @@ void ConvolutionalLayer::run(const std::vector<Tensor>& input,
                            group_, dilations_);
             break;
           }
+          /*case kTBB: {
+            Conv4DTBB<int>(input[0], kernel_, bias_, output[0], stride_, pads_,
+                        group_, dilations_);
+            break;
+          }*/
           default: {
             Conv4D<int>(input[0], kernel_, bias_, output[0], stride_, pads_,
                         group_, dilations_);
@@ -152,6 +187,10 @@ void ConvolutionalLayer::run(const std::vector<Tensor>& input,
                                pads_, group_, dilations_);
               break;
             }
+            /*case kTBB: {
+              Conv4DTBB<float>(input[0], kernel_, bias_, output[0], stride_,
+            pads_, group_, dilations_); break;
+            }*/
             default: {
               Conv4D<float>(input[0], kernel_, bias_, output[0], stride_, pads_,
                             group_, dilations_);