jcarr
/
coriolis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
coriolis/anabatic/src/Dijkstra.cpp

717 lines
22 KiB
C++
Raw Normal View History

Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
// -*- mode: C++; explicit-buffer-name: "Dijkstra.cpp<anabatic>" -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2016-2016, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | A n a b a t i c - Global Routing Toolbox |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Module : "./anabatic/Dijkstra.cpp" |
// +-----------------------------------------------------------------+
#include <limits>
#include "hurricane/Error.h"
#include "hurricane/Net.h"
#include "hurricane/RoutingPad.h"
#include "hurricane/Horizontal.h"
#include "hurricane/Vertical.h"
#include "hurricane/UpdateSession.h"
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
#include "hurricane/DebugSession.h"
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
#include "crlcore/Utilities.h"
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
#include "anabatic/AnabaticEngine.h"
#include "anabatic/Dijkstra.h"
namespace Anabatic {
using std::cerr;
using std::endl;
using std::numeric_limits;
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
using Hurricane::ForEachIterator;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
using Hurricane::Error;
using Hurricane::Component;
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
using Hurricane::Segment;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
using Hurricane::Horizontal;
using Hurricane::Vertical;
using Hurricane::RoutingPad;
using Hurricane::UpdateSession;
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
using Hurricane::DebugSession;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
// -------------------------------------------------------------------
// Class : "Anabatic::Vertex".
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
DbU::Unit Vertex::unreached = std::numeric_limits<long>::max();
in CMakeLists: - (Add) HurricaneAMS includes in Dijkstra: - (Add+Modify) Handle restriction rules in Vertex for analog devices in GCell: - (Add) Check neighboring cells (North/South/East/West)
2016-06-20 11:36:00 -05:00
DbU::Unit Vertex::unreachable = std::numeric_limits<long>::max()-1;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
bool Vertex::hasValidStamp () const
{ return _stamp == getAnabatic()->getStamp(); }
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
string Vertex::_getString () const
{
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
if (not _gcell) {
string s = "<Vertex [key] " + getString(_id) + ">";
return s;
}
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
string s = "<Vertex " + getString(_id)
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
+ " @(" + DbU::getValueString(_gcell->getXMin())
+ "," + DbU::getValueString(_gcell->getYMin()) + ")"
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
+ " connexId:" + ((_connexId >= 0) ? getString(_connexId) : "None")
Small correction after merge with E. Lao latest commit. Conflicts: anabatic/src/Dijkstra.cpp anabatic/src/anabatic/Dijkstra.h anabatic/src/anabatic/GCell.h
2016-06-26 07:55:34 -05:00
+ " d:" + ((_distance == unreached) ? "unreached"
: ((_distance == unreachable) ? "unreachable"
: DbU::getValueString(_distance)) )
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
+ "+" + getString(_branchId)
Anabatic transient commit 5. * Bug: In Anabatic: - In Dijkstra/Vertex, use the new Observer for fast access from the GCells. - In Dijktra::propagate() loop detection. - In Dijkstra, reset the "_from" of vertexes between two propagates on the same Net (otherwise: loops...). - In Matrix, there must be two different way of calculating an index from a position. One for the min, which is rounded to superior. And one for the max which is rounded to inferior. - In Matrix::updateArea(), checks for invalid indexes.
2016-06-03 10:29:22 -05:00
+ " stamp:" + (hasValidStamp() ? "valid" : "outdated")
+ " from:" + ((_from) ? "set" : "NULL")
in CMakeLists: - (Add) HurricaneAMS includes in Dijkstra: - (Add+Modify) Handle restriction rules in Vertex for analog devices in GCell: - (Add) Check neighboring cells (North/South/East/West)
2016-06-20 11:36:00 -05:00
+ " restricted:" + (isNRestricted() ? "N" : "-")
+ (isSRestricted() ? "S" : "-")
+ (isERestricted() ? "E" : "-")
+ (isWRestricted() ? "W" : "-")
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
+ ">";
return s;
}
Anabatic transient commit 5. * Bug: In Anabatic: - In Dijkstra/Vertex, use the new Observer for fast access from the GCells. - In Dijktra::propagate() loop detection. - In Dijkstra, reset the "_from" of vertexes between two propagates on the same Net (otherwise: loops...). - In Matrix, there must be two different way of calculating an index from a position. One for the min, which is rounded to superior. And one for the max which is rounded to inferior. - In Matrix::updateArea(), checks for invalid indexes.
2016-06-03 10:29:22 -05:00
void Vertex::notify ( Vertex* vertex, unsigned int flags )
{
//Vertex* vertex = getOwner();
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(111,0) << "Vertex::notify() " << vertex << endl;
Anabatic transient commit 5. * Bug: In Anabatic: - In Dijkstra/Vertex, use the new Observer for fast access from the GCells. - In Dijktra::propagate() loop detection. - In Dijkstra, reset the "_from" of vertexes between two propagates on the same Net (otherwise: loops...). - In Matrix, there must be two different way of calculating an index from a position. One for the min, which is rounded to superior. And one for the max which is rounded to inferior. - In Matrix::updateArea(), checks for invalid indexes.
2016-06-03 10:29:22 -05:00
// Take into account the GCell modification here.
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
// -------------------------------------------------------------------
// Class : "Anabatic::Dijkstra".
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
Dijkstra::Mode::~Mode ()
{ }
string Dijkstra::Mode::_getTypeName () const
{ return "Anabatic::Dijkstra::Mode"; }
string Dijkstra::Mode::_getString () const
{
string s = "";
s += (_flags & Standart ) ? 'S' : '-';
s += (_flags & Monotonic) ? 'M' : '-';
return s;
}
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
DbU::Unit Dijkstra::_distance ( const Vertex* a, const Vertex* b, const Edge* e )
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
{
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
DbU::Unit distance = a->getDistance() + e->getDistance();
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
in CMakeLists: - (Add) HurricaneAMS includes in Dijkstra: - (Add+Modify) Handle restriction rules in Vertex for analog devices in GCell: - (Add) Check neighboring cells (North/South/East/West)
2016-06-20 11:36:00 -05:00
if ( (a->isNotRestricted()) && (b->isNotRestricted()) ) { // A remplacer avec verification sur type IsDevice()?.
if (isRestricted(a, b)) distance = Vertex::unreachable;
}
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
// Edge* aFrom = a->getFrom();
// if (aFrom) {
// distance += (aFrom->isHorizontal() xor e->isHorizontal()) ? 3.0 : 0.0;
// }
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
return distance;
}
in CMakeLists: - (Add) HurricaneAMS includes in Dijkstra: - (Add+Modify) Handle restriction rules in Vertex for analog devices in GCell: - (Add) Check neighboring cells (North/South/East/West)
2016-06-20 11:36:00 -05:00
bool Dijkstra::isRestricted ( const Vertex* v1, const Vertex* v2 )
Temporary commit to pull and merge last commit.
2016-06-17 09:26:27 -05:00
{
bool restricted = true;
GCell* c1 = v1->getGCell();
GCell* c2 = v2->getGCell();
// Check from GCell 1
if ( c1->isNorth(c2) ) {
if ( !v1->isNRestricted() ) restricted = false;
} else if ( c1->isSouth(c2) ) {
if ( !v1->isSRestricted() ) restricted = false;
} else if ( c1->isEast (c2) ) {
if ( !v1->isERestricted() ) restricted = false;
} else if ( c1->isWest (c2) ) {
if ( !v1->isWRestricted() ) restricted = false;
} else {
cerr << Error( "GCells are not side by side." ) << endl;
return true;
}
if (restricted) return true;
else {
// Check from GCell 2
if ( c2->isNorth(c1) ) {
if ( v2->isNRestricted() ) return true;
else return false;
} else if ( c2->isSouth(c1) ) {
if ( v2->isSRestricted() ) return true;
else return false;
} else if ( c2->isEast (c1) ) {
if ( v2->isERestricted() ) return true;
else return false;
} else if ( c2->isWest (c1) ) {
if ( v2->isWRestricted() ) return true;
else return false;
} else {
cerr << Error( "GCells are not side by side." ) << endl;
return true;
}
}
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Dijkstra::Dijkstra ( AnabaticEngine* anabatic )
: _anabatic (anabatic)
, _vertexes ()
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
, _distanceCb (_distance)
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
, _mode (Mode::Standart)
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
, _net (NULL)
, _stamp (-1)
, _sources ()
, _targets ()
, _searchArea ()
, _connectedsId(-1)
, _queue ()
{
const vector<GCell*>& gcells = _anabatic->getGCells();
for ( GCell* gcell : gcells ) {
_vertexes.push_back( new Vertex (gcell) );
}
}
Dijkstra::~Dijkstra ()
{
for ( Vertex* vertex : _vertexes ) delete vertex;
}
void Dijkstra::load ( Net* net )
{
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
_cleanup();
const Layer* gcontactLayer = _anabatic->getConfiguration()->getGContactLayer();
_net = net;
_stamp = _anabatic->incStamp();
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
DebugSession::open( _net, 112, 120 );
cdebug_log(112,1) << "Dijkstra::load() " << _net << endl;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
vector< std::pair<Component*,bool> > components;
for ( Component* component : _net->getComponents() ) {
RoutingPad* rp = dynamic_cast<RoutingPad*>( component );
if (rp) { components.push_back( make_pair(rp,true) ); continue; }
Contact* gcontact = dynamic_cast<Contact*>( component );
if (gcontact and (gcontact->getLayer() == gcontactLayer))
components.push_back( make_pair(gcontact,false) );
}
for ( auto element : components ) {
RoutingPad* rp = NULL;
Contact* gcontact = NULL;
Point center;
if (element.second) {
rp = static_cast<RoutingPad*>( element.first );
center = rp->getBoundingBox().getCenter();
} else {
gcontact = static_cast<Contact*>( element.first );
center = gcontact->getCenter();
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
GCell* gcell = _anabatic->getGCellUnder( center );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
if (not gcell) {
cerr << Error( "Dijkstra::load(): %s of %s is not under any GCell.\n"
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
" It will be ignored so the routing may be incomplete."
, getString(element.first).c_str()
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
, getString(_net).c_str()
) << endl;
continue;
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
_searchArea.merge( gcell->getBoundingBox() );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
Vertex* vertex = gcell->getObserver<Vertex>(GCell::Observable::Vertex);
if (vertex->getConnexId() < 0) {
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
vertex->setDistance( Vertex::unreached );
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
vertex->setStamp ( _stamp );
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
vertex->setConnexId( _connectedsId );
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
vertex->setBranchId( 0 );
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
vertex->setFrom ( NULL );
_targets.insert( vertex );
in CMakeLists: - (Add) HurricaneAMS includes in Dijkstra: - (Add+Modify) Handle restriction rules in Vertex for analog devices in GCell: - (Add) Check neighboring cells (North/South/East/West)
2016-06-20 11:36:00 -05:00
vertex->clearRestriction();
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(112,0) << "Add Vertex: " << vertex << endl;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
if (gcontact) {
for ( Component* slave : gcontact->getSlaveComponents() ) {
Flags sideHint = Flags::NoFlags;
GCell* oppositeGCell = NULL;
Segment* segment = dynamic_cast<Horizontal*>(slave);
if (segment) {
cdebug_log(112,0) << "| " << segment << endl;
if (segment->getSource() == gcontact) {
oppositeGCell = _anabatic->getGCellUnder( segment->getTarget()->getCenter() );
sideHint = Flags::EastSide;
} else
if (segment->getTarget() == gcontact) {
cdebug_log(112,0) << " Connected by target, skipped." << endl;
continue;
}
} else {
segment = dynamic_cast<Vertical*>(slave);
if (segment) {
cdebug_log(112,0) << "| " << segment << endl;
if (segment->getSource() == gcontact) {
oppositeGCell = _anabatic->getGCellUnder( segment->getTarget()->getCenter() );
sideHint = Flags::NorthSide;
} else
if (segment->getTarget() == gcontact) {
cdebug_log(112,0) << " Connected by target, skipped." << endl;
continue;
}
}
}
Edge* edge = gcell->getEdgeTo( oppositeGCell, sideHint );
if (edge) {
cdebug_log(112,0) << "+ Associated to edge." << endl;
edge->setSegment( segment );
} else
cerr << Error( "Dijkstra::load(): Cannot bind segment to any edge:\n"
" %s\n"
" source:%s\n"
" target:%s"
, getString(segment).c_str()
, getString(gcell).c_str()
, getString(oppositeGCell).c_str()
) << endl;
}
}
if (rp) {
Contact* vcontact = vertex->getGContact( _net );
rp->getBodyHook()->detach();
rp->getBodyHook()->attach( vcontact->getBodyHook() );
}
}
for ( Vertex* vertex : _targets ) {
if (vertex->getConnexId() != 0) continue;
_tagConnecteds( vertex, ++_connectedsId );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(112,0) << "Search area: " << _searchArea << endl;
cdebug_tabw(112,-1);
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
DebugSession::close();
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
void Dijkstra::_selectFirstSource ()
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
{
if (_targets.empty()) {
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
#if 0
cparanoid << Error( "Dijkstra::_selectFirstSource(): %s has no vertexes to route, ignored."
, getString(_net).c_str()
) << endl;
#endif
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
return;
}
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
Vertex* firstSource = NULL;
if (_mode & Mode::Monotonic) {
if (_targets.size() == 2) {
auto ivertex = _targets.begin();
Vertex* v1 = *ivertex;
Vertex* v2 = *(++ivertex);
firstSource = (v1->getCenter().getX() <= v2->getCenter().getY()) ? v1 : v2;
} else {
cerr << Error( "Dijkstra::_selectFirstSource(): %s cannot be routed in monotonic mode.\n"
" Must have exactly two terminals (%u), revert to Standart."
, getString(_net).c_str()
, _targets.size()
) << endl;
_mode = Mode::Standart;
}
}
if (not firstSource) {
// Standart routing.
Point areaCenter = _searchArea.getCenter();
auto ivertex = _targets.begin();
firstSource = *ivertex++;
DbU::Unit minDistance = areaCenter.manhattanDistance( firstSource->getCenter() );
for ( ; ivertex != _targets.end() ; ++ivertex ) {
DbU::Unit distance = areaCenter.manhattanDistance( (*ivertex)->getCenter() );
if (distance < minDistance) {
minDistance = distance;
firstSource = *ivertex;
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
}
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
for ( auto ivertex = _targets.begin() ; ivertex != _targets.end() ; ) {
auto inext = ivertex; inext++;
if ((*ivertex)->getConnexId() == firstSource->getConnexId()) {
_sources.insert( *ivertex );
_targets.erase ( ivertex );
}
ivertex = inext;
}
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(112,0) << "Dijkstra::_selectFirstSource() " << *_sources.begin() << endl;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
void Dijkstra::_cleanup ()
{
for ( Vertex* vertex : _sources ) if (vertex->getFrom()) vertex->getFrom()->setSegment( NULL );
for ( Vertex* vertex : _targets ) if (vertex->getFrom()) vertex->getFrom()->setSegment( NULL );
//_checkEdges();
_sources.clear();
_targets.clear();
_searchArea.makeEmpty();
_connectedsId = 0;
}
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
bool Dijkstra::_propagate ( Flags enabledSides )
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
{
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(112,1) << "Dijkstra::_propagate() " << _net << endl;
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
while ( not _queue.empty() ) {
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
_queue.dump();
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Vertex* current = _queue.top();
_queue.pop();
if ((current->getConnexId() == _connectedsId) or (current->getConnexId() < 0)) {
for ( Edge* edge : current->getGCell()->getEdges() ) {
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
if (edge == current->getFrom()) continue;
GCell* gneighbor = edge->getOpposite(current->getGCell());
Anabatic transient commit 5. * Bug: In Anabatic: - In Dijkstra/Vertex, use the new Observer for fast access from the GCells. - In Dijktra::propagate() loop detection. - In Dijkstra, reset the "_from" of vertexes between two propagates on the same Net (otherwise: loops...). - In Matrix, there must be two different way of calculating an index from a position. One for the min, which is rounded to superior. And one for the max which is rounded to inferior. - In Matrix::updateArea(), checks for invalid indexes.
2016-06-03 10:29:22 -05:00
Vertex* vneighbor = gneighbor->getObserver<Vertex>(GCell::Observable::Vertex);
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
if (not _searchArea.contains(vneighbor->getCenter())) continue;
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(111,0) << "| Edge " << edge << endl;
cdebug_log(111,0) << "+ Neighbor: " << vneighbor << endl;
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
DbU::Unit distance = _distanceCb( current, vneighbor, edge );
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
if (vneighbor->getConnexId() == _connectedsId) continue;
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
if ( (distance < vneighbor->getDistance())
or ( (distance == vneighbor->getDistance())
and (current->getBranchId() > vneighbor->getBranchId())) ) {
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
if (vneighbor->getDistance() != Vertex::unreached) {
_queue.erase( vneighbor );
} else {
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
if (not vneighbor->hasValidStamp()) {
vneighbor->setConnexId( -1 );
vneighbor->setStamp ( _stamp );
}
Anabatic transient commit 6 "Somatoline, ca marche!". * Bug: In Anabatic: - In Dijktra::load(), do not create Contact while looping over the Net's components (for RoutingPads). - In Dijkstra::propagate(), reset the connexId of reached Vertexes on updating the stamp to avoid using connexId from previous runs. Push the vertexes on the queue while backtracking (with a distance of 0.0). Do not reset the "_from" as we need it in Dijkstra::toWires() to know how were the routing is. - In Edge::getDistance(), convert to float more early so the normalisation do not always end up in zero. - In GCell::_add(), when the axis of the new edge is equal to one already on the given side, adds it *after* the existing edge and not before. (to be coherent with the way GCells are split in two) - In GCell::hcut() and GCell::vcut(), create an Edge if is equal to X/Y Max, *but* the new chunk is flat. The new chunk is then expected to expand "below". - In GraphicsAnabaticEngine::drawGCell(), display the id of the GCell in a small box at the center of it's bounding box. Nothing displayed for flat GCells, to avoid cluttering.
2016-06-05 11:38:09 -05:00
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
vneighbor->setBranchId( current->getBranchId() );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
vneighbor->setDistance( distance );
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
vneighbor->setFrom ( edge );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
_queue.push( vneighbor );
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(111,0) << "Push: (size:" << _queue.size() << ") " << vneighbor << endl;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
}
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
continue;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
// We did reach another target (different <connexId>).
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
// Tag back the path, with a higher <branchId>.
Anabatic transient commit 9. Dijkstra::_traceback() replaces _toWires(). * Change: In Anabatic: - In Dijkstra, replace _toWires() by _trackback() which is called immediatly on reaching a target. - In Constants & GCell, added flags for typing the GCells. We now have: * DeviceGCell, for analogic devices. * ChannelGCell, for resizable routing channels. * StrutGCell, for fixed spaces in analog designs. * MatrixGCell, for square tile in digital designs.
2016-06-17 10:45:32 -05:00
_traceback( current );
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
cdebug_tabw(112,-1);
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
return true;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
cerr << Error( "Dijkstra::propagate(): %s has unreachable targets."
, getString(_net).c_str()
) << endl;
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_tabw(112,-1);
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
return false;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 9. Dijkstra::_traceback() replaces _toWires(). * Change: In Anabatic: - In Dijkstra, replace _toWires() by _trackback() which is called immediatly on reaching a target. - In Constants & GCell, added flags for typing the GCells. We now have: * DeviceGCell, for analogic devices. * ChannelGCell, for resizable routing channels. * StrutGCell, for fixed spaces in analog designs. * MatrixGCell, for square tile in digital designs.
2016-06-17 10:45:32 -05:00
void Dijkstra::_traceback ( Vertex* current )
{
cdebug_log(112,1) << "Dijkstra::_traceback() " << _net << " branchId:" << _sources.size() << endl;
int branchId = _sources.size();
_targets.erase( current );
while ( current ) {
cdebug_log(112,0) << "| " << current << endl;
if (current->getConnexId() == _connectedsId) break;
Edge* from = current->getFrom();
if (not from) break;
from->incRealOccupancy( 1 );
_sources.insert( current );
current->setDistance( 0.0 );
current->setConnexId( _connectedsId );
current->setBranchId( branchId );
_queue.push( current );
Vertex* source = current;
Vertex* target = source->getPredecessor();
current = target;
if ( (source->getGCell()->getXMin() > target->getGCell()->getXMin())
or (source->getGCell()->getYMin() > target->getGCell()->getYMin()) )
std::swap( source, target );
Contact* sourceContact = source->getGContact( _net );
Contact* targetContact = target->getGContact( _net );
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
Segment* segment = NULL;
Anabatic transient commit 9. Dijkstra::_traceback() replaces _toWires(). * Change: In Anabatic: - In Dijkstra, replace _toWires() by _trackback() which is called immediatly on reaching a target. - In Constants & GCell, added flags for typing the GCells. We now have: * DeviceGCell, for analogic devices. * ChannelGCell, for resizable routing channels. * StrutGCell, for fixed spaces in analog designs. * MatrixGCell, for square tile in digital designs.
2016-06-17 10:45:32 -05:00
if (from->isHorizontal()) {
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
segment = Horizontal::create( sourceContact
, targetContact
, _anabatic->getConfiguration()->getGHorizontalLayer()
, from->getAxis()
, DbU::fromLambda(2.0)
);
Anabatic transient commit 9. Dijkstra::_traceback() replaces _toWires(). * Change: In Anabatic: - In Dijkstra, replace _toWires() by _trackback() which is called immediatly on reaching a target. - In Constants & GCell, added flags for typing the GCells. We now have: * DeviceGCell, for analogic devices. * ChannelGCell, for resizable routing channels. * StrutGCell, for fixed spaces in analog designs. * MatrixGCell, for square tile in digital designs.
2016-06-17 10:45:32 -05:00
} else {
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
segment = Vertical::create( sourceContact
, targetContact
, _anabatic->getConfiguration()->getGVerticalLayer()
, from->getAxis()
, DbU::fromLambda(2.0)
);
Anabatic transient commit 9. Dijkstra::_traceback() replaces _toWires(). * Change: In Anabatic: - In Dijkstra, replace _toWires() by _trackback() which is called immediatly on reaching a target. - In Constants & GCell, added flags for typing the GCells. We now have: * DeviceGCell, for analogic devices. * ChannelGCell, for resizable routing channels. * StrutGCell, for fixed spaces in analog designs. * MatrixGCell, for square tile in digital designs.
2016-06-17 10:45:32 -05:00
}
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
from->setSegment( segment );
Anabatic transient commit 9. Dijkstra::_traceback() replaces _toWires(). * Change: In Anabatic: - In Dijkstra, replace _toWires() by _trackback() which is called immediatly on reaching a target. - In Constants & GCell, added flags for typing the GCells. We now have: * DeviceGCell, for analogic devices. * ChannelGCell, for resizable routing channels. * StrutGCell, for fixed spaces in analog designs. * MatrixGCell, for square tile in digital designs.
2016-06-17 10:45:32 -05:00
}
cdebug_tabw(112,-1);
}
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
void Dijkstra::run ( Dijkstra::Mode mode )
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
{
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
DebugSession::open( _net, 112, 120 );
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(112,1) << "Dijkstra::run() on " << _net << " mode:" << mode << endl;
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
_mode = mode;
_selectFirstSource();
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
if (_sources.empty()) {
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_log(112,0) << "No source to start, not routed." << endl;
cdebug_tabw(112,-1);
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
return;
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
Flags enabledEdges = Flags::AllSides;
if (_mode & Mode::Monotonic) {
if ((*_sources.begin())->getCenter().getY() <= (*_targets.begin())->getCenter().getY())
enabledEdges = Flags::EastSide | Flags::NorthSide;
else
enabledEdges = Flags::EastSide | Flags::SouthSide;
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
_queue.clear();
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
_connectedsId = (*_sources.begin())->getConnexId();
for ( Vertex* source : _sources ) {
_queue.push( source );
source->setDistance( 0.0 );
cdebug_log(112,0) << "Push source: (size:" << _queue.size() << ") "
<< source
<< " _connectedsId:" << _connectedsId << endl;
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
while ( not _targets.empty() and _propagate(enabledEdges) );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 4. * Bug: In Anabatic: - In Edge, materialize was done before the Edge get it's final position. Must be invalidated afterwards for the UpdateSession to put him in the correct QuadTree. - Functional (debugged) Dijkstra skeleton.
2016-05-30 11:52:38 -05:00
_queue.clear();
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 8. More Dijkstra bugs correcteds. * Bug: In Anabatic: - In _propagate(), on reaching a target, forgot to remove it from the queue before pushing it back with the new distance. It also simplificate the core algorithm as target as treated normal nodes. * New: In Anabatic: - Update cdebug to use the fastest macro version. - More readable drawings of GCells and Edges. - Added timer support. - The distance is now computed in DbU::Unit (aka long) and not in normalized float. - The distance function is now a callback (std::function<>) that can be changed (a default is provided at initialization). - New concept of branch in the agglomerated connex component. Each trace back part create a "branch" (tagged with a "branchId"). When a node is reached with the same distance, but from two different branches, choose the the branch that was lastly created. This create a slightly different tree which grows outward from the newest branches. - Makes the horizontal edges *slightly* longer than the vertical ones to skew the tree to use vertical edges, as it is usually less congested than the horiontal one (due to metal1 cell terminals). It is also my understanding that it is useful to reduce the number of vias, whithout introducing a via cost. * New: In Bootstrap: - Script sprof.py to perform sprof & demangle libraries execution profile. * ToDo: In Anabatic: - Corner optimization. Sometimes when two corners are possible, the wrong one is choosen. That is, one of it's edge cannot be used for further grow of the tree.
2016-06-17 06:09:34 -05:00
cdebug_tabw(112,-1);
Anabatic transient commit 7. More Dijkstra bugs correcteds. * Bug: In Anabatic: - Activate the searchArea to limit the area explored by the Dijkstra. Uses the bounding boxes of the vertexes/gcells instead of the ones the RoutingPads. - Always detach contacts from the rings in load(), even if the vertex is already marked as target. - On reaching a target (non-negative connexId), do not forget to update the distance to source. - In Edges locator, added support for side selection (needed by the monotonic feature). * New: In Anabatic: - Hide the atomic Dijkstra methods (made private). - Implementation of the monotonic mode in Dijkstra (for bipoints only). - Added a separate function for distance computation between two vertexes, now take account of the VIAs costs.
2016-06-10 11:27:06 -05:00
DebugSession::close();
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 10. Ripup & reroute support in Dijsktra. * New: In Anabatic: - In AnabaticEngine, keep track of overflowed edges. - In AnabaticEngine, getNetsFromedge() to lookup all nets going through an Edge. - In Configuration, read the Kite "reserved local" parameter to decrease the Edge capacity (it's a guessing of the cost of the local routing). - In Edge, add an attribute to know if there is an associated segment of the current net (set by Dijkstra::_traceback()). Transparently manage the overflowed edges. - In GCell_Edges, correct a filtering bug when not all sides are selecteds. - New GCell::getEdgeTo() to find the edge between two adjacent GCells. - New GCell::unrefContact() to automatically removes global contacts no longer used by any global segments (used during the ripup step). - In Dijkstra::load(), now able to "reload" and already partially or completly routed net (look for Contact of "gcontact" layer and their attached segments). - In Dijkstra, keep the last net loaded until the next one is. Put the cleanup operations in an isolated function "_cleanup()". - In Dijkstra::_selectFirstsource() and run(), load first source component made of multiple vertexes. - In Dijkstra::_trackback(), link the Net segments to the Edges. - New Dijkstra::ripup(), Dijkstra::_propagateRipup() to perform the ripup of one edge of a Net (must be loaded in Dijkstra first). Dijkstra::_tagConnecteds() setup the connexId of a set of Vertexes - that are connecteds through edges *with* segments. - In GraphicAnabaticengine & GlobalRoute.cpp, embryo of a global routing tool with ripup & reroute.
2016-06-26 07:32:32 -05:00
void Dijkstra::ripup ( Edge* edge )
{
DebugSession::open( _net, 112, 120 );
cdebug_log(112,1) << "Dijkstra::ripup(): " << edge << endl;
GCell* gsource = edge->getSource();
GCell* gtarget = edge->getTarget();
Vertex* vsource = gsource->getObserver<Vertex>(GCell::Observable::Vertex);
Vertex* vtarget = gtarget->getObserver<Vertex>(GCell::Observable::Vertex);
if ( (not isSourceVertex(vsource) and not isTargetVertex(vsource))
or (not isSourceVertex(vtarget) and not isTargetVertex(vtarget)) ) {
cerr << Error( "Dijkstra::ripup(): %s do *not* belong to %s (ignored)."
, getString(edge).c_str()
, getString(_net).c_str()
) << endl;
cdebug_tabw(112,-1);
DebugSession::close();
return;
}
edge->destroySegment();
// for ( Contact* contact : gsource->getGContacts() ) {
// if (contact->getNet() != _net) continue;
// for ( Component* component : contact->getSlaveComponents() ) {
// Segment* segment = dynamic_cast<Segment*>( component );
// if (segment and (gtarget->hasGContact(dynamic_cast<Contact*>(segment->getTarget())))) {
// segment->destroy();
// break;
// }
// }
// break;
// }
edge->incRealOccupancy( -1 );
_propagateRipup( vsource );
vtarget = _propagateRipup( vtarget );
_tagConnecteds( vtarget, ++_connectedsId );
cdebug_tabw(112,-1);
DebugSession::close();
}
Vertex* Dijkstra::_propagateRipup ( Vertex* end )
{
cdebug_log(112,1) << "Dijkstra::_propagateRipup() from:" << end << endl;
while ( end ) {
cdebug_log(112,0) << "| " << end << endl;
Contact* gcontact = end->getGCell()->getGContact( _net );
if (not gcontact) {
cdebug_log(112,0) << "Exiting on missing GContact." << endl;
cdebug_tabw(112,-1);
return end;
}
Edge* eneighbor = NULL;
for ( Edge* edge : end->getGCell()->getEdges() ) {
if (edge->getSegment()) {
if (not eneighbor) eneighbor = edge;
else {
eneighbor = NULL;
break;
}
}
}
for ( Component* component : gcontact->getSlaveComponents() ) {
if (dynamic_cast<RoutingPad*>(component)) {
eneighbor = NULL;
break;
}
}
if (not eneighbor) {
cdebug_log(112,0) << "Normal exit (fork or RoutingPad)." << endl;
cdebug_tabw(112,-1);
return end;
}
cdebug_log(112,0) << "+ " << eneighbor << endl;
eneighbor->incRealOccupancy( -1 );
eneighbor->destroySegment();
eneighbor->setSegment( NULL );
end->setConnexId( -1 );
end->setDistance( Vertex::unreached );
end = eneighbor->getOpposite(end->getGCell())->getObserver<Vertex>(GCell::Observable::Vertex);;
}
cdebug_log(112,0) << "Exiting on nothing left." << endl;
cdebug_tabw(112,-1);
return NULL;
}
void Dijkstra::_tagConnecteds ( Vertex* source, int connexId )
{
cdebug_log(112,1) << "Dijkstra::_tagConnecteds()" << endl;
source->setConnexId( connexId );
VertexSet stack;
stack.insert( source );
while ( not stack.empty() ) {
source = *stack.begin();
stack.erase( source );
cdebug_log(112,0) << "| source:" << source << " stack.size():" << stack.size() << endl;
for ( Edge* edge : source->getGCell()->getEdges() ) {
if (not edge->getSegment()) {
cdebug_log(112,0) << " Not connected:" << edge << endl;
continue;
}
GCell* gneighbor = edge->getOpposite(source->getGCell());
Vertex* vneighbor = gneighbor->getObserver<Vertex>(GCell::Observable::Vertex);
if (not vneighbor->hasValidStamp()) continue;
if (vneighbor->getConnexId() == connexId) continue;
vneighbor->setConnexId( connexId );
stack.insert( vneighbor );
}
}
cdebug_tabw(112,-1);
}
void Dijkstra::_checkEdges () const
{
cdebug_log(112,1) << "Dijkstra::_checkEdges()" << endl;
for ( Vertex* vertex : _vertexes ) {
for ( Edge* edge : vertex->getGCell()->getEdges(Flags::EastSide|Flags::NorthSide) ) {
if (edge->getSegment()) {
cdebug_log(112,0) << "Not reset:" << edge << edge->getSegment() << endl;
}
}
}
cdebug_tabw(112,-1);
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
} // Anabatic namespace.