Rt drc main

src/operation/iDRC/interface/DRCInterface.cpp

@@ -96,8 +96,10 @@ void DRCInterface::checkDef()
   bool origin_quiet = DRCLOG.isQuiet();
   DRCLOG.disableQuiet();
 
+  std::set<size_t> obs_shape_idx_set;
+  std::vector<ids::Shape> env_shape_list = buildEnvShapeList(obs_shape_idx_set);
   std::map<std::string, std::vector<ids::Violation>> type_violation_map;
-  for (ids::Violation& ids_violation : getViolationList(buildEnvShapeList(), buildResultShapeList(), {}, {})) {
+  for (ids::Violation& ids_violation : getViolationList(env_shape_list, buildResultShapeList(), {}, {}, obs_shape_idx_set)) {
     type_violation_map[ids_violation.violation_type].push_back(ids_violation);
   }
   printSummary(type_violation_map);
@@ -150,11 +152,21 @@ std::vector<ids::Violation> DRCInterface::getViolationList(const std::vector<ids
                                                            const std::vector<ids::Shape>& ids_result_shape_list,
                                                            const std::set<std::string>& ids_check_type_set,
                                                            const std::vector<ids::Shape>& ids_check_region_list)
+{
+  return getViolationList(ids_env_shape_list, ids_result_shape_list, ids_check_type_set, ids_check_region_list, {});
+}
+
+std::vector<ids::Violation> DRCInterface::getViolationList(const std::vector<ids::Shape>& ids_env_shape_list,
+                                                           const std::vector<ids::Shape>& ids_result_shape_list,
+                                                           const std::set<std::string>& ids_check_type_set,
+                                                           const std::vector<ids::Shape>& ids_check_region_list,
+                                                           const std::set<size_t>& obs_shape_idx_set)
 {
   std::vector<DRCShape> drc_env_shape_list;
   drc_env_shape_list.reserve(ids_env_shape_list.size());
-  for (const ids::Shape& ids_env_shape : ids_env_shape_list) {
-    drc_env_shape_list.push_back(convertToDRCShape(ids_env_shape));
+  for (size_t i = 0; i < ids_env_shape_list.size(); i++) {
+    drc_env_shape_list.push_back(convertToDRCShape(ids_env_shape_list[i]));
+    drc_env_shape_list.back().set_is_obs(obs_shape_idx_set.count(i) > 0);
   }
   std::vector<DRCShape> drc_result_shape_list;
   drc_result_shape_list.reserve(ids_result_shape_list.size());
@@ -911,41 +923,39 @@ void DRCInterface::output()
 
 std::vector<ids::Shape> DRCInterface::buildEnvShapeList()
 {
+  std::set<size_t> obs_shape_idx_set;
+  return buildEnvShapeList(obs_shape_idx_set);
+}
+
+std::vector<ids::Shape> DRCInterface::buildEnvShapeList(std::set<size_t>& obs_shape_idx_set)
+{
+  obs_shape_idx_set.clear();
   std::vector<ids::Shape> env_shape_list;
   auto monitor = Monitor::create();
   DRCLOG.info(Loc::current(), "Starting...");
 
-  std::vector<idb::IdbInstance*>& idb_instance_list = dmInst->get_idb_def_service()->get_design()->get_instance_list()->get_instance_list();
-  std::vector<idb::IdbNet*>& idb_net_list = dmInst->get_idb_def_service()->get_design()->get_net_list()->get_net_list();
-  std::vector<idb::IdbSpecialNet*>& idb_special_net_list = dmInst->get_idb_def_service()->get_design()->get_special_net_list()->get_net_list();
-  std::vector<idb::IdbPin*>& idb_io_pin_list = dmInst->get_idb_def_service()->get_design()->get_io_pin_list()->get_pin_list();
-  std::vector<idb::IdbBlockage*> idb_blockage_list = dmInst->get_idb_def_service()->get_design()->get_blockage_list()->get_blockage_list();
-  idb::IdbDesign* idb_design = dmInst->get_idb_def_service()->get_design();
-  std::map<idb::IdbPin*, int32_t> special_pin_net_idx_map;
+  auto* idb_design = dmInst->get_idb_def_service()->get_design();
+  std::vector<idb::IdbInstance*>& idb_instance_list = idb_design->get_instance_list()->get_instance_list();
+  std::vector<idb::IdbNet*>& idb_net_list = idb_design->get_net_list()->get_net_list();
+  std::vector<idb::IdbSpecialNet*>& idb_special_net_list = idb_design->get_special_net_list()->get_net_list();
+  std::vector<idb::IdbPin*>& idb_io_pin_list = idb_design->get_io_pin_list()->get_pin_list();
+  std::vector<idb::IdbBlockage*> idb_blockage_list = idb_design->get_blockage_list()->get_blockage_list();
   std::map<idb::IdbSpecialNet*, int32_t> special_net_idx_map;
   int32_t regular_net_num = static_cast<int32_t>(idb_net_list.size());
   for (size_t i = 0; i < idb_special_net_list.size(); ++i) {
-    int32_t special_net_id = regular_net_num + static_cast<int32_t>(i);
-    special_net_idx_map[idb_special_net_list[i]] = special_net_id;
-    for (idb::IdbPin* idb_pin : idb_special_net_list[i]->get_instance_pin_list()->get_pin_list()) {
-      special_pin_net_idx_map[idb_pin] = special_net_id;
-    }
-    for (idb::IdbPin* idb_pin : idb_special_net_list[i]->get_io_pins()->get_pin_list()) {
-      special_pin_net_idx_map[idb_pin] = special_net_id;
-    }
+    special_net_idx_map[idb_special_net_list[i]] = regular_net_num + static_cast<int32_t>(i);
   }
   auto get_pin_net_idx = [&](idb::IdbPin* idb_pin) {
-    auto it = special_pin_net_idx_map.find(idb_pin);
-    if (it != special_pin_net_idx_map.end()) {
-      return it->second;
+    if (idb_pin == nullptr) {
+      return -1;
     }
-    if (!idb_pin->is_io_pin()) {
-      idb::IdbSpecialNet* special_net = idb_design->findSpecialNetForInstancePin(idb_pin);
-      auto special_it = special_net_idx_map.find(special_net);
-      if (special_it != special_net_idx_map.end()) {
-        return special_it->second;
-      }
+    idb::IdbSpecialNet* special_net = idb_pin->is_io_pin() ? idb_pin->get_special_net()
+                                                            : idb_design->findSpecialNetForInstancePin(idb_pin);
+    auto special_net_it = special_net_idx_map.find(special_net);
+    if (special_net_it != special_net_idx_map.end()) {
+      return special_net_it->second;
     }
+
     if (!isSkipping(idb_pin->get_net())) {
       return static_cast<int32_t>(idb_pin->get_net()->get_id());
     }
@@ -1018,6 +1028,9 @@ std::vector<ids::Shape> DRCInterface::buildEnvShapeList()
           ids_shape.ur_y = rect->get_high_y();
           ids_shape.layer_idx = obs_box->get_layer()->get_id();
           ids_shape.is_routing = obs_box->get_layer()->is_routing();
+          if (ids_shape.is_routing) {
+            obs_shape_idx_set.insert(env_shape_list.size());
+          }
           env_shape_list.push_back(ids_shape);
         }
       }

src/operation/iDRC/interface/DRCInterface.hpp

@@ -118,6 +118,12 @@ class DRCInterface
   DRCInterface& operator=(const DRCInterface& other) = delete;
   DRCInterface& operator=(DRCInterface&& other) = delete;
   // function
+  std::vector<ids::Shape> buildEnvShapeList(std::set<size_t>& obs_shape_idx_set);
+  std::vector<ids::Violation> getViolationList(const std::vector<ids::Shape>& ids_env_shape_list,
+                                               const std::vector<ids::Shape>& ids_result_shape_list,
+                                               const std::set<std::string>& ids_check_type_set,
+                                               const std::vector<ids::Shape>& ids_check_region_list,
+                                               const std::set<size_t>& obs_shape_idx_set);
 };
 
 }  // namespace idrc

src/operation/iDRC/source/data_manager/advance/DRCShape.hpp

@@ -35,14 +35,17 @@ class DRCShape : public LayerRect
   // getter
   int32_t get_net_idx() const { return _net_idx; }
   bool get_is_routing() const { return _is_routing; }
+  bool get_is_obs() const { return _is_obs; }
   // setter
   void set_net_idx(const int32_t net_idx) { _net_idx = net_idx; }
   void set_is_routing(const bool is_routing) { _is_routing = is_routing; }
+  void set_is_obs(const bool is_obs) { _is_obs = is_obs; }
   // function
 
  private:
   int32_t _net_idx = -1;
   bool _is_routing = true;
+  bool _is_obs = false;
 };
 
 }  // namespace idrc

src/operation/iDRC/source/module/rule_validator/RuleValidator.cpp

@@ -455,6 +455,14 @@ void RuleValidator::prepareRVCluster(RVCluster& rv_cluster)
 
   auto add_shape_to_layer_data = [&](DRCShape* drc_shape, bool is_env_shape) {
     GTLRectInt gtl_rect = DRCUTIL.convertToGTLRectInt(drc_shape->get_rect());
+    if (drc_shape->get_is_routing()) {
+      RVLayerData& rv_layer_data = layer_data[drc_shape->get_layer_idx()];
+      if (drc_shape->get_is_obs()) {
+        rv_layer_data.obs_rtree.insert(gtl_rect);
+      } else {
+        rv_layer_data.metal_rtree.insert({gtl_rect, drc_shape->get_net_idx()});
+      }
+    }
     if (!drc_shape->get_is_routing()) {
       CutData cut_data;
       cut_data.rect = gtl_rect;

src/operation/iDRC/source/module/rule_validator/rv_data_manager/RVLayerData.hpp

@@ -122,6 +122,8 @@ struct RVLayerData
   bgi::rtree<std::pair<GTLRectInt, int32_t>, bgi::quadratic<16>> rect_rtrees;
   bgi::rtree<std::pair<GTLRectInt, int32_t>, bgi::quadratic<16>> boundary_rtrees;
   bgi::rtree<CutData, bgi::quadratic<16>, CutDataIndexable> cut_rtrees;
+  bgi::rtree<std::pair<GTLRectInt, int32_t>, bgi::quadratic<16>> metal_rtree;
+  bgi::rtree<GTLRectInt, bgi::quadratic<16>> obs_rtree;
 
   const CutData& getCut(int32_t cut_id) const { return cut_pool[cut_id]; }
   int32_t getCutId(const CutData& cut_data) const { return static_cast<int32_t>(&cut_data - cut_pool.data()); }
@@ -182,6 +184,18 @@ struct RVLayerData
     rect_rtrees.query(bgi::intersects(query_rect), out);
   }
 
+  template <typename OutputIt>
+  void queryMetalRects(const GTLRectInt& query_rect, OutputIt out) const
+  {
+    metal_rtree.query(bgi::intersects(query_rect), out);
+  }
+
+  template <typename OutputIt>
+  void queryObsRects(const GTLRectInt& query_rect, OutputIt out) const
+  {
+    obs_rtree.query(bgi::intersects(query_rect), out);
+  }
+
   template <typename OutputIt>
   void queryBoundaries(const GTLRectInt& query_rect, OutputIt out) const
   {

src/operation/iDRC/source/module/rule_validator/rv_design_rule/MetalShort.cpp

@@ -47,18 +47,18 @@ void RuleValidator::verifyMetalShort(RVCluster& rv_cluster)
     }
     const RVLayerData& rv_layer_data = layer_data_it->second;
     std::vector<Violation> layer_violations;
-    std::vector<std::pair<GTLRectInt, int32_t>> overlap_max_rects;
+    std::vector<std::pair<GTLRectInt, int32_t>> overlap_metal_rects;
+    std::vector<GTLRectInt> overlap_obs_rects;
     for (auto& [net_idx, polyset] : net_polyset) {
       std::vector<GTLRectInt> rect_list;
       gtl::get_max_rectangles(rect_list, polyset);
 
       for (GTLRectInt& gtl_rect : rect_list) {
         PlanarRect rect = DRCUTIL.convertToPlanarRect(gtl_rect);
 
-        overlap_max_rects.clear();
-        rv_layer_data.queryMaxRects(gtl_rect, std::back_inserter(overlap_max_rects));
-        for (auto [env_gtl_rect, env_max_rect_id] : overlap_max_rects) {
-          int32_t env_net_idx = rv_layer_data.getNetIdxByMaxRectId(env_max_rect_id);
+        overlap_metal_rects.clear();
+        rv_layer_data.queryMetalRects(gtl_rect, std::back_inserter(overlap_metal_rects));
+        for (auto [env_gtl_rect, env_net_idx] : overlap_metal_rects) {
           if (net_idx == env_net_idx) {
             continue;
           }
@@ -75,6 +75,23 @@ void RuleValidator::verifyMetalShort(RVCluster& rv_cluster)
           violation.set_required_size(0);
           layer_violations.push_back(std::move(violation));
         }
+
+        overlap_obs_rects.clear();
+        rv_layer_data.queryObsRects(gtl_rect, std::back_inserter(overlap_obs_rects));
+        for (const GTLRectInt& obs_gtl_rect : overlap_obs_rects) {
+          PlanarRect obs_rect = DRCUTIL.convertToPlanarRect(obs_gtl_rect);
+          if (!DRCUTIL.isOpenOverlap(rect, obs_rect)) {
+            continue;
+          }
+          Violation violation;
+          violation.set_violation_type(ViolationType::kMetalShort);
+          violation.set_is_routing(true);
+          violation.set_violation_net_set({net_idx, -1});
+          violation.set_layer_idx(routing_layer_idx);
+          violation.set_rect(DRCUTIL.getOverlap(rect, obs_rect));
+          violation.set_required_size(0);
+          layer_violations.push_back(std::move(violation));
+        }
       }
     }
 

src/operation/iRT/source/data_manager/advance/RoutingEdge.hpp

@@ -26,6 +26,7 @@ class RoutingEdge
   // getter
   int32_t get_supply() const { return _supply; }
   int32_t get_demand() const { return _demand; }
+  std::vector<int32_t>& get_demand_net_idx_list() { return _demand_net_idx_list; }
   std::set<int32_t>& get_ignore_net_set() { return _ignore_net_set; }
   double get_congestion_cost() const { return _congestion_cost; }
   int32_t get_overflow() const { return std::max(0, _demand - _supply); }
@@ -38,6 +39,7 @@ class RoutingEdge
  private:
   int32_t _supply = 0;
   int32_t _demand = 0;
+  std::vector<int32_t> _demand_net_idx_list;
   std::set<int32_t> _ignore_net_set;
   double _congestion_cost = 0;
 };

src/operation/iRT/source/module/gds_plotter/GDSPlotter.cpp

@@ -340,7 +340,8 @@ void GDSPlotter::buildGraphLypFile()
          {GPDataType::kKey, false},           {GPDataType::kGlobalPath, true}, {GPDataType::kDetailedPath, true},
          {GPDataType::kPatch, true},          {GPDataType::kShape, true},      {GPDataType::kAccessPoint, false},
          {GPDataType::kAxis, false},          {GPDataType::kOverflow, false},  {GPDataType::kRouteViolation, false},
-         {GPDataType::kPatchViolation, false}};
+         {GPDataType::kPatchViolation, false}, {GPDataType::kHEdgeAxis, false}, {GPDataType::kVEdgeAxis, false},
+         {GPDataType::kHEdgeInfo, false}, {GPDataType::kVEdgeInfo, false}};
   std::map<GPDataType, bool> cut_data_type_visible_map = {{GPDataType::kGlobalPath, true}, {GPDataType::kDetailedPath, true}, {GPDataType::kShape, true}};
 
   // 0为base_region 最后一个为GCell 中间为cut+routing

