Tune mpl2 based on multiple expamples

Signed-off-by: Ravi Varadarajan <[email protected]>

Author: ravi-varadarajan

src/mpl2/src/SACoreHardMacro.cpp

@@ -92,8 +92,9 @@ SACoreHardMacro::SACoreHardMacro(
 float SACoreHardMacro::calNormCost() const
 {
   float cost = 0.0;  // Initialize cost
+  const float outline_area = outline_width_ * outline_height_;
   if (norm_area_penalty_ > 0.0) {
-    cost += area_weight_ * (width_ * height_) / norm_area_penalty_;
+    cost += area_weight_ * (width_ * height_) / outline_area;
   }
   if (norm_outline_penalty_ > 0.0) {
     cost += outline_weight_ * outline_penalty_ / norm_outline_penalty_;
@@ -234,6 +235,22 @@ void SACoreHardMacro::initialize()
   norm_wirelength_ = calAverage(wirelength_list);
   norm_guidance_penalty_ = calAverage(guidance_penalty_list);
   norm_fence_penalty_ = calAverage(fence_penalty_list);
+
+  if (norm_area_penalty_ <= 1e-4)
+    norm_area_penalty_ = 1.0;
+
+  if (norm_outline_penalty_ <= 1e-4)
+    norm_outline_penalty_ = 1.0;
+
+  if (norm_wirelength_ <= 1e-4)
+    norm_wirelength_ = 1.0;
+
+  if (norm_guidance_penalty_ <= 1e-4)
+    norm_guidance_penalty_ = 1.0;
+
+  if (norm_fence_penalty_ <= 1e-4)
+    norm_fence_penalty_ = 1.0;
+
   // Calculate initial temperature
   std::vector<float> cost_list;
   for (int i = 0; i < outline_penalty_list.size(); i++) {
@@ -249,48 +266,41 @@ void SACoreHardMacro::initialize()
   for (int i = 1; i < cost_list.size(); i++) {
     delta_cost += std::abs(cost_list[i] - cost_list[i - 1]);
   }
-  init_temperature_
-      = (-1.0) * (delta_cost / (cost_list.size() - 1)) / log(init_prob_);
+  if (cost_list.size() > 1 && delta_cost > 0.0) {
+    init_temperature_
+        = (-1.0) * (delta_cost / (cost_list.size() - 1)) / log(init_prob_);
+  } else {
+    init_temperature_ = 1.0;
+  }
 }
 
 void SACoreHardMacro::printResults()
 {
+  logger_->report(std::string(80, '*'));
   logger_->report("SACoreHardMacro");
-  logger_->report("outline_penalty_  = {}", outline_penalty_);
-  logger_->report("wirelength_  = {}", wirelength_);
-  for (auto& net : nets_) {
-    logger_->report("net  src = {} target = {} weight = {}",
-                    net.terminals.first,
-                    net.terminals.second,
-                    net.weight);
+  logger_->report("number of macros : {}", macros_.size());
+  for (auto macro : macros_) {
+    logger_->report("Debug");
+    logger_->report("lx = {}, ly = {}, width = {}, height = {}",
+                    macro.getX(),
+                    macro.getY(),
+                    macro.getWidth(),
+                    macro.getHeight());
   }
-
-  for (auto& macro : macros_) {
-    logger_->report(
-        "name : {} lx = {} ly = {} pin_x = {} pin_y = {} orientation = {}",
-        macro.getName(),
-        macro.getX(),
-        macro.getY(),
-        macro.getPinX(),
-        macro.getPinY(),
-        macro.getOrientation());
-  }
-  // FlipMacro();
-  calPenalty();
-  logger_->report("wirelength_  = {}", wirelength_);
-  for (auto& macro : macros_) {
-    logger_->report(
-        "name : {} lx = {} ly = {} pin_x = {} pin_y = {} orientation = {}",
-        macro.getName(),
-        macro.getX(),
-        macro.getY(),
-        macro.getPinX(),
-        macro.getPinY(),
-        macro.getOrientation());
-  }
-
-  logger_->report("guidance_penalty_  = {}", guidance_penalty_);
-  logger_->report("fence_penalty_  = {}", fence_penalty_);
+  logger_->report("width = {}, outline_width = {}", width_, outline_width_);
+  logger_->report("height = {}, outline_height = {}", height_, outline_height_);
+  logger_->report("outline_penalty  = {}, norm_outline_penalty = {}",
+                  outline_penalty_,
+                  norm_outline_penalty_);
+  logger_->report(
+      "wirelength  = {}, norm_wirelength = {}", wirelength_, norm_wirelength_);
+  logger_->report("guidance_penalty  = {}, norm_guidance_penalty = {}",
+                  guidance_penalty_,
+                  norm_guidance_penalty_);
+  logger_->report("fence_penalty  = {}, norm_fence_penalty = {}",
+                  fence_penalty_,
+                  norm_fence_penalty_);
+  logger_->report("final cost = {}", getNormCost());
 }
 
 }  // namespace mpl2

src/mpl2/src/SACoreSoftMacro.cpp

@@ -138,8 +138,9 @@ float SACoreSoftMacro::getNormNotchPenalty() const
 float SACoreSoftMacro::calNormCost() const
 {
   float cost = 0.0;  // Initialize cost
+  const float outline_area = outline_height_ * outline_width_;
   if (norm_area_penalty_ > 0.0) {
-    cost += area_weight_ * (width_ * height_) / norm_area_penalty_;
+    cost += area_weight_ * (width_ * height_) / outline_area;
   }
   if (norm_outline_penalty_ > 0.0) {
     cost += outline_weight_ * outline_penalty_ / norm_outline_penalty_;
@@ -275,7 +276,8 @@ void SACoreSoftMacro::initialize()
     // store current penalties
     width_list.push_back(width_);
     height_list.push_back(height_);
-    area_penalty_list.push_back(width_ * height_);
+    area_penalty_list.push_back(width_ * height_ / outline_width_
+                                / outline_height_);
     outline_penalty_list.push_back(outline_penalty_);
     wirelength_list.push_back(wirelength_);
     guidance_penalty_list.push_back(guidance_penalty_);
@@ -292,8 +294,33 @@ void SACoreSoftMacro::initialize()
   norm_fence_penalty_ = calAverage(fence_penalty_list);
   norm_boundary_penalty_ = calAverage(boundary_penalty_list);
   norm_macro_blockage_penalty_ = calAverage(macro_blockage_penalty_list);
-  // norm_notch_penalty_    = calAverage(notch_penalty_list);
-  norm_notch_penalty_ = outline_width_ * outline_height_;
+  norm_notch_penalty_ = calAverage(notch_penalty_list);
+
+  // Reset penalites if lower than threshold
+
+  if (norm_area_penalty_ <= 1e-4)
+    norm_area_penalty_ = 1.0;
+
+  if (norm_outline_penalty_ <= 1e-4)
+    norm_outline_penalty_ = 1.0;
+
+  if (norm_wirelength_ <= 1e-4)
+    norm_wirelength_ = 1.0;
+
+  if (norm_guidance_penalty_ <= 1e-4)
+    norm_guidance_penalty_ = 1.0;
+
+  if (norm_fence_penalty_ <= 1e-4)
+    norm_fence_penalty_ = 1.0;
+
+  if (norm_macro_blockage_penalty_ <= 1e-4)
+    norm_macro_blockage_penalty_ = 1.0;
+
+  if (norm_boundary_penalty_ <= 1e-4)
+    norm_boundary_penalty_ = 1.0;
+
+  if (norm_notch_penalty_ <= 1e-4)
+    norm_notch_penalty_ = 1.0;
 
   // Calculate initial temperature
   std::vector<float> cost_list;
@@ -313,8 +340,13 @@ void SACoreSoftMacro::initialize()
   for (int i = 1; i < cost_list.size(); i++) {
     delta_cost += std::abs(cost_list[i] - cost_list[i - 1]);
   }
-  init_temperature_
-      = (-1.0) * (delta_cost / (cost_list.size() - 1)) / log(init_prob_);
+
+  if (cost_list.size() > 1 && delta_cost > 0.0) {
+    init_temperature_
+        = (-1.0) * (delta_cost / (cost_list.size() - 1)) / log(init_prob_);
+  } else {
+    init_temperature_ = 1.0;
+  }
 }
 
 // We only push hard macro clusters to boundaries
@@ -327,6 +359,14 @@ void SACoreSoftMacro::calBoundaryPenalty()
     return;
   }
 
+  int tot_num_macros = 0;
+  for (const auto& macro : macros_) {
+    tot_num_macros += macro.getNumMacro();
+  }
+  if (tot_num_macros <= 0) {
+    return;
+  }
+
   for (const auto& macro : macros_) {
     if (macro.getNumMacro() > 0) {
       const float lx = macro.getX();
@@ -335,16 +375,25 @@ void SACoreSoftMacro::calBoundaryPenalty()
       const float uy = ly + macro.getHeight();
       const float x_dist = std::min(lx, std::abs(outline_width_ - ux));
       const float y_dist = std::min(ly, std::abs(outline_height_ - uy));
-      boundary_penalty_
-          += std::pow(std::min(x_dist, y_dist) * macro.getNumMacro(), 2);
+      boundary_penalty_ += std::min(x_dist, y_dist) * macro.getNumMacro();
     }
   }
+  // normalization
+  boundary_penalty_ = boundary_penalty_ / tot_num_macros;
 }
 
 void SACoreSoftMacro::calMacroBlockagePenalty()
 {
   macro_blockage_penalty_ = 0.0;
-  if (blockages_.size() == 0) {
+  if (blockages_.size() == 0 || macro_blockage_weight_ <= 0.0) {
+    return;
+  }
+
+  int tot_num_macros = 0;
+  for (const auto& macro : macros_) {
+    tot_num_macros += macro.getNumMacro();
+  }
+  if (tot_num_macros <= 0) {
     return;
   }
 
@@ -359,16 +408,23 @@ void SACoreSoftMacro::calMacroBlockagePenalty()
         const float region_ly = bbox.yMin();
         const float region_ux = bbox.xMax();
         const float region_uy = bbox.yMax();
-        if (ux > region_lx && lx < region_ux && uy > region_ly
-            && ly < region_uy) {
-          const float width = std::min(ux, region_ux) - std::max(lx, region_lx);
-          const float height
-              = std::min(uy, region_uy) - std::max(ly, region_ly);
-          macro_blockage_penalty_ += width * height;
-        }
+        // check each dimension seperately
+        // center to center distance
+        const float width = ((ux - lx) + (region_ux - region_lx)) / 2.0;
+        const float height = ((uy - ly) + (region_uy - region_ly)) / 2.0;
+        float x_dist
+            = std::abs((region_ux + region_lx) / 2.0 - (ux + lx) / 2.0);
+        float y_dist
+            = std::abs((region_uy + region_ly) / 2.0 - (uy + ly) / 2.0);
+        x_dist = std::max(width - x_dist, 0.0f) / width;
+        y_dist = std::max(height - y_dist, 0.0f) / height;
+        macro_blockage_penalty_
+            += (x_dist * x_dist + y_dist * y_dist) * macro.getNumMacro();
       }
     }
   }
+  // normalization
+  macro_blockage_penalty_ = macro_blockage_penalty_ / tot_num_macros;
 }
 
 // Align macro clusters to reduce notch
