Merge branch 'lib-file' into bugfix/issue-2305

Author: Matthias Koefferlein

src/db/db/dbCell.h

@@ -857,7 +857,7 @@ class DB_PUBLIC Cell
   void check_locked () const;
 
   /**
-   *  @brief Tell, if this cell is a proxy cell
+   *  @brief Gets a value indicating if this cell is a proxy cell
    *
    *  Proxy cells are such whose layout represents a snapshot of another entity.
    *  Such cells can be PCell variants or library references for example.
@@ -867,6 +867,17 @@ class DB_PUBLIC Cell
     return false; 
   }
 
+  /**
+   *  @brief Gets a value indicating that this cell is a replica that can be skipped
+   *
+   *  This attribute is evaluated by file writers to skip cell replicas for
+   *  library cells that do not want to replicated.
+   */
+  virtual bool can_skip_replica () const
+  {
+    return false;
+  }
+
   /**
    *  @brief Sets the cell name
    *

src/db/db/dbCommonReader.cc

@@ -692,6 +692,11 @@ class CommonFormatDeclaration
     return false;
   }
 
+  virtual bool supports_context () const
+  {
+    return false;
+  }
+
   virtual tl::XMLElementBase *xml_reader_options_element () const
   {
     return new db::ReaderOptionsXMLElement<db::CommonReaderOptions> ("common",

src/db/db/dbLibrary.cc

@@ -33,14 +33,17 @@
 namespace db
 {
 
-Library::Library()
-  : m_id (std::numeric_limits<lib_id_type>::max ()), m_layout (true)
+Library::Library ()
+  : m_id (std::numeric_limits<lib_id_type>::max ()), m_layout (true), m_replicate (true)
 {
   m_layout.set_library (this);
 }
 
-Library::Library(const Library &d)
-  : gsi::ObjectBase (), tl::Object (), m_name (d.m_name), m_description (d.m_description), m_id (std::numeric_limits<lib_id_type>::max ()), m_layout (d.m_layout)
+Library::Library (const Library &d)
+  : gsi::ObjectBase (), tl::Object (),
+    m_name (d.m_name), m_description (d.m_description),
+    m_id (std::numeric_limits<lib_id_type>::max ()), m_layout (d.m_layout),
+    m_replicate (d.m_replicate)
 {
   m_layout.set_library (this);
 }
@@ -65,6 +68,12 @@ Library::for_technologies () const
   return ! m_technologies.empty ();
 }
 
+void
+Library::set_technologies (const std::set<std::string> &t)
+{
+  m_technologies = t;
+}
+
 void
 Library::set_technology (const std::string &t)
 {
@@ -148,6 +157,12 @@ Library::is_retired (const db::cell_index_type library_cell_index) const
   return (i != m_refcount.end () && j != m_retired_count.end () && i->second == j->second);
 }
 
+void
+Library::set_replicate (bool f)
+{
+  m_replicate = f;
+}
+
 void
 Library::rename (const std::string &name)
 {

src/db/db/dbLibrary.h

@@ -53,12 +53,12 @@ class DB_PUBLIC Library
   /**
    *  @brief The constructor
    */
-  Library();
+  Library ();
 
   /**
    *  @brief Copy constructor
    */
-  Library(const Library &);
+  Library (const Library &);
 
   /**
    *  @brief The destructor
@@ -138,6 +138,13 @@ class DB_PUBLIC Library
    */
   bool for_technologies () const;
 
+  /**
+   *  @brief Sets the technology names this library is associated with
+   *
+   *  This will reset the list of technologies to this set.
+   */
+  void set_technologies (const std::set<std::string> &t);
+
   /**
    *  @brief Sets the technology name this library is associated with
    *
@@ -172,6 +179,27 @@ class DB_PUBLIC Library
     m_description = description;
   }
 
+  /**
+   *  @brief Sets a value indicating whether the library produces replicas
+   *
+   *  If this value is true (the default), layout written will include the
+   *  actual layout of a library cell (replica). With this, it is possible
+   *  to regenerate the layout without actually having the library at the
+   *  cost of additional bytes in the file.
+   *
+   *  Setting this flag to false avoids this replication, but a layout
+   *  cannot be regenerated without having this library.
+   */
+  void set_replicate (bool f);
+
+  /**
+   *  @brief Gets a value indicating whether the library produces replicas
+   */
+  bool replicate () const
+  {
+    return m_replicate;
+  }
+
   /**
    *  @brief Getter for the library Id property
    */
