mpl: change best_valid_result to best_result to handle case of no valid result

If there is no valid result then we want to use the best invalid
result in a similar fashion to when there is a best result.  If a valid
result is found then then only valid results are considered for being
the best.

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -717,19 +717,19 @@ void SimulatedAnnealingCore<T>::fastSA()
   // as it is too expensive
   notch_weight_ = 0.0;
 
-  if (isValid()) {
-    updateBestValidResult(cost);
-  }
+  updateBestResult(cost);
 
   while (step <= max_num_step_) {
     for (int i = 0; i < num_perturb_per_step_; i++) {
       saveState();
       perturb();
       cost = calNormCost();
 
-      const bool keep_result = cost < pre_cost || best_valid_result_.empty();
-      if (isValid() && keep_result) {
-        updateBestValidResult(cost);
+      const bool is_valid = isValid();
+      const bool improved = cost < pre_cost || best_result_.empty();
+      if ((!is_best_result_valid_ || is_valid) && improved) {
+        updateBestResult(cost);
+        is_best_result_valid_ = is_valid;
       }
 
       const float delta_cost = cost - pre_cost;
@@ -767,40 +767,42 @@ void SimulatedAnnealingCore<T>::fastSA()
     graphics_->doNotSkip();
   }
   calPenalty();
+  cost = calNormCost();
 
-  if (!best_valid_result_.empty()
-      && (!isValid() || best_valid_result_.cost < calNormCost())) {
-    useBestValidResult();
+  const bool is_valid = isValid();
+  const bool improved = cost < best_result_.cost || best_result_.empty();
+  if ((is_best_result_valid_ && !is_valid) || !improved) {
+    useBestResult();
   }
 }
 
 template <class T>
-void SimulatedAnnealingCore<T>::updateBestValidResult(const float cost)
+void SimulatedAnnealingCore<T>::updateBestResult(const float cost)
 {
-  best_valid_result_.sequence_pair.pos_sequence = pos_seq_;
-  best_valid_result_.sequence_pair.neg_sequence = neg_seq_;
+  best_result_.sequence_pair.pos_sequence = pos_seq_;
+  best_result_.sequence_pair.neg_sequence = neg_seq_;
 
   if constexpr (std::is_same_v<T, SoftMacro>) {
     for (const int macro_id : pos_seq_) {
       SoftMacro& macro = macros_[macro_id];
-      best_valid_result_.macro_id_to_width[macro_id] = macro.getWidth();
+      best_result_.macro_id_to_width[macro_id] = macro.getWidth();
     }
   }
 
-  best_valid_result_.cost = cost;
+  best_result_.cost = cost;
 }
 
 template <class T>
-void SimulatedAnnealingCore<T>::useBestValidResult()
+void SimulatedAnnealingCore<T>::useBestResult()
 {
-  pos_seq_ = best_valid_result_.sequence_pair.pos_sequence;
-  neg_seq_ = best_valid_result_.sequence_pair.neg_sequence;
+  pos_seq_ = best_result_.sequence_pair.pos_sequence;
+  neg_seq_ = best_result_.sequence_pair.neg_sequence;
 
   if constexpr (std::is_same_v<T, SoftMacro>) {
     for (const int macro_id : pos_seq_) {
       SoftMacro& macro = macros_[macro_id];
       const float valid_result_width
-          = best_valid_result_.macro_id_to_width.at(macro_id);
+          = best_result_.macro_id_to_width.at(macro_id);
 
       if (macro.isMacroCluster()) {
         const float valid_result_height = macro.getArea() / valid_result_width;

src/mpl/src/SimulatedAnnealingCore.h

@@ -107,8 +107,8 @@ class SimulatedAnnealingCore
       const BoundaryRegionList& regions);
   void initSequencePair();
   void setDieArea(const Rect& die_area);
-  void updateBestValidResult(float cost);
-  void useBestValidResult();
+  void updateBestResult(float cost);
+  void useBestResult();
 
   virtual float calNormCost() const = 0;
   virtual void calPenalty() = 0;
@@ -212,7 +212,8 @@ class SimulatedAnnealingCore
   MplObserver* graphics_ = nullptr;
   odb::dbBlock* block_;
 
-  Result best_valid_result_;
+  Result best_result_;
+  bool is_best_result_valid_ = false;
 
   std::vector<float> cost_list_;  // store the cost in the list
   std::vector<float> T_list_;     // store the temperature