rmp: restructure, clang-tidy

Signed-off-by: Bartłomiej Chmiel <[email protected]>

Author: b-chmiel

src/rmp/include/rmp/Restructure.h

@@ -89,15 +89,21 @@ class Restructure
     annealing_revert_after_ = revert_after;
   }
   void setAnnealingInitialOps(unsigned ops) { annealing_init_ops_ = ops; }
-  void setGeneticSeed(std::mt19937::result_type seed)
-  {
-    genetic_seed_ = seed;
-  }
+  void setGeneticSeed(std::mt19937::result_type seed) { genetic_seed_ = seed; }
   void setGeneticPopSize(unsigned pop_size) { genetic_pop_size_ = pop_size; }
   void setGeneticMutProb(float mut_prob) { genetic_mut_prob_ = mut_prob; }
-  void setGeneticCrossProb(float cross_prob) { genetic_cross_prob_ = cross_prob; }
-  void setGeneticTournSize(unsigned tourn_size) { genetic_tourn_size_ = tourn_size; }
-  void setGeneticTournProb(float tourn_prob) { genetic_tourn_prob_ = tourn_prob; }
+  void setGeneticCrossProb(float cross_prob)
+  {
+    genetic_cross_prob_ = cross_prob;
+  }
+  void setGeneticTournSize(unsigned tourn_size)
+  {
+    genetic_tourn_size_ = tourn_size;
+  }
+  void setGeneticTournProb(float tourn_prob)
+  {
+    genetic_tourn_prob_ = tourn_prob;
+  }
   void setGeneticIters(unsigned iters) { genetic_iters_ = iters; }
   void setGeneticInitialOps(unsigned ops) { genetic_init_ops_ = ops; }
   void setSlackThreshold(sta::Slack thresh) { slack_threshold_ = thresh; }

src/rmp/src/annealing_strategy.cpp

@@ -3,12 +3,12 @@
 
 #include "annealing_strategy.h"
 
-#include <fcntl.h>
-
-#include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <cstddef>
 #include <cstdio>
+#include <random>
+#include <utility>
 #include <vector>
 
 #include "cut/abc_library_factory.h"
@@ -17,10 +17,10 @@
 #include "gia.h"
 #include "odb/db.h"
 #include "rsz/Resizer.hh"
+#include "slack_tuning_strategy.h"
 #include "sta/Delay.hh"
 #include "sta/Graph.hh"
 #include "sta/MinMax.hh"
-#include "utils.h"
 #include "utl/Logger.h"
 #include "utl/deleter.h"
 #include "utl/unique_name.h"
@@ -50,15 +50,14 @@ std::vector<GiaOp> AnnealingStrategy::RunStrategy(
   }
 
   SolutionSlack sol_slack;