@@ -425,16 +481,17 @@ void SACoreSoftMacro::calNotchPenalty()
   }
   // If the floorplan cannot fit into the outline
   // We think the entire floorplan is a "huge" notch
-  if (width_ > outline_width_ || height_ > outline_height_) {
-    notch_penalty_ += outline_width_ * outline_height_;
+  if (width_ > outline_width_ * 1.001 || height_ > outline_height_ * 1.001) {
+    notch_penalty_ += outline_width_ * outline_height_
+                      / (outline_width_ * outline_height_);
     return;
   }
 
   pre_macros_ = macros_;
-  // Fill dead space
-  fillDeadSpace();
   // align macro clusters to reduce notches
   alignMacroClusters();
+  // Fill dead space
+  fillDeadSpace();
   // Create grids based on location of MixedCluster and HardMacroCluster
   std::set<float> x_point;
   std::set<float> y_point;
@@ -605,6 +662,8 @@ void SACoreSoftMacro::calNotchPenalty()
     }
   }
   macros_ = pre_macros_;
+  // normalization
+  notch_penalty_ = notch_penalty_ / (outline_width_ * outline_height_);
 }
 
 void SACoreSoftMacro::resize()
@@ -693,24 +752,59 @@ void SACoreSoftMacro::shrink()
 
 void SACoreSoftMacro::printResults() const
 {
-  logger_->report("outline_penalty : {}",
-                  outline_penalty_ / norm_outline_penalty_);
-  logger_->report("wirelength : {}", wirelength_ / norm_wirelength_);
-  logger_->report("guidance_penalty : {}",
-                  guidance_penalty_ / norm_guidance_penalty_);
-  logger_->report("fence_penalty : {}", fence_penalty_ / norm_fence_penalty_);
-  logger_->report("boundary_penalty : {}",
-                  boundary_penalty_ / norm_boundary_penalty_);
-  logger_->report("macro_blockage_penalty : {}",
-                  macro_blockage_penalty_ / norm_macro_blockage_penalty_);
-  logger_->report("notch_penalty : {}", notch_penalty_ / norm_notch_penalty_);
+  logger_->report(std::string(80, '*'));
+  logger_->report("SACoreSoftMacro");
+  logger_->report("number of macros : {}", macros_.size());
+  for (auto macro : macros_)
+    logger_->report("lx = {}, ly = {}, width = {}, height = {}, name = {}",
+                    macro.getX(),
+                    macro.getY(),
+                    macro.getWidth(),
+                    macro.getHeight(),
+                    macro.getName());
+  logger_->report("width = {}, outline_width = {}", width_, outline_width_);
+  logger_->report("height = {}, outline_height = {}", height_, outline_height_);
+  logger_->report(
+      "outline_weight = {}, outline_penalty  = {}, norm_outline_penalty = {}",
+      outline_weight_,
+      outline_penalty_,
+      norm_outline_penalty_);
+  logger_->report(
+      "wirelength_weight = {}, wirelength  = {}, norm_wirelength = {}",
+      wirelength_weight_,
+      wirelength_,
+      norm_wirelength_);
+  logger_->report(
+      "guidance_weight = {}, guidance_penalty  = {}, norm_guidance_penalty = "
+      "{}",
+      guidance_weight_,
+      guidance_penalty_,
+      norm_guidance_penalty_);
+  logger_->report(
+      "fence_weight = {}, fence_penalty  = {}, norm_fence_penalty = {}",
+      fence_weight_,
+      fence_penalty_,
+      norm_fence_penalty_);
+  logger_->report(
+      "macro_blockage_weight = {}, macro_blockage_penalty  = {}, "
+      "norm_macro_blockage_penalty = {}",
+      macro_blockage_weight_,
+      macro_blockage_penalty_,
+      norm_macro_blockage_penalty_);
+  logger_->report(
+      "notch_weight = {}, notch_penalty  = {}, norm_notch_penalty = {}",
+      notch_weight_,
+      notch_penalty_,
+      norm_notch_penalty_);
+  logger_->report("final cost = {}", getNormCost());
 }
 
 // fill the dead space by adjust the size of MixedCluster
 void SACoreSoftMacro::fillDeadSpace()
 {
   // if the floorplan is invalid, do nothing
-  if (width_ > outline_width_ || height_ > outline_height_) {
+  if (width_ > outline_width_ * (1.0 + 0.001)
+      || height_ > outline_height_ * (1.0 + 0.001)) {
     return;
   }