Коновалов Сергей. Технология SEQ/MPI. Итеративные методы (Зейделя). Вариант 19.

tasks/konovalov_s_seidel_iterative_method/common/include/common.hpp

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

tasks/konovalov_s_seidel_iterative_method/data/sys_1.txt

@@ -0,0 +1 @@
+3 5 10 1 1 2 10 1 2 2 10 12 13 14 1 1 1

tasks/konovalov_s_seidel_iterative_method/data/sys_2.txt

@@ -0,0 +1 @@
+3 100 4 -1 1 1 6 2 -1 -2 5 4 9 2 1 1 1

tasks/konovalov_s_seidel_iterative_method/data/sys_3.txt

@@ -0,0 +1 @@
+4 10 20.9 1.2 2.1 0.9 1.2 21.2 1.5 2.5 2.1 1.5 19.8 1.3 0.9 2.5 1.3 32.1 21.7 27.46 28.76 49.72 0.8 1 1.2 1.4

tasks/konovalov_s_seidel_iterative_method/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Sergey",
+    "last_name": "Konovalov",
+    "middle_name": "Alexandrovich",
+    "group_number": "3823Б1Пр3",
+    "task_number": "2"
+  }
+}

tasks/konovalov_s_seidel_iterative_method/mpi/include/ops_mpi.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "konovalov_s_seidel_iterative_method/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace konovalov_s_seidel_iterative_method {
+
+class KonovalovSSeidelMethodMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit KonovalovSSeidelMethodMPI(const InType &in);
+
+ private:
+
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+  static std::vector<double> IterationStep(int mtr_szie, int diff, int rank, std::vector<int> &_A, std::vector<int> &_B, std::vector<double> &X_gl);
+  void InitMatrixA(int size, int fmax, std::vector<int> &A, int diff);
+  void InitMatrixB(int size, int fmax, std::vector<int> &B);
+  void DataDistr(int size, int diff, int mtr_size);
+  void DataRecv(std::vector<int> &A_local, std::vector<int> &B_local, int matrix_size, int diff);
+};
+
+}  // namespace konovalov_s_seidel_iterative_method

tasks/konovalov_s_seidel_iterative_method/mpi/src/ops_mpi.cpp