-  sol_slack.solution = ops;
-  auto* worst_vertex = EvaluateSlack(sol_slack,
-                                     candidate_vertices,
-                                     abc_library,
-                                     corner_,
-                                     sta,
-                                     name_generator,
-                                     logger);
-  float worst_slack = *sol_slack.worst_slack;
+  sol_slack.solution_ = ops;
+  auto* worst_vertex = sol_slack.Evaluate(
+      candidate_vertices, abc_library, corner_, sta, name_generator, logger);
+
+  if (!sol_slack.worst_slack_) {
+    logger->error(RMP, 51, "Should be evaluated");
+  }
+  float worst_slack = *sol_slack.worst_slack_;
 
   if (!temperature_) {
     sta::Delay required = sta->vertexRequired(worst_vertex, sta::MinMax::max());
@@ -72,8 +71,7 @@ std::vector<GiaOp> AnnealingStrategy::RunStrategy(
                *temperature_,
                worst_slack);
 
-  float best_worst_slack = worst_slack;
-  auto best_ops = ops;
+  SolutionSlack best_sol{.solution_ = ops, .worst_slack_ = worst_slack};
   size_t worse_iters = 0;
 
   for (unsigned i = 0; i < iterations_; i++) {
@@ -82,8 +80,8 @@ std::vector<GiaOp> AnnealingStrategy::RunStrategy(
 
     if (revert_after_ && worse_iters >= *revert_after_) {
       logger->info(RMP, 57, "Reverting to the best found solution");
-      ops = best_ops;
-      worst_slack = best_worst_slack;
+      ops = best_sol.solution_;
+      worst_slack = *best_sol.worst_slack_;
       worse_iters = 0;
     }
 
@@ -93,7 +91,7 @@ std::vector<GiaOp> AnnealingStrategy::RunStrategy(
                    "Iteration: {}, temperature: {}, best worst slack: {}",
                    i + 1,
                    current_temp,
-                   best_worst_slack);
+                   *best_sol.worst_slack_);
     } else {
       debugPrint(logger,
                  RMP,
@@ -102,23 +100,23 @@ std::vector<GiaOp> AnnealingStrategy::RunStrategy(
                  "Iteration: {}, temperature: {}, best worst slack: {}",
                  i + 1,
                  current_temp,
-                 best_worst_slack);
+                 best_sol.worst_slack_ ? *best_sol.worst_slack_ : 0);
     }
 
-    auto new_ops = RandomNeighbor(ops, all_ops, logger);
-    sol_slack.solution = new_ops;
+    SolutionSlack s;
+    s.solution_ = ops;
+    auto new_ops = s.RandomNeighbor(all_ops, logger, random_);
+    sol_slack.solution_ = new_ops;
 
-    EvaluateSlack(sol_slack,
-                  candidate_vertices,
-                  abc_library,
-                  corner_,
-                  sta,
-                  name_generator,
-                  logger);
+    sol_slack.Evaluate(
+        candidate_vertices, abc_library, corner_, sta, name_generator, logger);
 
-    float worst_slack_new = *sol_slack.worst_slack;
+    if (!sol_slack.worst_slack_) {
+      logger->error(RMP, 55, "Should be evaluated");
+    }
+    float worst_slack_new = *sol_slack.worst_slack_;
 
-    if (worst_slack_new < best_worst_slack) {
+    if (best_sol.worst_slack_ && worst_slack_new < *best_sol.worst_slack_) {
       worse_iters++;
     } else {
       worse_iters = 0;
@@ -167,12 +165,12 @@ std::vector<GiaOp> AnnealingStrategy::RunStrategy(
     ops = std::move(new_ops);
     worst_slack = worst_slack_new;
 
-    if (worst_slack > best_worst_slack) {
-      best_worst_slack = worst_slack;
-      best_ops = ops;
+    if (best_sol.worst_slack_ && worst_slack > *best_sol.worst_slack_) {
+      *best_sol.worst_slack_ = worst_slack;
+      best_sol.solution_ = ops;
     }
   }
-  return best_ops;
+  return best_sol.solution_;
 }
 
 }  // namespace rmp

src/rmp/src/annealing_strategy.h

@@ -5,15 +5,28 @@
 
 #include <optional>
 #include <random>
+#include <vector>
 
-#include "db_sta/dbSta.hh"
-#include "rsz/Resizer.hh"
+#include "cut/abc_library_factory.h"
+#include "gia.h"
 #include "slack_tuning_strategy.h"
-#include "sta/Corner.hh"
 #include "sta/Delay.hh"
-#include "utl/Logger.h"
 #include "utl/unique_name.h"
 
+namespace rsz {
+class Resizer;
+}  // namespace rsz
+
+namespace sta {
+class dbSta;
+class Corner;
+class Vertex;
+}  // namespace sta
+
+namespace utl {
+class Logger;
+}  // namespace utl
+
 namespace rmp {
 
 class AnnealingStrategy final : public SlackTuningStrategy
@@ -27,10 +40,10 @@ class AnnealingStrategy final : public SlackTuningStrategy
                              std::optional<unsigned> revert_after,
                              unsigned initial_ops)
       : SlackTuningStrategy(corner,
-                             slack_threshold,
-                             seed,
-                             iterations,
-                             initial_ops),
+                            slack_threshold,
+                            seed,
+                            iterations,
+                            initial_ops),
         temperature_(temperature),
         revert_after_(revert_after)
   {

src/rmp/src/genetic_strategy.cpp

@@ -3,10 +3,13 @@
 
 #include "genetic_strategy.h"
 
-#include <fcntl.h>
-
 #include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <random>
+#include <ranges>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "boost/container_hash/hash.hpp"
@@ -15,10 +18,7 @@
 #include "db_sta/dbSta.hh"
 #include "gia.h"
 #include "rsz/Resizer.hh"
-#include "sta/Graph.hh"
-#include "sta/MinMax.hh"
-#include "sta/Search.hh"
-#include "utils.h"
+#include "slack_tuning_strategy.h"
 #include "utl/Logger.h"
 #include "utl/deleter.h"
 #include "utl/unique_name.h"
@@ -31,7 +31,7 @@ static void removeDuplicates(std::vector<SolutionSlack>& population,
 {
   struct HashVector final
   {
-    size_t operator()(const Solution& sol) const
+    size_t operator()(const SolutionSlack::Type& sol) const
     {
       size_t res = 0;
       for (const auto& item : sol) {
@@ -43,20 +43,19 @@ static void removeDuplicates(std::vector<SolutionSlack>& population,
     }
   };
 
-  std::unordered_set<Solution, HashVector> taken;
+  std::unordered_set<SolutionSlack::Type, HashVector> taken;
   population.erase(
-      std::remove_if(
-          population.begin(),
-          population.end(),
+      std::ranges::begin(std::ranges::remove_if(
+          population,
           [&taken, logger](const SolutionSlack& s) {
-            if (!taken.insert(s.solution).second) {
+            if (!taken.insert(s.solution_).second) {
               debugPrint(
                   logger, RMP, "genetic", 2, "Removing: " + s.toString());
               return true;
             }
             debugPrint(logger, RMP, "genetic", 2, "Keeping: " + s.toString());
             return false;
-          }),
+          })),
       population.end());
 }
 
@@ -77,25 +76,15 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
              "Generating and evaluating the initial population");
   std::vector<SolutionSlack> population(pop_size_);
   for (auto& ind : population) {
-    ind.solution.reserve(initial_ops_);
+    ind.solution_.reserve(initial_ops_);
     for (size_t i = 0; i < initial_ops_; i++) {
-      ind.solution.push_back(all_ops[random_() % all_ops.size()]);
+      ind.solution_.push_back(all_ops[random_() % all_ops.size()]);
     }
   }
 
-  logger->info(RMP,
-               62,
-               "Resynthesis: starting genetic algorithm, Worst slack is {}",
-               GetWorstSlack(sta, corner_));
-
   for (auto& candidate : population) {
-    EvaluateSlack(candidate,
-                  candidate_vertices,
-                  abc_library,
-                  corner_,
-                  sta,
-                  name_generator,
-                  logger);
+    candidate.Evaluate(
+        candidate_vertices, abc_library, corner_, sta, name_generator, logger);
 
     debugPrint(logger, RMP, "genetic", 1, candidate.toString());
   }
@@ -111,51 +100,50 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
       if (rand1 == rand2) {
         continue;
       }
-      Solution& parent1_sol = population[rand1].solution;
-      Solution& parent2_sol = population[rand2].solution;
-      Solution child_sol(parent1_sol.begin(),
-                         parent1_sol.begin() + parent1_sol.size() / 2);
+      SolutionSlack::Type& parent1_sol = population[rand1].solution_;
+      SolutionSlack::Type& parent2_sol = population[rand2].solution_;
+      SolutionSlack::Type child_sol(
+          parent1_sol.begin(), parent1_sol.begin() + parent1_sol.size() / 2);
       child_sol.insert(child_sol.end(),
                        parent2_sol.begin() + parent2_sol.size() / 2,
                        parent2_sol.end());
       SolutionSlack child_sol_slack;
-      child_sol_slack.solution = std::move(child_sol);
+      child_sol_slack.solution_ = std::move(child_sol);
       population.emplace_back(child_sol_slack);
     }
     // Mutations
     unsigned mut_size = std::max<unsigned>(mut_prob_ * generation_size, 1);
     for (unsigned j = 0; j < mut_size; j++) {
       SolutionSlack sol_slack;
       auto rand = random_() % generation_size;
-      sol_slack.solution
-          = RandomNeighbor(population[rand].solution, all_ops, logger);
+      sol_slack.solution_
+          = population[rand].RandomNeighbor(all_ops, logger, random_);
       population.emplace_back(sol_slack);
     }
     removeDuplicates(population, logger);
     // Evaluation
     for (auto& sol_slack : population) {
-      if (sol_slack.worst_slack) {
+      if (sol_slack.worst_slack_) {
         continue;
       }
-      EvaluateSlack(sol_slack,
-                    candidate_vertices,
-                    abc_library,
-                    corner_,
-                    sta,
-                    name_generator,
-                    logger);
+      sol_slack.Evaluate(candidate_vertices,
+                         abc_library,
+                         corner_,
+                         sta,
+                         name_generator,
+                         logger);
     }
     // Selection
-    std::sort(population.begin(), population.end());
+    std::ranges::sort(population, std::less{});
     std::vector<SolutionSlack> newPopulation;
     newPopulation.reserve(pop_size_);
     for (int j = 0; j < pop_size_; j++) {
       std::vector<size_t> tournament(tourn_size_);
       std::generate_n(tournament.begin(), tourn_size_, [&]() {
         return random_() % population.size();
       });
-      std::sort(tournament.begin(), tournament.end());
-      tournament.erase(std::unique(tournament.begin(), tournament.end()),
+      std::ranges::sort(tournament);
+      tournament.erase(std::ranges::begin(std::ranges::unique(tournament)),
                        tournament.end());
       std::bernoulli_distribution bern_dist{tourn_prob_};
       for (const auto& candidateId : tournament) {
@@ -173,11 +161,11 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
     }
   }
 
-  auto best_it = std::min_element(population.begin(), population.end());
+  auto best_it = std::ranges::min_element(population, std::less{});
   logger->info(RMP,
                66,
                "Resynthesis: Best result is of individual {}",
                std::distance(population.begin(), best_it));
-  return best_it->solution;
+  return best_it->solution_;
 }
 }  // namespace rmp