Merge pull request #10909 from AcKoucher/rcx-set-corners-refactor

rcx: refactor to isolate extraction rules parsing logic into its own function

Author: maliberty

src/rcx/include/rcx/extRCap.h

@@ -1827,7 +1827,7 @@ class extMain
                                const char* prefix,
                                const char* postfix,
                                bool v = false);
-  bool modelExists(const char* extRules);
+  bool modelExists();
 
   void addInstsGeometries(const Array1D<uint32_t>* instTable,
                           Array1D<uint32_t>* tmpInstIdTable,
@@ -2267,7 +2267,7 @@ class extMain
   void cleanCornerTables();
   int getDbCornerIndex(const char* name);
   int getDbCornerModel(const char* name);
-  bool setCorners(const char* rulesFileName);
+  void registerRulesModel(extRCModel* rules_model);
   int getProcessCornerDbIndex(int pcidx);
   void getScaledCornerDbIndex(int pcidx, int& scidx, int& scdbIdx);
   void getScaledRC(int sidx, double& res, double& cap);
@@ -2713,7 +2713,6 @@ class extMain
   int _ccMaxY;
   double _mergeResBound = 0.0;
   bool _mergeViaRes = false;
-  const char* rules_file_path_{nullptr};
   const char* target_nets_names_{nullptr};
   bool _mergeParallelCC = false;
   bool _reportNetNoWire = false;
@@ -2829,4 +2828,10 @@ class extMain
   // ---------------------------------------------------------
 };
 
+std::unique_ptr<extRCModel> parseRules(
+    odb::dbTech* tech,
+    const Array1D<extCorner*>* extractor_corner_table,
+    bool is_v2,
+    utl::Logger* logger);
+
 }  // namespace rcx

src/rcx/src/OpenRCX.tcl

@@ -83,13 +83,7 @@ proc extract_parasitics { args } {
 
   set ext_model_file ""
   if { [info exists keys(-ext_model_file)] } {
-    utl::warn RCX 514 "The -ext_model_file option is deprecated. Use\
-                       set_extraction_rules_file command instead."
-
-    # We may have multiple technologies loaded, so use the current block's
-    # tech to prevent an error resolving an ambiguous default tech.
-    set tech [[ord::get_db_block] getTech]
-    set_extraction_rules_file -tech [$tech getName] $keys(-ext_model_file)
+    set ext_model_file $keys(-ext_model_file)
   }
 
   set corner_cnt 1

src/rcx/src/ext.cpp

@@ -216,7 +216,17 @@ void Ext::extract(ExtractOptions options)
 
   odb::orderWires(logger_, block);
 
-  std::string rules_file = block->getTech()->getExtractionRulesFile();
+  odb::dbTech* tech = block->getTech();
+  if (options.ext_model_file != nullptr && options.ext_model_file[0] != '\0') {
+    logger_->warn(RCX,
+                  514,
+                  "The ext_model_file option is deprecated. Use "
+                  "set_extraction_rules_file command instead.");
+
+    tech->setExtractionRulesFile(options.ext_model_file);
+  }
+
+  std::string rules_file = tech->getExtractionRulesFile();
   if (!rules_file.empty()) {
     options.ext_model_file = rules_file.c_str();
   }

src/rcx/src/extmain.cpp

@@ -43,7 +43,6 @@ void extMain::setExtractionOptions(const ExtractOptions& options)
   _lef_res = options.lef_res;
   _lefRC = options.lef_rc;
   _dbgOption = options._dbg;
-  rules_file_path_ = options.ext_model_file;
   target_nets_names_ = options.net;
 }
 

src/rcx/src/extmain_v2.cpp

@@ -72,7 +72,7 @@ void extMain::makeBlockRCsegs_v2(const char* netNames, const char* extRules)
   // Model file is required if not option _lefRC is used.
   // _lefRC option requires Resistance and Capacitance values per Layer and
   // Technology to be taken from LEF file.
-  if (!_lefRC && !modelExists(extRules)) {
+  if (!_lefRC && !modelExists()) {
     return;
   }
 

src/rcx/src/netRC.cpp

@@ -1469,88 +1469,121 @@ void extMain::makeCornerNameMap()
   updatePrevControl();
 }
 