src/operation/iRT/source/module/gds_plotter/gp_data_manager/GPDataType.hpp

@@ -38,7 +38,11 @@ enum class GPDataType
   kAxis,
   kOverflow,
   kRouteViolation,
-  kPatchViolation
+  kPatchViolation,
+  kHEdgeAxis,
+  kVEdgeAxis,
+  kHEdgeInfo,
+  kVEdgeInfo
 };
 
 struct GetGPDataTypeName
@@ -95,6 +99,18 @@ struct GetGPDataTypeName
       case GPDataType::kPatchViolation:
         data_type_name = "patch_violation";
         break;
+      case GPDataType::kHEdgeAxis:
+        data_type_name = "h_edge_axis";
+        break;
+      case GPDataType::kVEdgeAxis:
+        data_type_name = "v_edge_axis";
+        break;
+      case GPDataType::kHEdgeInfo:
+        data_type_name = "h_edge_info";
+        break;
+      case GPDataType::kVEdgeInfo:
+        data_type_name = "v_edge_info";
+        break;
       default:
         RTLOG.error(Loc::current(), "Unrecognized type!");
         break;

src/operation/iRT/source/module/layer_assigner/LayerAssigner.cpp

@@ -84,6 +84,7 @@ void LayerAssigner::clearRoutingEdgeDemand()
       for (int32_t x = 0; x < routing_edge_map.get_x_size(); x++) {
         for (int32_t y = 0; y < routing_edge_map.get_y_size(); y++) {
           routing_edge_map[x][y].set_demand(0);
+          routing_edge_map[x][y].get_demand_net_idx_list().clear();
         }
       }
     }
@@ -785,6 +786,16 @@ void LayerAssigner::updateRoutingTreeToGraph(LAModel& la_model, const RoutingSeg
       if (change_type == ChangeType::kDel && routing_edge.get_demand() <= 0) {
         RTLOG.error(Loc::current(), "The routing edge demand is error!");
       }
+      std::vector<int32_t>& demand_net_idx_list = routing_edge.get_demand_net_idx_list();
+      if (change_type == ChangeType::kAdd) {
+        demand_net_idx_list.push_back(curr_net_idx);
+      } else {
+        auto iter = std::find(demand_net_idx_list.begin(), demand_net_idx_list.end(), curr_net_idx);
+        if (iter == demand_net_idx_list.end()) {
+          RTLOG.error(Loc::current(), "The routing edge demand net is error!");
+        }
+        demand_net_idx_list.erase(iter);
+      }
       routing_edge.set_demand(routing_edge.get_demand() + delta);
     }
   }