diff --git a/src/db/db/dbHierNetworkProcessor.cc b/src/db/db/dbHierNetworkProcessor.cc index d3eac046f..c3ad9bc85 100644 --- a/src/db/db/dbHierNetworkProcessor.cc +++ b/src/db/db/dbHierNetworkProcessor.cc @@ -44,6 +44,11 @@ namespace db // ------------------------------------------------------------------------------ +// Don't cache instance to instance interaction sets beyond this size +const size_t instance_to_instance_cache_set_size_threshold = 10000; + +// ------------------------------------------------------------------------------ + template void insert_transformed (db::Layout &layout, db::Shapes &shapes, const Shape &s, const Trans &t); template void insert_transformed (db::Layout &layout, db::Shapes &shapes, const db::PolygonRef &s, const Trans &t) @@ -311,6 +316,54 @@ bool Connectivity::interacts (const T &a, unsigned int la, const T &b, unsigned } } +bool Connectivity::interacts (const std::set &la, const std::set &lb) const +{ + for (std::set::const_iterator i = la.begin (); i != la.end (); ++i) { + db::Connectivity::layer_iterator je = end_connected (*i); + for (db::Connectivity::layer_iterator j = begin_connected (*i); j != je; ++j) { + if (lb.find (*j) != lb.end ()) { + return true; + } + } + } + + return false; +} + +bool Connectivity::interact (const db::Cell &a, const db::Cell &b) const +{ + for (std::map::const_iterator i = m_connected.begin (); i != m_connected.end (); ++i) { + if (! a.bbox (i->first).empty ()) { + for (layers_type::const_iterator j = i->second.begin (); j != i->second.end (); ++j) { + if (! b.bbox (*j).empty ()) { + return true; + } + } + } + } + + return false; +} + +template +bool Connectivity::interact (const db::Cell &a, const T &ta, const db::Cell &b, const T &tb) const +{ + for (std::map::const_iterator i = m_connected.begin (); i != m_connected.end (); ++i) { + db::Box ba = a.bbox (i->first); + if (! ba.empty ()) { + ba.transform (ta); + for (layers_type::const_iterator j = i->second.begin (); j != i->second.end (); ++j) { + db::Box bb = b.bbox (*j); + if (! bb.empty () && bb.transformed (tb).touches (ba)) { + return true; + } + } + } + } + + return false; +} + // explicit instantiations template DB_PUBLIC bool Connectivity::interacts (const db::NetShape &a, unsigned int la, const db::NetShape &b, unsigned int lb, const db::UnitTrans &trans) const; template DB_PUBLIC bool Connectivity::interacts (const db::NetShape &a, unsigned int la, const db::NetShape &b, unsigned int lb, const db::ICplxTrans &trans) const; @@ -318,6 +371,7 @@ template DB_PUBLIC bool Connectivity::interacts (const db::Polyg template DB_PUBLIC bool Connectivity::interacts (const db::PolygonRef &a, unsigned int la, const db::PolygonRef &b, unsigned int lb, const db::ICplxTrans &trans) const; template DB_PUBLIC bool Connectivity::interacts (const db::Edge &a, unsigned int la, const db::Edge &b, unsigned int lb, const db::UnitTrans &trans) const; template DB_PUBLIC bool Connectivity::interacts (const db::Edge &a, unsigned int la, const db::Edge &b, unsigned int lb, const db::ICplxTrans &trans) const; +template DB_PUBLIC bool Connectivity::interact (const db::Cell &a, const db::ICplxTrans &ta, const db::Cell &b, const db::ICplxTrans &tb) const; // ------------------------------------------------------------------------------ // local_cluster implementation @@ -556,15 +610,7 @@ local_cluster::interacts (const local_cluster &other, const db::ICplxTrans return false; } - bool any = false; - - for (std::set::const_iterator i = ll1.begin (); i != ll1.end () && !any; ++i) { - db::Connectivity::layer_iterator je = conn.end_connected (*i); - for (db::Connectivity::layer_iterator j = conn.begin_connected (*i); j != je && !any; ++j) { - any = (ll2.find (*j) != ll2.end ()); - } - } - if (! any) { + if (! conn.interacts (ll1, ll2)) { return false; } @@ -1392,11 +1438,37 @@ public: * @brief Constructor */ hc_receiver (const db::Layout &layout, const db::Cell &cell, db::connected_clusters &cell_clusters, hier_clusters &tree, const cell_clusters_box_converter &cbc, const db::Connectivity &conn, const std::set *breakout_cells, typename hier_clusters::instance_interaction_cache_type *instance_interaction_cache) - : mp_layout (&layout), mp_cell (&cell), mp_tree (&tree), mp_cbc (&cbc), mp_conn (&conn), mp_breakout_cells (breakout_cells), mp_instance_interaction_cache (instance_interaction_cache) + : mp_layout (&layout), mp_cell (&cell), mp_tree (&tree), mp_cbc (&cbc), mp_conn (&conn), mp_breakout_cells (breakout_cells), m_cluster_cache_misses (0), m_cluster_cache_hits (0), mp_instance_interaction_cache (instance_interaction_cache) { mp_cell_clusters = &cell_clusters; } + /** + * @brief Gets the cache size + */ + size_t cluster_cache_size () const + { + db::MemStatisticsSimple ms; + ms << m_interaction_cache_for_clusters; + return ms.used (); + } + + /** + * @brief Gets the cache hits + */ + size_t cluster_cache_hits () const + { + return m_cluster_cache_hits; + } + + /** + * @brief Gets the cache misses + */ + size_t cluster_cache_misses () const + { + return m_cluster_cache_misses; + } + /** * @brief Receiver main event for instance-to-instance interactions */ @@ -1482,32 +1554,6 @@ public: void finalize (bool) { } private: - struct InteractionKeyForClustersType - : public InstanceToInstanceInteraction - { - InteractionKeyForClustersType (db::cell_index_type _ci1, db::cell_index_type _ci2, const db::ICplxTrans &_t1, const db::ICplxTrans &_t21, const box_type &_box) - : InstanceToInstanceInteraction (_ci1, 0, _ci2, 0, _t1, _t21), box (_box) - { } - - bool operator== (const InteractionKeyForClustersType &other) const - { - return InstanceToInstanceInteraction::operator== (other) && box == other.box; - } - - bool operator< (const InteractionKeyForClustersType &other) const - { - if (! InstanceToInstanceInteraction::operator== (other)) { - return InstanceToInstanceInteraction::operator< (other); - } - if (box != other.box) { - return box < other.box; - } - return false; - } - - box_type box; - }; - const db::Layout *mp_layout; const db::Cell *mp_cell; db::connected_clusters *mp_cell_clusters; @@ -1519,7 +1565,8 @@ private: std::map m_cm2join_map; join_set_list m_cm2join_sets; std::list m_ci_interactions; - std::map > > m_interaction_cache_for_clusters; + instance_interaction_cache, std::list > > m_interaction_cache_for_clusters; + size_t m_cluster_cache_misses, m_cluster_cache_hits; typename hier_clusters::instance_interaction_cache_type *mp_instance_interaction_cache; /** @@ -1559,13 +1606,21 @@ private: return; } + // gross shortcut: the cells do no comprise a constallation which will ever interact + if (! mp_conn->interact (mp_layout->cell (i1.cell_index ()), mp_layout->cell (i2.cell_index ()))) { + return; + } + InstanceToInstanceInteraction ii_key; db::ICplxTrans i1t, i2t; bool fill_cache = false; + size_t n1 = i1element.at_end () ? i1.size () : 1; + size_t n2 = i2element.at_end () ? i2.size () : 1; + // Cache is only used for single instances or simple and regular arrays. - if ((! i1element.at_end () || i1.size () == 1 || ! i1.is_iterated_array ()) && - (! i2element.at_end () || i2.size () == 1 || ! i2.is_iterated_array ())) { + if ((n1 == 1 || ! i1.is_iterated_array ()) && + (n2 == 1 || ! i2.is_iterated_array ())) { i1t = i1element.at_end () ? i1.complex_trans () : i1.complex_trans (*i1element); db::ICplxTrans tt1 = t1 * i1t; @@ -1574,11 +1629,11 @@ private: db::ICplxTrans tt2 = t2 * i2t; db::ICplxTrans cache_norm = tt1.inverted (); - ii_key = InstanceToInstanceInteraction (i1.cell_index (), (! i1element.at_end () || i1.size () == 1) ? 0 : i1.cell_inst ().delegate (), - i2.cell_index (), (! i2element.at_end () || i2.size () == 1) ? 0 : i2.cell_inst ().delegate (), + ii_key = InstanceToInstanceInteraction ((! i1element.at_end () || i1.size () == 1) ? 0 : i1.cell_inst ().delegate (), + (! i2element.at_end () || i2.size () == 1) ? 0 : i2.cell_inst ().delegate (), cache_norm, cache_norm * tt2); - const cluster_instance_pair_list_type *cached = mp_instance_interaction_cache->find (ii_key); + const cluster_instance_pair_list_type *cached = mp_instance_interaction_cache->find (i1.cell_index (), i2.cell_index (), ii_key); if (cached) { // use cached interactions @@ -1595,10 +1650,35 @@ private: } + // avoid caching few-to-many interactions as this typically does not contribute anything fill_cache = true; } + // shortcut: if the instances cannot interact because their bounding boxes do no comprise a valid constellation, + // reject the pair + + bool any = false; + for (db::Connectivity::layer_iterator la = mp_conn->begin_layers (); la != mp_conn->end_layers () && ! any; ++la) { + db::box_convert bca (*mp_layout, *la); + box_type bb1 = i1.cell_inst ().bbox (bca).transformed (t1); + if (! bb1.empty ()) { + db::Connectivity::layer_iterator lbe = mp_conn->end_connected (*la); + for (db::Connectivity::layer_iterator lb = mp_conn->begin_connected (*la); lb != lbe && ! any; ++lb) { + db::box_convert bcb (*mp_layout, *lb); + box_type bb2 = i2.cell_inst ().bbox (bcb).transformed (t2); + any = bb1.touches (bb2); + } + } + } + + if (! any) { + if (fill_cache) { + mp_instance_interaction_cache->insert (i1.cell_index (), i2.cell_index (), ii_key); + } + return; + } + // array interactions db::ICplxTrans t1i = t1.inverted (); @@ -1625,9 +1705,9 @@ private: box_type common12 = ib1 & ib2 & common; if (! common12.empty ()) { - const std::vector > &i2i_interactions = compute_instance_interactions (common12, i1.cell_index (), tt1, i2.cell_index (), tt2); + const std::list > &i2i_interactions = compute_instance_interactions (common12, i1.cell_index (), tt1, i2.cell_index (), tt2); - for (std::vector >::const_iterator ii = i2i_interactions.begin (); ii != i2i_interactions.end (); ++ii) { + for (std::list >::const_iterator ii = i2i_interactions.begin (); ii != i2i_interactions.end (); ++ii) { ClusterInstance k1 (ii->first, i1.cell_index (), i1t, i1.prop_id ()); ClusterInstance k2 (ii->second, i2.cell_index (), i2t, i2.prop_id ()); interacting_clusters.push_back (std::make_pair (k1, k2)); @@ -1692,7 +1772,7 @@ private: // return the list of unique interactions interacting_clusters.insert (interacting_clusters.end (), sorted_interactions.begin (), sorted_interactions.end ()); - if (fill_cache) { + if (fill_cache && sorted_interactions.size () < instance_to_instance_cache_set_size_threshold) { // normalize transformations for cache db::ICplxTrans i1ti = i1t.inverted (), i2ti = i2t.inverted (); @@ -1701,7 +1781,7 @@ private: i->second.transform (i2ti); } - cluster_instance_pair_list_type &cached = mp_instance_interaction_cache->insert (ii_key); + cluster_instance_pair_list_type &cached = mp_instance_interaction_cache->insert (i1.cell_index (), i2.cell_index (), ii_key); cached.insert (cached.end (), sorted_interactions.begin (), sorted_interactions.end ()); } @@ -1710,13 +1790,13 @@ private: /** * @brief Computes a list of interacting clusters for two instances */ - const std::vector > & + const std::list > & compute_instance_interactions (const box_type &common, db::cell_index_type ci1, const db::ICplxTrans &t1, db::cell_index_type ci2, const db::ICplxTrans &t2) { if (is_breakout_cell (mp_breakout_cells, ci1) || is_breakout_cell (mp_breakout_cells, ci2)) { - static const std::vector > empty; + static const std::list > empty; return empty; } @@ -1726,12 +1806,12 @@ private: box_type common2 = common.transformed (t2i); - InteractionKeyForClustersType ikey (ci1, ci2, t1i, t21, common2); + interaction_key_for_clusters ikey (t1i, t21, common2); - typename std::map > >::const_iterator ici = m_interaction_cache_for_clusters.find (ikey); - if (ici != m_interaction_cache_for_clusters.end ()) { + const std::list > *ici = m_interaction_cache_for_clusters.find (ci1, ci2, ikey); + if (ici) { - return ici->second; + return *ici; } else { @@ -1740,7 +1820,7 @@ private: const db::local_clusters &cl1 = mp_tree->clusters_per_cell (ci1); const db::local_clusters &cl2 = mp_tree->clusters_per_cell (ci2); - std::vector > &new_interactions = m_interaction_cache_for_clusters [ikey]; + std::list > &new_interactions = m_interaction_cache_for_clusters.insert (ci1, ci2, ikey); db::ICplxTrans t12 = t2i * t1; for (typename db::local_clusters::touching_iterator i = cl1.begin_touching (common2.transformed (t21)); ! i.at_end (); ++i) { @@ -1806,8 +1886,8 @@ private: cluster_instance_pair_list_type interacting_clusters; box_type common = (ib & ib2); - const std::vector > &i2i_interactions = compute_instance_interactions (common, i.cell_index (), tt, i.cell_index (), tt2); - for (std::vector >::const_iterator ii = i2i_interactions.begin (); ii != i2i_interactions.end (); ++ii) { + const std::list > &i2i_interactions = compute_instance_interactions (common, i.cell_index (), tt, i.cell_index (), tt2); + for (std::list >::const_iterator ii = i2i_interactions.begin (); ii != i2i_interactions.end (); ++ii) { ClusterInstance k1 (ii->first, i.cell_index (), tt, i.prop_id ()); ClusterInstance k2 (ii->second, i.cell_index (), tt2, i.prop_id ()); interacting_clusters.push_back (std::make_pair (k1, k2)); @@ -2050,6 +2130,7 @@ private: // for instance-to-instance interactions the number of connections is more important for the // cost of the join operation: make the one with more connections the target + // TODO: this will be SLOW for STL's not providing a fast size() if (mp_cell_clusters->connections_for_cluster (x1).size () < mp_cell_clusters->connections_for_cluster (x2).size ()) { std::swap (x1, x2); } @@ -2236,8 +2317,8 @@ hier_clusters::do_build (cell_clusters_box_converter &cbc, const db::Layou build_hier_connections_for_cells (cbc, layout, todo, conn, breakout_cells, progress, instance_interaction_cache); } - if (tl::verbosity () >= 51) { - tl::info << "Cluster build cache statistics: size=" << instance_interaction_cache.size () << ", hits=" << instance_interaction_cache.hits () << ", misses=" << instance_interaction_cache.misses (); + if (tl::verbosity () >= m_base_verbosity + 20) { + tl::info << "Cluster build cache statistics (instance to instance cache): size=" << instance_interaction_cache.size () << ", hits=" << instance_interaction_cache.hits () << ", misses=" << instance_interaction_cache.misses (); } } @@ -2430,6 +2511,11 @@ hier_clusters::build_hier_connections (cell_clusters_box_converter &cbc, c // join local clusters which got connected by child clusters rec->finish_cluster_to_instance_interactions (); + + if (tl::verbosity () >= m_base_verbosity + 20) { + tl::info << "Cluster build cache statistics (instance to shape cache): size=" << rec->cluster_cache_size () << ", hits=" << rec->cluster_cache_hits () << ", misses=" << rec->cluster_cache_misses (); + } + rec.reset (0); // finally connect global nets diff --git a/src/db/db/dbHierNetworkProcessor.h b/src/db/db/dbHierNetworkProcessor.h index aeb41b006..9475783c6 100644 --- a/src/db/db/dbHierNetworkProcessor.h +++ b/src/db/db/dbHierNetworkProcessor.h @@ -187,6 +187,22 @@ public: return interacts (a, la, b, lb, UnitTrans ()); } + /** + * @brief Returns true, if two sets of layers interact + */ + bool interacts (const std::set &la, const std::set &lb) const; + + /** + * @brief Returns true, if two cells basically (without considering transformation) interact + */ + bool interact (const db::Cell &a, const db::Cell &b) const; + + /** + * @brief Returns true, if two cells with the given transformations interact + */ + template + bool interact (const db::Cell &a, const T &ta, const db::Cell &b, const T &tb) const; + private: layers_type m_all_layers; std::map m_connected; @@ -796,10 +812,10 @@ inline bool less_array_delegates (const db::ArrayBase *a, const db::ArrayBase *b /** * @brief A helper struct to describe a pair of cell instances with a specific relative transformation */ -struct InstanceToInstanceInteraction +struct DB_PUBLIC InstanceToInstanceInteraction { - InstanceToInstanceInteraction (db::cell_index_type _ci1, const db::ArrayBase *_array1, db::cell_index_type _ci2, const db::ArrayBase *_array2, const db::ICplxTrans &_tn, const db::ICplxTrans &_t21) - : ci1 (_ci1), ci2 (_ci2), array1 (0), array2 (0), t21 (_t21) + InstanceToInstanceInteraction (const db::ArrayBase *_array1, const db::ArrayBase *_array2, const db::ICplxTrans &_tn, const db::ICplxTrans &_t21) + : array1 (0), array2 (0), t21 (_t21) { if (_array1) { array1 = _array1->basic_clone (); @@ -813,14 +829,13 @@ struct InstanceToInstanceInteraction } InstanceToInstanceInteraction () - : ci1 (0), ci2 (0), array1 (0), array2 (0) + : array1 (0), array2 (0) { // .. nothing yet .. } InstanceToInstanceInteraction (const InstanceToInstanceInteraction &other) - : ci1 (other.ci1), ci2 (other.ci2), - array1 (other.array1 ? other.array1->basic_clone () : 0), + : array1 (other.array1 ? other.array1->basic_clone () : 0), array2 (other.array2 ? other.array2->basic_clone () : 0), t21 (other.t21) { @@ -831,9 +846,6 @@ struct InstanceToInstanceInteraction { if (this != &other) { - ci1 = other.ci1; - ci2 = other.ci2; - if (array1) { delete array1; } @@ -866,19 +878,13 @@ struct InstanceToInstanceInteraction bool operator== (const InstanceToInstanceInteraction &other) const { - return ci1 == other.ci1 && ci2 == other.ci2 && t21.equal (other.t21) && + return t21.equal (other.t21) && equal_array_delegates (array1, other.array1) && equal_array_delegates (array2, other.array2); } bool operator< (const InstanceToInstanceInteraction &other) const { - if (ci1 != other.ci1) { - return ci1 < other.ci1; - } - if (ci2 != other.ci2) { - return ci2 < other.ci2; - } if (! t21.equal (other.t21)) { return t21.less (other.t21); } @@ -890,11 +896,110 @@ struct InstanceToInstanceInteraction return less_array_delegates (array2, other.array2); } - db::cell_index_type ci1, ci2; db::ArrayBase *array1, *array2; db::ICplxTrans t21; }; +template +struct DB_PUBLIC_TEMPLATE interaction_key_for_clusters + : public InstanceToInstanceInteraction +{ + interaction_key_for_clusters (const db::ICplxTrans &_t1, const db::ICplxTrans &_t21, const Box &_box) + : InstanceToInstanceInteraction (0, 0, _t1, _t21), box (_box) + { } + + bool operator== (const interaction_key_for_clusters &other) const + { + return InstanceToInstanceInteraction::operator== (other) && box == other.box; + } + + bool operator< (const interaction_key_for_clusters &other) const + { + if (! InstanceToInstanceInteraction::operator== (other)) { + return InstanceToInstanceInteraction::operator< (other); + } + if (box != other.box) { + return box < other.box; + } + return false; + } + + Box box; +}; + +/** + * @brief An object representing the instance interaction cache + */ +template +class DB_PUBLIC_TEMPLATE instance_interaction_cache +{ +public: + instance_interaction_cache () + : m_hits (0), m_misses (0) + { } + + size_t size () const + { + MemStatisticsSimple ms; + ms << m_map; + return ms.used (); + } + + size_t hits () const + { + return m_hits; + } + + size_t misses () const + { + return m_misses; + } + + const Value *find (db::cell_index_type ci1, db::cell_index_type ci2, const Key &key) const + { + typename std::map , std::list > >::iterator i1 = m_map.find (std::make_pair (ci1, ci2)); + if (i1 == m_map.end ()) { + ++m_misses; + return 0; + } + + // NOTE: the number of entries is low, so we can afford a linear search + typename std::list >::iterator i = i1->second.begin (); + while (i != i1->second.end () && ! (i->first == key)) { + ++i; + } + + if (i == i1->second.end ()) { + ++m_misses; + return 0; + } else { + // move the element to the front so the most frequently used ones are at the front + if (i != i1->second.begin ()) { + i1->second.splice (i1->second.begin(), i1->second, i, std::next (i)); + } + ++m_hits; + return &i->second; + } + } + + Value &insert (db::cell_index_type ci1, db::cell_index_type ci2, const Key &key) + { + const size_t instance_cache_variant_threshold = 20; + + std::list > &m = m_map [std::make_pair (ci1, ci2)]; + if (m.size () >= instance_cache_variant_threshold) { + m.pop_back (); + } + + m.push_front (std::make_pair (key, Value ())); + return m.front ().second; + } + +private: + mutable size_t m_hits, m_misses; + mutable std::map , std::list > > m_map; +}; + template class hier_clusters; template class connected_clusters; @@ -1083,54 +1188,7 @@ class DB_PUBLIC_TEMPLATE hier_clusters public: typedef typename local_cluster::box_type box_type; - /** - * @brief An object representing the instance interaction cache - */ - class instance_interaction_cache - { - public: - instance_interaction_cache () - : m_hits (0), m_misses (0) - { } - - size_t size () const - { - return m_map.size (); - } - - size_t hits () const - { - return m_hits; - } - - size_t misses () const - { - return m_misses; - } - - const cluster_instance_pair_list_type *find (const InstanceToInstanceInteraction &key) const - { - std::map::const_iterator i = m_map.find (key); - if (i == m_map.end ()) { - ++m_misses; - return 0; - } else { - ++m_hits; - return &i->second; - } - } - - cluster_instance_pair_list_type &insert (const InstanceToInstanceInteraction &key) - { - return m_map [key]; - } - - private: - mutable size_t m_hits, m_misses; - std::map m_map; - }; - - typedef instance_interaction_cache instance_interaction_cache_type; + typedef instance_interaction_cache instance_interaction_cache_type; /** * @brief Creates an empty set of clusters diff --git a/src/db/db/dbMemStatistics.h b/src/db/db/dbMemStatistics.h index 8293c85bf..4ed03a805 100644 --- a/src/db/db/dbMemStatistics.h +++ b/src/db/db/dbMemStatistics.h @@ -108,6 +108,45 @@ private: std::map > m_per_purpose; }; +/** + * @brief A simple memory statistics collector + * This collector will simply add the size required + */ +class DB_PUBLIC MemStatisticsSimple + : public MemStatistics +{ +public: + MemStatisticsSimple () + : m_size (0), m_used (0) + { } + + size_t size () const + { + return m_size; + } + + size_t used () const + { + return m_used; + } + + virtual void add (const std::type_info & /*ti*/, void * /*ptr*/, size_t size, size_t used, void * /*parent*/, purpose_t /*purpose*/, int /*cat*/) + { + m_size += size; + m_used += used; + } + + template + MemStatisticsSimple &operator<< (const T &x) + { + mem_stat (this, None, 0, x); + return *this; + } + +private: + size_t m_size, m_used; +}; + // Some standard templates to collect the information template void mem_stat (MemStatistics *stat, MemStatistics::purpose_t purpose, int cat, const X &x, bool no_self = false, void *parent = 0)