Merge pull request #8778 from VLSIDA/nested_journal

odb: Nested ECO journaling

Author: maliberty

src/dbSta/test/cpp/TestHconn.cpp

@@ -945,7 +945,6 @@ TEST_F(TestHconn, ConnectionMade)
   // Journalling test.
   // Undo everything and check initial state preserved
   //
-  odb::dbDatabase::endEco(block_);
   odb::dbDatabase::undoEco(block_);
 
   size_t restored_db_net_count = block_->getNets().size();

src/odb/include/odb/db.h

@@ -7409,46 +7409,46 @@ class dbDatabase : public dbObject
   ///
 
   ///
-  /// Begin collecting netlist changes on specified block.
-  ///
-  /// NOTE: Eco changes can not be nested at this time.
+  /// Start collecting ECO changes on the specified block.
   ///
   static void beginEco(dbBlock* block);
 
   ///
-  /// End collecting netlist changes on specified block.
+  /// Stop collecting ECO changes on the specified block.
   ///
   static void endEco(dbBlock* block);
 
   ///
-  /// Returns true of the pending eco is empty
+  /// Commit the last ECO changes on the specified block.
   ///
-  static bool ecoEmpty(dbBlock* block);
+  static void commitEco(dbBlock* block);
 
   ///
-  /// Read the eco changes from the specified stream to be applied to the
-  /// specified block.
+  /// Undo the last ECO changes on the specified block.
   ///
-  static void readEco(dbBlock* block, const char* filename);
+  static void undoEco(dbBlock* block);
 
   ///
-  /// Write the eco netlist changes to the specified stream.
+  /// Returns true if the current ECO is empty
   ///
-  static void writeEco(dbBlock* block, const char* filename);
-  static int checkEco(dbBlock* block);
+  static bool ecoEmpty(dbBlock* block);
 
   ///
-  /// Commit any pending netlist changes.
+  /// Return true if the ECO stack is empty. The ECO stack holds
+  /// the nested uncommitted ECOs that can still be undone.
   ///
-  static void commitEco(dbBlock* block);
+  static bool ecoStackEmpty(dbBlock* block);
 
   ///
-  /// Undo any pending netlist changes.  Only supports:
-  ///   create and destroy of dbInst and dbNet
-  ///   dbInst::swapMaster
-  ///   connect and disconnect of dbBTerm and dbITerm
+  /// Read the ECO changes from the specified file to be applied to the
+  /// specified block.
   ///
-  static void undoEco(dbBlock* block);
+  static void readEco(dbBlock* block, const char* filename);
+
+  ///
+  /// Write the ECO changes to the specified file.
+  ///
+  static void writeEco(dbBlock* block, const char* filename);
 
   ///
   /// links to utl::Logger

src/odb/src/db/dbBTerm.cpp

@@ -691,7 +691,6 @@ void _dbBTerm::connectModNet(_dbModNet* mod_net, _dbBlock* block)
                mod_net->getId(),
                static_cast<void*>(mod_net),
                ((dbModNet*) mod_net)->getHierarchicalName());
-
     block->_journal->beginAction(dbJournal::CONNECT_OBJECT);
     block->_journal->pushParam(dbBTermObj);
     block->_journal->pushParam(bterm->getId());

src/odb/src/db/dbBlock.cpp

@@ -422,7 +422,6 @@ _dbBlock::_dbBlock(_dbDatabase* db)
   _searchDb = nullptr;
   _extmi = nullptr;
   _journal = nullptr;
-  _journal_pending = nullptr;
 }
 
 _dbBlock::~_dbBlock()
@@ -517,7 +516,6 @@ _dbBlock::~_dbBlock()
     (*_cbitr)->removeOwner();
   }
   delete _journal;
-  delete _journal_pending;
 }
 
 void dbBlock::clear()
@@ -561,11 +559,6 @@ void dbBlock::clear()
     delete block->_journal;
     block->_journal = nullptr;
   }
