rmp: review fixes

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

Author: b-chmiel

src/rmp/BUILD

@@ -53,12 +53,13 @@ cc_library(
         "//third-party/abc:abc-lib",
         "@boost.bind",
         "@boost.config",
-        "@boost.container_hash",
         "@boost.fusion",
         "@boost.lambda",
         "@boost.optional",
         "@boost.phoenix",
         "@boost.spirit",
+        "@com_google_absl//absl/hash",
+        "@com_google_absl//absl/random",
     ],
 )
 

src/rmp/README.md

@@ -98,7 +98,41 @@ resynth_annealing
 
 ### Resynth with genetic slack tuning
 
-TODO
+Resynthesize parts of the design with an ABC script found via genetic algorithm.
+An individual in a population is a series of operations on ABC's internal AIG data structure.
+Each such operation is considered a gene. Genotype can be changed by a mutation with operations such
+as adding, removing or swapping genes with a `mut_prob` probability. Individual can also be changed
+by crossing two genes together with a `cross_prob` probability.
+The optimization function is defined as the worst slack.
+
+```tcl
+resynth_genetic
+    [-corner corner]
+    [-slack_threshold slack_threshold]
+    [-seed seed]
+    [-pop_size pop_size]
+    [-mut_prob mut_prob]
+    [-cross_prob cross_prob]
+    [-tourn_prob tourn_prob]
+    [-tourn_size tourn_size]
+    [-iters iters]
+    [-initial_ops initial_ops]
+```
+
+#### Options
+
+| Switch Name | Description |
+| ----- | ----- |
+| `-corner` | Process corner to use. |
+| `-slack_threshold` | Specifies a (setup) timing slack value below which timing paths need to be analyzed for restructuring. The default value is `0`. |
+| `-seed` | Seed to use for randomness. |
+| `-pop_size` | Population size. |
+| `-mut_prob` | Probability of applying mutation operator. |
+| `-cross_prob` | Probability of applying crossover operator. |
+| `-tourn_prob` | Tournament probability. |
+| `-tourn_size` | Tournament size. |
+| `-iters` | Number of iterations to run genetic algorithm. |
+| `-initial_ops` | Size of the initial random solution (number of commands in the script for ABC). |
 
 
 ## Example scripts

src/rmp/src/CMakeLists.txt

@@ -46,15 +46,13 @@ target_include_directories(rmp
     # Unfortunate side-effect of swig include StaTcl.i
     ${OPENSTA_HOME}/include/sta
     ${OPENSTA_HOME}
-    ${Boost_INCLUDE_DIRS}
 )
 
 target_include_directories(rmp_lib
   PUBLIC
     ../include
   PRIVATE
     .
-  ${Boost_INCLUDE_DIRS}
 )
 
 target_link_libraries(rmp_lib
@@ -66,6 +64,7 @@ target_link_libraries(rmp_lib
     utl_lib
     cut
     ${ABC_LIBRARY}
+    absl_hash
 )
 
 target_link_libraries(rmp

src/rmp/src/annealing_strategy.h

@@ -13,20 +13,6 @@
 #include "sta/Delay.hh"
 #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

src/rmp/src/genetic_strategy.cpp

@@ -6,13 +6,13 @@
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
-#include <random>
 #include <ranges>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
-#include "boost/container_hash/hash.hpp"
+#include "absl/hash/hash.h"
+#include "absl/random/random.h"
 #include "cut/abc_library_factory.h"
 #include "db_sta/dbNetwork.hh"
 #include "db_sta/dbSta.hh"
@@ -29,21 +29,8 @@ using utl::RMP;
 static void removeDuplicates(std::vector<SolutionSlack>& population,
                              utl::Logger* logger)
 {
-  struct HashVector final
-  {
-    size_t operator()(const SolutionSlack::Type& sol) const
-    {
-      size_t res = 0;
-      for (const auto& item : sol) {
-        size_t hash = boost::hash<size_t>()(item.id);
-        // TODO set seed
-        boost::hash_combine(hash, res);
-      }
-      return res;
-    }
-  };
-
-  std::unordered_set<SolutionSlack::Type, HashVector> taken;
+  std::unordered_set<SolutionSlack::Type, absl::Hash<SolutionSlack::Type>>
+      taken;
   population.erase(
       std::ranges::begin(std::ranges::remove_if(
           population,
@@ -78,7 +65,8 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
   for (auto& ind : population) {
     ind.solution_.reserve(initial_ops_);
     for (size_t i = 0; i < initial_ops_; i++) {
-      ind.solution_.push_back(all_ops[random_() % all_ops.size()]);
+      const auto idx = absl::Uniform<int>(random_, 0, all_ops.size());
+      ind.solution_.push_back(all_ops[idx]);
     }
   }
 
@@ -95,8 +83,8 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
     // Crossover
     unsigned cross_size = std::max<unsigned>(cross_prob_ * generation_size, 1);
     for (unsigned j = 0; j < cross_size; j++) {
-      auto rand1 = random_() % generation_size;
-      auto rand2 = random_() % generation_size;
+      auto rand1 = absl::Uniform<int>(random_, 0, generation_size);
+      auto rand2 = absl::Uniform<int>(random_, 0, generation_size);
       if (rand1 == rand2) {
         continue;
       }
@@ -115,7 +103,7 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
     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;
+      auto rand = absl::Uniform<int>(random_, 0, generation_size);
       sol_slack.solution_
           = population[rand].RandomNeighbor(all_ops, logger, random_);
       population.emplace_back(sol_slack);
@@ -134,34 +122,34 @@ std::vector<GiaOp> GeneticStrategy::RunStrategy(
                          logger);
     }
     // Selection
-    std::ranges::sort(population, std::less{});
+    std::ranges::sort(population, std::greater{}, &SolutionSlack::worst_slack_);
     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();
+        return absl::Uniform<int>(random_, 0, population.size());
       });
       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) {
-        if (bern_dist(random_)) {
-          newPopulation.push_back(population[candidateId]);
-          break;
-        }
+      auto winner = std::ranges::find_if(tournament, [&](auto const& _) {
+        return absl::Bernoulli(random_, static_cast<double>(tourn_prob_));
+      });
+      if (winner != tournament.end()) {
+        newPopulation.push_back(population[*winner]);
       }
     }
     removeDuplicates(newPopulation, logger);
-    population = newPopulation;
+    population = std::move(newPopulation);
 
     for (const auto& candidate : population) {
       debugPrint(logger, RMP, "genetic", 1, candidate.toString());
     }
   }
 
-  auto best_it = std::ranges::min_element(population, std::less{});
+  auto best_it
+      = std::ranges::max_element(population, {}, &SolutionSlack::worst_slack_);
   logger->info(RMP,
                66,
                "Resynthesis: Best result is of individual {}",

src/rmp/src/genetic_strategy.h

@@ -13,23 +13,8 @@
 #include "sta/Delay.hh"
 #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 {
 
-// TODO docs
 class GeneticStrategy final : public SlackTuningStrategy
 {
  public: