Merge pull request #10029 from QuantamHD/lef_parsing_jetski

ant: Supports LEF58_ANTENNAGATEPLUSDIFF rule in ant and odb

Author: maliberty

src/ant/src/AntennaChecker.cc

@@ -56,6 +56,8 @@ struct AntennaModel
 
   double minus_diff_factor;
   double plus_diff_factor;
+  std::vector<double> gate_plus_diff_idx;
+  std::vector<double> gate_plus_diff_ratios;
   double diff_metal_reduce_factor;
 };
 
@@ -138,6 +140,8 @@ void AntennaChecker::Impl::initAntennaRules()
 
     double minus_diff_factor = 0.0;
     double plus_diff_factor = 0.0;
+    std::vector<double> gate_plus_diff_idx;
+    std::vector<double> gate_plus_diff_ratios;
     double diff_metal_reduce_factor = 1.0;
 
     if (tech_layer->hasDefaultAntennaRule()) {
@@ -164,6 +168,9 @@ void AntennaChecker::Impl::initAntennaRules()
 
       minus_diff_factor = antenna_rule->getAreaMinusDiffFactor();
       plus_diff_factor = antenna_rule->getGatePlusDiffFactor();
+      auto pwl = antenna_rule->getGatePlusDiffPWL();
+      gate_plus_diff_idx = pwl.indices;
+      gate_plus_diff_ratios = pwl.ratios;
 
       const double PSR_ratio = antenna_rule->getPSR();
       const odb::dbTechLayerAntennaRule::pwl_pair diffPSR
@@ -195,6 +202,8 @@ void AntennaChecker::Impl::initAntennaRules()
                                   diff_side_metal_factor,
                                   minus_diff_factor,
                                   plus_diff_factor,
+                                  gate_plus_diff_idx,
+                                  gate_plus_diff_ratios,
                                   diff_metal_reduce_factor};
     layer_info_[tech_layer] = layer_antenna;
   }
@@ -405,15 +414,22 @@ void AntennaChecker::Impl::calculateWirePar(odb::dbTechLayer* tech_layer,
     info.PAR = (diff_metal_factor * info.area) / info.iterm_gate_area;
     info.PSR = (diff_side_metal_factor * info.side_area) / info.iterm_gate_area;
 
+    double plus_diff_protect = plus_diff_factor * info.iterm_diff_area;
+    if (!layer_info_[tech_layer].gate_plus_diff_idx.empty()) {
+      odb::dbTechLayerAntennaRule::pwl_pair pwl
+          = {.indices = layer_info_[tech_layer].gate_plus_diff_idx,
+             .ratios = layer_info_[tech_layer].gate_plus_diff_ratios};
+      plus_diff_protect = getPwlFactor(pwl, info.iterm_diff_area, 0.0);
+    }
+
     // Calculate PSR
-    info.diff_PAR
-        = (diff_metal_factor * info.area * diff_metal_reduce_factor
-           - minus_diff_factor * info.iterm_diff_area)
-          / (info.iterm_gate_area + plus_diff_factor * info.iterm_diff_area);
+    info.diff_PAR = (diff_metal_factor * info.area * diff_metal_reduce_factor
+                     - minus_diff_factor * info.iterm_diff_area)
+                    / (info.iterm_gate_area + plus_diff_protect);
     info.diff_PSR
         = (diff_side_metal_factor * info.side_area * diff_metal_reduce_factor
            - minus_diff_factor * info.iterm_diff_area)
-          / (info.iterm_gate_area + plus_diff_factor * info.iterm_diff_area);
+          / (info.iterm_gate_area + plus_diff_protect);
   } else {
     // Calculate PAR
     info.PAR = (metal_factor * info.area) / info.iterm_gate_area;
@@ -448,11 +464,19 @@ void AntennaChecker::Impl::calculateViaPar(odb::dbTechLayer* tech_layer,
   if (info.iterm_diff_area != 0) {
     // Calculate PAR
     info.PAR = (diff_cut_factor * info.area) / info.iterm_gate_area;
+
+    double plus_diff_protect = plus_diff_factor * info.iterm_diff_area;
+    if (!layer_info_[tech_layer].gate_plus_diff_idx.empty()) {
+      odb::dbTechLayerAntennaRule::pwl_pair pwl
+          = {.indices = layer_info_[tech_layer].gate_plus_diff_idx,
+             .ratios = layer_info_[tech_layer].gate_plus_diff_ratios};
+      plus_diff_protect = getPwlFactor(pwl, info.iterm_diff_area, 0.0);
+    }
+
     // Calculate diff_PAR
-    info.diff_PAR
-        = (diff_cut_factor * info.area * diff_metal_reduce_factor
-           - minus_diff_factor * info.iterm_diff_area)
-          / (info.iterm_gate_area + plus_diff_factor * info.iterm_diff_area);
+    info.diff_PAR = (diff_cut_factor * info.area * diff_metal_reduce_factor
+                     - minus_diff_factor * info.iterm_diff_area)
+                    / (info.iterm_gate_area + plus_diff_protect);
   } else {
     // Calculate PAR
     info.PAR = (cut_factor * info.area) / info.iterm_gate_area;

src/odb/include/odb/db.h

@@ -6670,6 +6670,7 @@ class dbTechLayerAntennaRule : public dbObject
   pwl_pair getDiffPSR() const;
   pwl_pair getDiffCSR() const;
   pwl_pair getAreaDiffReduce() const;
+  pwl_pair getGatePlusDiffPWL() const;
 
   // PWL
   void setDiffPAR(const std::vector<double>& diff_idx,
@@ -6680,6 +6681,8 @@ class dbTechLayerAntennaRule : public dbObject
                   const std::vector<double>& ratios);
   void setDiffCSR(const std::vector<double>& diff_idx,
                   const std::vector<double>& ratios);
+  void setGatePlusDiffPWL(const std::vector<double>& diff_idx,
+                          const std::vector<double>& ratios);
 
   // Single value
   void setDiffPAR(double ratio);
@@ -9343,6 +9346,7 @@ class dbTechLayer : public dbObject
   ///
   dbTechLayerAntennaRule* createDefaultAntennaRule();
   dbTechLayerAntennaRule* createOxide2AntennaRule();
+  dbTechLayerAntennaRule* getOrCreateAntennaModel(int oxide_idx);
 
   ///
   /// Access and write antenna rule models -- get functions will return nullptr

src/odb/src/db/dbDatabase.h

@@ -50,7 +50,11 @@ namespace odb {
 inline constexpr uint32_t kSchemaMajor = 0;  // Not used...
 inline constexpr uint32_t kSchemaInitial = 57;
 
-inline constexpr uint32_t kSchemaMinor = 128;  // Current revision number
+inline constexpr uint32_t kSchemaMinor = 129;  // Current revision number
+
+// Revision where _dbTechLayerAntennaRule was modified to use ARuleRatio for
+// gate_plus_diff
+inline constexpr uint32_t kSchemaLef58AntennaGatePlusDiff = 129;
 
 // Revision where dbChipPath was added to dbChip
 inline constexpr uint32_t kSchemaChipPath = 128;

src/odb/src/db/dbTechLayer.cpp

@@ -1215,6 +1215,21 @@ bool dbTechLayer::isRectOnlyExceptNonCorePins() const
 
 // User Code Begin dbTechLayerPublicMethods
 
+dbTechLayerAntennaRule* dbTechLayer::getOrCreateAntennaModel(int oxide_idx)
+{
+  if (oxide_idx == 2) {
+    auto rule = getOxide2AntennaRule();
+    return rule ? rule : createOxide2AntennaRule();
+  }
+  if (oxide_idx == 1) {
+    auto rule = getDefaultAntennaRule();
+    return rule ? rule : createDefaultAntennaRule();
+  }
+  getImpl()->getLogger()->warn(
+      utl::ODB, 1118, "Unsupported oxide index: {}", oxide_idx);
+  return nullptr;
+}
+
 void dbTechLayer::setLef58Type(LEF58_TYPE type)
 {
   _dbTechLayer* layer = (_dbTechLayer*) this;

src/odb/src/db/dbTechLayerAntennaRule.cpp

@@ -95,7 +95,7 @@ bool _dbTechLayerAntennaRule::operator==(
     return false;
   }
 
-  if (gate_plus_diff_factor_ != rhs.gate_plus_diff_factor_) {
+  if (gate_plus_diff_val_ != rhs.gate_plus_diff_val_) {
     return false;
   }
 
@@ -239,7 +239,7 @@ dbOStream& operator<<(dbOStream& stream, const _dbTechLayerAntennaRule& inrule)
   stream << inrule.par_sidearea_val_;
   stream << inrule.cum_sidearea_val_;
   stream << inrule.area_diff_reduce_val_;
-  stream << inrule.gate_plus_diff_factor_;
+  stream << inrule.gate_plus_diff_val_;
   stream << inrule.area_minus_diff_factor_;
   stream << inrule.has_antenna_cumroutingpluscut_;
   return stream;
@@ -255,7 +255,13 @@ dbIStream& operator>>(dbIStream& stream, _dbTechLayerAntennaRule& inrule)
   stream >> inrule.par_sidearea_val_;
   stream >> inrule.cum_sidearea_val_;
   stream >> inrule.area_diff_reduce_val_;
-  stream >> inrule.gate_plus_diff_factor_;
+  if (inrule.getDatabase()->isSchema(kSchemaLef58AntennaGatePlusDiff)) {
+    stream >> inrule.gate_plus_diff_val_;
+  } else {
+    double factor;
+    stream >> factor;
+    inrule.gate_plus_diff_val_.ratio_ = factor;
+  }
   stream >> inrule.area_minus_diff_factor_;
   stream >> inrule.has_antenna_cumroutingpluscut_;
   return stream;
@@ -292,10 +298,22 @@ void dbTechLayerAntennaRule::writeLef(lefout& writer) const
     fmt::print(writer.out(), "    ANTENNACUMROUTINGPLUSCUT ;\n");
   }
 
-  if (ant_rule->gate_plus_diff_factor_ > 0.0) {
+  if (ant_rule->gate_plus_diff_val_.diff_ratio_.size() > 1) {
+    fmt::print(writer.out(), "    ANTENNAGATEPLUSDIFF  PWL ( ");
+    dbVector<double>::const_iterator diffdx_itr;
+    dbVector<double>::const_iterator ratio_itr;
+    for (diffdx_itr = ant_rule->gate_plus_diff_val_.diff_idx_.begin(),
+        ratio_itr = ant_rule->gate_plus_diff_val_.diff_ratio_.begin();
+         diffdx_itr != ant_rule->gate_plus_diff_val_.diff_idx_.end()
+         && ratio_itr != ant_rule->gate_plus_diff_val_.diff_ratio_.end();
+         diffdx_itr++, ratio_itr++) {
+      fmt::print(writer.out(), "( {:g} {:g} ) ", *diffdx_itr, *ratio_itr);
+    }
+    fmt::print(writer.out(), ") ;\n");
+  } else if (ant_rule->gate_plus_diff_val_.ratio_ > 0.0) {
     fmt::print(writer.out(),
                "    ANTENNAGATEPLUSDIFF {:g} ;\n",
-               ant_rule->gate_plus_diff_factor_);
+               ant_rule->gate_plus_diff_val_.ratio_);
   }
 
   if (ant_rule->area_minus_diff_factor_ > 0.0) {
@@ -639,13 +657,29 @@ void dbTechLayerAntennaRule::setAntennaCumRoutingPlusCut(bool value)
 double dbTechLayerAntennaRule::getGatePlusDiffFactor() const
 {
   _dbTechLayerAntennaRule* ant_rule = (_dbTechLayerAntennaRule*) this;
-  return ant_rule->gate_plus_diff_factor_;
+  return ant_rule->gate_plus_diff_val_.ratio_;
 }
 
 void dbTechLayerAntennaRule::setGatePlusDiffFactor(double factor)
 {
   _dbTechLayerAntennaRule* ant_rule = (_dbTechLayerAntennaRule*) this;
-  ant_rule->gate_plus_diff_factor_ = factor;
+  ant_rule->gate_plus_diff_val_.ratio_ = factor;
+}
+
+dbTechLayerAntennaRule::pwl_pair dbTechLayerAntennaRule::getGatePlusDiffPWL()
+    const
+{
+  _dbTechLayerAntennaRule* ant_rule = (_dbTechLayerAntennaRule*) this;
+  auto& rule = ant_rule->gate_plus_diff_val_;
+  return {.indices = rule.diff_idx_, .ratios = rule.diff_ratio_};
+}
+
+void dbTechLayerAntennaRule::setGatePlusDiffPWL(
+    const std::vector<double>& diff_idx,
+    const std::vector<double>& ratios)
+{
+  _dbTechLayerAntennaRule* ant_rule = (_dbTechLayerAntennaRule*) this;
+  ant_rule->gate_plus_diff_val_.setDiff(diff_idx, ratios);
 }
 
 double dbTechLayerAntennaRule::getAreaMinusDiffFactor() const

src/odb/src/db/dbTechLayerAntennaRule.h

@@ -82,9 +82,7 @@ class _dbTechLayerAntennaRule : public _dbObject
 {
  public:
   _dbTechLayerAntennaRule(_dbDatabase*)
-      : gate_plus_diff_factor_(0),
-        area_minus_diff_factor_(0),
-        has_antenna_cumroutingpluscut_(false)
+      : area_minus_diff_factor_(0), has_antenna_cumroutingpluscut_(false)
   {
   }
   _dbTechLayerAntennaRule(_dbDatabase*, const _dbTechLayerAntennaRule& r)
@@ -96,7 +94,7 @@ class _dbTechLayerAntennaRule : public _dbObject
         par_sidearea_val_(r.par_sidearea_val_),
         cum_sidearea_val_(r.cum_sidearea_val_),
         area_diff_reduce_val_(r.area_diff_reduce_val_),
-        gate_plus_diff_factor_(r.gate_plus_diff_factor_),
+        gate_plus_diff_val_(r.gate_plus_diff_val_),
         area_minus_diff_factor_(r.area_minus_diff_factor_)
   {
   }
@@ -116,7 +114,7 @@ class _dbTechLayerAntennaRule : public _dbObject
   ARuleRatio par_sidearea_val_;
   ARuleRatio cum_sidearea_val_;
   ARuleRatio area_diff_reduce_val_;
-  double gate_plus_diff_factor_;
+  ARuleRatio gate_plus_diff_val_;
   double area_minus_diff_factor_;
   bool has_antenna_cumroutingpluscut_;
 };