-
-  if (block->_journal_pending) {
-    delete block->_journal_pending;
-    block->_journal_pending = nullptr;
-  }
 }
 
 void _dbBlock::initialize(_dbChip* chip,

src/odb/src/db/dbBlock.h

@@ -6,6 +6,7 @@
 #include <functional>
 #include <list>
 #include <map>
+#include <stack>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -301,7 +302,7 @@ class _dbBlock : public _dbObject
   void* _extmi;
 
   dbJournal* _journal;
-  dbJournal* _journal_pending;
+  std::stack<dbJournal*> _journal_stack;
 
   _dbBlock(_dbDatabase* db);
   ~_dbBlock();

src/odb/src/db/dbDatabase.cpp

@@ -717,47 +717,104 @@ void dbDatabase::write(std::ostream& file)
 void dbDatabase::beginEco(dbBlock* block_)
 {
   _dbBlock* block = (_dbBlock*) block_;
-
-  {
-    delete block->_journal;
+  if (block->_journal) {
+    endEco(block_);
   }
-
   block->_journal = new dbJournal(block_);
   assert(block->_journal);
+  debugPrint(block_->getImpl()->getLogger(),
+             utl::ODB,
+             "DB_ECO",
+             2,
+             "ECO: Started ECO #{}",
+             block->_journal_stack.size());
 }
 
 void dbDatabase::endEco(dbBlock* block_)
 {
   _dbBlock* block = (_dbBlock*) block_;
-  dbJournal* eco = block->_journal;
+  assert(block->_journal);
+  block->_journal_stack.push(block->_journal);
   block->_journal = nullptr;
+  debugPrint(block_->getImpl()->getLogger(),
+             utl::ODB,
+             "DB_ECO",
+             2,
+             "ECO: Ended ECO #{} (size {}) and pushed to ECO stack",
+             block->_journal_stack.size() - 1,
+             block->_journal_stack.top()->size());
+}
 
-  {
-    delete block->_journal_pending;
-  }
+void dbDatabase::commitEco(dbBlock* block_)
+{
+  _dbBlock* block = (_dbBlock*) block_;
+  // Commit the current ECO or the last ECO into stack
+  assert(block->_journal || !block->_journal_stack.empty());
+  if (!block->_journal) {
+    block->_journal = block->_journal_stack.top();
+    block->_journal_stack.pop();
+  }
+  if (!block->_journal_stack.empty()) {
+    dbJournal* prev_journal = block->_journal_stack.top();
+    int old_size = prev_journal->size();
+    prev_journal->append(block->_journal);
+    debugPrint(block_->getImpl()->getLogger(),
+               utl::ODB,
+               "DB_ECO",
+               2,
+               "ECO: Merged ECO #{} (size {}) with ECO #{} (size {} -> {})",
+               block->_journal_stack.size(),
+               block->_journal->size(),
+               block->_journal_stack.size() - 1,
+               old_size,
+               block->_journal_stack.top()->size());
+  } else {
+    debugPrint(block_->getImpl()->getLogger(),
+               utl::ODB,
+               "DB_ECO",
+               2,
+               "ECO: Committed ECO #{} (size {}) and removed from ECO stack",
+               block->_journal_stack.size(),
+               block->_journal->size());
+  }
+  delete block->_journal;
+  block->_journal = nullptr;
+}
 
-  block->_journal_pending = eco;
+void dbDatabase::undoEco(dbBlock* block_)
+{
+  _dbBlock* block = (_dbBlock*) block_;
+  assert(block->_journal || !block->_journal_stack.empty());
+  if (!block->_journal) {
+    block->_journal = block->_journal_stack.top();
+    block->_journal_stack.pop();
+  }
+  debugPrint(block_->getImpl()->getLogger(),
+             utl::ODB,
+             "DB_ECO",
+             2,
+             "ECO: Undid ECO #{} (size {})",
+             block->_journal_stack.size(),
+             block->_journal->size());
+  dbJournal* journal = block->_journal;
+  block->_journal = nullptr;
+  journal->undo();
+  delete block->_journal;
 }
 
 bool dbDatabase::ecoEmpty(dbBlock* block_)
 {
   _dbBlock* block = (_dbBlock*) block_;
-
   if (block->_journal) {
     return block->_journal->empty();
   }
-
   return false;
 }
 
-int dbDatabase::checkEco(dbBlock* block_)
+bool dbDatabase::ecoStackEmpty(dbBlock* block_)
 {
   _dbBlock* block = (_dbBlock*) block_;
-
-  if (block->_journal) {
-    return block->_journal->size();
-  }
-  return 0;
+  return block->_journal_stack.empty();
 }
 
 void dbDatabase::readEco(dbBlock* block_, const char* filename)
@@ -774,11 +831,10 @@ void dbDatabase::readEco(dbBlock* block_, const char* filename)
   assert(eco);
   stream >> *eco;
 
-  {
-    delete block->_journal_pending;
-  }
-
-  block->_journal_pending = eco;
+  delete block->_journal;
+  block->_journal = nullptr;
+  eco->redo();
+  block->_journal = eco;
 }
 
 void dbDatabase::writeEco(dbBlock* block_, const char* filename)
@@ -796,33 +852,12 @@ void dbDatabase::writeEco(dbBlock* block_, const char* filename)
   file.exceptions(std::ifstream::failbit | std::ifstream::badbit
                   | std::ios::eofbit);
 
-  if (block->_journal_pending) {
+  if (block->_journal) {
     dbOStream stream(block->getDatabase(), file);
-    stream << *block->_journal_pending;
-  }
-}
-
-void dbDatabase::commitEco(dbBlock* block_)
-{
-  _dbBlock* block = (_dbBlock*) block_;
-
-  // TODO: Need a check to ensure the commit is not applied to the block of
-  // which this eco was generated from.
-  if (block->_journal_pending) {
-    block->_journal_pending->redo();
-    delete block->_journal_pending;
-    block->_journal_pending = nullptr;
-  }
-}
-
-void dbDatabase::undoEco(dbBlock* block_)
-{
-  _dbBlock* block = (_dbBlock*) block_;
-
-  if (block->_journal_pending) {
-    block->_journal_pending->undo();
-    delete block->_journal_pending;
-    block->_journal_pending = nullptr;
+    stream << *block->_journal;
+  } else if (!block->_journal_stack.empty()) {
+    dbOStream stream(block->getDatabase(), file);
+    stream << *block->_journal_stack.top();
   }
 }
 

src/odb/src/db/dbGuide.cpp

@@ -155,7 +155,8 @@ dbGuide* dbGuide::create(dbNet* net,
                utl::ODB,
                "DB_ECO",
                1,
-               "ECO: create guide, layer {} box {}",
+               "ECO: create dbGuide at id {}, in layer {} box {}",
+               guide->getOID(),
                layer->getName(),
                box);
     block->_journal->beginAction(dbJournal::CREATE_OBJECT);
@@ -192,8 +193,10 @@ void dbGuide::destroy(dbGuide* guide)
                utl::ODB,
                "DB_ECO",
                1,
-               "ECO: destroy guide, id: {}",
-               guide->getId());
+               "ECO: delete dbGuide at id {}, in layer {} box {}",
+               guide->getId(),
+               guide->getLayer()->getName(),
+               guide->getBox());
     block->_journal->beginAction(dbJournal::DELETE_OBJECT);
     block->_journal->pushParam(dbGuideObj);
     block->_journal->pushParam(net->getOID());

src/odb/src/db/dbITerm.cpp

@@ -510,7 +510,6 @@ void dbITerm::disconnect()
                (mod_net_impl) ? mod_net_impl->getId() : 0,
                static_cast<void*>(mod_net),
                (mod_net) ? mod_net->getHierarchicalName() : "NULL");
-
     block->_journal->beginAction(dbJournal::DISCONNECT_OBJECT);
     block->_journal->pushParam(dbITermObj);
     block->_journal->pushParam(getId());