Add files via upload

vadimbelan · Jun 11, 2024 · da63cd0 · da63cd0
1 parent 4d4d8a9
commit da63cd0
Show file tree

Hide file tree

Showing 14 changed files with 1,692 additions and 0 deletions.
diff --git a/tasks/omp/belan_vadim_mat_fox_omp/func_tests/main.cpp b/tasks/omp/belan_vadim_mat_fox_omp/func_tests/main.cpp
@@ -0,0 +1,212 @@
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include "omp/belan_vadim_mat_fox_omp/include/ops_omp.hpp"
+
+using namespace BelanOMP;
+
+TEST(FoxBlockedParallel, MatrixMultiplication2x2) {
+  // Define input matrices
+  std::vector<double> matrixA = {1, 2, 3, 4};
+  std::vector<double> matrixB = {4, 3, 2, 1};
+  std::vector<double> expectedOutput = {8, 5, 20, 13};
+
+  // Create TaskData
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data()));
+  taskData->inputs_count.emplace_back(2);
+  taskData->inputs_count.emplace_back(2);
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data()));
+  taskData->inputs_count.emplace_back(2);
+  taskData->inputs_count.emplace_back(2);
+  taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[4]()));
+  taskData->outputs_count.emplace_back(2);
+  taskData->outputs_count.emplace_back(2);
+
+  // Create Task
+  FoxBlockedParallel foxBlockedParallel(taskData);
+  foxBlockedParallel.validation();
+  foxBlockedParallel.pre_processing();
+  auto *output = reinterpret_cast<double *>(taskData->outputs[0]);
+  foxBlockedParallel.run();
+  foxBlockedParallel.post_processing();
+
+  // Check the output
+  for (size_t i = 0; i < 4; ++i) {
+    ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]);
+  }
+
+  // Free memory
+  delete[] output;
+}
+
+TEST(FoxBlockedParallel, MatrixMultiplication) {
+  // Define input matrices
+  std::vector<double> matrixA = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  std::vector<double> matrixB = {9, 8, 7, 6, 5, 4, 3, 2, 1};
+  std::vector<double> expectedOutput = {30, 24, 18, 84, 69, 54, 138, 114, 90};
+
+  // Create TaskData
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data()));
+  taskData->inputs_count.emplace_back(3);
+  taskData->inputs_count.emplace_back(3);
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data()));
+  taskData->inputs_count.emplace_back(3);
+  taskData->inputs_count.emplace_back(3);
+  taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[9]()));
+  taskData->outputs_count.emplace_back(3);
+  taskData->outputs_count.emplace_back(3);
+
+  // Create Task
+  FoxBlockedParallel foxBlockedParallel(taskData);
+  foxBlockedParallel.validation();
+  foxBlockedParallel.pre_processing();
+  auto *output = reinterpret_cast<double *>(taskData->outputs[0]);
+  foxBlockedParallel.run();
+  foxBlockedParallel.post_processing();
+
+  // Check the output
+  for (size_t i = 0; i < 9; ++i) {
+    ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]);
+  }
+
+  // Free memory
+  delete[] output;
+}
+
+TEST(FoxBlockedParallel, MatrixMultiplication_VerySmallMatrices) {
+  // Define input matrices
+  std::vector<double> matrixA(10 * 10);
+  std::vector<double> matrixB(10 * 10);
+  std::vector<double> expectedOutput(10 * 10);
+
+  // Initialize matrices with random values
+  for (size_t i = 0; i < 10 * 10; ++i) {
+    matrixA[i] = rand() % 10;
+    matrixB[i] = rand() % 10;
+    expectedOutput[i] = 0;
+  }
+
+  for (size_t i = 0; i < 10; ++i) {
+    for (size_t j = 0; j < 10; ++j) {
+      for (size_t k = 0; k < 10; ++k) {
+        expectedOutput[i * 10 + j] += matrixA[i * 10 + k] * matrixB[k * 10 + j];
+      }
+    }
+  }
+
+  // Create TaskData
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data()));
+  taskData->inputs_count.emplace_back(10);
+  taskData->inputs_count.emplace_back(10);
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data()));
+  taskData->inputs_count.emplace_back(10);
+  taskData->inputs_count.emplace_back(10);
+  taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[10 * 10]()));
+  taskData->outputs_count.emplace_back(10);
+  taskData->outputs_count.emplace_back(10);
+
+  // Create Task
+  FoxBlockedParallel foxBlockedParallel(taskData);
+  foxBlockedParallel.validation();
+  foxBlockedParallel.pre_processing();
+  auto *output = reinterpret_cast<double *>(taskData->outputs[0]);
+  foxBlockedParallel.run();
+  foxBlockedParallel.post_processing();
+
+  // Check the output
+  for (size_t i = 0; i < 10 * 10; ++i) {
+    ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]);
+  }
+
+  // Free memory
+  delete[] output;
+}
+
+TEST(FoxBlockedParallel, MatrixMultiplication_SmallMatrices) {
+  // Define input matrices
+  std::vector<double> matrixA(100 * 100);
+  std::vector<double> matrixB(100 * 100);
+  std::vector<double> expectedOutput(100 * 100);
+
+  // Initialize matrices with random values
+  for (size_t i = 0; i < 100 * 100; ++i) {
+    matrixA[i] = rand() % 10;
+    matrixB[i] = rand() % 10;
+    expectedOutput[i] = 0;
+  }
+
+  for (size_t i = 0; i < 100; ++i) {
+    for (size_t j = 0; j < 100; ++j) {
+      for (size_t k = 0; k < 100; ++k) {
+        expectedOutput[i * 100 + j] += matrixA[i * 100 + k] * matrixB[k * 100 + j];
+      }
+    }
+  }
+
+  // Create TaskData
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data()));
+  taskData->inputs_count.emplace_back(100);
+  taskData->inputs_count.emplace_back(100);
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data()));
+  taskData->inputs_count.emplace_back(100);
+  taskData->inputs_count.emplace_back(100);
+  taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[100 * 100]()));
+  taskData->outputs_count.emplace_back(100);
+  taskData->outputs_count.emplace_back(100);
+
+  // Create Task
+  FoxBlockedParallel foxBlockedParallel(taskData);
+  foxBlockedParallel.validation();
+  foxBlockedParallel.pre_processing();
+  auto *output = reinterpret_cast<double *>(taskData->outputs[0]);
+  foxBlockedParallel.run();
+  foxBlockedParallel.post_processing();
+
+  // Check the output
+  for (size_t i = 0; i < 100 * 100; ++i) {
+    ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]);
+  }
+
+  // Free memory
+  delete[] output;
+}
+
+TEST(FoxBlockedParallel, MatrixMultiplicationWithNegatives) {
+  // Define input matrices with negative values
+  std::vector<double> matrixA = {-1, -2, -3, -4, -5, -6, -7, -8, -9};
+  std::vector<double> matrixB = {-9, -8, -7, -6, -5, -4, -3, -2, -1};
+  std::vector<double> expectedOutput = {30, 24, 18, 84, 69, 54, 138, 114, 90};
+
+  // Create TaskData
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data()));
+  taskData->inputs_count.emplace_back(3);
+  taskData->inputs_count.emplace_back(3);
+  taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data()));
+  taskData->inputs_count.emplace_back(3);
+  taskData->inputs_count.emplace_back(3);
+  taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[9]()));
+  taskData->outputs_count.emplace_back(3);
+  taskData->outputs_count.emplace_back(3);
+
+  // Create Task
+  FoxBlockedParallel foxBlockedParallel(taskData);
+  foxBlockedParallel.validation();
+  foxBlockedParallel.pre_processing();
+  auto *output = reinterpret_cast<double *>(taskData->outputs[0]);
+  foxBlockedParallel.run();
+  foxBlockedParallel.post_processing();
+
+  // Check the output
+  for (size_t i = 0; i < 9; ++i) {
+    ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]);
+  }
+
+  // Free memory
+  delete[] output;
+}
diff --git a/tasks/omp/belan_vadim_mat_fox_omp/include/ops_omp.hpp b/tasks/omp/belan_vadim_mat_fox_omp/include/ops_omp.hpp
@@ -0,0 +1,44 @@
+// Copyright 2024 Vadim Belan
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "core/task/include/task.hpp"
+
+namespace BelanOMP {
+
+using Matrix = std::vector<std::vector<double>>;
+
+class FoxBlockedSequential : public ppc::core::Task {
+ public:
+  explicit FoxBlockedSequential(std::shared_ptr<ppc::core::TaskData> taskData_) : Task(std::move(taskData_)) {}
+  bool pre_processing() override;
+  bool validation() override;
+  bool run() override;
+  bool post_processing() override;
+
+ private:
+  Matrix A{};
+  Matrix B{};
+  Matrix C{};
+  int block_size{};
+};
+
+class FoxBlockedParallel : public ppc::core::Task {
+ public:
+  explicit FoxBlockedParallel(std::shared_ptr<ppc::core::TaskData> taskData_) : Task(std::move(taskData_)) {}
+  bool pre_processing() override;
+  bool validation() override;
+  bool run() override;
+  bool post_processing() override;
+
+ private:
+  Matrix A{};
+  Matrix B{};
+  Matrix C{};
+  int block_size{};
+};
+
+}  // namespace BelanOMP
diff --git a/tasks/omp/belan_vadim_mat_fox_omp/perf.hpp b/tasks/omp/belan_vadim_mat_fox_omp/perf.hpp
@@ -0,0 +1,55 @@
+// Copyright 2023 Nesterov Alexander
+
+#ifndef MODULES_CORE_INCLUDE_PERF_HPP_
+#define MODULES_CORE_INCLUDE_PERF_HPP_
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "core/task/include/task.hpp"
+
+namespace ppc {
+namespace core {
+
+struct PerfAttr {
+  // count of task's running
+  uint64_t num_running;
+  std::function<double(void)> current_timer = [&] { return 0.0; };
+};
+
+struct PerfResults {
+  // measurement of task's time (in seconds)
+  double time_sec = 0.0;
+  enum TypeOfRunning { PIPELINE, TASK_RUN, NONE } type_of_running = NONE;
+  constexpr const static double MAX_TIME = 10.0;
+  constexpr const static double MIN_TIME = 0.05;
+};
+
+class Perf {
+ public:
+  // Init performance analysis with initialized task and initialized data
+  explicit Perf(std::shared_ptr<Task> task_);
+  // Set task with initialized task and initialized data for performance
+  // analysis c
+  void set_task(std::shared_ptr<Task> task_);
+  // Check performance of full task's pipeline:  pre_processing() ->
+  // validation() -> run() -> post_processing()
+  void pipeline_run(const std::shared_ptr<PerfAttr>& perfAttr,
+                    const std::shared_ptr<ppc::core::PerfResults>& perfResults);
+  // Check performance of task's run() function
+  void task_run(const std::shared_ptr<PerfAttr>& perfAttr, const std::shared_ptr<ppc::core::PerfResults>& perfResults);
+  // Pint results for automation checkers
+  static void print_perf_statistic(const std::shared_ptr<PerfResults>& perfResults);
+
+ private:
+  std::shared_ptr<Task> task;
+  static void common_run(const std::shared_ptr<PerfAttr>& perfAttr, const std::function<void()>& pipeline,
+                         const std::shared_ptr<ppc::core::PerfResults>& perfResults);
+};
+
+}  // namespace core
+}  // namespace ppc
+
+#endif  // MODULES_CORE_INCLUDE_PERF_HPP_