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

811 lines
26 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".
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -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(); }
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
void Vertex::setPathPoint( DbU::Unit x, DbU::Unit y )
{
_xpath = x;
_ypath = y;
}
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())
For merging purpose
2016-09-22 11:52:53 -05:00
+ "-" + DbU::getValueString(_gcell->getYMin())
+ "-" + DbU::getValueString(_gcell->getXMax())
+ "-" + DbU::getValueString(_gcell->getYMax()) + ")"
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
+ " rps:" + getString(_rpCount)
+ " deg:" + getString(_degree)
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 )
{
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;
}
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
DbU::Unit Dijkstra::_distance ( const Vertex* current, const Vertex* vneighbour, 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
{
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(112,0) << "Calcul _distance "<< endl;
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
cdebug_log(112,0) << "current : "<< current->hasRestrictions() << ", " << current << endl;
cdebug_log(112,0) << "vneighbour: "<< vneighbour->hasRestrictions() << ", " << vneighbour << endl;
DbU::Unit distance = current->getDistance();
DbU::Unit addedDistance = 0;
/*
if ((current->getGCell()->isMatrix())&&(vneighbour->getGCell()->isMatrix())) addedDistance = e->getDistance();
else {
Point pneighbour = _getNextPathPoint( current, vneighbour );
addedDistance = abs(pneighbour.getX() - current->getXPath()) + abs(pneighbour.getY() - current->getXPath());
}*/
addedDistance = e->getDistance();
distance += addedDistance;
if ( (current->hasRestrictions()) || (vneighbour->hasRestrictions()) ) {
if (isRestricted(current, vneighbour)) {
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
distance = Vertex::unreachable;
}
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
}
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
if ((!current->getGCell()->isMatrix()) || (!vneighbour->getGCell()->isMatrix())){
if (distance != Vertex::unreachable) {
if (current->getFrom() != NULL){
GCell* gprevious = current->getFrom()->getOpposite(current->getGCell());
GCell* gcurrent = current->getGCell();
GCell* gneighbour = vneighbour->getGCell();
float cost = 0;
if ( ( gcurrent->isNorth(gprevious) && (!gcurrent->isSouth(gneighbour)) )
|| ( gcurrent->isEast (gprevious) && (!gcurrent->isWest (gneighbour)) )
|| ( gcurrent->isSouth(gprevious) && (!gcurrent->isNorth(gneighbour)) )
|| ( gcurrent->isWest (gprevious) && (!gcurrent->isEast (gneighbour)) )
){
distance += cost * addedDistance;
}
}
}
}
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;
}
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
Point Dijkstra::_getNextPathPoint( const Vertex* current, const Vertex* next )
{
if ((current == NULL) || (next == NULL)){
cdebug_log(112,0) << "Error(Point Dijkstra::_getNextPathPoint( const Vertex*, const Vertex* )): Unvalid NULL argument."<< endl;
return Point(0,0);
}
if (next->getGCell()->isMatrix()) return Point(next->getGCell()->getXCenter(), next->getGCell()->getYCenter());
if (next->getGCell()->isDevice()) return next->getPathPoint();
if (next->isNorth(current)){
if (next->getGCell()->isHChannel()){
return Point(current->getXPath(), next->getGCell()->getYCenter());
} else if ( (next->getGCell()->isVChannel()) || (next->getGCell()->isStrut())) {
return Point(current->getXPath(), next->getGCell()->getYMax());
} else {
cdebug_log(112,0) << "Error(Point Dijkstra::_getNextPathPoint( const Vertex*, const Vertex* )): Unknown GCell type."<< endl;
return Point(0,0);
}
} else if (next->isSouth(current)){
if (next->getGCell()->isHChannel()){
return Point(current->getXPath(), next->getGCell()->getYCenter());
} else if ( (next->getGCell()->isVChannel()) || (next->getGCell()->isStrut())) {
return Point(current->getXPath(), next->getGCell()->getYMin());
} else {
cdebug_log(112,0) << "Error(Point Dijkstra::_getNextPathPoint( const Vertex*, const Vertex* )): Unknown GCell type."<< endl;
return Point(0,0);
}
} else if (next->isEast (current)){
if (next->getGCell()->isHChannel()){
return Point(next->getGCell()->getXMax(), current->getYPath());
} else if ( (next->getGCell()->isVChannel()) || (next->getGCell()->isStrut())) {
return Point(next->getGCell()->getXCenter(), current->getYPath());
} else {
cdebug_log(112,0) << "Error(Point Dijkstra::_getNextPathPoint( const Vertex*, const Vertex* )): Unknown GCell type."<< endl;
return Point(0,0);
}
} else if (next->isWest (current)){
if (next->getGCell()->isHChannel()){
return Point(next->getGCell()->getXMin(), current->getYPath());
} else if ( (next->getGCell()->isVChannel()) || (next->getGCell()->isStrut())) {
return Point(next->getGCell()->getXCenter(), current->getYPath());
} else {
cdebug_log(112,0) << "Error(Point Dijkstra::_getNextPathPoint( const Vertex*, const Vertex* )): Unknown GCell type."<< endl;
return Point(0,0);
}
} else {
cdebug_log(112,0) << "Error(Point Dijkstra::_getNextPathPoint( const Vertex*, const Vertex* )): Vertex are not neighbours."<< endl;
return Point(0,0);
}
}
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 transient commit 16. First implementation of edge's historical cost.
2016-08-10 16:48:06 -05:00
: _anabatic (anabatic)
, _vertexes ()
, _distanceCb (_distance)
, _mode (Mode::Standart)
, _net (NULL)
, _stamp (-1)
, _sources ()
, _targets ()
, _searchArea ()
, _searchAreaHalo(0)
, _connectedsId (-1)
, _queue ()
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
{
const vector<GCell*>& gcells = _anabatic->getGCells();
for ( GCell* gcell : gcells ) {
_vertexes.push_back( new Vertex (gcell) );
}
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
_anabatic->getMatrix()->show();
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
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();
_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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
vector<RoutingPad*> rps;
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 ( Component* component : _net->getComponents() ) {
RoutingPad* rp = dynamic_cast<RoutingPad*>( component );
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
if (rp) {
rps.push_back( rp );
First intergration of the Analogic router parts. * New: In Anabatic::AutoSegment, introduce a the kind (associated to a flag) "LongLocal". Analog GCells can be very wide, so at least some carefuly choosen long local segments must be took into account as attractors in the computation of the optimal axis. * New: In Anabatic::AutoSegment::computeOptimal(), take LongLocal into account as attractors. * Change: In ::GCellTopology constructors compare the layers of the RoutingPads using layer masks instead of Layer pointers. Allows to find both "METALx" (symbolic) and "metalX" (real). * Change: In ::GCellTopology::_doHChannel(), _doChannel(), _doStrut() and _doDevice(), tag long locals as "LongLocal". This need to be reviewed as it as bind done a bit too quickly. * Change: In Anabatic::AutoSegment, due too a much bigger span of the analogic GCells the _optimalMin & _optimalMax bitfields must use 16 bits instead of 8 (they where overflowed). * New: In Katana, reorganisation of the initialization procedure to fit both digital and analogic cases. Create an analogInit() method. * Change: In Katana::RoutingEvent, the _tracksNb and _tracksFree bitfields where too short for the Analog GCell size, now uses 16 bits instead of 6. * Bug: In Katana::GraphicKatanEngine::drawGCell(), skip drawing of a GCell if *both* width and height are under 150 pixels. * New: In Katana::Session, add a new isOpen() method.
2016-10-04 10:12:58 -05:00
cdebug_log(112,0) << "| " << rp << endl;
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
continue;
}
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
for ( auto rp : rps ) {
Point center = rp->getBoundingBox().getCenter();
GCell* gcell = _anabatic->getGCellUnder( center );
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
if (gcell->isDevice()){
_searchArea.merge( _net->getCell()->getAbutmentBox() );
}
Anabatic transient commit 16. First implementation of edge's historical cost.
2016-08-10 16:48:06 -05:00
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(112,0) << "| " << rp << 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 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) {
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
cerr << Error( "Dijkstra::load(): %s\n"
" @%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."
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
, getString(rp).c_str()
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
, getString(center).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
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(112,0) << "Current Search area: " << _searchArea << ", gcell: " << gcell << 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
_searchArea.merge( gcell->getBoundingBox() );
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(112,0) << "New Search area: " << _searchArea << 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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
Vertex* seed = gcell->getObserver<Vertex>(GCell::Observable::Vertex);
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
seed->setPathPoint(rp->getBoundingBox().getCenter().getX(), rp->getBoundingBox().getCenter().getY());
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
if (seed->getConnexId() < 0) {
VertexSet connecteds;
_getConnecteds( seed, connecteds );
++_connectedsId;
for ( Vertex* vertex : connecteds ) {
vertex->setDistance ( Vertex::unreached );
vertex->setStamp ( _stamp );
vertex->setConnexId ( _connectedsId );
vertex->setBranchId ( 0 );
vertex->setDegree ( 1 );
vertex->setRpCount ( 0 );
vertex->setFrom ( NULL );
vertex->clearRestriction();
_targets.insert( vertex );
Anabatic transient commit 16. First implementation of edge's historical cost.
2016-08-10 16:48:06 -05:00
cdebug_log(112,0) << "| Add: " << vertex << endl;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
seed->incRpCount();
Contact* vcontact = seed->getGContact( _net );
rp->getBodyHook()->detach();
rp->getBodyHook()->attach( vcontact->getBodyHook() );
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
}
Anabatic transient commit 16. First implementation of edge's historical cost.
2016-08-10 16:48:06 -05:00
_searchArea.inflate( _searchAreaHalo );
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 ()
{
//_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();
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(111,0) << "[Current Vertex]: " << current << endl;
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
_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
in Dijkstra: - Bug: in _propagate, the GCell's bounding box intersection with the search area is now the way to check if the GCell should be treated.
2016-08-11 08:40:21 -05:00
if (edge == current->getFrom()) {
cdebug_log(111,0) << "edge == current->getFrom()" << endl;
continue;
}
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
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
in Dijkstra: - Bug: in _propagate, the GCell's bounding box intersection with the search area is now the way to check if the GCell should be treated.
2016-08-11 08:40:21 -05:00
//if (not _searchArea.contains(vneighbor->getCenter())) {
if (not _searchArea.intersect(gneighbor->getBoundingBox())) {
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(111,0) << "not in _searchArea: " << _searchArea << ", gneighbor area: " << gneighbor->getBoundingBox() << endl;
in Dijkstra: - Bug: in _propagate, the GCell's bounding box intersection with the search area is now the way to check if the GCell should be treated.
2016-08-11 08:40:21 -05:00
continue;
}
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
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 );
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(111,0) << "Distance: " << distance << ", unreachable: " << Vertex::unreachable << 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
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
if (vneighbor->getConnexId() == _connectedsId) {
cdebug_log(111,0) << "ConnectedsId" << endl;
continue;
}
if ( ( (distance < vneighbor->getDistance())
or ( (distance == vneighbor->getDistance())
and (current->getBranchId() > vneighbor->getBranchId()))
)
and (distance != Vertex::unreachable)
){
cdebug_log(111,0) << "1" << 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
if (vneighbor->getDistance() != Vertex::unreached) {
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(111,0) << "2" << 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
_queue.erase( vneighbor );
} else {
* Change: Dijkstra, GCell Restriction on vertex are now correctly done. * Change: Constants There is only one type of Strut. * New: LoadGlobalRouting Detailed Routing can be performed for analog circuits. The router does not take into account analog constraints yet. Warnings on "metal2" should be corrected in the future. Types of GCell considered by the router are: Device, VChannel/HChannel and Strut. The analog circuit MUST be organized in a slicing structure.
2016-09-30 11:09:05 -05:00
cdebug_log(111,0) << "3" << 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
if (not vneighbor->hasValidStamp()) {
vneighbor->setConnexId( -1 );
vneighbor->setStamp ( _stamp );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
vneighbor->setDegree ( 1 );
vneighbor->setRpCount ( 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
}
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 );
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
Point pathPoint =_getNextPathPoint( current, vneighbor );
vneighbor->setPathPoint( pathPoint.getX(), pathPoint.getY() );
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();
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
_toSources( current, _connectedsId );
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
current = current->getPredecessor();
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
while ( current ) {
cdebug_log(112,0) << "| " << current << endl;
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
current->incDegree();
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 (current->getConnexId() == _connectedsId) break;
Edge* from = current->getFrom();
if (not from) break;
current->setDistance( 0.0 );
- Add: New distance estimation in Dijsktra for Analog GCells. Still in developement ...
2016-12-22 04:21:25 -06:00
if (!current->getGCell()->isDevice()) current->setPathPoint( current->getGCell()->getXCenter(), current->getGCell()->getYCenter() );
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
current->setConnexId( _connectedsId );
current->setBranchId( branchId );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
_sources.insert( current );
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
_queue.push( current );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
current = current->getPredecessor();
}
cdebug_tabw(112,-1);
}
void Dijkstra::_materialize ()
{
cdebug_log(112,1) << "Dijkstra::_materialize() " << _net << " _sources:" << _sources.size() << endl;
if (_sources.size() < 2) { cdebug_tabw(112,-1); return; }
for ( Vertex* startVertex : _sources ) {
cdebug_log(112,0) << "? " << startVertex << endl;
if (not startVertex->getFrom()) continue;
if ( not startVertex->hasGContact(_net)
and not startVertex->getRpCount()
and (startVertex->getDegree() < 3)) continue;
Vertex* source = startVertex;
while ( source ) {
cdebug_log(112,0) << "* " << source << endl;
Edge* from = source->getFrom();
vector<Edge*> aligneds;
aligneds.push_back( from );
Vertex* target = source->getPredecessor();
Interval constraint = from->getSide();
source->setFrom( 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
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
cdebug_log(112,0) << "+ " << target << endl;
if (target->getConnexId() < 0) {
cdebug_log(112,0) << "| " << "break (abort: false start)." << endl;
break;
}
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
while ( true ) {
from = target->getFrom();
in Dijkstra: - Bug: in _propagate, the GCell's bounding box intersection with the search area is now the way to check if the GCell should be treated.
2016-08-11 08:40:21 -05:00
if ( not from
or not (target->getGCell()->isMatrix())
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
or (target->hasGContact(_net))
or (target->getRpCount())
or (target->getDegree() > 2)
or (aligneds.back()->isHorizontal() xor from->isHorizontal())
or not constraint.intersect(from->getSide())) break;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
aligneds.push_back( from );
constraint.merge( from->getSide() );
Vertex* nextTarget = target->getPredecessor();
target->setFrom( NULL );
target = nextTarget;
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
cdebug_log(112,0) << "| " << target << endl;
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
}
Contact* sourceContact = source->getGContact( _net );
Contact* targetContact = target->hasGContact( _net );
Segment* segment = NULL;
if (not targetContact) {
if (target->getFrom()) targetContact = target->getGContact( _net );
else targetContact = target->breakGoThrough( _net );
}
if (aligneds.front()->isHorizontal()) {
Matrix: - Modified: Matrix is now correctly updated for irregular floorplans. Dijkstra: - Modified: Source and Target contacts are now correctly chosen in _materialize.
2016-08-18 04:59:19 -05:00
if (sourceContact->getX() > targetContact->getX())
std::swap( sourceContact, targetContact );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
segment = Horizontal::create( sourceContact
, targetContact
, _anabatic->getConfiguration()->getGHorizontalLayer()
, constraint.getCenter()
, DbU::fromLambda(2.0)
);
for ( Edge* through : aligneds ) through->add( segment );
} else {
Matrix: - Modified: Matrix is now correctly updated for irregular floorplans. Dijkstra: - Modified: Source and Target contacts are now correctly chosen in _materialize.
2016-08-18 04:59:19 -05:00
if (sourceContact->getY() > targetContact->getY())
std::swap( sourceContact, targetContact );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
segment = Vertical::create( sourceContact
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
, targetContact
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
, _anabatic->getConfiguration()->getGVerticalLayer()
, constraint.getCenter()
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
, DbU::fromLambda(2.0)
);
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
for ( Edge* through : aligneds ) through->add( segment );
}
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
cdebug_log(112,0) << "| " << segment << endl;
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
cdebug_log(112,0) << "| " << "break (turn, branch or terminal)." << endl;
source = (target->getFrom()) ? target : 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
}
}
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
_materialize();
Anabatic transient commit 4. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
Anabatic transient commit 15. Introduce Net ordering for global route. * New: In Anabatic: - In AnabaticEngine, create a new NetData information for storing the static ordering of nets (for the global routing). The order is the half perimeter of the search area divided by the number of RoutingPads. The order is static once it as been computed in the first place (even through ripup stages).
2016-07-31 11:43:44 -05:00
_anabatic->getNetData( _net )->setGlobalRouted( true );
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
void Dijkstra::_toSources ( Vertex* source, int connexId )
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
{
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
cdebug_log(112,1) << "Dijkstra::_toSources() " << endl;
cdebug_log(112,0) << "* from: " << source << endl;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
source->setConnexId( connexId );
source->setDistance( 0.0 );
_targets.erase ( source );
_sources.insert( source );
_queue.push( source );
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
VertexSet stack;
stack.insert( source );
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
while ( not stack.empty() ) {
source = *stack.begin();
stack.erase( source );
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
cdebug_log(112,0) << "| source:" << source << " stack.size():" << stack.size() << endl;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
for ( Edge* edge : source->getGCell()->getEdges() ) {
if (not edge->hasNet(_net)) {
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
cdebug_log(112,0) << " Not connected:" << edge
<< " to:" << edge->getOpposite(source->getGCell()) << endl;
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
continue;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
GCell* gneighbor = edge->getOpposite(source->getGCell());
Vertex* vneighbor = gneighbor->getObserver<Vertex>(GCell::Observable::Vertex);
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
if (not vneighbor->hasValidStamp()) continue;
if (vneighbor->getConnexId() == connexId) continue;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
vneighbor->setConnexId( connexId );
vneighbor->setDistance( 0.0 );
Correct multiple backtrack from same connex components (pathological). * Bug: In Dijkstra::_materialize(), in some special case a connex component can is reached by two (or more) vertexes. But of course it will be connected only through one, all others must be discarteds. The right one will have it's connex id set, all the others will stay to -1. So stop any backtrack when the first neighbor of a starting point has it's connex id *not* set.
2016-08-27 09:00:14 -05:00
//vneighbor->setFrom ( edge );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
_targets.erase ( vneighbor );
_sources.insert( vneighbor );
_queue.push( vneighbor );
stack.insert( vneighbor );
}
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
void Dijkstra::_getConnecteds ( Vertex* source, VertexSet& connecteds )
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
cdebug_log(112,1) << "Dijkstra::_getConnecteds()" << endl;
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 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
connecteds.clear();
connecteds.insert( source );
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
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() ) {
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
if (not edge->hasNet(_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
cdebug_log(112,0) << " Not connected:" << edge << endl;
continue;
}
GCell* gneighbor = edge->getOpposite(source->getGCell());
Vertex* vneighbor = gneighbor->getObserver<Vertex>(GCell::Observable::Vertex);
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
if (connecteds.find(vneighbor) != connecteds.end()) continue;
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
stack.insert( vneighbor );
Anabatic transient commit 14. Change model for long wires. * Change: In Anabatic: - Long wires, going straight accross multiple GCells were splitted into a long sequence of segment+contact, one for each gone-through GCell. It was memory-consuming and algorithmically inefficient. Now there is only one straight wire. As a consequence, Edges now store the list of all segments going through them. That way we do not need to load a Net into Dijkstra before riping up some of it's segment. The ripup mechanims can now be implemented right at AnabaticEngine level, without dependencies over Dijkstra. Note that long wires are automatically broken in two if we need to attach a new branch on it (breakAt()). And fused back into one if a branch is removed (unify()).
2016-07-30 05:15:49 -05:00
connecteds.insert( vneighbor );
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);
}
void Dijkstra::_checkEdges () const
{
cdebug_log(112,1) << "Dijkstra::_checkEdges()" << endl;
Anabatic transient commit 15. Introduce Net ordering for global route. * New: In Anabatic: - In AnabaticEngine, create a new NetData information for storing the static ordering of nets (for the global routing). The order is the half perimeter of the search area divided by the number of RoutingPads. The order is static once it as been computed in the first place (even through ripup stages).
2016-07-31 11:43:44 -05:00
// for ( Vertex* vertex : _vertexes ) {
// for ( Edge* edge : vertex->getGCell()->getEdges(Flags::EastSide|Flags::NorthSide) ) {
// }
// }
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. * New: In Anabatic: - A Dijkstra skeleton, not debugged yet.
2016-05-30 04:30:29 -05:00
} // Anabatic namespace.