mirror of https://github.com/KLayout/klayout.git
Merge branch 'master' into lefdef-enhancements
This commit is contained in:
Matthias Koefferlein
commit
4473e53b96
|
|
@ -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 <class Shape, class Trans> void insert_transformed (db::Layout &layout, db::Shapes &shapes, const Shape &s, const Trans &t);
|
||||
|
||||
template <class Trans> 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<unsigned int> &la, const std::set<unsigned int> &lb) const
|
||||
{
|
||||
for (std::set<unsigned int>::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<unsigned int, layers_type>::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 <class T>
|
||||
bool Connectivity::interact (const db::Cell &a, const T &ta, const db::Cell &b, const T &tb) const
|
||||
{
|
||||
for (std::map<unsigned int, layers_type>::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<db::NetShape> (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<db::NetShape> (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<db::PolygonRef> (const db::Polyg
|
|||
template DB_PUBLIC bool Connectivity::interacts<db::PolygonRef> (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<db::Edge> (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<db::Edge> (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<db::ICplxTrans> (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<T>::interacts (const local_cluster<T> &other, const db::ICplxTrans
|
|||
return false;
|
||||
}
|
||||
|
||||
bool any = false;
|
||||
|
||||
for (std::set<unsigned int>::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<T> &cell_clusters, hier_clusters<T> &tree, const cell_clusters_box_converter<T> &cbc, const db::Connectivity &conn, const std::set<db::cell_index_type> *breakout_cells, typename hier_clusters<T>::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<T> *mp_cell_clusters;
|
||||
|
|
@ -1519,7 +1565,8 @@ private:
|
|||
std::map<id_type, typename join_set_list::iterator> m_cm2join_map;
|
||||
join_set_list m_cm2join_sets;
|
||||
std::list<ClusterInstanceInteraction> m_ci_interactions;
|
||||
std::map<InteractionKeyForClustersType, std::vector<std::pair<size_t, size_t> > > m_interaction_cache_for_clusters;
|
||||
instance_interaction_cache<interaction_key_for_clusters<box_type>, std::list<std::pair<size_t, size_t> > > m_interaction_cache_for_clusters;
|
||||
size_t m_cluster_cache_misses, m_cluster_cache_hits;
|
||||
typename hier_clusters<T>::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<db::CellInst, true> 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<db::CellInst, true> 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<std::pair<size_t, size_t> > &i2i_interactions = compute_instance_interactions (common12, i1.cell_index (), tt1, i2.cell_index (), tt2);
|
||||
const std::list<std::pair<size_t, size_t> > &i2i_interactions = compute_instance_interactions (common12, i1.cell_index (), tt1, i2.cell_index (), tt2);
|
||||
|
||||
for (std::vector<std::pair<size_t, size_t> >::const_iterator ii = i2i_interactions.begin (); ii != i2i_interactions.end (); ++ii) {
|
||||
for (std::list<std::pair<size_t, size_t> >::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<std::pair<size_t, size_t> > &
|
||||
const std::list<std::pair<size_t, size_t> > &
|
||||
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<std::pair<size_t, size_t> > empty;
|
||||
static const std::list<std::pair<size_t, size_t> > 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<box_type> ikey (t1i, t21, common2);
|
||||
|
||||
typename std::map<InteractionKeyForClustersType, std::vector<std::pair<size_t, size_t> > >::const_iterator ici = m_interaction_cache_for_clusters.find (ikey);
|
||||
if (ici != m_interaction_cache_for_clusters.end ()) {
|
||||
const std::list<std::pair<size_t, size_t> > *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<T> &cl1 = mp_tree->clusters_per_cell (ci1);
|
||||
const db::local_clusters<T> &cl2 = mp_tree->clusters_per_cell (ci2);
|
||||
|
||||
std::vector<std::pair<size_t, size_t> > &new_interactions = m_interaction_cache_for_clusters [ikey];
|
||||
std::list<std::pair<size_t, size_t> > &new_interactions = m_interaction_cache_for_clusters.insert (ci1, ci2, ikey);
|
||||
db::ICplxTrans t12 = t2i * t1;
|
||||
|
||||
for (typename db::local_clusters<T>::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<std::pair<size_t, size_t> > &i2i_interactions = compute_instance_interactions (common, i.cell_index (), tt, i.cell_index (), tt2);
|
||||
for (std::vector<std::pair<size_t, size_t> >::const_iterator ii = i2i_interactions.begin (); ii != i2i_interactions.end (); ++ii) {
|
||||
const std::list<std::pair<size_t, size_t> > &i2i_interactions = compute_instance_interactions (common, i.cell_index (), tt, i.cell_index (), tt2);
|
||||
for (std::list<std::pair<size_t, size_t> >::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<T>::do_build (cell_clusters_box_converter<T> &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<T>::build_hier_connections (cell_clusters_box_converter<T> &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
|
||||
|
|
|
|||
|
|
@ -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<unsigned int> &la, const std::set<unsigned int> &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 <class T>
|
||||
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<unsigned int, layers_type> 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 <class Box>
|
||||
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 Key, class Value>
|
||||
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::pair<db::cell_index_type, db::cell_index_type>, std::list <std::pair<Key, Value> > >::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 <std::pair<Key, Value> >::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 <std::pair<Key, Value> > &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::pair<db::cell_index_type, db::cell_index_type>, std::list <std::pair<Key, Value> > > m_map;
|
||||
};
|
||||
|
||||
template <class T> class hier_clusters;
|
||||
template <class T> class connected_clusters;
|
||||
|
||||
|
|
@ -1083,54 +1188,7 @@ class DB_PUBLIC_TEMPLATE hier_clusters
|
|||
public:
|
||||
typedef typename local_cluster<T>::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<InstanceToInstanceInteraction, cluster_instance_pair_list_type>::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<InstanceToInstanceInteraction, cluster_instance_pair_list_type> m_map;
|
||||
};
|
||||
|
||||
typedef instance_interaction_cache instance_interaction_cache_type;
|
||||
typedef instance_interaction_cache<InstanceToInstanceInteraction, cluster_instance_pair_list_type> instance_interaction_cache_type;
|
||||
|
||||
/**
|
||||
* @brief Creates an empty set of clusters
|
||||
|
|
|
|||
|
|
@ -108,6 +108,45 @@ private:
|
|||
std::map<purpose_t, std::pair<size_t, size_t> > 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 <class T>
|
||||
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 <class X>
|
||||
void mem_stat (MemStatistics *stat, MemStatistics::purpose_t purpose, int cat, const X &x, bool no_self = false, void *parent = 0)
|
||||
|
|
|
|||
Loading…
Reference in New Issue