2010-03-09 09:24:55 -06:00
|
|
|
|
|
|
|
|
// -*- C++ -*-
|
|
|
|
|
//
|
|
|
|
|
// This file is part of the Coriolis Software.
|
2010-04-23 08:14:17 -05:00
|
|
|
// Copyright (c) UPMC/LIP6 2008-2010, All Rights Reserved
|
2010-03-09 09:24:55 -06:00
|
|
|
//
|
|
|
|
|
// ===================================================================
|
|
|
|
|
//
|
|
|
|
|
// $Id$
|
|
|
|
|
//
|
|
|
|
|
// x-----------------------------------------------------------------x
|
|
|
|
|
// | |
|
|
|
|
|
// | C O R I O L I S |
|
|
|
|
|
// | K i t e - D e t a i l e d R o u t e r |
|
|
|
|
|
// | |
|
|
|
|
|
// | Author : Jean-Paul CHAPUT |
|
|
|
|
|
// | E-mail : Jean-Paul.Chaput@asim.lip6.fr |
|
|
|
|
|
// | =============================================================== |
|
|
|
|
|
// | C++ Module : "./TrackElement.cpp" |
|
|
|
|
|
// | *************************************************************** |
|
|
|
|
|
// | U p d a t e s |
|
|
|
|
|
// | |
|
|
|
|
|
// x-----------------------------------------------------------------x
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include <limits>
|
|
|
|
|
#include <sstream>
|
|
|
|
|
|
|
|
|
|
#include "hurricane/Bug.h"
|
|
|
|
|
#include "hurricane/Warning.h"
|
|
|
|
|
#include "hurricane/Net.h"
|
|
|
|
|
#include "hurricane/Name.h"
|
|
|
|
|
#include "katabatic/AutoContact.h"
|
2010-12-12 15:42:57 -06:00
|
|
|
#include "katabatic/GCell.h"
|
2010-03-09 09:24:55 -06:00
|
|
|
#include "crlcore/RoutingGauge.h"
|
|
|
|
|
#include "kite/DataNegociate.h"
|
|
|
|
|
#include "kite/TrackElement.h"
|
|
|
|
|
#include "kite/TrackCost.h"
|
|
|
|
|
#include "kite/Track.h"
|
|
|
|
|
#include "kite/Session.h"
|
|
|
|
|
#include "kite/RoutingEvent.h"
|
|
|
|
|
#include "kite/NegociateWindow.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
using namespace Hurricane;
|
|
|
|
|
using namespace CRL;
|
|
|
|
|
using namespace Kite;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
|
// Function : "DummyOverlapCost ()".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void DummyOverlapCost ( const TrackElement* segment, TrackCost& cost )
|
|
|
|
|
{
|
|
|
|
|
cerr << Warning("No overlapCost callback has been set (%s)."
|
|
|
|
|
,getString(segment).c_str()) << endl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} // End of local namespace.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace Kite {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
using Hurricane::Bug;
|
|
|
|
|
using Hurricane::Net;
|
|
|
|
|
using Hurricane::Name;
|
2010-12-12 15:42:57 -06:00
|
|
|
using Katabatic::GCell;
|
2010-03-09 09:24:55 -06:00
|
|
|
|
|
|
|
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
// Class : "TrackElement::Compare".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool TrackElement::Compare::operator() ( TrackElement* lhs, TrackElement* rhs )
|
|
|
|
|
{
|
|
|
|
|
return lhs->getArea() > rhs->getArea();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
// Class : "TrackElement::CompareByPosition".
|
|
|
|
|
//
|
|
|
|
|
// Return: lhs < rhs.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool TrackElement::CompareByPosition::operator() ( const TrackElement* lhs, const TrackElement* rhs ) const
|
|
|
|
|
{
|
|
|
|
|
if ( lhs == rhs ) return false;
|
|
|
|
|
|
|
|
|
|
if ( lhs->isBlockage() xor rhs->isBlockage() )
|
|
|
|
|
return lhs->isBlockage();
|
|
|
|
|
|
|
|
|
|
if ( lhs->getLength() < rhs->getLength() ) return true;
|
|
|
|
|
if ( lhs->getLength() > rhs->getLength() ) return false;
|
|
|
|
|
|
|
|
|
|
if ( lhs->isHorizontal() xor rhs->isHorizontal() )
|
|
|
|
|
return rhs->isHorizontal();
|
|
|
|
|
|
|
|
|
|
if ( lhs->getAxis() > rhs->getAxis() ) return true;
|
|
|
|
|
if ( lhs->getAxis() < rhs->getAxis() ) return false;
|
|
|
|
|
|
|
|
|
|
if ( lhs->getSourceU() > rhs->getSourceU() ) return true;
|
|
|
|
|
if ( lhs->getSourceU() < rhs->getSourceU() ) return false;
|
|
|
|
|
|
|
|
|
|
if ( lhs->isBlockage() and rhs->isBlockage() ) return false;
|
|
|
|
|
|
|
|
|
|
//return lhs->getNet()->getName() < rhs->getNet()->getName();
|
|
|
|
|
return lhs->getId() < rhs->getId();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
// Class : "TrackElement".
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SegmentOverlapCostCB* TrackElement::_overlapCostCallback = DummyOverlapCost;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SegmentOverlapCostCB* TrackElement::setOverlapCostCB ( SegmentOverlapCostCB* cb )
|
|
|
|
|
{
|
|
|
|
|
SegmentOverlapCostCB* oldCb = _overlapCostCallback;
|
|
|
|
|
|
|
|
|
|
_overlapCostCallback = cb;
|
|
|
|
|
|
|
|
|
|
return oldCb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Former inline functions.
|
|
|
|
|
AutoSegment* TrackElement::base () const { return NULL; }
|
* ./kite:
- New: In NegociateWindow/RoutingEvent, adds a more comprehensive stage
"Repair". Perform in three stage: first try to place with a relaxed
constraint (one GCell on each side). Second try to minimize the faulty
segment. Third perform another "repack perpandicular" but this time
the faulty segment is re-inserted *before* any of it's perpandiculars.
- New: In RoutingEvent::cacheAxisHint(), when a segment has a parent, that
is comes for a "moveUp()", uses the parent axis hint as it's own.
- New: In State::slackenTopology(), in the global FSM, adds a special
operation when reaching MaximumSlack: forceOverLocals(), try to insert
the global on track containing only local segments. Should tend to
concentrate locals on a small set of shared tracks. Most useful on the
highest layers.
- New: In State::slackenTopology(), in the "MoveUp" state, try to find the
more appropriate segment to move up (Manipulator::desaturate()).
Effectively move up the longest segment fully enclosing the one we are
processing.
- New: In State::slackenTopology(), add a check for fully blocked segments
in the local segment FSM. Calls State::solveFullBlocked().
- New: In KiteEngine::createGlobalGraph(), decrease the vertical capacity
of one track inside the core. Helps smooth the vertical density.
- Change: In Manipulator::insertInTrack(), when a track is freed for a
to be inserted changes the priorities so that the segment is immediatly
inserted. Parallels ripeds and theirs perpandiculars are replaced
only *after*. This is the opposite of the previous behavior.
- Change: In NegociateWindow::NegociateOverlapCost(), account the costs
of terminals only for deep depth layers (M1, M2 & M3).
- Change: In RoutingEvent::insertInTrack(), expand the excluded interval
by a half-pitch (2.5l) instead of one lambda.
- Change: In State::State(), do not uses DiscardGlobal if the ripup count
exceed 5. Case of the "Strap" segments that can be ripped a lot
before changing state.
- Change: In State::_processNegociate(), no longer lock into position
(fixed) the local terminal segments as a last resort.
- Change: In RoutingEvent::_processNegociate(), no longer ripup perpandiculars
when a segment is inserted in a free space. Reduce the number of
events whithout degrading the routing quality.
- Change: In State::conflictSolve1_v1b(), if getLongestConflict() is nul,
ignore the track, the conflict must occurs on another track.
- Change: In TrackCost, add a flag support. First uses, a flags to prevent
a local of the topmost layer to ripup a global which is in moveUp
state.
- Bug: In State::solveFullBlockage(), after have been freed, reset the
segment state to "moveUp".
- Bug: In manipulator::minimize(), the axisHint was miscalculated if the
punctual span was empty.
2011-01-25 11:16:50 -06:00
|
|
|
bool TrackElement::isBipoint () const { return false; }
|
2010-03-09 09:24:55 -06:00
|
|
|
bool TrackElement::isCreated () const { return false; }
|
|
|
|
|
bool TrackElement::isFixed () const { return false; }
|
|
|
|
|
bool TrackElement::isBlockage () const { return false; }
|
|
|
|
|
bool TrackElement::isStrap () const { return false; }
|
|
|
|
|
bool TrackElement::isSlackenStrap () const { return false; }
|
|
|
|
|
bool TrackElement::isLocal () const { return true; }
|
|
|
|
|
bool TrackElement::isGlobal () const { return not isLocal(); }
|
|
|
|
|
bool TrackElement::isLocked () const { return false; }
|
|
|
|
|
bool TrackElement::isTerminal () const { return false; }
|
* ./kite:
- New: In NegociateWindow/RoutingEvent, adds a more comprehensive stage
"Repair". Perform in three stage: first try to place with a relaxed
constraint (one GCell on each side). Second try to minimize the faulty
segment. Third perform another "repack perpandicular" but this time
the faulty segment is re-inserted *before* any of it's perpandiculars.
- New: In RoutingEvent::cacheAxisHint(), when a segment has a parent, that
is comes for a "moveUp()", uses the parent axis hint as it's own.
- New: In State::slackenTopology(), in the global FSM, adds a special
operation when reaching MaximumSlack: forceOverLocals(), try to insert
the global on track containing only local segments. Should tend to
concentrate locals on a small set of shared tracks. Most useful on the
highest layers.
- New: In State::slackenTopology(), in the "MoveUp" state, try to find the
more appropriate segment to move up (Manipulator::desaturate()).
Effectively move up the longest segment fully enclosing the one we are
processing.
- New: In State::slackenTopology(), add a check for fully blocked segments
in the local segment FSM. Calls State::solveFullBlocked().
- New: In KiteEngine::createGlobalGraph(), decrease the vertical capacity
of one track inside the core. Helps smooth the vertical density.
- Change: In Manipulator::insertInTrack(), when a track is freed for a
to be inserted changes the priorities so that the segment is immediatly
inserted. Parallels ripeds and theirs perpandiculars are replaced
only *after*. This is the opposite of the previous behavior.
- Change: In NegociateWindow::NegociateOverlapCost(), account the costs
of terminals only for deep depth layers (M1, M2 & M3).
- Change: In RoutingEvent::insertInTrack(), expand the excluded interval
by a half-pitch (2.5l) instead of one lambda.
- Change: In State::State(), do not uses DiscardGlobal if the ripup count
exceed 5. Case of the "Strap" segments that can be ripped a lot
before changing state.
- Change: In State::_processNegociate(), no longer lock into position
(fixed) the local terminal segments as a last resort.
- Change: In RoutingEvent::_processNegociate(), no longer ripup perpandiculars
when a segment is inserted in a free space. Reduce the number of
events whithout degrading the routing quality.
- Change: In State::conflictSolve1_v1b(), if getLongestConflict() is nul,
ignore the track, the conflict must occurs on another track.
- Change: In TrackCost, add a flag support. First uses, a flags to prevent
a local of the topmost layer to ripup a global which is in moveUp
state.
- Bug: In State::solveFullBlockage(), after have been freed, reset the
segment state to "moveUp".
- Bug: In manipulator::minimize(), the axisHint was miscalculated if the
punctual span was empty.
2011-01-25 11:16:50 -06:00
|
|
|
bool TrackElement::isDogleg () const { return false; }
|
2010-03-09 09:24:55 -06:00
|
|
|
bool TrackElement::isRevalidated () const { return false; }
|
|
|
|
|
bool TrackElement::isRouted () const { return true; }
|
|
|
|
|
bool TrackElement::isSlackened () const { return false; }
|
|
|
|
|
bool TrackElement::isSlackenDogLeg () const { return false; }
|
|
|
|
|
bool TrackElement::hasSourceDogLeg () const { return false; }
|
|
|
|
|
bool TrackElement::hasTargetDogLeg () const { return false; }
|
|
|
|
|
bool TrackElement::allowOutsideGCell () const { return false; }
|
|
|
|
|
bool TrackElement::canGoOutsideGCell () const { return false; }
|
|
|
|
|
bool TrackElement::canRipple () const { return false; }
|
|
|
|
|
unsigned long TrackElement::getId () const { return 0; }
|
|
|
|
|
unsigned long TrackElement::getArea () const { return 0; }
|
|
|
|
|
unsigned int TrackElement::getDogLegLevel () const { return 0; }
|
|
|
|
|
unsigned int TrackElement::getDogLegOrder () const { return 0; }
|
|
|
|
|
Interval TrackElement::getSourceConstraints () const { return Interval(); }
|
|
|
|
|
Interval TrackElement::getTargetConstraints () const { return Interval(); }
|
* ./Kite:
- New: In BuildPowerRails, special processing for the power ring segments.
The "diagonal" of vias at each corner is causing a misbehavior of the
routing algorithm (due to fully saturated GCells in one direction).
As a temporary fix, extend the segments so they form a "square corner".
(problem arise on "d_in_i(22)").
- New: In RoutingEvent::_processNegociate, disable the "isForcedToHint()"
feature. No noticeable loss of quality or speed.
- New: In TrackElement/TrackSegment, wraps the AutoSegment parent's mechanism.
Allows to gets the DataNegociate of either the segment or it's parent.
- New: State::solveFullBlockages(), dedicated method to solves the case when
all the allowed tracks of a segment are blocked, tries to moves up
local segments and to break-up global ones.
- New: RoutingEventLoop, a more sophisticated way to detect looping.
Maintain a dynamic histogram of the last N (default 10) segments routeds,
with the count of how many times they have occurred. If that count
exeed 40, we *may* be facing a loop.
- Change: In State::conflictSolve1, implement new policy. The global segments
no more can be broken by local ones. The idea behind is that breaking
a global on the request of a local will only produce more cluttering
in the GCell. Globals must be keep straigth pass through, especially
inside near-saturated GCells. Globals breaking however can occurs at
another global's request.
- Change: In TrackCost, implement the new policy about locals segments that
cannot break globals segments. The sorting class now accept flags to
modulate the sorting function. Two options avalaibles: IgnoreAxisWeigth
(to uses for strap segments) and DiscardGlobals (to uses with locals).
- Change: In TrackCost, the "distance to fixed" have now an upper bound of
50 lambdas (no need to be greater because it means it's outside the
begin & en GCells). Take account not only of fixed segment, but also
of placed segments which makes bound.
- Bug: In Track::_check(), while calling each individual TrackSegment check,
uses it as the *first* argument of the "or", otherwise it may not be
called.
- Bug: In ProtectRoutingPad, loop over segment Collections while modificating
it was producing non-deterministic results. The fact that a collection
must be not modificated while beeing iterated is becoming a more and more
painful problem.
2010-12-30 12:42:17 -06:00
|
|
|
DataNegociate* TrackElement::getDataNegociate ( unsigned int ) const { return NULL; }
|
2010-03-09 09:24:55 -06:00
|
|
|
TrackElements TrackElement::getCollapsedPerpandiculars () { return new TrackElements_CollapsedPerpandicular(NULL); }
|
|
|
|
|
void TrackElement::setAllowOutsideGCell ( bool ) { }
|
|
|
|
|
void TrackElement::setLock ( bool ) { }
|
|
|
|
|
void TrackElement::setRevalidated ( bool ) { }
|
|
|
|
|
void TrackElement::invalidate () { }
|
|
|
|
|
void TrackElement::setCanRipple ( bool ) { }
|
|
|
|
|
void TrackElement::setSourceDogLeg ( bool ) { }
|
|
|
|
|
void TrackElement::setTargetDogLeg ( bool ) { }
|
|
|
|
|
TrackElement* TrackElement::getCanonical ( Interval& i ) { i=Interval(getSourceU(),getTargetU()); return this; }
|
|
|
|
|
bool TrackElement::canSlacken () const { return false; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool TrackElement::canDesalignate () const { return false; }
|
2010-04-23 08:14:17 -05:00
|
|
|
bool TrackElement::canPivotUp ( float ) const { return false; };
|
* ./Kite:
- New: In BuildPowerRails, special processing for the power ring segments.
The "diagonal" of vias at each corner is causing a misbehavior of the
routing algorithm (due to fully saturated GCells in one direction).
As a temporary fix, extend the segments so they form a "square corner".
(problem arise on "d_in_i(22)").
- New: In RoutingEvent::_processNegociate, disable the "isForcedToHint()"
feature. No noticeable loss of quality or speed.
- New: In TrackElement/TrackSegment, wraps the AutoSegment parent's mechanism.
Allows to gets the DataNegociate of either the segment or it's parent.
- New: State::solveFullBlockages(), dedicated method to solves the case when
all the allowed tracks of a segment are blocked, tries to moves up
local segments and to break-up global ones.
- New: RoutingEventLoop, a more sophisticated way to detect looping.
Maintain a dynamic histogram of the last N (default 10) segments routeds,
with the count of how many times they have occurred. If that count
exeed 40, we *may* be facing a loop.
- Change: In State::conflictSolve1, implement new policy. The global segments
no more can be broken by local ones. The idea behind is that breaking
a global on the request of a local will only produce more cluttering
in the GCell. Globals must be keep straigth pass through, especially
inside near-saturated GCells. Globals breaking however can occurs at
another global's request.
- Change: In TrackCost, implement the new policy about locals segments that
cannot break globals segments. The sorting class now accept flags to
modulate the sorting function. Two options avalaibles: IgnoreAxisWeigth
(to uses for strap segments) and DiscardGlobals (to uses with locals).
- Change: In TrackCost, the "distance to fixed" have now an upper bound of
50 lambdas (no need to be greater because it means it's outside the
begin & en GCells). Take account not only of fixed segment, but also
of placed segments which makes bound.
- Bug: In Track::_check(), while calling each individual TrackSegment check,
uses it as the *first* argument of the "or", otherwise it may not be
called.
- Bug: In ProtectRoutingPad, loop over segment Collections while modificating
it was producing non-deterministic results. The fact that a collection
must be not modificated while beeing iterated is becoming a more and more
painful problem.
2010-12-30 12:42:17 -06:00
|
|
|
bool TrackElement::canPivotDown ( float ) const { return false; };
|
* ./kite:
- Change: Propagate renaming "obstacle" -> "blockage".
- Bug/Change: In Configuration, the value of the extensionCap was too big
(1.5 lambda), reduce to 0.5 lambda. This is a problem, the extension
should be coupled to the layer as it is not the same for each METAL.
- Bug: When using TrackElement, always uses the virtual "->isFixed()" method
instead of trying to access to "->base()->isFixed()" as the base may be
NULL in case of blockage/fixed segment.
- Change: Merge PowerRails & Blockage trans-hierarchical construction (into
PowerRails). All blockages are groupeds under "blockagenet".
Allows to remove TrackBlockage & BuildBlockages.
- Change: In KiteEngine::annotateGloblalGraph(), when routing a full chip,
ring power segments around the core must completly saturate the edges
in their segment direction. This is to prevent the global router to
use paths under the power/ground ring (may generate unsolvable configs).
- Change: In KiteEngine::annotateGloblalGraph(), when routing a full chip,
distinguish three areas: the core (65%), the corona (90%) and the pads
(100%). Capacities on the edges are sets accordingly.
- Change: In RoutingEvent, introduce an alternative algorithm for
conflictSolve1, FindPath which try to deduce the breakpoints from a
truly explorated path. Unfortunatly this gives worst results than the
Cs1Candidates method. The why should be investigated as it's a critical
point in the algorithm.
- Change: In Manipulator::ripupPerpandicular(), when a caged perpandicular
is encountered, instead of just "stopping", rip it up and change is
axis hint (actually increase) it's axis hint so it stands a chance to
go outside the track with an obstacle.
- Change: In RoutingEvent/State::slackenTopology(), allow move up of local
segments when they are tightly constrained *and* blocked (cageds).
Partial modification of functions calls from booleans to flags.
- Bug: In NegociateWindow::NegociateOverlapCost, check for fixed segments
before trying to get DataNegociate. The lack of DataNegociate cause the
TrackElement to be discarted. It's a failsafe behavior, but it leads to
overlaps.
- Bug: In ProtectRoutingPad, in Pad Cells only, *do not* protect RoutingPad
to avoid the edge capacity over the pad to decrease to zero. This is
due to unused RoutingPads being accounted as blockages.
2010-12-04 09:25:48 -06:00
|
|
|
bool TrackElement::canMoveUp ( float, unsigned int ) const { return false; };
|
* ./kite:
- New: In NegociateWindow/RoutingEvent, adds a more comprehensive stage
"Repair". Perform in three stage: first try to place with a relaxed
constraint (one GCell on each side). Second try to minimize the faulty
segment. Third perform another "repack perpandicular" but this time
the faulty segment is re-inserted *before* any of it's perpandiculars.
- New: In RoutingEvent::cacheAxisHint(), when a segment has a parent, that
is comes for a "moveUp()", uses the parent axis hint as it's own.
- New: In State::slackenTopology(), in the global FSM, adds a special
operation when reaching MaximumSlack: forceOverLocals(), try to insert
the global on track containing only local segments. Should tend to
concentrate locals on a small set of shared tracks. Most useful on the
highest layers.
- New: In State::slackenTopology(), in the "MoveUp" state, try to find the
more appropriate segment to move up (Manipulator::desaturate()).
Effectively move up the longest segment fully enclosing the one we are
processing.
- New: In State::slackenTopology(), add a check for fully blocked segments
in the local segment FSM. Calls State::solveFullBlocked().
- New: In KiteEngine::createGlobalGraph(), decrease the vertical capacity
of one track inside the core. Helps smooth the vertical density.
- Change: In Manipulator::insertInTrack(), when a track is freed for a
to be inserted changes the priorities so that the segment is immediatly
inserted. Parallels ripeds and theirs perpandiculars are replaced
only *after*. This is the opposite of the previous behavior.
- Change: In NegociateWindow::NegociateOverlapCost(), account the costs
of terminals only for deep depth layers (M1, M2 & M3).
- Change: In RoutingEvent::insertInTrack(), expand the excluded interval
by a half-pitch (2.5l) instead of one lambda.
- Change: In State::State(), do not uses DiscardGlobal if the ripup count
exceed 5. Case of the "Strap" segments that can be ripped a lot
before changing state.
- Change: In State::_processNegociate(), no longer lock into position
(fixed) the local terminal segments as a last resort.
- Change: In RoutingEvent::_processNegociate(), no longer ripup perpandiculars
when a segment is inserted in a free space. Reduce the number of
events whithout degrading the routing quality.
- Change: In State::conflictSolve1_v1b(), if getLongestConflict() is nul,
ignore the track, the conflict must occurs on another track.
- Change: In TrackCost, add a flag support. First uses, a flags to prevent
a local of the topmost layer to ripup a global which is in moveUp
state.
- Bug: In State::solveFullBlockage(), after have been freed, reset the
segment state to "moveUp".
- Bug: In manipulator::minimize(), the axisHint was miscalculated if the
punctual span was empty.
2011-01-25 11:16:50 -06:00
|
|
|
float TrackElement::getMaxUnderDensity ( unsigned int ) const { return 0.0; };
|
2010-03-09 09:24:55 -06:00
|
|
|
bool TrackElement::canDogLeg () { return false; };
|
|
|
|
|
bool TrackElement::canDogLeg ( Interval ) { return false; };
|
* ./Kite:
- New: In BuildPowerRails, special processing for the power ring segments.
The "diagonal" of vias at each corner is causing a misbehavior of the
routing algorithm (due to fully saturated GCells in one direction).
As a temporary fix, extend the segments so they form a "square corner".
(problem arise on "d_in_i(22)").
- New: In RoutingEvent::_processNegociate, disable the "isForcedToHint()"
feature. No noticeable loss of quality or speed.
- New: In TrackElement/TrackSegment, wraps the AutoSegment parent's mechanism.
Allows to gets the DataNegociate of either the segment or it's parent.
- New: State::solveFullBlockages(), dedicated method to solves the case when
all the allowed tracks of a segment are blocked, tries to moves up
local segments and to break-up global ones.
- New: RoutingEventLoop, a more sophisticated way to detect looping.
Maintain a dynamic histogram of the last N (default 10) segments routeds,
with the count of how many times they have occurred. If that count
exeed 40, we *may* be facing a loop.
- Change: In State::conflictSolve1, implement new policy. The global segments
no more can be broken by local ones. The idea behind is that breaking
a global on the request of a local will only produce more cluttering
in the GCell. Globals must be keep straigth pass through, especially
inside near-saturated GCells. Globals breaking however can occurs at
another global's request.
- Change: In TrackCost, implement the new policy about locals segments that
cannot break globals segments. The sorting class now accept flags to
modulate the sorting function. Two options avalaibles: IgnoreAxisWeigth
(to uses for strap segments) and DiscardGlobals (to uses with locals).
- Change: In TrackCost, the "distance to fixed" have now an upper bound of
50 lambdas (no need to be greater because it means it's outside the
begin & en GCells). Take account not only of fixed segment, but also
of placed segments which makes bound.
- Bug: In Track::_check(), while calling each individual TrackSegment check,
uses it as the *first* argument of the "or", otherwise it may not be
called.
- Bug: In ProtectRoutingPad, loop over segment Collections while modificating
it was producing non-deterministic results. The fact that a collection
must be not modificated while beeing iterated is becoming a more and more
painful problem.
2010-12-30 12:42:17 -06:00
|
|
|
bool TrackElement::canDogLegAt ( Katabatic::GCell*, unsigned int ) { return false; };
|
2010-03-09 09:24:55 -06:00
|
|
|
TrackElement* TrackElement::getSourceDogLeg () { return NULL; }
|
|
|
|
|
TrackElement* TrackElement::getTargetDogLeg () { return NULL; }
|
* ./Kite:
- New: In BuildPowerRails, special processing for the power ring segments.
The "diagonal" of vias at each corner is causing a misbehavior of the
routing algorithm (due to fully saturated GCells in one direction).
As a temporary fix, extend the segments so they form a "square corner".
(problem arise on "d_in_i(22)").
- New: In RoutingEvent::_processNegociate, disable the "isForcedToHint()"
feature. No noticeable loss of quality or speed.
- New: In TrackElement/TrackSegment, wraps the AutoSegment parent's mechanism.
Allows to gets the DataNegociate of either the segment or it's parent.
- New: State::solveFullBlockages(), dedicated method to solves the case when
all the allowed tracks of a segment are blocked, tries to moves up
local segments and to break-up global ones.
- New: RoutingEventLoop, a more sophisticated way to detect looping.
Maintain a dynamic histogram of the last N (default 10) segments routeds,
with the count of how many times they have occurred. If that count
exeed 40, we *may* be facing a loop.
- Change: In State::conflictSolve1, implement new policy. The global segments
no more can be broken by local ones. The idea behind is that breaking
a global on the request of a local will only produce more cluttering
in the GCell. Globals must be keep straigth pass through, especially
inside near-saturated GCells. Globals breaking however can occurs at
another global's request.
- Change: In TrackCost, implement the new policy about locals segments that
cannot break globals segments. The sorting class now accept flags to
modulate the sorting function. Two options avalaibles: IgnoreAxisWeigth
(to uses for strap segments) and DiscardGlobals (to uses with locals).
- Change: In TrackCost, the "distance to fixed" have now an upper bound of
50 lambdas (no need to be greater because it means it's outside the
begin & en GCells). Take account not only of fixed segment, but also
of placed segments which makes bound.
- Bug: In Track::_check(), while calling each individual TrackSegment check,
uses it as the *first* argument of the "or", otherwise it may not be
called.
- Bug: In ProtectRoutingPad, loop over segment Collections while modificating
it was producing non-deterministic results. The fact that a collection
must be not modificated while beeing iterated is becoming a more and more
painful problem.
2010-12-30 12:42:17 -06:00
|
|
|
TrackElement* TrackElement::getParent () const { return NULL; }
|
2010-03-09 09:24:55 -06:00
|
|
|
void TrackElement::dataInvalidate () { }
|
|
|
|
|
void TrackElement::eventInvalidate () { }
|
|
|
|
|
void TrackElement::setArea () { }
|
|
|
|
|
void TrackElement::setRouted ( bool ) { }
|
|
|
|
|
void TrackElement::setTrack ( Track* track ) { _track = track; }
|
|
|
|
|
void TrackElement::setDogLegLevel ( unsigned int ) { }
|
|
|
|
|
void TrackElement::setDogLegOrder ( unsigned int ) { }
|
|
|
|
|
void TrackElement::swapTrack ( TrackElement* ) { }
|
|
|
|
|
void TrackElement::reschedule ( unsigned int ) { }
|
|
|
|
|
void TrackElement::detach () { }
|
|
|
|
|
void TrackElement::revalidate ( bool invalidEvent ) { }
|
|
|
|
|
void TrackElement::setAxis ( DbU::Unit, unsigned int flags ) { }
|
|
|
|
|
void TrackElement::slacken () { }
|
* ./kite:
- Change: Propagate renaming "obstacle" -> "blockage".
- Bug/Change: In Configuration, the value of the extensionCap was too big
(1.5 lambda), reduce to 0.5 lambda. This is a problem, the extension
should be coupled to the layer as it is not the same for each METAL.
- Bug: When using TrackElement, always uses the virtual "->isFixed()" method
instead of trying to access to "->base()->isFixed()" as the base may be
NULL in case of blockage/fixed segment.
- Change: Merge PowerRails & Blockage trans-hierarchical construction (into
PowerRails). All blockages are groupeds under "blockagenet".
Allows to remove TrackBlockage & BuildBlockages.
- Change: In KiteEngine::annotateGloblalGraph(), when routing a full chip,
ring power segments around the core must completly saturate the edges
in their segment direction. This is to prevent the global router to
use paths under the power/ground ring (may generate unsolvable configs).
- Change: In KiteEngine::annotateGloblalGraph(), when routing a full chip,
distinguish three areas: the core (65%), the corona (90%) and the pads
(100%). Capacities on the edges are sets accordingly.
- Change: In RoutingEvent, introduce an alternative algorithm for
conflictSolve1, FindPath which try to deduce the breakpoints from a
truly explorated path. Unfortunatly this gives worst results than the
Cs1Candidates method. The why should be investigated as it's a critical
point in the algorithm.
- Change: In Manipulator::ripupPerpandicular(), when a caged perpandicular
is encountered, instead of just "stopping", rip it up and change is
axis hint (actually increase) it's axis hint so it stands a chance to
go outside the track with an obstacle.
- Change: In RoutingEvent/State::slackenTopology(), allow move up of local
segments when they are tightly constrained *and* blocked (cageds).
Partial modification of functions calls from booleans to flags.
- Bug: In NegociateWindow::NegociateOverlapCost, check for fixed segments
before trying to get DataNegociate. The lack of DataNegociate cause the
TrackElement to be discarted. It's a failsafe behavior, but it leads to
overlaps.
- Bug: In ProtectRoutingPad, in Pad Cells only, *do not* protect RoutingPad
to avoid the edge capacity over the pad to decrease to zero. This is
due to unused RoutingPads being accounted as blockages.
2010-12-04 09:25:48 -06:00
|
|
|
bool TrackElement::moveUp ( unsigned int ) { return false; }
|
* ./Kite:
- New: In BuildPowerRails, special processing for the power ring segments.
The "diagonal" of vias at each corner is causing a misbehavior of the
routing algorithm (due to fully saturated GCells in one direction).
As a temporary fix, extend the segments so they form a "square corner".
(problem arise on "d_in_i(22)").
- New: In RoutingEvent::_processNegociate, disable the "isForcedToHint()"
feature. No noticeable loss of quality or speed.
- New: In TrackElement/TrackSegment, wraps the AutoSegment parent's mechanism.
Allows to gets the DataNegociate of either the segment or it's parent.
- New: State::solveFullBlockages(), dedicated method to solves the case when
all the allowed tracks of a segment are blocked, tries to moves up
local segments and to break-up global ones.
- New: RoutingEventLoop, a more sophisticated way to detect looping.
Maintain a dynamic histogram of the last N (default 10) segments routeds,
with the count of how many times they have occurred. If that count
exeed 40, we *may* be facing a loop.
- Change: In State::conflictSolve1, implement new policy. The global segments
no more can be broken by local ones. The idea behind is that breaking
a global on the request of a local will only produce more cluttering
in the GCell. Globals must be keep straigth pass through, especially
inside near-saturated GCells. Globals breaking however can occurs at
another global's request.
- Change: In TrackCost, implement the new policy about locals segments that
cannot break globals segments. The sorting class now accept flags to
modulate the sorting function. Two options avalaibles: IgnoreAxisWeigth
(to uses for strap segments) and DiscardGlobals (to uses with locals).
- Change: In TrackCost, the "distance to fixed" have now an upper bound of
50 lambdas (no need to be greater because it means it's outside the
begin & en GCells). Take account not only of fixed segment, but also
of placed segments which makes bound.
- Bug: In Track::_check(), while calling each individual TrackSegment check,
uses it as the *first* argument of the "or", otherwise it may not be
called.
- Bug: In ProtectRoutingPad, loop over segment Collections while modificating
it was producing non-deterministic results. The fact that a collection
must be not modificated while beeing iterated is becoming a more and more
painful problem.
2010-12-30 12:42:17 -06:00
|
|
|
bool TrackElement::moveDown ( unsigned int ) { return false; }
|
2010-03-09 09:24:55 -06:00
|
|
|
bool TrackElement::moveAside ( bool onLeft ) { return false; }
|
|
|
|
|
TrackElement* TrackElement::makeDogLeg () { return NULL; }
|
|
|
|
|
TrackElement* TrackElement::makeDogLeg ( Interval, bool& leftDogleg ) { return NULL; }
|
2010-12-12 15:42:57 -06:00
|
|
|
TrackElement* TrackElement::makeDogLeg ( Katabatic::GCell* ) { return NULL; }
|
|
|
|
|
TrackElement* TrackElement::_postDogLeg ( Katabatic::GCell* ) { return NULL; }
|
2010-03-09 09:24:55 -06:00
|
|
|
void TrackElement::_postModify () { }
|
|
|
|
|
void TrackElement::desalignate () { }
|
|
|
|
|
bool TrackElement::_check () const { return true; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
TrackElement::TrackElement ( Track* track )
|
|
|
|
|
: _track(track)
|
|
|
|
|
, _index((size_t)-1)
|
|
|
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TrackElement::_postCreate ()
|
|
|
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
TrackElement::~TrackElement ()
|
|
|
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TrackElement::_preDestroy ()
|
|
|
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TrackElement::destroy ()
|
|
|
|
|
{
|
|
|
|
|
_preDestroy ();
|
|
|
|
|
delete this;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
TrackElement* TrackElement::getNext () const
|
|
|
|
|
{
|
|
|
|
|
size_t dummy = _index;
|
|
|
|
|
return _track->getNext ( dummy, getNet() );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
TrackElement* TrackElement::getPrevious () const
|
|
|
|
|
{
|
|
|
|
|
size_t dummy = _index;
|
|
|
|
|
return _track->getPrevious ( dummy, getNet() );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-12-12 15:42:57 -06:00
|
|
|
Interval TrackElement::getFreeInterval () const
|
2010-03-09 09:24:55 -06:00
|
|
|
{
|
|
|
|
|
if ( !_track ) return Interval(false);
|
|
|
|
|
|
|
|
|
|
size_t begin = _index;
|
|
|
|
|
size_t end = _index;
|
2010-12-12 15:42:57 -06:00
|
|
|
return _track->expandFreeInterval ( begin, end, Track::Inside, getNet() );
|
2010-03-09 09:24:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
size_t TrackElement::getGCells ( vector<GCell*>& gcells ) const
|
|
|
|
|
{
|
|
|
|
|
vector<GCell*>().swap ( gcells );
|
|
|
|
|
return gcells.size();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
size_t TrackElement::getPerpandicularsBound ( set<TrackElement*>& bounds )
|
|
|
|
|
{
|
|
|
|
|
bounds.clear ();
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
unsigned int TrackElement::getOrder () const
|
|
|
|
|
{ return numeric_limits<unsigned int>::max(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TrackElement::incOverlapCost ( Net* net, TrackCost& cost ) const
|
|
|
|
|
{
|
|
|
|
|
if ( not _track or (getNet() == net) ) return;
|
|
|
|
|
|
|
|
|
|
_overlapCostCallback ( this, cost );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
string TrackElement::_getTypeName () const
|
|
|
|
|
{ return "TrackElement"; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
string TrackElement::_getString () const
|
|
|
|
|
{ return "<" + _getTypeName() + ">"; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Record* TrackElement::_getRecord () const
|
|
|
|
|
{
|
|
|
|
|
Record* record = new Record ( _getString() );
|
|
|
|
|
record->add ( getSlot ( "_track", _track ) );
|
|
|
|
|
record->add ( getSlot ( "_index", _index ) );
|
|
|
|
|
|
|
|
|
|
return record;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} // End of Kite namespace.
|