From 4b5736ba6a570d0a5324c5d1b87de6d8514112a1 Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Tue, 12 Feb 2019 20:32:07 +0100 Subject: [PATCH] Added result type template parameter to local hier processor. --- src/db/db/dbDeepRegion.cc | 2 +- src/db/db/dbHierProcessor.cc | 271 ++++++++++++---------- src/db/db/dbHierProcessor.h | 110 ++++----- src/db/db/dbLocalOperation.cc | 2 +- src/db/db/dbLocalOperation.h | 8 +- src/db/unit_tests/dbHierProcessorTests.cc | 16 +- 6 files changed, 216 insertions(+), 193 deletions(-) diff --git a/src/db/db/dbDeepRegion.cc b/src/db/db/dbDeepRegion.cc index 461d3e01f..8f61ac34f 100644 --- a/src/db/db/dbDeepRegion.cc +++ b/src/db/db/dbDeepRegion.cc @@ -463,7 +463,7 @@ DeepRegion::and_or_not_with (const DeepRegion *other, bool and_op) const db::BoolAndOrNotLocalOperation op (and_op); - db::local_processor proc (const_cast (&m_deep_layer.layout ()), const_cast (&m_deep_layer.initial_cell ()), &other->deep_layer ().layout (), &other->deep_layer ().initial_cell ()); + db::local_processor proc (const_cast (&m_deep_layer.layout ()), const_cast (&m_deep_layer.initial_cell ()), &other->deep_layer ().layout (), &other->deep_layer ().initial_cell ()); proc.set_base_verbosity (base_verbosity ()); proc.set_threads (m_deep_layer.store ()->threads ()); proc.set_area_ratio (m_deep_layer.store ()->max_area_ratio ()); diff --git a/src/db/db/dbHierProcessor.cc b/src/db/db/dbHierProcessor.cc index cddcebd6c..121a8c16b 100644 --- a/src/db/db/dbHierProcessor.cc +++ b/src/db/db/dbHierProcessor.cc @@ -158,13 +158,13 @@ public: }; template -class shape_reference_translator_with_trans +class shape_reference_translator_with_trans_from_shape_ref { public: typedef typename Ref::shape_type shape_type; typedef typename Ref::trans_type ref_trans_type; - shape_reference_translator_with_trans (db::Layout *target_layout, const Trans &trans) + shape_reference_translator_with_trans_from_shape_ref (db::Layout *target_layout, const Trans &trans) : mp_layout (target_layout), m_trans (trans), m_ref_trans (trans), m_bare_trans (Trans (m_ref_trans.inverted ()) * trans) { // .. nothing yet .. @@ -205,10 +205,22 @@ private: }; template -class shape_reference_translator_with_trans +class shape_reference_translator_with_trans + : public shape_reference_translator_with_trans_from_shape_ref { public: - typedef typename db::Edge shape_type; + shape_reference_translator_with_trans (db::Layout *target_layout, const Trans &trans) + : shape_reference_translator_with_trans_from_shape_ref (target_layout, trans) + { + // .. nothing yet .. + } +}; + +template +class shape_reference_translator_with_trans +{ +public: + typedef Sh shape_type; shape_reference_translator_with_trans (db::Layout * /*target_layout*/, const Trans &trans) : m_trans (trans) @@ -228,44 +240,44 @@ private: // --------------------------------------------------------------------------------------------- // LocalProcessorCellContext implementation -template -local_processor_cell_context::local_processor_cell_context () +template +local_processor_cell_context::local_processor_cell_context () { // .. nothing yet .. } -template -local_processor_cell_context::local_processor_cell_context (const local_processor_cell_context &other) +template +local_processor_cell_context::local_processor_cell_context (const local_processor_cell_context &other) : m_propagated (other.m_propagated), m_drops (other.m_drops) { // .. nothing yet .. } -template +template void -local_processor_cell_context::add (db::local_processor_cell_context *parent_context, db::Cell *parent, const db::ICplxTrans &cell_inst) +local_processor_cell_context::add (db::local_processor_cell_context *parent_context, db::Cell *parent, const db::ICplxTrans &cell_inst) { - m_drops.push_back (local_processor_cell_drop (parent_context, parent, cell_inst)); + m_drops.push_back (local_processor_cell_drop (parent_context, parent, cell_inst)); } -template +template void -local_processor_cell_context::propagate (const std::unordered_set &res) +local_processor_cell_context::propagate (const std::unordered_set &res) { if (res.empty ()) { return; } - for (typename std::vector >::const_iterator d = m_drops.begin (); d != m_drops.end (); ++d) { + for (typename std::vector >::const_iterator d = m_drops.begin (); d != m_drops.end (); ++d) { tl_assert (d->parent_context != 0); tl_assert (d->parent != 0); db::Layout *subject_layout = d->parent->layout (); - shape_reference_translator_with_trans rt (subject_layout, d->cell_inst); - std::vector new_refs; + shape_reference_translator_with_trans rt (subject_layout, d->cell_inst); + std::vector new_refs; new_refs.reserve (res.size ()); - for (typename std::unordered_set::const_iterator r = res.begin (); r != res.end (); ++r) { + for (typename std::unordered_set::const_iterator r = res.begin (); r != res.end (); ++r) { new_refs.push_back (rt (*r)); } @@ -277,46 +289,48 @@ local_processor_cell_context::propagate (const std::unordered_set &r } } -template class DB_PUBLIC local_processor_cell_context; -template class DB_PUBLIC local_processor_cell_context; -template class DB_PUBLIC local_processor_cell_context; -template class DB_PUBLIC local_processor_cell_context; +template class DB_PUBLIC local_processor_cell_context; +template class DB_PUBLIC local_processor_cell_context; +template class DB_PUBLIC local_processor_cell_context; +template class DB_PUBLIC local_processor_cell_context; +template class DB_PUBLIC local_processor_cell_context; +template class DB_PUBLIC local_processor_cell_context; // --------------------------------------------------------------------------------------------- // LocalProcessorCellContexts implementation -template -local_processor_cell_contexts::local_processor_cell_contexts () +template +local_processor_cell_contexts::local_processor_cell_contexts () : mp_intruder_cell (0) { // .. nothing yet .. } -template -local_processor_cell_contexts::local_processor_cell_contexts (const db::Cell *intruder_cell) +template +local_processor_cell_contexts::local_processor_cell_contexts (const db::Cell *intruder_cell) : mp_intruder_cell (intruder_cell) { // .. nothing yet .. } -template -db::local_processor_cell_context * -local_processor_cell_contexts::find_context (const context_key_type &intruders) +template +db::local_processor_cell_context * +local_processor_cell_contexts::find_context (const context_key_type &intruders) { - typename std::unordered_map >::iterator c = m_contexts.find (intruders); + typename std::unordered_map >::iterator c = m_contexts.find (intruders); return c != m_contexts.end () ? &c->second : 0; } -template -db::local_processor_cell_context * -local_processor_cell_contexts::create (const context_key_type &intruders) +template +db::local_processor_cell_context * +local_processor_cell_contexts::create (const context_key_type &intruders) { return &m_contexts[intruders]; } -template +template static void -subtract (std::unordered_set &res, const std::unordered_set &other, db::Layout *layout, const db::local_processor *proc) +subtract (std::unordered_set &res, const std::unordered_set &other, db::Layout *layout, const db::local_processor *proc) { if (other.empty ()) { return; @@ -354,22 +368,23 @@ subtract (std::unordered_set &res, const std::unordered_set +template static void -subtract (std::unordered_set &res, const std::unordered_set &other, db::Layout * /*layout*/, const db::local_processor * /*proc*/) +subtract (std::unordered_set &res, const std::unordered_set &other, db::Layout * /*layout*/, const db::local_processor * /*proc*/) { // for edges, we don't use a boolean core but just set intersection - for (std::unordered_set::const_iterator o = other.begin (); o != other.end (); ++o) { + for (typename std::unordered_set::const_iterator o = other.begin (); o != other.end (); ++o) { res.erase (*o); } } namespace { -template +template struct context_sorter { - bool operator () (const std::pair::context_key_type *, db::local_processor_cell_context *> &a, const std::pair::context_key_type *, db::local_processor_cell_context *> &b) + bool operator () (const std::pair::context_key_type *, db::local_processor_cell_context *> &a, + const std::pair::context_key_type *, db::local_processor_cell_context *> &b) { return *a.first < *b.first; } @@ -377,14 +392,14 @@ struct context_sorter } -template +template void -local_processor_cell_contexts::compute_results (const local_processor_contexts &contexts, db::Cell *cell, const local_operation *op, unsigned int output_layer, const local_processor *proc) +local_processor_cell_contexts::compute_results (const local_processor_contexts &contexts, db::Cell *cell, const local_operation *op, unsigned int output_layer, const local_processor *proc) { CRONOLOGY_COMPUTE_BRACKET(event_compute_results) bool first = true; - std::unordered_set common; + std::unordered_set common; int index = 0; int total = int (m_contexts.size ()); @@ -392,15 +407,15 @@ local_processor_cell_contexts::compute_results (const local_processor_co // NOTE: we use the ordering provided by key_type::operator< rather than the unordered map to achieve // reproducability across different platforms. unordered_map is faster, but for processing them, // strict ordering is a more robust choice. - std::vector *> > sorted_contexts; + std::vector *> > sorted_contexts; sorted_contexts.reserve (m_contexts.size ()); - for (typename std::unordered_map >::iterator c = m_contexts.begin (); c != m_contexts.end (); ++c) { + for (typename std::unordered_map >::iterator c = m_contexts.begin (); c != m_contexts.end (); ++c) { sorted_contexts.push_back (std::make_pair (&c->first, &c->second)); } - std::sort (sorted_contexts.begin (), sorted_contexts.end (), context_sorter ()); + std::sort (sorted_contexts.begin (), sorted_contexts.end (), context_sorter ()); - for (typename std::vector *> >::const_iterator c = sorted_contexts.begin (); c != sorted_contexts.end (); ++c) { + for (typename std::vector *> >::const_iterator c = sorted_contexts.begin (); c != sorted_contexts.end (); ++c) { ++index; @@ -421,7 +436,7 @@ local_processor_cell_contexts::compute_results (const local_processor_co } else { - std::unordered_set res; + std::unordered_set res; { tl::MutexLocker locker (&c->second->lock ()); res = c->second->propagated (); @@ -441,8 +456,8 @@ local_processor_cell_contexts::compute_results (const local_processor_co CRONOLOGY_COMPUTE_BRACKET(event_propagate) - std::unordered_set lost; - for (typename std::unordered_set::const_iterator i = common.begin (); i != common.end (); ++i) { + std::unordered_set lost; + for (typename std::unordered_set::const_iterator i = common.begin (); i != common.end (); ++i) { if (res.find (*i) == res.end ()) { lost.insert (*i); } @@ -454,15 +469,15 @@ local_processor_cell_contexts::compute_results (const local_processor_co if (! lost.empty ()) { subtract (common, lost, cell->layout (), proc); - for (typename std::vector *> >::const_iterator cc = sorted_contexts.begin (); cc != c; ++cc) { + for (typename std::vector *> >::const_iterator cc = sorted_contexts.begin (); cc != c; ++cc) { cc->second->propagate (lost); } } } - std::unordered_set gained; - for (typename std::unordered_set::const_iterator i = res.begin (); i != res.end (); ++i) { + std::unordered_set gained; + for (typename std::unordered_set::const_iterator i = res.begin (); i != res.end (); ++i) { if (common.find (*i) == common.end ()) { gained.insert (*i); } @@ -487,10 +502,12 @@ local_processor_cell_contexts::compute_results (const local_processor_co proc->push_results (cell, output_layer, common); } -template class DB_PUBLIC local_processor_cell_contexts; -template class DB_PUBLIC local_processor_cell_contexts; -template class DB_PUBLIC local_processor_cell_contexts; -template class DB_PUBLIC local_processor_cell_contexts; +template class DB_PUBLIC local_processor_cell_contexts; +template class DB_PUBLIC local_processor_cell_contexts; +template class DB_PUBLIC local_processor_cell_contexts; +template class DB_PUBLIC local_processor_cell_contexts; +template class DB_PUBLIC local_processor_cell_contexts; +template class DB_PUBLIC local_processor_cell_contexts; // --------------------------------------------------------------------------------------------- @@ -922,8 +939,8 @@ private: // --------------------------------------------------------------------------------------------- // LocalProcessorContextComputationTask implementation -template -local_processor_context_computation_task::local_processor_context_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) +template +local_processor_context_computation_task::local_processor_context_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) : tl::Task (), mp_proc (proc), mp_contexts (&contexts), mp_parent_context (parent_context), mp_subject_parent (subject_parent), mp_subject_cell (subject_cell), m_subject_cell_inst (subject_cell_inst), @@ -933,31 +950,33 @@ local_processor_context_computation_task::local_processor_context_comput m_intruders.swap (intruders); } -template +template void -local_processor_context_computation_task::perform () +local_processor_context_computation_task::perform () { mp_proc->compute_contexts (*mp_contexts, mp_parent_context, mp_subject_parent, mp_subject_cell, m_subject_cell_inst, mp_intruder_cell, m_intruders, m_dist); } -template class DB_PUBLIC local_processor_context_computation_task; -template class DB_PUBLIC local_processor_context_computation_task; -template class DB_PUBLIC local_processor_context_computation_task; -template class DB_PUBLIC local_processor_context_computation_task; +template class DB_PUBLIC local_processor_context_computation_task; +template class DB_PUBLIC local_processor_context_computation_task; +template class DB_PUBLIC local_processor_context_computation_task; +template class DB_PUBLIC local_processor_context_computation_task; +template class DB_PUBLIC local_processor_context_computation_task; +template class DB_PUBLIC local_processor_context_computation_task; // --------------------------------------------------------------------------------------------- // LocalProcessorResultComputationTask implementation -template -local_processor_result_computation_task::local_processor_result_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::Cell *cell, local_processor_cell_contexts *cell_contexts, const local_operation *op, unsigned int output_layer) +template +local_processor_result_computation_task::local_processor_result_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::Cell *cell, local_processor_cell_contexts *cell_contexts, const local_operation *op, unsigned int output_layer) : mp_proc (proc), mp_contexts (&contexts), mp_cell (cell), mp_cell_contexts (cell_contexts), mp_op (op), m_output_layer (output_layer) { // .. nothing yet .. } -template +template void -local_processor_result_computation_task::perform () +local_processor_result_computation_task::perform () { mp_cell_contexts->compute_results (*mp_contexts, mp_cell, mp_op, m_output_layer, mp_proc); @@ -966,13 +985,13 @@ local_processor_result_computation_task::perform () tl::MutexLocker locker (& mp_contexts->lock ()); #if defined(ENABLE_DB_HP_SANITY_ASSERTIONS) - std::set *> td; - for (typename db::local_processor_cell_contexts::iterator i = mp_cell_contexts->begin (); i != mp_cell_contexts->end (); ++i) { + std::set *> td; + for (typename db::local_processor_cell_contexts::iterator i = mp_cell_contexts->begin (); i != mp_cell_contexts->end (); ++i) { td.insert (&i->second); } - for (typename db::local_processor_cell_contexts::contexts_per_cell_type::iterator pcc = mp_contexts->context_map ().begin (); pcc != mp_contexts->context_map ().end (); ++pcc) { - for (typename db::local_processor_cell_contexts::iterator i = pcc->second.begin (); i != pcc->second.end (); ++i) { - for (typename db::local_processor_cell_context::drop_iterator j = i->second.begin_drops (); j != i->second.end_drops (); ++j) { + for (typename db::local_processor_cell_contexts::contexts_per_cell_type::iterator pcc = mp_contexts->context_map ().begin (); pcc != mp_contexts->context_map ().end (); ++pcc) { + for (typename db::local_processor_cell_contexts::iterator i = pcc->second.begin (); i != pcc->second.end (); ++i) { + for (typename db::local_processor_cell_context::drop_iterator j = i->second.begin_drops (); j != i->second.end_drops (); ++j) { if (td.find (j->parent_context) != td.end ()) { tl_assert (false); } @@ -985,30 +1004,32 @@ local_processor_result_computation_task::perform () } } -template class DB_PUBLIC local_processor_result_computation_task; -template class DB_PUBLIC local_processor_result_computation_task; -template class DB_PUBLIC local_processor_result_computation_task; -template class DB_PUBLIC local_processor_result_computation_task; +template class DB_PUBLIC local_processor_result_computation_task; +template class DB_PUBLIC local_processor_result_computation_task; +template class DB_PUBLIC local_processor_result_computation_task; +template class DB_PUBLIC local_processor_result_computation_task; +template class DB_PUBLIC local_processor_result_computation_task; +template class DB_PUBLIC local_processor_result_computation_task; // --------------------------------------------------------------------------------------------- // LocalProcessor implementation -template -local_processor::local_processor (db::Layout *layout, db::Cell *top) +template +local_processor::local_processor (db::Layout *layout, db::Cell *top) : mp_subject_layout (layout), mp_intruder_layout (layout), mp_subject_top (top), mp_intruder_top (top), m_nthreads (0), m_max_vertex_count (0), m_area_ratio (0.0), m_base_verbosity (30) { // .. nothing yet .. } -template -local_processor::local_processor (db::Layout *subject_layout, db::Cell *subject_top, const db::Layout *intruder_layout, const db::Cell *intruder_top) +template +local_processor::local_processor (db::Layout *subject_layout, db::Cell *subject_top, const db::Layout *intruder_layout, const db::Cell *intruder_top) : mp_subject_layout (subject_layout), mp_intruder_layout (intruder_layout), mp_subject_top (subject_top), mp_intruder_top (intruder_top), m_nthreads (0), m_max_vertex_count (0), m_area_ratio (0.0), m_base_verbosity (30) { // .. nothing yet .. } -template -std::string local_processor::description (const local_operation *op) const +template +std::string local_processor::description (const local_operation *op) const { if (op && m_description.empty ()) { return op->description (); @@ -1017,18 +1038,18 @@ std::string local_processor::description (const local_operation } } -template -void local_processor::run (local_operation *op, unsigned int subject_layer, unsigned int intruder_layer, unsigned int output_layer) +template +void local_processor::run (local_operation *op, unsigned int subject_layer, unsigned int intruder_layer, unsigned int output_layer) { tl::SelfTimer timer (tl::verbosity () > m_base_verbosity, tl::to_string (tr ("Executing ")) + description (op)); - local_processor_contexts contexts; + local_processor_contexts contexts; compute_contexts (contexts, op, subject_layer, intruder_layer); compute_results (contexts, op, output_layer); } -template -void local_processor::push_results (db::Cell *cell, unsigned int output_layer, const std::unordered_set &result) const +template +void local_processor::push_results (db::Cell *cell, unsigned int output_layer, const std::unordered_set &result) const { if (! result.empty ()) { tl::MutexLocker locker (&cell->layout ()->lock ()); @@ -1036,15 +1057,15 @@ void local_processor::push_results (db::Cell *cell, unsigned int output_ } } -template -void local_processor::compute_contexts (local_processor_contexts &contexts, const local_operation *op, unsigned int subject_layer, unsigned int intruder_layer) const +template +void local_processor::compute_contexts (local_processor_contexts &contexts, const local_operation *op, unsigned int subject_layer, unsigned int intruder_layer) const { try { tl::SelfTimer timer (tl::verbosity () > m_base_verbosity + 10, tl::to_string (tr ("Computing contexts for ")) + description (op)); if (m_nthreads > 0) { - mp_cc_job.reset (new tl::Job > (m_nthreads)); + mp_cc_job.reset (new tl::Job > (m_nthreads)); } else { mp_cc_job.reset (0); } @@ -1053,7 +1074,7 @@ void local_processor::compute_contexts (local_processor_contexts contexts.set_intruder_layer (intruder_layer); contexts.set_subject_layer (subject_layer); - typename local_processor_cell_contexts::context_key_type intruders; + typename local_processor_cell_contexts::context_key_type intruders; issue_compute_contexts (contexts, 0, 0, mp_subject_top, db::ICplxTrans (), mp_intruder_top, intruders, op->dist ()); if (mp_cc_job.get ()) { @@ -1067,34 +1088,34 @@ void local_processor::compute_contexts (local_processor_contexts } } -template -void local_processor::issue_compute_contexts (local_processor_contexts &contexts, - db::local_processor_cell_context *parent_context, +template +void local_processor::issue_compute_contexts (local_processor_contexts &contexts, + db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, - typename local_processor_cell_contexts::context_key_type &intruders, + typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const { bool is_small_job = subject_cell->begin ().at_end (); if (! is_small_job && mp_cc_job.get ()) { - mp_cc_job->schedule (new local_processor_context_computation_task (this, contexts, parent_context, subject_parent, subject_cell, subject_cell_inst, intruder_cell, intruders, dist)); + mp_cc_job->schedule (new local_processor_context_computation_task (this, contexts, parent_context, subject_parent, subject_cell, subject_cell_inst, intruder_cell, intruders, dist)); } else { compute_contexts (contexts, parent_context, subject_parent, subject_cell, subject_cell_inst, intruder_cell, intruders, dist); } } -template -void local_processor::compute_contexts (local_processor_contexts &contexts, - db::local_processor_cell_context *parent_context, - db::Cell *subject_parent, - db::Cell *subject_cell, - const db::ICplxTrans &subject_cell_inst, - const db::Cell *intruder_cell, - const typename local_processor_cell_contexts::context_key_type &intruders, - db::Coord dist) const +template +void local_processor::compute_contexts (local_processor_contexts &contexts, + db::local_processor_cell_context *parent_context, + db::Cell *subject_parent, + db::Cell *subject_cell, + const db::ICplxTrans &subject_cell_inst, + const db::Cell *intruder_cell, + const typename local_processor_cell_contexts::context_key_type &intruders, + db::Coord dist) const { CRONOLOGY_COLLECTION_BRACKET(event_compute_contexts) @@ -1106,7 +1127,7 @@ void local_processor::compute_contexts (local_processor_contexts } } - db::local_processor_cell_context *cell_context = 0; + db::local_processor_cell_context *cell_context = 0; // prepare a new cell context: this has to happen in a thread-safe way as we share the contexts // object between threads @@ -1114,17 +1135,17 @@ void local_processor::compute_contexts (local_processor_contexts { tl::MutexLocker locker (& contexts.lock ()); - db::local_processor_cell_contexts &cell_contexts = contexts.contexts_per_cell (subject_cell, intruder_cell); + db::local_processor_cell_contexts &cell_contexts = contexts.contexts_per_cell (subject_cell, intruder_cell); #if defined(ENABLE_DB_HP_SANITY_ASSERTIONS) if (subject_parent) { - typename db::local_processor_cell_contexts::contexts_per_cell_type::iterator pcc = contexts.context_map ().find (subject_parent); + typename db::local_processor_cell_contexts::contexts_per_cell_type::iterator pcc = contexts.context_map ().find (subject_parent); if (pcc == contexts.context_map ().end ()) { tl_assert (false); } tl_assert (pcc->first == subject_parent); bool any = false; - for (typename db::local_processor_cell_contexts::iterator pcci = pcc->second.begin (); pcci != pcc->second.end () && !any; ++pcci) { + for (typename db::local_processor_cell_contexts::iterator pcci = pcc->second.begin (); pcci != pcc->second.end () && !any; ++pcci) { any = (&pcci->second == parent_context); } if (!any) { @@ -1259,7 +1280,7 @@ void local_processor::compute_contexts (local_processor_contexts if (! nbox.empty ()) { - typename local_processor_cell_contexts::context_key_type intruders_below; + typename local_processor_cell_contexts::context_key_type intruders_below; db::shape_reference_translator_with_trans rt (mp_subject_layout, tni); @@ -1293,9 +1314,9 @@ void local_processor::compute_contexts (local_processor_contexts } } -template +template void -local_processor::compute_results (local_processor_contexts &contexts, const local_operation *op, unsigned int output_layer) const +local_processor::compute_results (local_processor_contexts &contexts, const local_operation *op, unsigned int output_layer) const { tl::SelfTimer timer (tl::verbosity () > m_base_verbosity + 10, tl::to_string (tr ("Computing results for ")) + description (op)); @@ -1305,7 +1326,7 @@ local_processor::compute_results (local_processor_contexts &cont if (m_nthreads > 0) { - std::auto_ptr > > rc_job (new tl::Job > (m_nthreads)); + std::auto_ptr > > rc_job (new tl::Job > (m_nthreads)); // schedule computation jobs in "waves": we need to make sure they are executed // bottom-up. So we identify a new bunch of cells each time we pass through the cell set @@ -1331,12 +1352,12 @@ local_processor::compute_results (local_processor_contexts &cont for (std::vector::const_iterator bu = cells_bu.begin (); bu != cells_bu.end (); ++bu) { - typename local_processor_contexts::iterator cpc = contexts.context_map ().find (&mp_subject_layout->cell (*bu)); + typename local_processor_contexts::iterator cpc = contexts.context_map ().find (&mp_subject_layout->cell (*bu)); if (cpc != contexts.context_map ().end ()) { if (later.find (*bu) == later.end ()) { - rc_job->schedule (new local_processor_result_computation_task (this, contexts, cpc->first, &cpc->second, op, output_layer)); + rc_job->schedule (new local_processor_result_computation_task (this, contexts, cpc->first, &cpc->second, op, output_layer)); any = true; } else { @@ -1368,7 +1389,7 @@ local_processor::compute_results (local_processor_contexts &cont for (db::Layout::bottom_up_const_iterator bu = mp_subject_layout->begin_bottom_up (); bu != mp_subject_layout->end_bottom_up (); ++bu) { - typename local_processor_contexts::iterator cpc = contexts.context_map ().find (&mp_subject_layout->cell (*bu)); + typename local_processor_contexts::iterator cpc = contexts.context_map ().find (&mp_subject_layout->cell (*bu)); if (cpc != contexts.context_map ().end ()) { cpc->second.compute_results (contexts, cpc->first, op, output_layer, this); contexts.context_map ().erase (cpc); @@ -1458,9 +1479,9 @@ struct scan_shape2shape_different_layers } }; -template +template void -local_processor::compute_local_cell (const db::local_processor_contexts &contexts, db::Cell *subject_cell, const db::Cell *intruder_cell, const local_operation *op, const typename local_processor_cell_contexts::context_key_type &intruders, std::unordered_set &result) const +local_processor::compute_local_cell (const db::local_processor_contexts &contexts, db::Cell *subject_cell, const db::Cell *intruder_cell, const local_operation *op, const typename local_processor_cell_contexts::context_key_type &intruders, std::unordered_set &result) const { const db::Shapes *subject_shapes = &subject_cell->shapes (contexts.subject_layer ()); @@ -1487,7 +1508,7 @@ local_processor::compute_local_cell (const db::local_processor_contexts< subject_id0 = id; } - if (op->on_empty_intruder_hint () != local_operation::Drop) { + if (op->on_empty_intruder_hint () != local_operation::Drop) { const TS *ref = i->basic_ptr (typename TS::tag ()); interactions.add_subject (id, *ref); } @@ -1550,10 +1571,12 @@ local_processor::compute_local_cell (const db::local_processor_contexts< op->compute_local (mp_subject_layout, interactions, result, m_max_vertex_count, m_area_ratio); } -template class DB_PUBLIC local_processor; -template class DB_PUBLIC local_processor; -template class DB_PUBLIC local_processor; -template class DB_PUBLIC local_processor; +template class DB_PUBLIC local_processor; +template class DB_PUBLIC local_processor; +template class DB_PUBLIC local_processor; +template class DB_PUBLIC local_processor; +template class DB_PUBLIC local_processor; +template class DB_PUBLIC local_processor; } diff --git a/src/db/db/dbHierProcessor.h b/src/db/db/dbHierProcessor.h index 6665c3c96..9e4a11cb2 100644 --- a/src/db/db/dbHierProcessor.h +++ b/src/db/db/dbHierProcessor.h @@ -42,9 +42,9 @@ namespace db { -template class local_processor; -template class local_processor_cell_context; -template class local_processor_contexts; +template class local_processor; +template class local_processor_cell_context; +template class local_processor_contexts; // TODO: move this somewhere else? template @@ -90,40 +90,40 @@ private: }; // TODO: should be hidden (private data?) -template +template struct DB_PUBLIC local_processor_cell_drop { - local_processor_cell_drop (db::local_processor_cell_context *_parent_context, db::Cell *_parent, const db::ICplxTrans &_cell_inst) + local_processor_cell_drop (db::local_processor_cell_context *_parent_context, db::Cell *_parent, const db::ICplxTrans &_cell_inst) : parent_context (_parent_context), parent (_parent), cell_inst (_cell_inst) { // .. nothing yet .. } - db::local_processor_cell_context *parent_context; + db::local_processor_cell_context *parent_context; db::Cell *parent; db::ICplxTrans cell_inst; }; // TODO: should be hidden (private data?) -template +template class DB_PUBLIC local_processor_cell_context { public: typedef std::pair parent_inst_type; - typedef typename std::vector >::const_iterator drop_iterator; + typedef typename std::vector >::const_iterator drop_iterator; local_processor_cell_context (); local_processor_cell_context (const local_processor_cell_context &other); - void add (db::local_processor_cell_context *parent_context, db::Cell *parent, const db::ICplxTrans &cell_inst); - void propagate (const std::unordered_set &res); + void add (db::local_processor_cell_context *parent_context, db::Cell *parent, const db::ICplxTrans &cell_inst); + void propagate (const std::unordered_set &res); - std::unordered_set &propagated () + std::unordered_set &propagated () { return m_propagated; } - const std::unordered_set &propagated () const + const std::unordered_set &propagated () const { return m_propagated; } @@ -151,25 +151,25 @@ public: } private: - std::unordered_set m_propagated; - std::vector > m_drops; + std::unordered_set m_propagated; + std::vector > m_drops; tl::Mutex m_lock; }; -template +template class DB_PUBLIC local_processor_cell_contexts { public: typedef std::pair, std::set > context_key_type; - typedef std::unordered_map > context_map_type; + typedef std::unordered_map > context_map_type; typedef typename context_map_type::const_iterator iterator; local_processor_cell_contexts (); local_processor_cell_contexts (const db::Cell *intruder_cell); - db::local_processor_cell_context *find_context (const context_key_type &intruders); - db::local_processor_cell_context *create (const context_key_type &intruders); - void compute_results (const local_processor_contexts &contexts, db::Cell *cell, const local_operation *op, unsigned int output_layer, const local_processor *proc); + db::local_processor_cell_context *find_context (const context_key_type &intruders); + db::local_processor_cell_context *create (const context_key_type &intruders); + void compute_results (const local_processor_contexts &contexts, db::Cell *cell, const local_operation *op, unsigned int output_layer, const local_processor *proc); iterator begin () const { @@ -183,14 +183,14 @@ public: private: const db::Cell *mp_intruder_cell; - std::unordered_map > m_contexts; + std::unordered_map > m_contexts; }; -template +template class DB_PUBLIC local_processor_contexts { public: - typedef std::unordered_map > contexts_per_cell_type; + typedef std::unordered_map > contexts_per_cell_type; typedef typename contexts_per_cell_type::iterator iterator; local_processor_contexts () @@ -210,11 +210,11 @@ public: m_contexts_per_cell.clear (); } - local_processor_cell_contexts &contexts_per_cell (db::Cell *subject_cell, const db::Cell *intruder_cell) + local_processor_cell_contexts &contexts_per_cell (db::Cell *subject_cell, const db::Cell *intruder_cell) { typename contexts_per_cell_type::iterator ctx = m_contexts_per_cell.find (subject_cell); if (ctx == m_contexts_per_cell.end ()) { - ctx = m_contexts_per_cell.insert (std::make_pair (subject_cell, local_processor_cell_contexts (intruder_cell))).first; + ctx = m_contexts_per_cell.insert (std::make_pair (subject_cell, local_processor_cell_contexts (intruder_cell))).first; } return ctx->second; } @@ -265,27 +265,27 @@ private: mutable tl::Mutex m_lock; }; -template +template class DB_PUBLIC local_processor_context_computation_task : public tl::Task { public: - local_processor_context_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist); + local_processor_context_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist); void perform (); private: - const local_processor *mp_proc; - local_processor_contexts *mp_contexts; - db::local_processor_cell_context *mp_parent_context; + const local_processor *mp_proc; + local_processor_contexts *mp_contexts; + db::local_processor_cell_context *mp_parent_context; db::Cell *mp_subject_parent; db::Cell *mp_subject_cell; db::ICplxTrans m_subject_cell_inst; const db::Cell *mp_intruder_cell; - typename local_processor_cell_contexts::context_key_type m_intruders; + typename local_processor_cell_contexts::context_key_type m_intruders; db::Coord m_dist; }; -template +template class DB_PUBLIC local_processor_context_computation_worker : public tl::Worker { @@ -298,28 +298,28 @@ public: void perform_task (tl::Task *task) { - static_cast *> (task)->perform (); + static_cast *> (task)->perform (); } }; -template +template class DB_PUBLIC local_processor_result_computation_task : public tl::Task { public: - local_processor_result_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::Cell *cell, local_processor_cell_contexts *cell_contexts, const local_operation *op, unsigned int output_layer); + local_processor_result_computation_task (const local_processor *proc, local_processor_contexts &contexts, db::Cell *cell, local_processor_cell_contexts *cell_contexts, const local_operation *op, unsigned int output_layer); void perform (); private: - const local_processor *mp_proc; - local_processor_contexts *mp_contexts; + const local_processor *mp_proc; + local_processor_contexts *mp_contexts; db::Cell *mp_cell; - local_processor_cell_contexts *mp_cell_contexts; - const local_operation *mp_op; + local_processor_cell_contexts *mp_cell_contexts; + const local_operation *mp_op; unsigned int m_output_layer; }; -template +template class DB_PUBLIC local_processor_result_computation_worker : public tl::Worker { @@ -332,19 +332,19 @@ public: void perform_task (tl::Task *task) { - static_cast *> (task)->perform (); + static_cast *> (task)->perform (); } }; -template +template class DB_PUBLIC local_processor { public: local_processor (db::Layout *layout, db::Cell *top); local_processor (db::Layout *subject_layout, db::Cell *subject_top, const db::Layout *intruder_layout, const db::Cell *intruder_cell); - void run (local_operation *op, unsigned int subject_layer, unsigned int intruder_layer, unsigned int output_layer); - void compute_contexts (local_processor_contexts &contexts, const local_operation *op, unsigned int subject_layer, unsigned int intruder_layer) const; - void compute_results (local_processor_contexts &contexts, const local_operation *op, unsigned int output_layer) const; + void run (local_operation *op, unsigned int subject_layer, unsigned int intruder_layer, unsigned int output_layer); + void compute_contexts (local_processor_contexts &contexts, const local_operation *op, unsigned int subject_layer, unsigned int intruder_layer) const; + void compute_results (local_processor_contexts &contexts, const local_operation *op, unsigned int output_layer) const; void set_description (const std::string &d) { @@ -392,8 +392,8 @@ public: } private: - template friend class local_processor_cell_contexts; - template friend class local_processor_context_computation_task; + template friend class local_processor_cell_contexts; + template friend class local_processor_context_computation_task; db::Layout *mp_subject_layout; const db::Layout *mp_intruder_layout; @@ -404,14 +404,14 @@ private: size_t m_max_vertex_count; double m_area_ratio; int m_base_verbosity; - mutable std::auto_ptr > > mp_cc_job; + mutable std::auto_ptr > > mp_cc_job; - std::string description (const local_operation *op) const; - void compute_contexts (db::local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, const typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const; - void do_compute_contexts (db::local_processor_cell_context *cell_context, const db::local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, const typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const; - void issue_compute_contexts (db::local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const; - void push_results (db::Cell *cell, unsigned int output_layer, const std::unordered_set &result) const; - void compute_local_cell (const db::local_processor_contexts &contexts, db::Cell *subject_cell, const db::Cell *intruder_cell, const local_operation *op, const typename local_processor_cell_contexts::context_key_type &intruders, std::unordered_set &result) const; + std::string description (const local_operation *op) const; + void compute_contexts (db::local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, const typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const; + void do_compute_contexts (db::local_processor_cell_context *cell_context, const db::local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, const typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const; + void issue_compute_contexts (db::local_processor_contexts &contexts, db::local_processor_cell_context *parent_context, db::Cell *subject_parent, db::Cell *subject_cell, const db::ICplxTrans &subject_cell_inst, const db::Cell *intruder_cell, typename local_processor_cell_contexts::context_key_type &intruders, db::Coord dist) const; + void push_results (db::Cell *cell, unsigned int output_layer, const std::unordered_set &result) const; + void compute_local_cell (const db::local_processor_contexts &contexts, db::Cell *subject_cell, const db::Cell *intruder_cell, const local_operation *op, const typename local_processor_cell_contexts::context_key_type &intruders, std::unordered_set &result) const; }; } @@ -419,8 +419,8 @@ private: namespace tl { -template -struct type_traits > : public tl::type_traits +template +struct type_traits > : public tl::type_traits { // mark "LocalProcessor" as not having a default ctor and no copy ctor typedef tl::false_tag has_default_constructor; diff --git a/src/db/db/dbLocalOperation.cc b/src/db/db/dbLocalOperation.cc index 0abc895aa..7d87c0b85 100644 --- a/src/db/db/dbLocalOperation.cc +++ b/src/db/db/dbLocalOperation.cc @@ -45,7 +45,7 @@ BoolAndOrNotLocalOperation::BoolAndOrNotLocalOperation (bool is_and) // .. nothing yet .. } -local_operation::on_empty_intruder_mode +local_operation::on_empty_intruder_mode BoolAndOrNotLocalOperation::on_empty_intruder_hint () const { return m_is_and ? local_operation::Drop : local_operation::Copy; diff --git a/src/db/db/dbLocalOperation.h b/src/db/db/dbLocalOperation.h index a818678fe..fb128a103 100644 --- a/src/db/db/dbLocalOperation.h +++ b/src/db/db/dbLocalOperation.h @@ -49,7 +49,7 @@ template class shape_interactions; * This class implements the actual operation. It receives a * cluster of subject shapes vs. corresponding intruder shapes. */ -template +template class DB_PUBLIC local_operation { public: @@ -89,7 +89,7 @@ public: * @param interactions The interaction set * @param result The container to which the results are written */ - virtual void compute_local (db::Layout *layout, const shape_interactions &interactions, std::unordered_set &result, size_t max_vertex_count, double area_ratio) const = 0; + virtual void compute_local (db::Layout *layout, const shape_interactions &interactions, std::unordered_set &result, size_t max_vertex_count, double area_ratio) const = 0; /** * @brief Indicates the desired behaviour when a shape does not have an intruder @@ -112,7 +112,7 @@ public: * @brief Implements a boolean AND or NOT operation */ class DB_PUBLIC BoolAndOrNotLocalOperation - : public local_operation + : public local_operation { public: BoolAndOrNotLocalOperation (bool is_and); @@ -131,7 +131,7 @@ private: * the original shapes overlap at least "wrap_count" times. */ class DB_PUBLIC SelfOverlapMergeLocalOperation - : public local_operation + : public local_operation { public: SelfOverlapMergeLocalOperation (unsigned int wrap_count); diff --git a/src/db/unit_tests/dbHierProcessorTests.cc b/src/db/unit_tests/dbHierProcessorTests.cc index 902213fa9..e5b2724c8 100644 --- a/src/db/unit_tests/dbHierProcessorTests.cc +++ b/src/db/unit_tests/dbHierProcessorTests.cc @@ -140,15 +140,15 @@ static void normalize_layer (db::Layout &layout, unsigned int layer) } -static std::string contexts_to_s (db::Layout *layout, db::local_processor_contexts &contexts) +static std::string contexts_to_s (db::Layout *layout, db::local_processor_contexts &contexts) { std::string res; for (db::Layout::top_down_const_iterator i = layout->begin_top_down (); i != layout->end_top_down(); ++i) { - db::local_processor_contexts::iterator cc = contexts.context_map ().find (&layout->cell (*i)); + db::local_processor_contexts::iterator cc = contexts.context_map ().find (&layout->cell (*i)); if (cc != contexts.context_map ().end ()) { int index = 1; - for (db::local_processor_cell_contexts::iterator j = cc->second.begin (); j != cc->second.end (); ++j) { + for (db::local_processor_cell_contexts::iterator j = cc->second.begin (); j != cc->second.end (); ++j) { res += tl::sprintf ("%s[%d] %d insts, %d shapes (%d times)\n", layout->cell_name (*i), index, int (j->first.first.size ()), int (j->first.second.size ()), int (j->second.size ())); index += 1; } @@ -203,7 +203,7 @@ static void run_test_bool_gen (tl::TestBase *_this, const char *file, TestMode m normalize_layer (layout_org, l2); } - db::local_operation *lop = 0; + db::local_operation *lop = 0; db::BoolAndOrNotLocalOperation bool_op (mode == TMAnd || mode == TMAndSwapped); db::SelfOverlapMergeLocalOperation self_intersect_op (2); BoolAndOrNotWithSizedLocalOperation sized_bool_op (mode == TMAnd || mode == TMAndSwapped, dist); @@ -224,7 +224,7 @@ static void run_test_bool_gen (tl::TestBase *_this, const char *file, TestMode m if (single) { - db::local_processor proc (&layout_org, &layout_org.cell (*layout_org.begin_top_down ())); + db::local_processor proc (&layout_org, &layout_org.cell (*layout_org.begin_top_down ())); proc.set_threads (nthreads); proc.set_area_ratio (3.0); proc.set_max_vertex_count (16); @@ -232,7 +232,7 @@ static void run_test_bool_gen (tl::TestBase *_this, const char *file, TestMode m if (! context_doc) { proc.run (lop, l1, l2, lout); } else { - db::local_processor_contexts contexts; + db::local_processor_contexts contexts; proc.compute_contexts (contexts, lop, l1, l2); *context_doc = contexts_to_s (&layout_org, contexts); proc.compute_results (contexts, lop, lout); @@ -242,7 +242,7 @@ static void run_test_bool_gen (tl::TestBase *_this, const char *file, TestMode m db::Layout layout_org2 = layout_org; - db::local_processor proc (&layout_org, &layout_org.cell (*layout_org.begin_top_down ()), &layout_org2, &layout_org2.cell (*layout_org2.begin_top_down ())); + db::local_processor proc (&layout_org, &layout_org.cell (*layout_org.begin_top_down ()), &layout_org2, &layout_org2.cell (*layout_org2.begin_top_down ())); proc.set_threads (nthreads); proc.set_area_ratio (3.0); proc.set_max_vertex_count (16); @@ -250,7 +250,7 @@ static void run_test_bool_gen (tl::TestBase *_this, const char *file, TestMode m if (! context_doc) { proc.run (lop, l1, l2, lout); } else { - db::local_processor_contexts contexts; + db::local_processor_contexts contexts; proc.compute_contexts (contexts, lop, l1, l2); *context_doc = contexts_to_s (&layout_org, contexts); proc.compute_results (contexts, lop, lout);