Merge pull request #6738 from joaomai/mpl-multi-pattern

MPL: support for multi pattern snapping

Author: maliberty

src/mpl/src/hier_rtlmp.cpp

@@ -3220,41 +3220,43 @@ void Snapper::snapMacro()
 
 void Snapper::snap(const odb::dbTechLayerDir& target_direction)
 {
-  SameDirectionLayersData layers_data
-      = computeSameDirectionLayersData(target_direction);
+  LayerDataList layers_data_list = computeLayerDataList(target_direction);
 
   int origin = target_direction == odb::dbTechLayerDir::VERTICAL
                    ? inst_->getOrigin().x()
                    : inst_->getOrigin().y();
 
-  if (!layers_data.snap_layer) {
+  if (layers_data_list.empty()) {
     // There are no pins to align with the track-grid.
     alignWithManufacturingGrid(origin);
     setOrigin(origin, target_direction);
     return;
   }
 
-  odb::dbITerm* snap_pin = layers_data.layer_to_pin.at(layers_data.snap_layer);
-  const LayerParameters& snap_layer_params
-      = layers_data.layer_to_params.at(layers_data.snap_layer);
+  const std::vector<int>& lowest_grid_positions
+      = layers_data_list[0].available_positions;
+  odb::dbITerm* lowest_grid_pin = layers_data_list[0].pins[0];
 
-  if (!pinsAreAlignedWithTrackGrid(
-          snap_pin, snap_layer_params, target_direction)) {
-    // The idea here is to first align the origin of the macro with
-    // the track-grid taking into account that the grid has a certain
-    // offset with regards to (0,0) and, then, compensate the offset
-    // of the pins themselves so that the lines of the grid cross
-    // their center.
-    origin = std::round(origin / static_cast<double>(snap_layer_params.pitch))
-                 * snap_layer_params.pitch
-             + snap_layer_params.offset - snap_layer_params.pin_offset;
+  const int lowest_pin_center_pos
+      = origin + getPinOffset(lowest_grid_pin, target_direction);
 
-    alignWithManufacturingGrid(origin);
-    setOrigin(origin, target_direction);
+  auto closest_pos = std::lower_bound(lowest_grid_positions.begin(),
+                                      lowest_grid_positions.end(),
+                                      lowest_pin_center_pos);
+
+  int starting_position_index
+      = std::distance(lowest_grid_positions.begin(), closest_pos);
+  // If no position is found, use the last available
+  if (starting_position_index == lowest_grid_positions.size()) {
+    starting_position_index -= 1;
   }
 
-  attemptSnapToExtraLayers(
-      origin, layers_data, snap_layer_params, target_direction);
+  snapPinToPosition(lowest_grid_pin,
+                    lowest_grid_positions[starting_position_index],
+                    target_direction);
+
+  attemptSnapToExtraPatterns(
+      starting_position_index, layers_data_list, target_direction);
 }
 
 void Snapper::setOrigin(const int origin,
@@ -3267,183 +3269,197 @@ void Snapper::setOrigin(const int origin,
   }
 }
 
-SameDirectionLayersData Snapper::computeSameDirectionLayersData(
+Snapper::LayerDataList Snapper::computeLayerDataList(
     const odb::dbTechLayerDir& target_direction)
 {
-  SameDirectionLayersData data;
+  TrackGridToPinListMap track_grid_to_pin_list;
+
+  odb::dbBlock* block = inst_->getBlock();
 
   for (odb::dbITerm* iterm : inst_->getITerms()) {
     if (iterm->getSigType() != odb::dbSigType::SIGNAL) {
       continue;
     }
 
     for (odb::dbMPin* mpin : iterm->getMTerm()->getMPins()) {
-      for (odb::dbBox* box : mpin->getGeometry()) {
-        odb::dbTechLayer* layer = box->getTechLayer();
-        if (layer->getDirection() == target_direction) {
-          if (data.layer_to_pin.find(layer) != data.layer_to_pin.end()) {
-            continue;
-          }
+      odb::dbTechLayer* layer = getPinLayer(mpin);
 
-          if (data.layer_to_pin.empty()) {
-            data.snap_layer = layer;
-          }
+      if (layer->getDirection() != target_direction) {
+        continue;
+      }
 
-          data.layer_to_pin[layer] = iterm;
-          data.layer_to_params[layer]
-              = computeLayerParameters(layer, iterm, target_direction);
-        }
+      odb::dbTrackGrid* track_grid = block->findTrackGrid(layer);
+      if (track_grid == nullptr) {
+        logger_->error(
+            MPL, 39, "No track-grid found for layer {}", layer->getName());
       }
+
+      track_grid_to_pin_list[track_grid].push_back(iterm);
+    }
+  }
+
+  auto compare_pin_center = [&](odb::dbITerm* pin1, odb::dbITerm* pin2) {
+    return (target_direction == odb::dbTechLayerDir::VERTICAL
+                ? pin1->getBBox().xCenter() < pin2->getBBox().xCenter()
+                : pin1->getBBox().yCenter() < pin2->getBBox().yCenter());
+  };
+
+  LayerDataList layers_data;
+  for (auto& [track_grid, pins] : track_grid_to_pin_list) {
+    std::vector<int> positions;
+    if (target_direction == odb::dbTechLayerDir::VERTICAL) {
+      track_grid->getGridX(positions);
+    } else {
+      track_grid->getGridY(positions);
     }
+    std::sort(pins.begin(), pins.end(), compare_pin_center);
+    layers_data.push_back(LayerData{track_grid, positions, pins});
   }
 
-  return data;
+  auto compare_layer_number = [](LayerData data1, LayerData data2) {
+    return (data1.track_grid->getTechLayer()->getNumber()
+            < data2.track_grid->getTechLayer()->getNumber());
+  };
+  std::sort(layers_data.begin(), layers_data.end(), compare_layer_number);
+
+  return layers_data;
 }
 
-LayerParameters Snapper::computeLayerParameters(
-    odb::dbTechLayer* layer,
-    odb::dbITerm* pin,
-    const odb::dbTechLayerDir& target_direction)
+odb::dbTechLayer* Snapper::getPinLayer(odb::dbMPin* pin)
 {
-  LayerParameters params;
-
-  odb::dbBlock* block = inst_->getBlock();
-  odb::dbTrackGrid* track_grid = block->findTrackGrid(layer);
+  return (*pin->getGeometry().begin())->getTechLayer();
+}
 
-  if (track_grid) {
-    getTrackGrid(track_grid, params.offset, params.pitch, target_direction);
+int Snapper::getPinOffset(odb::dbITerm* pin,
+                          const odb::dbTechLayerDir& direction)
+{
+  int pin_width = 0;
+  if (direction == odb::dbTechLayerDir::VERTICAL) {
+    pin_width = pin->getBBox().dx();
   } else {
-    logger_->error(
-        MPL, 39, "No track-grid found for layer {}", layer->getName());
+    pin_width = pin->getBBox().dy();
   }
 
-  params.pin_width = getPinWidth(pin, target_direction);
-  params.lower_left_to_first_pin
-      = getPinToLowerLeftDistance(pin, target_direction);
-
-  // The distance between the pins and the lower-left corner
-  // of the master of a macro instance may not be a multiple
-  // of the track-grid, in these cases, we need to compensate
-  // a small offset.
-  int mterm_offset = 0;
-  if (params.pitch != 0) {
-    mterm_offset = params.lower_left_to_first_pin
-                   - std::floor(params.lower_left_to_first_pin / params.pitch)
-                         * params.pitch;
+  int pin_to_origin = 0;
+  odb::dbMTerm* mterm = pin->getMTerm();
+  if (direction == odb::dbTechLayerDir::VERTICAL) {
+    pin_to_origin = mterm->getBBox().xMin();
+  } else {
+    pin_to_origin = mterm->getBBox().yMin();
   }
-  params.pin_offset = params.pin_width / 2 + mterm_offset;
+
+  int pin_offset = pin_to_origin + (pin_width / 2);
 
   const odb::dbOrientType& orientation = inst_->getOrient();
-  if (target_direction == odb::dbTechLayerDir::VERTICAL) {
+  if (direction == odb::dbTechLayerDir::VERTICAL) {
     if (orientation == odb::dbOrientType::MY
         || orientation == odb::dbOrientType::R180) {
-      params.pin_offset = -params.pin_offset;
+      pin_offset = -pin_offset;
     }
-  } else if (orientation == odb::dbOrientType::MX
-             || orientation == odb::dbOrientType::R180) {
-    params.pin_offset = -params.pin_offset;
-  }
-  return params;
-}
-
-int Snapper::getPinWidth(odb::dbITerm* pin,
-                         const odb::dbTechLayerDir& target_direction)
-{
-  int pin_width = 0;
-  if (target_direction == odb::dbTechLayerDir::VERTICAL) {
-    pin_width = pin->getBBox().dx();
   } else {
-    pin_width = pin->getBBox().dy();
+    if (orientation == odb::dbOrientType::MX
+        || orientation == odb::dbOrientType::R180) {
+      pin_offset = -pin_offset;
+    }
   }
-  return pin_width;
+
+  return pin_offset;
 }
 
-void Snapper::getTrackGrid(odb::dbTrackGrid* track_grid,
-                           int& origin,
-                           int& step,
-                           const odb::dbTechLayerDir& target_direction)
+void Snapper::snapPinToPosition(odb::dbITerm* pin,
+                                int position,
+                                const odb::dbTechLayerDir& direction)
 {
-  // TODO: handle multiple patterns
-  int count;
-  if (target_direction == odb::dbTechLayerDir::VERTICAL) {
-    track_grid->getGridPatternX(0, origin, count, step);
-  } else {
-    track_grid->getGridPatternY(0, origin, count, step);
-  }
+  int origin = position - getPinOffset(pin, direction);
+  alignWithManufacturingGrid(origin);
+  setOrigin(origin, direction);
 }
 
-int Snapper::getPinToLowerLeftDistance(
-    odb::dbITerm* pin,
-    const odb::dbTechLayerDir& target_direction)
+void Snapper::getTrackGridPattern(odb::dbTrackGrid* track_grid,
+                                  int pattern_idx,
+                                  int& origin,
+                                  int& step,
+                                  const odb::dbTechLayerDir& target_direction)
 {
-  int pin_to_origin = 0;
-
-  odb::dbMTerm* mterm = pin->getMTerm();
+  int count;
   if (target_direction == odb::dbTechLayerDir::VERTICAL) {
-    pin_to_origin = mterm->getBBox().xMin();
+    track_grid->getGridPatternX(pattern_idx, origin, count, step);
   } else {
-    pin_to_origin = mterm->getBBox().yMin();
+    track_grid->getGridPatternY(pattern_idx, origin, count, step);
   }
-
-  return pin_to_origin;
 }
 
-void Snapper::attemptSnapToExtraLayers(
-    const int origin,
-    const SameDirectionLayersData& layers_data,
-    const LayerParameters& snap_layer_params,
+void Snapper::attemptSnapToExtraPatterns(
+    const int start_index,
+    const LayerDataList& layers_data_list,
     const odb::dbTechLayerDir& target_direction)
 {
-  // Calculate LCM from the layers pitches to define the search
-  // range
-  int lcm = 1;
-  for (const auto& [layer, params] : layers_data.layer_to_params) {
-    lcm = std::lcm(lcm, params.pitch);
-  }
-  const int pitch = snap_layer_params.pitch;
-  const int total_attempts = lcm / snap_layer_params.pitch;
+  const int total_attempts = 100;
+  const int total_pins = std::accumulate(layers_data_list.begin(),
+                                         layers_data_list.end(),
+                                         0,
+                                         [](int total, const LayerData& data) {
+                                           return total + data.pins.size();
+                                         });
 
-  const int total_layers = static_cast<int>(layers_data.layer_to_pin.size());
+  odb::dbITerm* snap_pin = layers_data_list[0].pins[0];
+  const std::vector<int>& positions = layers_data_list[0].available_positions;
 
-  int best_origin = origin;
-  int best_snapped_layers = 1;
+  int best_index = start_index;
+  int best_snapped_pins = 0;
 
   for (int i = 0; i <= total_attempts; i++) {
     // Alternates steps from positive to negative incrementally
     int steps = (i % 2 == 1) ? (i + 1) / 2 : -(i / 2);
 
-    setOrigin(origin + (pitch * steps), target_direction);
-    int snapped_layers = 0;
-    for (const auto& [layer, pin] : layers_data.layer_to_pin) {
-      if (pinsAreAlignedWithTrackGrid(
-              pin, layers_data.layer_to_params.at(layer), target_direction)) {
-        ++snapped_layers;
-      }
+    int current_index = start_index + steps;
+
+    if (current_index < 0
+        || current_index >= layers_data_list[0].available_positions.size()) {
+      continue;
     }
+    snapPinToPosition(snap_pin, positions[current_index], target_direction);
 
-    if (snapped_layers > best_snapped_layers) {
-      best_snapped_layers = snapped_layers;
-      best_origin = origin + (pitch * steps);
+    int snapped_pins = totalPinsAligned(layers_data_list, target_direction);
 
-      // Stop search if all layers are snapped
-      if (total_layers == best_snapped_layers) {
+    if (snapped_pins > best_snapped_pins) {
+      best_snapped_pins = snapped_pins;
+      best_index = current_index;
+      if (best_snapped_pins == total_pins) {
         break;
       }
     }
   }
 
-  setOrigin(best_origin, target_direction);
+  snapPinToPosition(snap_pin, positions[best_index], target_direction);
 }
 
-bool Snapper::pinsAreAlignedWithTrackGrid(
-    odb::dbITerm* pin,
-    const LayerParameters& layer_params,
-    const odb::dbTechLayerDir& target_direction)
+int Snapper::totalPinsAligned(const LayerDataList& layers_data_list,
+                              const odb::dbTechLayerDir& direction)
 {
-  int pin_center = target_direction == odb::dbTechLayerDir::VERTICAL
-                       ? pin->getBBox().xCenter()
-                       : pin->getBBox().yCenter();
-  return (pin_center - layer_params.offset) % layer_params.pitch == 0;
+  int pins_aligned = 0;
+
+  for (auto& data : layers_data_list) {
+    std::vector<int> pin_centers(data.pins.size());
+    for (auto& pin : data.pins) {
+      pin_centers.push_back(direction == odb::dbTechLayerDir::VERTICAL
+                                ? pin->getBBox().xCenter()
+                                : pin->getBBox().yCenter());
+    }
+
+    int i = 0, j = 0;
+    while (i < pin_centers.size() && j < data.available_positions.size()) {
+      if (pin_centers[i] == data.available_positions[j]) {
+        pins_aligned++;
+        i++;
+      } else if (pin_centers[i] < data.available_positions[j]) {
+        i++;
+      } else {
+        j++;
+      }
+    }
+  }
+  return pins_aligned;
 }
 
 void Snapper::alignWithManufacturingGrid(int& origin)