@@ -0,0 +1,184 @@
+#include "konovalov_s_seidel_iterative_method/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <numeric>
+#include <vector>
+
+#include "konovalov_s_seidel_iterative_method/common/include/common.hpp"
+#include "util/include/util.hpp"
+
+namespace konovalov_s_seidel_iterative_method {
+
+KonovalovSSeidelMethodMPI::KonovalovSSeidelMethodMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = std::vector<double>(GetInput(), 0.0);
+}
+
+bool KonovalovSSeidelMethodMPI::ValidationImpl() {
+  return GetInput() > 3;
+}
+
+bool KonovalovSSeidelMethodMPI::PreProcessingImpl() {
+  return true;
+}
+
+void KonovalovSSeidelMethodMPI::InitMatrixA(int size, int fmax, std::vector<int> &A, int _diff) {
+  int diff = _diff;
+  int x = size + rand() % fmax;
+
+  for (int i = 0; i < size; i++) {
+    int sum = 0;
+    int j = 1;
+    do {
+      int diff_addr_pos = i * size + i + j;
+      int diff_addr_neg = i * size + i - j;
+
+      if (diff_addr_neg > 0 && diff_addr_neg >= i * size) {
+        A[diff_addr_neg] = x * (diff - j);
+        sum += A[diff_addr_neg];
+      }
+
+      if (diff_addr_pos < size * size && i + j < size) {
+        A[diff_addr_pos] = x * (diff - j);
+        sum += A[diff_addr_pos];
+      }
+      j++;
+    } while (j < diff);
+    A[i * size + i] = abs(sum + 1);
+  }
+}
+
+void KonovalovSSeidelMethodMPI::InitMatrixB(int size, int fmax, std::vector<int> &B) {
+  for (int i = 0; i < size; i++) {
+    B[i] = pow(size + rand() % fmax, 2);
+  }
+}
+
+
+std::vector<double> KonovalovSSeidelMethodMPI::IterationStep(int mtr_size, int diff, int rank, std::vector<int> &_A,
+                                                             std::vector<int> &_B, std::vector<double> &X_gl) {
+  std::vector<double> X = X_gl;
+  std::vector<double> X_ret(diff, 0.0);
+  std::vector<double> X_new(mtr_size, 0.0);
+
+  for (int i = 0; i < diff; i++) {
+    int diag = (rank - 1) * (diff) + i;
+    X_new[diag] = (double)_B[i] / (double)_A[diag + i * mtr_size];
+    for (int j = 0; j < mtr_size; j++) {
+      if (i * mtr_size + j == diag) {
+        continue;
+      }
+
+      X_new[diag] -= ((double)_A[i * mtr_size + j] / (double)_A[diag + i * mtr_size]) * X[j];
+    }
+
+    X[diag] = round(X_new[diag] * 1000) / 1000;
+    X_ret[i] = X[diag];
+  }
+  return X_ret;
+}
+
+void KonovalovSSeidelMethodMPI::DataDistr(int matrix_size, int size, int diff) {
+  std::vector<int> A;
+  std::vector<int> B;
+
+  A.resize(matrix_size * matrix_size, 0);
+  B.resize(matrix_size, 0);
+
+  InitMatrixA(matrix_size, 10, A, matrix_size / (size - 1));
+  InitMatrixB(matrix_size, 10, B);
+
+  int r = matrix_size * diff;
+  for (int i = 1; i < size; i++) {
+    int p = (i - 1) * r;
+    MPI_Send(&A[p], r, MPI_INT, i, 0, MPI_COMM_WORLD);
+    MPI_Send(&B[(i - 1) * diff], diff, MPI_INT, i, 0, MPI_COMM_WORLD);
+  }
+}
+
+void KonovalovSSeidelMethodMPI::DataRecv(std::vector<int> &A_local, std::vector<int> &B_local, int matrix_size,
+                                         int diff) {
+  MPI_Status s;
+  A_local.resize(matrix_size * diff);
+  B_local.resize(diff);
+
+  MPI_Recv(&A_local[0], matrix_size * diff, MPI_INT, 0, 0, MPI_COMM_WORLD, &s);
+  MPI_Recv(&B_local[0], diff, MPI_INT, 0, 0, MPI_COMM_WORLD, &s);
+}
+
+bool KonovalovSSeidelMethodMPI::RunImpl() {
+  srand(time(NULL));
+
+  int rank = 0;
+  int size = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  int matrix_size = GetInput();
+  int diff = matrix_size / (size - 1);
+
+  std::vector<double> gl_x_vec(size * diff, 0.0);
+  std::vector<double> local_x_vec(diff, 0.0);
+  std::vector<int> colors(matrix_size);
+  std::vector<int> A_local;
+  std::vector<int> B_local;
+  double epsi = 0.001;
+  int iter = 10;
+  bool stop_calc = true;
+
+  gl_x_vec.resize(matrix_size, 0.0);
+  colors.resize(matrix_size, 0);
+
+  if (rank == 0) {
+    DataDistr(matrix_size, size, diff);
+  } else {
+    DataRecv(A_local, B_local, matrix_size, diff);
+  }
+
+  while (iter != 0) {
+    bool cover_tracker = true;
+    if (rank != 0) {
+      local_x_vec = IterationStep(matrix_size, diff, rank, A_local, B_local, gl_x_vec);
+
+      for (int i = 0; i < diff; i++) {
+        cover_tracker = cover_tracker && (std::fabs(local_x_vec[i] - gl_x_vec[(rank)*diff + i]) < epsi);
+      }
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    if (rank == 0) {
+      std::vector<int> counts(size, diff);
+      std::vector<int> displacements(size);
+
+      for (int i = 0; i < size; i++) {
+        displacements[i] = diff * i;
+      }
+
+      MPI_Gatherv(&local_x_vec[0], diff, MPI_DOUBLE, &gl_x_vec[0], counts.data(), displacements.data(), MPI_DOUBLE, 0,
+                  MPI_COMM_WORLD);
+    } else {
+      MPI_Gatherv(&local_x_vec[0], diff, MPI_DOUBLE, NULL, NULL, NULL, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    }
+    MPI_Bcast(&gl_x_vec[0], size * diff, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+
+    MPI_Allreduce(&cover_tracker, &stop_calc, 1, MPI_C_BOOL, MPI_LAND, MPI_COMM_WORLD);
+
+    if (stop_calc) {
+      break;
+    }
+    iter--;
+  }
+  for (int i = diff; i < size * diff; i++) {
+    GetOutput()[i - diff] = gl_x_vec[i];
+  }
+    return true;
+  }
+
+  bool KonovalovSSeidelMethodMPI::PostProcessingImpl() {
+    return true;
+  }
+
+}  // namespace konovalov_s_seidel_iterative_method