Apply clang-tidy fixes and formatting

Author: hydroimperium

tasks/klimov_m_torus/common/include/common.hpp

@@ -8,8 +8,8 @@
 namespace klimov_m_torus {
 
 struct TransferRequest {
-  int sender;
-  int receiver;
+  int sender{};
+  int receiver{};
   std::vector<int> data;
 };
 

tasks/klimov_m_torus/mpi/include/ops_mpi.hpp

@@ -22,14 +22,14 @@ class TorusMeshCommunicator : public BaseTask {
   bool RunImpl() override;
   bool PostProcessingImpl() override;
 
-  static std::pair<int, int> CalculateGridSize(int totalProcesses);
+  static std::pair<int, int> CalculateGridSize(int total_processes);
   static int CombineCoordinates(int row, int col, int rows, int cols);
   static std::pair<int, int> SplitRank(int rank, int cols);
   static std::vector<int> BuildMessageRoute(int rows, int cols, int from, int to);
 
   void DistributeSenderReceiver(int &src, int &dst);
   void DistributeDataLength(int src, int &len) const;
-  std::vector<int> AssembleSendBuffer(int src, int len) const;
+  [[nodiscard]] std::vector<int> AssembleSendBuffer(int src, int len) const;
   void RelayMessage(int src, int dst, const std::vector<int> &route, const std::vector<int> &buffer,
                     std::vector<int> &output) const;
   void SaveFinalResult(int dst, const std::vector<int> &output, const std::vector<int> &route);

tasks/klimov_m_torus/mpi/src/ops_mpi.cpp

@@ -12,21 +12,65 @@
 
 namespace klimov_m_torus {
 
+namespace {
+
+// Вспомогательные функции, вынесенные в анонимный namespace для снижения сложности RelayMessage
+
+void HandleSameNode(int current_rank, int src, const std::vector<int> &buffer, std::vector<int> &output) {
+  if (current_rank == src) {
+    output = buffer;
+  }
+}
+
+void HandleSourceNode(int current_rank, int src, const std::vector<int> &route, const std::vector<int> &buffer,
+                      std::vector<int> &output) {
+  output = buffer;
+  if (current_rank == src && route.size() > 1) {
+    int next_hop = route[1];
+    int send_len = static_cast<int>(buffer.size());
+    MPI_Send(&send_len, 1, MPI_INT, next_hop, 0, MPI_COMM_WORLD);
+    if (send_len > 0) {
+      MPI_Send(output.data(), send_len, MPI_INT, next_hop, 1, MPI_COMM_WORLD);
+    }
+  }
+}
+
+void HandleIntermediateNode(int current_rank, int dst, const std::vector<int> &route, int my_pos,
+                            std::vector<int> &output) {
+  int prev_hop = route[my_pos - 1];
+  int recv_len = 0;
+  MPI_Recv(&recv_len, 1, MPI_INT, prev_hop, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  output.resize(recv_len);
+  if (recv_len > 0) {
+    MPI_Recv(output.data(), recv_len, MPI_INT, prev_hop, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  }
+
+  if (current_rank != dst && my_pos + 1 < static_cast<int>(route.size())) {
+    int next_hop = route[my_pos + 1];
+    MPI_Send(&recv_len, 1, MPI_INT, next_hop, 0, MPI_COMM_WORLD);
+    if (recv_len > 0) {
+      MPI_Send(output.data(), recv_len, MPI_INT, next_hop, 1, MPI_COMM_WORLD);
+    }
+  }
+}
+
+}  // namespace
+
 TorusMeshCommunicator::TorusMeshCommunicator(const InType &in) {
   SetTypeOfTask(GetStaticTypeOfTask());
   GetInput() = in;
   GetOutput() = {};
 }
 
-std::pair<int, int> TorusMeshCommunicator::CalculateGridSize(int totalProcesses) {
-  int rows = static_cast<int>(std::sqrt(static_cast<double>(totalProcesses)));
-  while (rows > 1 && (totalProcesses % rows != 0)) {
+std::pair<int, int> TorusMeshCommunicator::CalculateGridSize(int total_processes) {
+  int rows = static_cast<int>(std::sqrt(static_cast<double>(total_processes)));
+  while (rows > 1 && (total_processes % rows != 0)) {
     --rows;
   }
   if (rows <= 0) {
     rows = 1;
   }
-  int cols = totalProcesses / rows;
+  int cols = total_processes / rows;
   if (cols <= 0) {
     cols = 1;
   }
@@ -119,7 +163,8 @@ bool TorusMeshCommunicator::PreProcessingImpl() {
 }
 
 bool TorusMeshCommunicator::RunImpl() {
-  int sender = 0, receiver = 0;
+  int sender = 0;
+  int receiver = 0;
   DistributeSenderReceiver(sender, receiver);
 
   int data_len = 0;
@@ -155,48 +200,23 @@ void TorusMeshCommunicator::DistributeDataLength(int src, int &len) const {
 std::vector<int> TorusMeshCommunicator::AssembleSendBuffer(int src, int len) const {
   std::vector<int> buffer(len);
   if (current_rank_ == src && len > 0) {
-    std::copy(local_request_.data.begin(), local_request_.data.end(), buffer.begin());
+    std::ranges::copy(local_request_.data, buffer.begin());
   }
   return buffer;
 }
 
 void TorusMeshCommunicator::RelayMessage(int src, int dst, const std::vector<int> &route,
                                          const std::vector<int> &buffer, std::vector<int> &output) const {
-  const int route_len = static_cast<int>(route.size());
-  auto it = std::find(route.begin(), route.end(), current_rank_);
+  auto it = std::ranges::find(route, current_rank_);
   bool on_route = (it != route.end());
   int my_pos = on_route ? static_cast<int>(std::distance(route.begin(), it)) : -1;
 
   if (src == dst) {
-    if (current_rank_ == src) {
-      output = buffer;
-    }
+    HandleSameNode(current_rank_, src, buffer, output);
   } else if (current_rank_ == src) {
-    output = buffer;
-    if (route_len > 1) {
-      int next_hop = route[1];
-      int send_len = static_cast<int>(buffer.size());
-      MPI_Send(&send_len, 1, MPI_INT, next_hop, 0, MPI_COMM_WORLD);
-      if (send_len > 0) {
-        MPI_Send(output.data(), send_len, MPI_INT, next_hop, 1, MPI_COMM_WORLD);
-      }
-    }
+    HandleSourceNode(current_rank_, src, route, buffer, output);
   } else if (on_route) {
-    int prev_hop = route[my_pos - 1];
-    int recv_len = 0;
-    MPI_Recv(&recv_len, 1, MPI_INT, prev_hop, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    output.resize(recv_len);
-    if (recv_len > 0) {
-      MPI_Recv(output.data(), recv_len, MPI_INT, prev_hop, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    }
-
-    if (current_rank_ != dst && my_pos + 1 < route_len) {
-      int next_hop = route[my_pos + 1];
-      MPI_Send(&recv_len, 1, MPI_INT, next_hop, 0, MPI_COMM_WORLD);
-      if (recv_len > 0) {
-        MPI_Send(output.data(), recv_len, MPI_INT, next_hop, 1, MPI_COMM_WORLD);
-      }
-    }
+    HandleIntermediateNode(current_rank_, dst, route, my_pos, output);
   }
 }
 

tasks/klimov_m_torus/tests/.clang-tidy

@@ -12,79 +12,77 @@ namespace klimov_m_torus {
 
 class TorusPerformanceTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
  protected:
-  InType test_data_;
-  bool data_ready_ = false;
-  int world_size_ = 1;
-  int rank_ = 0;
-  bool is_seq_mode_ = false;
+  InType test_data;
+  bool data_ready = false;
+  int world_size = 1;
+  int rank = 0;
+  bool is_seq_mode = false;
 
   void SetUp() override {
     std::string task_name = std::get<1>(GetParam());
-    is_seq_mode_ = (task_name.find("seq") != std::string::npos);
+    is_seq_mode = (task_name.find("seq") != std::string::npos);
 
     int mpi_initialized = 0;
     MPI_Initialized(&mpi_initialized);
     if (mpi_initialized != 0) {
-      MPI_Comm_size(MPI_COMM_WORLD, &world_size_);
-      MPI_Comm_rank(MPI_COMM_WORLD, &rank_);
+      MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+      MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     }
 
     PrepareTestData();
   }
 
   void PrepareTestData() {
-    if (data_ready_) {
+    if (data_ready) {
       return;
     }
 
     const int data_size = 10000000;
 
-    test_data_.sender = 0;
-    if (is_seq_mode_) {
-      test_data_.receiver = 0;
+    test_data.sender = 0;
+    if (is_seq_mode) {
+      test_data.receiver = 0;
     } else {
-      test_data_.receiver = (world_size_ > 1) ? (world_size_ - 1) : 0;
+      test_data.receiver = (world_size > 1) ? (world_size - 1) : 0;
     }
 
-    test_data_.data.resize(data_size);
+    test_data.data.resize(data_size);
     for (int i = 0; i < data_size; ++i) {
-      test_data_.data[i] = i + 1;
+      test_data.data[i] = i + 1;
     }
 
-    data_ready_ = true;
+    data_ready = true;
   }
 
   InType GetTestInputData() override {
-    return test_data_;
+    return test_data;
   }
 
   bool CheckTestOutputData(OutType &out) override {
     std::string task_name = std::get<1>(GetParam());
     bool is_mpi = (task_name.find("mpi") != std::string::npos);
 
     if (is_mpi) {
-      if (rank_ != test_data_.receiver) {
+      if (rank != test_data.receiver) {
         return out.received_data.empty() && out.route.empty();
       }
-      if (out.received_data.size() != test_data_.data.size()) {
+      if (out.received_data.size() != test_data.data.size()) {
         return false;
       }
       if (out.received_data.empty()) {
         return true;
       }
-      return (out.received_data.front() == test_data_.data.front() &&
-              out.received_data.back() == test_data_.data.back());
+      return (out.received_data.front() == test_data.data.front() && out.received_data.back() == test_data.data.back());
     }
 
-    if (rank_ == 0) {
-      if (out.received_data.size() != test_data_.data.size()) {
+    if (rank == 0) {
+      if (out.received_data.size() != test_data.data.size()) {
         return false;
       }
       if (out.received_data.empty()) {
         return true;
       }
-      return (out.received_data.front() == test_data_.data.front() &&
-              out.received_data.back() == test_data_.data.back());
+      return (out.received_data.front() == test_data.data.front() && out.received_data.back() == test_data.data.back());
     }
     return true;
   }