@@ -263,6 +291,7 @@ class DB_PUBLIC Library
   db::Layout m_layout;
   std::map<db::Layout *, int> m_referrers;
   std::map<db::cell_index_type, int> m_refcount, m_retired_count;
+  bool m_replicate;
 
   // no copying.
   Library &operator=(const Library &);

src/db/db/dbLibraryProxy.cc

@@ -249,6 +249,13 @@ LibraryProxy::update (db::ImportLayerMapping *layer_mapping)
   }
 }
 
+bool
+LibraryProxy::can_skip_replica () const
+{
+  const Library *lib = LibraryManager::instance ().lib (lib_id ());
+  return lib && ! lib->replicate ();
+}
+
 std::string 
 LibraryProxy::get_basic_name () const
 {

src/db/db/dbLibraryProxy.h

@@ -93,6 +93,14 @@ class DB_PUBLIC LibraryProxy
     return true; 
   }
 
+  /**
+   *  @brief Gets a value indicating that this cell is a replica that can be skipped
+   *
+   *  This attribute is evaluated by file writers to skip cell replicas for
+   *  library cells that do not want to replicated.
+   */
+  virtual bool can_skip_replica () const;
+
   /**
    *  @brief Gets the basic name
    *

src/db/db/dbSaveLayoutOptions.cc

@@ -56,7 +56,7 @@ SaveLayoutOptions::operator= (const SaveLayoutOptions &d)
     m_format = d.m_format;
     m_layers = d.m_layers;
     m_cells = d.m_cells;
-    m_implied_childred = d.m_implied_childred;
+    m_implied_children = d.m_implied_children;
     m_all_layers = d.m_all_layers;
     m_all_cells = d.m_all_cells;
     m_dbu = d.m_dbu;
@@ -189,7 +189,7 @@ SaveLayoutOptions::add_cell (db::cell_index_type cell_index)
 {
   m_all_cells = false;
   m_cells.insert (cell_index);
-  m_implied_childred.insert (cell_index);
+  m_implied_children.insert (cell_index);
 }
 
 void 
@@ -204,15 +204,15 @@ SaveLayoutOptions::clear_cells ()
 {
   m_all_cells = false;
   m_cells.clear ();
-  m_implied_childred.clear ();
+  m_implied_children.clear ();
 }
 
 void
 SaveLayoutOptions::select_all_cells ()
 {
   m_all_cells = true;
   m_cells.clear ();
-  m_implied_childred.clear ();
+  m_implied_children.clear ();
 }
 
 void 
@@ -340,21 +340,75 @@ SaveLayoutOptions::get_valid_layers (const db::Layout &layout, std::vector <std:
   }
 }
 
+static void
+collect_called_cells_unskipped (db::cell_index_type ci, const db::Layout &layout, std::set<cell_index_type> &called)
+{
+  const db::Cell &c = layout.cell (ci);
+  if (c.can_skip_replica ()) {
+    return;
+  }
+
+  for (auto cc = c.begin_child_cells (); ! cc.at_end (); ++cc) {
+    if (called.find (*cc) == called.end () && layout.is_valid_cell_index (*cc)) {
+      called.insert (*cc);
+      collect_called_cells_unskipped (*cc, layout, called);
+    }
+  }
+}
+
 void 
 SaveLayoutOptions::get_cells (const db::Layout &layout, std::set <db::cell_index_type> &cells, const std::vector <std::pair <unsigned int, db::LayerProperties> > &valid_layers, bool require_unique_names) const
 {
+  bool has_context = m_write_context_info;
+  for (tl::Registrar<db::StreamFormatDeclaration>::iterator fmt = tl::Registrar<db::StreamFormatDeclaration>::begin (); fmt != tl::Registrar<db::StreamFormatDeclaration>::end (); ++fmt) {
+    if (fmt->format_name () == m_format) {
+      if (! fmt->supports_context ()) {
+        has_context = false;
+      }
+      break;
+    }
+  }
+
   if (m_all_cells) {
 
-    for (db::Layout::const_iterator cell = layout.begin (); cell != layout.end (); ++cell) {
-      cells.insert (cell->cell_index ());
+    bool has_skipped_replica = false;
+
+    //  check if we have skipped replicas
+    if (has_context) {
+      for (db::Layout::const_iterator cell = layout.begin (); cell != layout.end () && ! has_skipped_replica; ++cell) {
+        has_skipped_replica = cell->can_skip_replica ();
+      }
+    }
+
+    //  with skipped replicas start again and skip child cells of such cells
+    //  unless they are needed in other places.
+    if (has_skipped_replica) {
+
+      for (db::Layout::const_iterator cell = layout.begin (); cell != layout.end (); ++cell) {
+        if (cell->is_top ()) {
+          cells.insert (cell->cell_index ());
+          collect_called_cells_unskipped (cell->cell_index (), layout, cells);
+        }
+      }
+
+    } else {
+
+      for (db::Layout::const_iterator cell = layout.begin (); cell != layout.end () && ! has_skipped_replica; ++cell) {
+        cells.insert (cell->cell_index ());
+      }
+
     }
 
   } else {
 
     for (std::set <db::cell_index_type>::const_iterator c = m_cells.begin (); c != m_cells.end (); ++c) {
       cells.insert (*c);
-      if (m_implied_childred.find (*c) != m_implied_childred.end ()) {
-        layout.cell (*c).collect_called_cells (cells);
+      if (m_implied_children.find (*c) != m_implied_children.end ()) {
+        if (has_context) {
+          collect_called_cells_unskipped (*c, layout, cells);
+        } else {
+          layout.cell (*c).collect_called_cells (cells);
+        }
       }
     }
 

src/db/db/dbSaveLayoutOptions.h

@@ -449,7 +449,7 @@ class DB_PUBLIC SaveLayoutOptions
   std::string m_format;
   std::map<unsigned int, db::LayerProperties> m_layers;
   std::set<db::cell_index_type> m_cells;
-  std::set<db::cell_index_type> m_implied_childred;
+  std::set<db::cell_index_type> m_implied_children;
   bool m_all_layers;
   bool m_all_cells;
   double m_dbu;

src/db/db/dbStream.h

@@ -109,6 +109,11 @@ class DB_PUBLIC StreamFormatDeclaration
    */
   virtual bool can_write () const = 0;
 