-bool extMain::setCorners(const char* rulesFileName)
+std::unique_ptr<extRCModel> parseRules(
+    odb::dbTech* tech,
+    const Array1D<extCorner*>* extractor_corner_table,
+    bool is_v2,
+    utl::Logger* logger)
 {
-  _modelMap.resetCnt(0);
-  _metRCTable.resetCnt(0);
+  // Rules files are written assuming this DBU-per-micron resolution; the
+  // tech may use a finer one, in which case rules-file values are scaled
+  // up when read.
+  constexpr int rules_file_dbu_per_micron = 1000;
+  const int tech_dbu_per_micron = tech->getDbUnitsPerMicron();
+  double rules_to_dbu_scale = 1.0;
+
+  if (tech_dbu_per_micron > rules_file_dbu_per_micron) {
+    rules_to_dbu_scale
+        = static_cast<double>(tech_dbu_per_micron) / rules_file_dbu_per_micron;
+  }
 
-  if (rulesFileName != nullptr) {  // read rules
+  auto model = std::make_unique<extRCModel>("MINTYPMAX", logger);
 
-    int dbunit = _block->getDbUnitsPerMicron();
-    double dbFactor = 1;
-    if (dbunit > 1000) {
-      dbFactor = dbunit * 0.001;
+  std::vector<uint32_t> corner_table;
+  if (extractor_corner_table) {
+    for (uint32_t ii = 0; ii < extractor_corner_table->getCnt(); ii++) {
+      extCorner* corner = extractor_corner_table->get(ii);
+      corner_table.push_back(corner->_model);
     }
+  }
 
-    extRCModel* m = new extRCModel("MINTYPMAX", logger_);
-    _modelTable->add(m);
+  const std::string rules_file = tech->getExtractionRulesFile();
+  if (rules_file.empty()) {
+    logger->error(RCX,
+                  17,
+                  "Could not parse extraction rules. No extraction rules file "
+                  "specified. Use set_extraction_rules_file to specify it.");
+  }
 
-    uint32_t cornerTable[10];
-    uint32_t extDbCnt = 0;
+  logger->info(RCX, 435, "Reading extraction model file {} ...", rules_file);
 
-    if (_processCornerTable != nullptr) {
-      for (uint32_t ii = 0; ii < _processCornerTable->getCnt(); ii++) {
-        extCorner* s = _processCornerTable->get(ii);
-        cornerTable[extDbCnt++] = s->_model;
-        _modelMap.add(ii);
-      }
+  FILE* file = fopen(rules_file.c_str(), "r");
+  if (file == nullptr) {
+    logger->error(RCX, 468, "Can't open extraction model file {}", rules_file);
+  }
+
+  fclose(file);
+
+  const bool is_v2_rules_file
+      = model->isRulesFile_v2((char*) rules_file.c_str(), false);
+
+  if (is_v2 || is_v2_rules_file) {
+    model->_v2_flow = is_v2;
+    if (!model->readRules((char*) rules_file.c_str(),
+                          false,
+                          true,
+                          true,
+                          true,
+                          true,
+                          corner_table.size(),
+                          corner_table.data(),
+                          rules_to_dbu_scale)) {
+      logger->error(
+          RCX, 14, "Failed to parse extraction model file {}", rules_file);
     }
+  } else {
+    if (!model->readRules_v1((char*) rules_file.c_str(),
+                             false,
+                             true,
+                             true,
+                             true,
+                             true,
+                             corner_table.size(),
+                             corner_table.data(),
+                             rules_to_dbu_scale)) {
+      logger->error(
+          RCX, 15, "Failed to parse extraction model file {}", rules_file);
+    }
+  }
 
-    logger_->info(
-        RCX, 435, "Reading extraction model file {} ...", rulesFileName);
+  if (model->getModelCnt() == 0) {
+    logger->error(RCX,
+                  487,
+                  "No RC model read from the extraction model! "
+                  "Ensure the right extRules file is used!");
+  }
 
-    FILE* rules_file = fopen(rulesFileName, "r");
-    if (rules_file == nullptr) {
-      logger_->error(
-          RCX, 468, "Can't open extraction model file {}", rulesFileName);
-    }
-    fclose(rules_file);
-    bool v2_rules_file = m->isRulesFile_v2((char*) rulesFileName, false);
-
-    if (_v2 || v2_rules_file) {
-      m->_v2_flow = _v2;
-
-      if (!(m->readRules((char*) rulesFileName,
-                         false,
-                         true,
-                         true,
-                         true,
-                         true,
-                         extDbCnt,
-                         cornerTable,
-                         dbFactor))) {
-        return false;
-      }
-    } else {
-      if (!(m->readRules_v1((char*) rulesFileName,
-                            false,
-                            true,
-                            true,
-                            true,
-                            true,
-                            extDbCnt,
-                            cornerTable,
-                            dbFactor))) {
-        return false;
-      }
+  return model;
+}
+
+void extMain::registerRulesModel(extRCModel* rules_model)
+{
+  // Differently from the other corner-related structures, the
+  // list of models is cleared at the end of the extraction flow.
+  _modelTable->add(rules_model);
+
+  // Clear rules data per corner.
+  _metRCTable.resetCnt(0);
+
+  // Clear corner -> model mapping.
+  _modelMap.resetCnt(0);
+
+  if (_processCornerTable != nullptr) {
+    for (uint32_t ii = 0; ii < _processCornerTable->getCnt(); ii++) {
+      _modelMap.add(ii);
     }
-    int modelCnt = getRCmodel(0)->getModelCnt();
+  }
 
-    // If RCX reads wrong extRules file format
-    if (modelCnt == 0) {
-      logger_->error(RCX,
-                     487,
-                     "No RC model read from the extraction model! "
-                     "Ensure the right extRules file is used!");
-    }
-    if (_processCornerTable == nullptr) {
-      for (int ii = 0; ii < modelCnt; ii++) {
-        addRCCorner(nullptr, ii, 0);
-        _modelMap.add(ii);
-      }
+  if (_processCornerTable == nullptr) {
+    const int modelCnt = getRCmodel(0)->getModelCnt();
+    for (int ii = 0; ii < modelCnt; ii++) {
+      addRCCorner(nullptr, ii, 0);
+      _modelMap.add(ii);
     }
   }
+
   _currentModel = getRCmodel(0);
+
   if (_v2) {
     if (_processCornerTable != nullptr && _couplingFlag > 0) {
       for (uint32_t ii = 0; ii < _processCornerTable->getCnt(); ii++) {
@@ -1566,18 +1599,8 @@ bool extMain::setCorners(const char* rulesFileName)
       _metRCTable.add(_currentModel->getMetRCTable(jj));
     }
   }
-  _extDbCnt = _processCornerTable->getCnt();
-
-#ifndef NDEBUG
-  uint32_t scaleCornerCnt = 0;
-  if (_scaledCornerTable != nullptr) {
-    scaleCornerCnt = _scaledCornerTable->getCnt();
-  }
-  assert(_cornerCnt == _extDbCnt + scaleCornerCnt);
-#endif
 
-  _block->setCornerCount(_cornerCnt, _extDbCnt, nullptr);
-  return true;
+  _extDbCnt = _processCornerTable->getCnt();
 }
 
 void extMain::addDummyCorners(uint32_t cornerCnt)
@@ -1635,10 +1658,10 @@ void extMain::getPrevControl()
   _ccNoPowerTarget = _prevControl->_ccNoPowerTarget;
   _usingMetalPlanes = _prevControl->_usingMetalPlanes;
 }
-bool extMain::modelExists(const char* extRules)
+bool extMain::modelExists()
 {
   if ((_prevControl->_ruleFileName.empty()) && (getRCmodel(0) == nullptr)
-      && (extRules == nullptr)) {
+      && (_block->getTech()->getExtractionRulesFile().empty())) {
     logger_->warn(RCX,
                   127,
                   "No RC model was read with command <load_model>, "
@@ -1650,7 +1673,7 @@ bool extMain::modelExists(const char* extRules)
 
 void extMain::makeBlockRCsegs()
 {
-  if (!modelExists(rules_file_path_)) {
+  if (!modelExists()) {
     return;
   }
 
@@ -1659,17 +1682,31 @@ void extMain::makeBlockRCsegs()
   _diagFlow = true;
   _usingMetalPlanes = true;
 
+  odb::dbTech* tech = _block->getTech();
+  const bool has_rules_file = !tech->getExtractionRulesFile().empty();
+
   if ((_processCornerTable != nullptr)
-      || ((_processCornerTable == nullptr) && (rules_file_path_ != nullptr))) {
-    const char* rules_file_path = rules_file_path_
-                                      ? rules_file_path_
-                                      : _prevControl->_ruleFileName.c_str();
-
-    // Reading model file
-    if (!setCorners(rules_file_path)) {
-      logger_->info(RCX, 128, "skipping Extraction ...");
-      return;
+      || ((_processCornerTable == nullptr) && has_rules_file)) {
+    std::unique_ptr<extRCModel> rules_model
+        = parseRules(tech, _processCornerTable, _v2, logger_);
+    registerRulesModel(rules_model.release());
+
+    uint32_t scaled_corner_count = 0;
+    if (_scaledCornerTable != nullptr) {
+      scaled_corner_count = _scaledCornerTable->getCnt();
+    }
+
+    if (_cornerCnt != _extDbCnt + scaled_corner_count) {
+      logger_->error(RCX,
+                     16,
+                     "Corner count invariant violated: total corners ({}) != "
+                     "process corners ({}) + scaled corners ({})",
+                     _cornerCnt,
+                     _extDbCnt,
+                     scaled_corner_count);
     }
+
+    _block->setCornerCount(_cornerCnt, _extDbCnt, nullptr);
   } else if (setMinTypMax(false, false, false, -1, -1, -1, 1) < 0) {
     logger_->warn(RCX, 129, "Wrong combination of corner related options!");
     return;

src/rcx/test/rcx_aux.py

@@ -1,4 +1,3 @@
-import utl
 import rcx
 
 # Thin wrapper over api defined in ext.i (and reused by ext-py.i)
@@ -28,21 +27,11 @@ def extract_parasitics(
     dbg=0
 ):
 
-    if ext_model_file is not None:
-        utl.warn(
-            utl.RCX,
-            514,
-            "The ext_model_file option is deprecated. Use "
-            "set_extraction_rules_file command instead.",
-        )
-
-        # We may have multiple technologies loaded, so use the current block's
-        # tech to prevent an error resolving an ambiguous default tech.
-        db_tech = design.getBlock().getTech()
-        db_tech.setExtractionRulesFile(ext_model_file)
-
     opts = rcx.ExtractOptions()
 
+    if ext_model_file is not None:
+        opts.ext_model_file = ext_model_file
+
     opts.corner_cnt = corner_cnt
     opts.corner = corner
     opts.max_res = max_res