Гасенин Леонид. Технология OMP. Поиск кратчайших путей из одной вершины (алгоритм Дейкстры). Вариант 21.

tasks/gasenin_l_djstra_omp/common/include/common.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+
+#include "task/include/task.hpp"
+
+namespace gasenin_l_djstra {
+
+using InType = int;
+using OutType = int;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace gasenin_l_djstra

tasks/gasenin_l_djstra_omp/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Леонид",
+    "group_number": "3823Б1ФИ3",
+    "last_name": "Гасенин",
+    "middle_name": "Вячеславович",
+    "task_number": "1"
+  }
+}

tasks/gasenin_l_djstra_omp/omp/include/ops_omp.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+
+#include "gasenin_l_djstra_omp/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace gasenin_l_djstra {
+
+class GaseninLDjstraOMP : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kOMP;
+  }
+  explicit GaseninLDjstraOMP(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+  std::vector<InType> dist_;
+  std::vector<char> visited_;
+};
+
+}  // namespace gasenin_l_djstra

tasks/gasenin_l_djstra_omp/omp/src/ops_omp.cpp

@@ -0,0 +1,155 @@
+#include "gasenin_l_djstra_omp/omp/include/ops_omp.hpp"
+
+#include <omp.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include <vector>
+
+#include "gasenin_l_djstra_omp/common/include/common.hpp"
+
+namespace gasenin_l_djstra {
+
+namespace {
+
+int GetNumThreads() {
+  int num_threads = 1;
+
+#pragma omp parallel default(none) shared(num_threads)
+  {
+#pragma omp single
+    num_threads = omp_get_num_threads();
+  }
+
+  return num_threads;
+}
+
+InType FindGlobalVertexOMP(const InType n, const InType inf, std::vector<InType> &dist, std::vector<char> &visited,
+                           const int num_threads) {
+  std::vector<InType> local_min(num_threads, inf);
+  std::vector<InType> local_vertex(num_threads, -1);
+
+  InType global_vertex = -1;
+
+#pragma omp parallel default(none) shared(n, inf, dist, visited, local_min, local_vertex, global_vertex, num_threads)
+  {
+    const int thread_id = omp_get_thread_num();
+
+    InType thread_min = inf;
+    InType thread_vertex = -1;
+
+#pragma omp for nowait
+    for (int index = 0; index < n; ++index) {
+      if (visited[index] == 0 && dist[index] < thread_min) {
+        thread_min = dist[index];
+        thread_vertex = index;
+      }
+    }
+
+    local_min[thread_id] = thread_min;
+    local_vertex[thread_id] = thread_vertex;
+
+#pragma omp barrier
+
+#pragma omp single
+    {
+      InType global_min = inf;
+
+      for (int thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
+        if (local_min[thread_idx] < global_min) {
+          global_min = local_min[thread_idx];
+          global_vertex = local_vertex[thread_idx];
+        }
+      }
+
+      if (global_vertex != -1 && global_min != inf) {
+        visited[global_vertex] = 1;
+      } else {
+        global_vertex = -1;
+      }
+    }
+  }
+
+  return global_vertex;
+}
+
+void RelaxEdgesOMP(const InType n, const InType inf, const InType global_vertex, std::vector<InType> &dist,
+                   std::vector<char> &visited) {
+#pragma omp parallel for default(none) shared(n, inf, global_vertex, dist, visited)
+  for (int vertex = 0; vertex < n; ++vertex) {
+    if (visited[vertex] == 0 && vertex != global_vertex) {
+      const InType weight = std::abs(global_vertex - vertex);
+
+      if (dist[global_vertex] != inf) {
+        const InType new_dist = dist[global_vertex] + weight;
+        dist[vertex] = std::min(dist[vertex], new_dist);
+      }
+    }
+  }
+}
+
+int64_t CalculateTotalSumOMP(const InType n, const InType inf, std::vector<InType> &dist) {
+  int64_t total_sum = 0;
+
+#pragma omp parallel for reduction(+ : total_sum) default(none) shared(n, inf, dist)
+  for (int i = 0; i < n; ++i) {
+    if (dist[i] != inf) {
+      total_sum += dist[i];
+    }
+  }
+
+  return total_sum;
+}
+
+}  // namespace
+
+GaseninLDjstraOMP::GaseninLDjstraOMP(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool GaseninLDjstraOMP::ValidationImpl() {
+  return GetInput() > 0;
+}
+
+bool GaseninLDjstraOMP::PreProcessingImpl() {
+  const InType n = GetInput();
+  const InType inf = std::numeric_limits<InType>::max();
+
+  dist_.assign(n, inf);
+  visited_.assign(n, 0);
+
+  dist_[0] = 0;
+  return true;
+}
+
+bool GaseninLDjstraOMP::RunImpl() {
+  const InType n = GetInput();
+  const InType inf = std::numeric_limits<InType>::max();
+
+  const int num_threads = GetNumThreads();
+
+  for (int iteration = 0; iteration < n; ++iteration) {
+    InType global_vertex = FindGlobalVertexOMP(n, inf, dist_, visited_, num_threads);
+
+    if (global_vertex == -1) {
+      break;
+    }
+
+    RelaxEdgesOMP(n, inf, global_vertex, dist_, visited_);
+  }
+
+  const int64_t total_sum = CalculateTotalSumOMP(n, inf, dist_);
+
+  GetOutput() = static_cast<OutType>(total_sum);
+  return true;
+}
+
+bool GaseninLDjstraOMP::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace gasenin_l_djstra

tasks/gasenin_l_djstra_omp/settings.json

@@ -0,0 +1,10 @@
+{
+  "tasks": {
+    "all": "enabled",
+    "omp": "enabled",
+    "seq": "enabled",
+    "stl": "enabled",
+    "tbb": "enabled"
+  },
+  "tasks_type": "threads"
+}

tasks/gasenin_l_djstra_omp/tests/functional/main.cpp

@@ -0,0 +1,59 @@
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cstddef>
+#include <string>
+#include <tuple>
+
+#include "gasenin_l_djstra_omp/common/include/common.hpp"
+#include "gasenin_l_djstra_omp/omp/include/ops_omp.hpp"
+#include "util/include/func_test_util.hpp"
+#include "util/include/util.hpp"
+
+namespace gasenin_l_djstra {
+
+class GaseninLDjstraOmpFuncTests : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+ public:
+  static std::string PrintTestParam(const TestType &test_param) {
+    return std::to_string(std::get<0>(test_param)) + "_" + std::get<1>(test_param);
+  }
+
+ protected:
+  void SetUp() override {
+    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    input_data_ = std::get<0>(params);
+    expected_output_ = input_data_ * (input_data_ - 1) / 2;
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return expected_output_ == output_data;
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+
+ private:
+  InType input_data_ = 0;
+  OutType expected_output_ = 0;
+};
+
+namespace {
+
+TEST_P(GaseninLDjstraOmpFuncTests, DijkstraFromParams) {
+  ExecuteTest(GetParam());
+}
+
+const std::array<TestType, 3> kTestParam = {std::make_tuple(3, "3"), std::make_tuple(5, "5"), std::make_tuple(7, "7")};
+
+const auto kTestTasksList =
+    std::tuple_cat(ppc::util::AddFuncTask<GaseninLDjstraOMP, InType>(kTestParam, PPC_SETTINGS_gasenin_l_djstra_omp));
+
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+const auto kPerfTestName = GaseninLDjstraOmpFuncTests::PrintFuncTestName<GaseninLDjstraOmpFuncTests>;
+
+INSTANTIATE_TEST_SUITE_P(DijkstraOmpTests, GaseninLDjstraOmpFuncTests, kGtestValues, kPerfTestName);
+
+}  // namespace
+
+}  // namespace gasenin_l_djstra

tasks/gasenin_l_djstra_omp/tests/performance/main.cpp

@@ -0,0 +1,40 @@
+#include <gtest/gtest.h>
+
+#include "gasenin_l_djstra_omp/common/include/common.hpp"
+#include "gasenin_l_djstra_omp/omp/include/ops_omp.hpp"
+#include "util/include/perf_test_util.hpp"
+
+namespace gasenin_l_djstra {
+
+class GaseninLDjstraOmpPerfTests : public ppc::util::BaseRunPerfTests<InType, OutType> {
+  InType input_data_{};
+  OutType expected_output_{};
+
+  void SetUp() override {
+    input_data_ = 200;
+    expected_output_ = input_data_ * (input_data_ - 1) / 2;
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return expected_output_ == output_data;
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+};
+
+TEST_P(GaseninLDjstraOmpPerfTests, RunPerfModes) {
+  ExecuteTest(GetParam());
+}
+
+namespace {
+
+const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks<InType, GaseninLDjstraOMP>(PPC_SETTINGS_gasenin_l_djstra_omp);
+const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
+const auto kPerfTestName = GaseninLDjstraOmpPerfTests::CustomPerfTestName;
+
+INSTANTIATE_TEST_SUITE_P(DjkstraOmpPerf, GaseninLDjstraOmpPerfTests, kGtestValues, kPerfTestName);
+
+}  // namespace
+}  // namespace gasenin_l_djstra