+  /**
+   *  @brief Returns true, when the format supports a context (e.g. PCell parameters, Library references)
+   */
+  virtual bool supports_context () const = 0;
+
   /**
    *  @brief Delivers the XMLElement object that represents the reader options within a technology XML tree
    *

src/db/db/gsiDeclDbLibrary.cc

@@ -266,6 +266,26 @@ LibraryClass<db::Library> decl_Library ("db", "LibraryBase",
     "\n"
     "This method has been introduced in version 0.30.5."
   ) +
+  gsi::method ("replicate=", &db::Library::set_replicate, gsi::arg ("flag"),
+    "@brief Sets a value indicating whether the library produces replicas\n"
+    "\n"
+    "If this value is true (the default), layout written will include the\n"
+    "actual layout of a library cell (replica). With this, it is possible\n"
+    "to regenerate the layout without actually having the library at the\n"
+    "cost of additional bytes in the file.\n"
+    "\n"
+    "Setting this flag to false avoids this replication, but a layout\n"
+    "cannot be regenerated without having this library.\n"
+    "\n"
+    "This attribute has been introduced in version 0.30.8."
+  ) +
+  gsi::method ("replicate", &db::Library::replicate,
+    "@brief Gets a value indicating whether the library produces replicas\n"
+    "\n"
+    "See \\replicate= for a description of this attribute.\n"
+    "\n"
+    "This attribute has been introduced in version 0.30.8."
+  ) +
   gsi::method ("rename", &db::Library::rename, gsi::arg ("name"),
     "@brief Renames the library\n"
     "\n"