1052 lines
34 KiB
C++
1052 lines
34 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC 2008-2018, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | 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 : "./TrackSegment.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include <sstream>
|
|
#include <limits>
|
|
#include "hurricane/Bug.h"
|
|
#include "hurricane/Warning.h"
|
|
#include "hurricane/BasicLayer.h"
|
|
#include "hurricane/Net.h"
|
|
#include "hurricane/Name.h"
|
|
#include "hurricane/RoutingPad.h"
|
|
#include "anabatic/AutoContact.h"
|
|
#include "anabatic/GCell.h"
|
|
#include "crlcore/RoutingGauge.h"
|
|
#include "katana/DataNegociate.h"
|
|
#include "katana/RoutingPlane.h"
|
|
#include "katana/TrackSegmentRegular.h"
|
|
#include "katana/TrackSegmentWide.h"
|
|
#include "katana/Track.h"
|
|
#include "katana/Session.h"
|
|
#include "katana/RoutingEvent.h"
|
|
#include "katana/NegociateWindow.h"
|
|
#include "katana/KatanaEngine.h"
|
|
|
|
|
|
namespace Katana {
|
|
|
|
using namespace std;
|
|
using Hurricane::tab;
|
|
using Hurricane::ForEachIterator;
|
|
using Hurricane::Bug;
|
|
using Hurricane::Error;
|
|
using Hurricane::BasicLayer;
|
|
using Hurricane::Net;
|
|
using Hurricane::Name;
|
|
using Hurricane::RoutingPad;
|
|
using Anabatic::AutoSegment;
|
|
using Anabatic::perpandicularTo;
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "TrackSegment".
|
|
|
|
size_t TrackSegment::_allocateds = 0;
|
|
|
|
|
|
size_t TrackSegment::getAllocateds ()
|
|
{ return _allocateds; }
|
|
|
|
|
|
TrackSegment::TrackSegment ( AutoSegment* segment, Track* track )
|
|
: TrackElement (track)
|
|
, _base (segment)
|
|
, _symmetric (NULL)
|
|
, _freedomDegree(0)
|
|
, _ppitch (0)
|
|
, _data (NULL)
|
|
, _priority (0.0)
|
|
, _dogLegLevel (0)
|
|
, _flags (NoFlags)
|
|
{
|
|
cdebug_log(155,0) << "CTOR TrackSegment " << /*(void*)this <<*/ ":" << this << endl;
|
|
cdebug_log(155,0) << " over " << /*(void*)segment <<*/ ":" << segment << endl;
|
|
|
|
setFlags( TElemCreated|TElemLocked );
|
|
if (segment) {
|
|
_data = new DataNegociate( this );
|
|
_base->getCanonical( _sourceU, _targetU );
|
|
updateFreedomDegree();
|
|
updatePPitch();
|
|
}
|
|
|
|
++_allocateds;
|
|
}
|
|
|
|
|
|
void TrackSegment::_postCreate ()
|
|
{
|
|
TrackElement::_postCreate();
|
|
base()->setObserver( AutoSegment::Observable::TrackSegment, getObserver() );
|
|
}
|
|
|
|
|
|
TrackSegment::~TrackSegment ()
|
|
{
|
|
if (_data) delete _data;
|
|
--_allocateds;
|
|
}
|
|
|
|
|
|
void TrackSegment::_preDestroy ()
|
|
{
|
|
cdebug_log(155,0) << "TrackSegment::_preDestroy() - " << (void*)this
|
|
<< " [" << (void*)_base << ", "
|
|
<< (void*)(_base?_base->base():NULL) << "]" << endl;
|
|
|
|
DbU::Unit length = base()->getLength();
|
|
if ( (length > 0) and (length < getPPitch()) ) {
|
|
BasicLayer* layer = getLayer()->getBasicLayers().getFirst();
|
|
DbU::Unit width = base()->getWidth();
|
|
Contact* source = base()->getAutoSource()->base();
|
|
Contact* target = base()->getAutoTarget()->base();
|
|
if (isHorizontal()) {
|
|
width = std::max( width, source->getBoundingBox(layer).getHeight() );
|
|
width = std::max( width, target->getBoundingBox(layer).getHeight() );
|
|
} else {
|
|
width = std::max( width, source->getBoundingBox(layer).getWidth() );
|
|
width = std::max( width, target->getBoundingBox(layer).getWidth() );
|
|
}
|
|
base()->base()->setWidth( width );
|
|
}
|
|
|
|
base()->setObserver( AutoSegment::Observable::TrackSegment, NULL );
|
|
TrackElement::_preDestroy();
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::create ( AutoSegment* segment, Track* track, bool& created )
|
|
{
|
|
created = false;
|
|
|
|
DbU::Unit defaultWireWidth = Session::getWireWidth( segment->base()->getLayer() );
|
|
TrackElement* trackElement = Session::lookup( segment->base() );
|
|
if (not trackElement) {
|
|
if (segment->base()->getWidth() <= defaultWireWidth)
|
|
trackElement = new TrackSegmentRegular( segment, track );
|
|
else
|
|
trackElement = new TrackSegmentWide ( segment, track );
|
|
|
|
trackElement->_postCreate();
|
|
trackElement->invalidate();
|
|
created = true;
|
|
cdebug_log(159,0) << "TrackSegment::create(): " << trackElement << endl;
|
|
}
|
|
|
|
return trackElement;
|
|
}
|
|
|
|
|
|
// Formerly Inline Functions.
|
|
// Wrappeds.
|
|
AutoSegment* TrackSegment::base () const { return _base; }
|
|
Segment* TrackSegment::getSegment () const { return _base->base(); }
|
|
bool TrackSegment::isFixed () const { return _base->isFixed(); }
|
|
bool TrackSegment::isFixedAxis () const { return _base->isFixedAxis(); }
|
|
bool TrackSegment::isHorizontal () const { return _base->isHorizontal(); }
|
|
bool TrackSegment::isVertical () const { return _base->isVertical(); }
|
|
bool TrackSegment::isLocal () const { return not _base->isWeakGlobal() and not _base->isGlobal(); }
|
|
bool TrackSegment::isGlobal () const { return _base->isWeakGlobal() or _base->isGlobal(); }
|
|
bool TrackSegment::isBipoint () const { return _base->isBipoint(); }
|
|
bool TrackSegment::isTerminal () const { return _base->isTerminal(); }
|
|
bool TrackSegment::isDrag () const { return _base->isDrag(); }
|
|
bool TrackSegment::isStrongTerminal ( Flags flags ) const { return _base->isStrongTerminal(flags); }
|
|
bool TrackSegment::isStrap () const { return _base->isStrap(); }
|
|
bool TrackSegment::isSlackened () const { return _base->isSlackened(); }
|
|
bool TrackSegment::isDogleg () const { return _base->isDogleg(); }
|
|
bool TrackSegment::isShortDogleg () const { return _flags & TElemShortDogleg; }
|
|
bool TrackSegment::isReduced () const { return _base->isReduced(); }
|
|
bool TrackSegment::isUserDefined () const { return _base->isUserDefined(); }
|
|
bool TrackSegment::isUTurn () const { return _base->isUTurn(); }
|
|
bool TrackSegment::isAnalog () const { return _base->isAnalog(); }
|
|
bool TrackSegment::isWide () const { return _base->isWide(); }
|
|
bool TrackSegment::isShortNet () const { return _base->isShortNet(); }
|
|
bool TrackSegment::isPriorityLocked () const { return _flags & PriorityLocked; }
|
|
// Predicates.
|
|
bool TrackSegment::hasSymmetric () const { return _symmetric != NULL; }
|
|
// Accessors.
|
|
unsigned long TrackSegment::getId () const { return _base->getId(); }
|
|
Flags TrackSegment::getDirection () const { return _base->getDirection(); }
|
|
Net* TrackSegment::getNet () const { return _base->getNet(); }
|
|
DbU::Unit TrackSegment::getWidth () const { return _base->getWidth(); }
|
|
const Layer* TrackSegment::getLayer () const { return _base->getLayer(); }
|
|
unsigned int TrackSegment::getDepth () const { return _base->getDepth(); }
|
|
DbU::Unit TrackSegment::getPitch () const { return _base->getPitch(); }
|
|
DbU::Unit TrackSegment::getPPitch () const { return _ppitch; }
|
|
DbU::Unit TrackSegment::getExtensionCap ( Flags flags ) const { return _base->getExtensionCap(flags); }
|
|
DbU::Unit TrackSegment::getAxis () const { return _base->getAxis(); }
|
|
unsigned long TrackSegment::getFreedomDegree () const { return _freedomDegree; }
|
|
float TrackSegment::getPriority () const { return _priority; }
|
|
uint32_t TrackSegment::getDoglegLevel () const { return _dogLegLevel; }
|
|
Interval TrackSegment::getSourceConstraints () const { return _base->getSourceConstraints(); }
|
|
Interval TrackSegment::getTargetConstraints () const { return _base->getTargetConstraints(); }
|
|
TrackElement* TrackSegment::getCanonical ( Interval& i ) { return Session::lookup( _base->getCanonical(i)->base() ); }
|
|
TrackElement* TrackSegment::getSymmetric () { return _symmetric; }
|
|
TrackElements TrackSegment::getPerpandiculars () { return new TrackElements_Perpandiculars(this); }
|
|
// Mutators.
|
|
void TrackSegment::invalidate () { setFlags( TElemInvalidated ); _base->invalidate(); }
|
|
|
|
|
|
DbU::Unit TrackSegment::getSourceAxis () const
|
|
{
|
|
DbU::Unit sourceAxis = 0;
|
|
DbU::Unit targetAxis = 0;
|
|
base()->getEndAxes( sourceAxis, targetAxis );
|
|
return sourceAxis;
|
|
}
|
|
|
|
|
|
DbU::Unit TrackSegment::getTargetAxis () const
|
|
{
|
|
DbU::Unit sourceAxis = 0;
|
|
DbU::Unit targetAxis = 0;
|
|
base()->getEndAxes( sourceAxis, targetAxis );
|
|
return targetAxis;
|
|
}
|
|
|
|
|
|
DataNegociate* TrackSegment::getDataNegociate ( Flags flags ) const
|
|
{
|
|
if (flags & Flags::DataSelf) return _data;
|
|
|
|
TrackElement* parent = getParent();
|
|
return (parent) ? parent->getDataNegociate() : NULL;
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::getNext () const
|
|
{
|
|
size_t dummy = _track->find( this );
|
|
return _track->getNext( dummy, getNet() );
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::getPrevious () const
|
|
{
|
|
size_t dummy = _track->find( this );
|
|
return _track->getPrevious( dummy, getNet() );
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::getParent () const
|
|
{
|
|
AutoSegment* baseParent = base()->getParent();
|
|
if (not baseParent) return NULL;
|
|
|
|
TrackElement* element = Session::lookup( baseParent );
|
|
return element;
|
|
}
|
|
|
|
|
|
Interval TrackSegment::getFreeInterval () const
|
|
{
|
|
if (not _track) return Interval(false);
|
|
|
|
size_t begin = _track->find( this );
|
|
size_t end = begin;
|
|
|
|
return _track->expandFreeInterval( begin, end, Track::InsideElement, getNet() );
|
|
}
|
|
|
|
|
|
size_t TrackSegment::getGCells ( vector<GCell*>& gcells ) const
|
|
{
|
|
vector<GCell*>().swap( gcells );
|
|
|
|
Flags direction = getDirection();
|
|
GCell* sourceGCell = base()->getAutoSource()->getGCell();
|
|
GCell* targetGCell = base()->getAutoTarget()->getGCell();
|
|
|
|
cdebug_log(155,0) << "getGCells(): sourceGCell: " << sourceGCell << endl;
|
|
cdebug_log(155,0) << "getGCells(): targetGCell: " << targetGCell << endl;
|
|
|
|
for ( AutoSegment* segment : base()->getAligneds() ) {
|
|
cdebug_log(155,0) << "| " << segment << endl;
|
|
|
|
Anabatic::GCell* gcell = segment->getAutoSource()->getGCell();
|
|
if (isLess(gcell,sourceGCell,direction)) {
|
|
sourceGCell = gcell;
|
|
cdebug_log(155,0) << "getGCells(): new sourceGCell: " << sourceGCell << endl;
|
|
}
|
|
|
|
gcell = segment->getAutoTarget()->getGCell();
|
|
if (isGreater(gcell,targetGCell,direction)) {
|
|
targetGCell = gcell;
|
|
cdebug_log(155,0) << "getGCells(): new targetGCell: " << targetGCell << endl;
|
|
}
|
|
}
|
|
|
|
if (not sourceGCell or not targetGCell) return 0;
|
|
if (not sourceGCell) { gcells.push_back( targetGCell ); return 1; }
|
|
if (not targetGCell) { gcells.push_back( sourceGCell ); return 1; }
|
|
|
|
Flags side = (direction & Flags::Horizontal) ? Flags::EastSide : Flags::NorthSide;
|
|
DbU::Unit axis = getAxis();
|
|
cdebug_log(155,0) << "* dir:" << side._getString() << " @" << DbU::getValueString(axis) << endl;
|
|
|
|
gcells.push_back( sourceGCell );
|
|
while ( sourceGCell != targetGCell ) {
|
|
sourceGCell = sourceGCell->getNeighborAt( direction, axis );
|
|
cdebug_log(155,0) << "| " << sourceGCell << endl;
|
|
if (not sourceGCell) break;
|
|
|
|
gcells.push_back( sourceGCell );
|
|
}
|
|
|
|
return gcells.size();
|
|
}
|
|
|
|
|
|
size_t TrackSegment::getPerpandicularsBound ( set<TrackElement*>& bounds )
|
|
{
|
|
bounds.clear ();
|
|
|
|
set<AutoSegment*> baseBounds;
|
|
set<AutoSegment*>::iterator ibase;
|
|
_base->getPerpandicularsBound( baseBounds );
|
|
|
|
for ( ibase=baseBounds.begin() ; ibase!=baseBounds.end() ; ++ibase ) {
|
|
TrackElement* segment = Session::lookup( *ibase );
|
|
if (segment)
|
|
bounds.insert( segment );
|
|
}
|
|
|
|
return bounds.size();
|
|
}
|
|
|
|
|
|
void TrackSegment::setDoglegLevel ( uint32_t level )
|
|
{
|
|
if (level > 15) {
|
|
cerr << Bug("%s has reached maximum dog leg count (15)."
|
|
,_getString().c_str()) << endl;
|
|
level = 15;
|
|
}
|
|
_dogLegLevel = level;
|
|
}
|
|
|
|
|
|
void TrackSegment::setPriorityLock ( bool state )
|
|
{
|
|
if (state) _flags |= PriorityLocked;
|
|
else _flags &= ~PriorityLocked;
|
|
}
|
|
|
|
|
|
void TrackSegment::updateFreedomDegree ()
|
|
{ _freedomDegree = _base->getSlack(); }
|
|
|
|
|
|
void TrackSegment::forcePriority ( float forced )
|
|
{ if (not isPriorityLocked()) _priority = forced; }
|
|
|
|
|
|
void TrackSegment::computePriority ()
|
|
{
|
|
if (isPriorityLocked()) return;
|
|
if (isAnalog() and isTerminal()) { _priority = 0.0; return; }
|
|
|
|
double length = DbU::toLambda(getLength());
|
|
double slack = DbU::toLambda(base()->getSlack());
|
|
double pitch = DbU::toLambda(getPitch());
|
|
|
|
//if (length > 200.0) length = 200.0 - std::log(length)*20.0;
|
|
//if (length < 0.0) length = 0.0;
|
|
//if (slack / DbU::toLambda(_segment->getPitch()) < 2.0 ) slack = 999.0;
|
|
if (slack / pitch > 10.0) slack = 10.0*pitch;
|
|
|
|
//cerr << "TrackSegment::computePriority() length:" << length << " slack:" << slack
|
|
// << " pri:" << (length + 1.0) * (slack + 1.0) << " pitch:" << DbU::toLambda(getPitch()) << endl;
|
|
|
|
_priority = (length + 1.0) * (slack + 1.0);
|
|
|
|
//if (_priority > 10000.0) cerr << "_priority:" << _priority
|
|
// << " length:" << DbU::toLambda(getLength())
|
|
// << " slack:" << DbU::toLambda(base()->getSlack()) << endl;
|
|
}
|
|
|
|
|
|
void TrackSegment::updatePPitch ()
|
|
{
|
|
_ppitch = _base->getPPitch();
|
|
//cerr << "Update P/Pitch (" << DbU::toLambda(getPPitch()) << ") on " << this << endl;
|
|
}
|
|
|
|
|
|
void TrackSegment::setTrack ( Track* track )
|
|
{
|
|
if (track) {
|
|
DbU::Unit axis = track->getAxis();
|
|
if (getTrackSpan() > 1) {
|
|
DbU::Unit pitch = track->getRoutingPlane()->getLayerGauge()->getPitch();
|
|
axis += (pitch * (getTrackSpan() - 1)) / 2;
|
|
|
|
cdebug_log(155,0) << "TrackSegment::setTrack(): pitch:" << DbU::getValueString(pitch)
|
|
<< " trackSpan:" << getTrackSpan() << endl;
|
|
}
|
|
addTrackCount( getTrackSpan() );
|
|
setAxis( axis, AutoSegment::SegAxisSet );
|
|
}
|
|
TrackElement::setTrack( track );
|
|
}
|
|
|
|
|
|
void TrackSegment::setSymmetric ( TrackElement* segment )
|
|
{ _symmetric = dynamic_cast<TrackSegment*>( segment ); }
|
|
|
|
|
|
void TrackSegment::detach ()
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::detach() - <id:" << getId() << ">" << endl;
|
|
|
|
setTrack( NULL );
|
|
setFlags( TElemLocked );
|
|
addTrackCount( -1 );
|
|
}
|
|
|
|
|
|
void TrackSegment::detach ( set<Track*>& removeds )
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::detach(set<Track*>&) - <id:" << getId() << ">" << endl;
|
|
|
|
Track* wtrack = getTrack();
|
|
for ( size_t i=0 ; wtrack and (i<getTrackSpan()) ; ++i ) {
|
|
|
|
removeds.insert( wtrack );
|
|
wtrack = wtrack->getNextTrack();
|
|
}
|
|
|
|
detach();
|
|
}
|
|
|
|
|
|
void TrackSegment::revalidate ()
|
|
{
|
|
unsetFlags( TElemCreated );
|
|
cdebug_log(159,0) << "revalidate() - " << this << endl;
|
|
|
|
_base->getCanonical( _sourceU, _targetU );
|
|
|
|
if (_track) Session::addSortEvent( _track, true );
|
|
unsetFlags( TElemInvalidated );
|
|
}
|
|
|
|
|
|
void TrackSegment::setAxis ( DbU::Unit axis, uint32_t flags )
|
|
{
|
|
_base->setAxis( axis, flags );
|
|
invalidate();
|
|
}
|
|
|
|
|
|
void TrackSegment::swapTrack ( TrackElement* other )
|
|
{
|
|
if (not other) return;
|
|
|
|
cdebug_log(159,0) << "TrackSegment::swapTrack()" << endl;
|
|
|
|
Track* thisTrack = getTrack();
|
|
Track* otherTrack = other->getTrack();
|
|
size_t thisIndex = ( thisTrack) ? thisTrack->find( this) : Track::npos;
|
|
size_t otherIndex = (otherTrack) ? otherTrack->find(other) : Track::npos;
|
|
|
|
if (_track and otherTrack and (_track != otherTrack)) {
|
|
cerr << Error("TrackSegment::swapTrack() - swapping TrackSegments from different tracks.") << endl;
|
|
}
|
|
|
|
setTrack( NULL );
|
|
other->setTrack( NULL );
|
|
|
|
other->setTrack( thisTrack );
|
|
if (thisTrack) thisTrack->setSegment( other, thisIndex );
|
|
|
|
setTrack( otherTrack );
|
|
if (_track) _track->setSegment( this, otherIndex );
|
|
|
|
#if defined(CHECK_DATABASE_DISABLED)
|
|
if (_track) _track->_check();
|
|
else if (other->getTrack()) other->getTrack()->_check();
|
|
#endif
|
|
|
|
RoutingEvent* thisEvent = getDataNegociate(Flags::DataSelf)->getRoutingEvent();
|
|
RoutingEvent* otherEvent = other->getDataNegociate()->getRoutingEvent();
|
|
|
|
if (thisEvent ) thisEvent ->setSegment( other );
|
|
if (otherEvent) otherEvent->setSegment( this );
|
|
|
|
cdebug_log(159,0) << "| this: " << this << endl;
|
|
cdebug_log(159,0) << "| other: " << other << endl;
|
|
}
|
|
|
|
|
|
void TrackSegment::reschedule ( uint32_t level )
|
|
{
|
|
cdebug_log(159,1) << "TrackSegment::reschedule() - " << this << endl;
|
|
|
|
if (not _data or not _data->hasRoutingEvent())
|
|
Session::getNegociateWindow()->addRoutingEvent( this, level );
|
|
else {
|
|
if (_track != NULL)
|
|
Session::addRemoveEvent( this );
|
|
Session::getNegociateWindow()->rescheduleEvent( _data->getRoutingEvent(), level );
|
|
}
|
|
|
|
cdebug_tabw(159,-1);
|
|
}
|
|
|
|
|
|
void TrackSegment::computeAlignedPriority ()
|
|
{
|
|
if (isPriorityLocked() or isTerminal()) return;
|
|
|
|
computePriority();
|
|
|
|
AutoSegment* canonical = base();
|
|
|
|
vector<TrackElement*> sourceAligneds;
|
|
vector<TrackElement*> targetAligneds;
|
|
for ( AutoSegment* segment : canonical->getAligneds(Flags::Source|Flags::WithDoglegs) ) {
|
|
if (not segment->isCanonical()) continue;
|
|
sourceAligneds.push_back( Session::lookup(segment) );
|
|
}
|
|
for ( AutoSegment* segment : canonical->getAligneds(Flags::Target|Flags::WithDoglegs) ) {
|
|
if (not segment->isCanonical()) continue;
|
|
sourceAligneds.push_back( Session::lookup(segment) );
|
|
}
|
|
|
|
if (sourceAligneds.empty() and targetAligneds.empty()) return;
|
|
|
|
setPriorityLock( true );
|
|
|
|
cdebug_log(159,0) << "TrackSegment::computeAlignedPriority() " << this << endl;
|
|
cdebug_log(159,0) << "Aligneds on:" << getPriority() << ":" << this << endl;
|
|
for ( size_t i=0 ; i<sourceAligneds.size() ; ++i ) {
|
|
sourceAligneds[i]->forcePriority( getPriority() - 2.0*(i+1) + 1.0 );
|
|
sourceAligneds[i]->setPriorityLock( true );
|
|
|
|
cdebug_log(159,0) << "| S:" << i << " " << sourceAligneds[i]->getPriority()
|
|
<< ":" << sourceAligneds[i] << endl;
|
|
}
|
|
for ( size_t i=0 ; i<targetAligneds.size() ; ++i ) {
|
|
targetAligneds[i]->forcePriority( getPriority() - 2.0*(i+1) );
|
|
targetAligneds[i]->setPriorityLock( true );
|
|
|
|
cdebug_log(159,0) << "| T:" << i << " " << targetAligneds[i]->getPriority()
|
|
<< ":" << targetAligneds[i] << endl;
|
|
}
|
|
}
|
|
|
|
|
|
float TrackSegment::getMaxUnderDensity ( Flags flags ) const
|
|
{ return _base->getMaxUnderDensity( flags ); }
|
|
|
|
|
|
bool TrackSegment::canPivotUp ( float reserve, Flags flags ) const
|
|
{ return _base->canPivotUp( reserve, flags ); }
|
|
|
|
|
|
bool TrackSegment::canPivotDown ( float reserve, Flags flags ) const
|
|
{ return _base->canPivotDown( reserve, flags ); }
|
|
|
|
|
|
bool TrackSegment::canMoveUp ( float reserve, Flags flags ) const
|
|
{ return _base->canMoveUp( reserve, flags ); }
|
|
|
|
|
|
bool TrackSegment::canSlacken () const
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::canSlacken() doglegLevel:" << getDoglegLevel() << endl;
|
|
return (not isSlackened() and (getDoglegLevel() <= 3)) ? _base->canSlacken(Flags::Propagate) : false;
|
|
}
|
|
|
|
|
|
bool TrackSegment::slacken ( Flags flags )
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::slacken()" << endl;
|
|
|
|
bool success = false;
|
|
|
|
if (not isSlackened()) {
|
|
TrackElement* perpandicular = NULL;
|
|
TrackElement* parallel = NULL;
|
|
|
|
cdebug_tabw(159,1);
|
|
|
|
success = base()->slacken( flags|Flags::Propagate );
|
|
_postDoglegs( perpandicular, parallel );
|
|
|
|
cdebug_tabw(159,-1);
|
|
return success;
|
|
} else
|
|
cerr << Bug("TrackSegment::slacken(): NULL base or already slackened.") << endl;
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
bool TrackSegment::moveUp ( Flags flags )
|
|
{
|
|
bool success = false;
|
|
|
|
cdebug_log(159,1) << "TrackSegment::moveUp() " << flags << endl;
|
|
|
|
success = base()->moveUp( flags );
|
|
if (success) {
|
|
TrackElement* perpandicular = NULL;
|
|
TrackElement* parallel = NULL;
|
|
|
|
Session::revalidateTopology();
|
|
_postDoglegs( perpandicular, parallel );
|
|
}
|
|
|
|
cdebug_tabw(159,-1);
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
bool TrackSegment::moveDown ( Flags flags )
|
|
{
|
|
bool success = false;
|
|
|
|
cdebug_log(159,1) << "TrackSegment::moveDown() " << flags << endl;
|
|
|
|
success = base()->moveDown( flags );
|
|
if (success) {
|
|
TrackElement* perpandicular = NULL;
|
|
TrackElement* parallel = NULL;
|
|
|
|
Session::revalidateTopology();
|
|
_postDoglegs( perpandicular, parallel );
|
|
}
|
|
|
|
cdebug_tabw(159,-1);
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
bool TrackSegment::moveAside ( Flags flags )
|
|
{
|
|
bool success = true;
|
|
|
|
cdebug_log(159,1) << "TrackSegment::moveAside() - "
|
|
<< ((flags&Flags::MoveToLeft )?"left" :"")
|
|
<< ((flags&Flags::MoveToRight)?"rigth":"") << endl;
|
|
if (flags & Flags::MoveToLeft ) base()->moveULeft ();
|
|
if (flags & Flags::MoveToRight) base()->moveURight();
|
|
cdebug_tabw(159,-1);
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::getSourceDogleg ()
|
|
{
|
|
if (not hasSourceDogleg()) return NULL;
|
|
|
|
Flags direction = perpandicularTo( getDirection() );
|
|
TrackElement* dogleg = NULL;
|
|
for( Segment* segment : base()->getAutoSource()->getSlaveComponents().getSubSet<Segment*>() ) {
|
|
dogleg = Session::lookup( segment );
|
|
if (dogleg and (dogleg->getDirection() == direction)) {
|
|
cdebug_log(159,0) << "Source dogleg: " << dogleg << endl;
|
|
return dogleg;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::getTargetDogleg ()
|
|
{
|
|
if (not hasSourceDogleg()) return NULL;
|
|
|
|
Flags direction = perpandicularTo( getDirection() );
|
|
TrackElement* dogleg = NULL;
|
|
for( Segment* segment : base()->getAutoTarget()->getSlaveComponents().getSubSet<Segment*>() ) {
|
|
dogleg = Session::lookup( segment );
|
|
if (dogleg and (dogleg->getDirection() == direction)) {
|
|
cdebug_log(159,0) << "Target dogleg: " << dogleg << endl;
|
|
return dogleg;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool TrackSegment::canDogleg ()
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::canDogleg()" << endl;
|
|
|
|
if (not isLocal()) {
|
|
cdebug_log(159,0) << "Failed: is not local." << endl;
|
|
return false;
|
|
}
|
|
|
|
if (isFixed()) {
|
|
cdebug_log(159,0) << "Failed: is fixed." << endl;
|
|
return false;
|
|
}
|
|
|
|
if (isRouted()) {
|
|
cdebug_log(159,0) << "Failed: belongs to an already routed net." << endl;
|
|
return false;
|
|
}
|
|
|
|
if (isSlackened()) {
|
|
cdebug_log(159,0) << "Failed: is local & slackened." << endl;
|
|
return false;
|
|
}
|
|
|
|
if (hasSourceDogleg() or hasTargetDogleg()) {
|
|
cdebug_log(159,0) << "Failed: already has source or target dogleg." << endl;
|
|
return false;
|
|
}
|
|
|
|
if (getDoglegLevel() > 3) {
|
|
cdebug_log(159,0) << "Failed: maximum dogleg level reached (4)." << endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool TrackSegment::canDogleg ( Anabatic::GCell* doglegGCell, Flags flags )
|
|
{
|
|
cdebug_log(159,1) << "TrackSegment::canDogleg(GCell*) " << doglegGCell << endl;
|
|
|
|
if (doglegGCell->isIoPad()) {
|
|
cdebug_log(159,0) << "false: Cannot dogleg in a GCell under an I/O Pad." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
if (doglegGCell->isStdCellRow()) {
|
|
cdebug_log(159,0) << "false: Cannot dogleg in a Standard Cell row." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
if (isFixed()) {
|
|
cdebug_log(159,0) << "false: Cannot dogleg a fixed segment." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
if (isRouted()) {
|
|
cdebug_log(159,0) << "false: Cannot dogleg a segment belonging to an already routed net." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
if (isLocal()) {
|
|
if (hasSourceDogleg() or hasTargetDogleg()) {
|
|
cdebug_log(159,0) << "false: Cannot dogleg again a local segment." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
if (isSlackened()) {
|
|
cdebug_log(159,0) << "false: Cannot dogleg a local slackened segment." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (getDoglegLevel() > 3) {
|
|
cdebug_log(159,0) << "Failed: maximum dogleg level reached (4)." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
vector<Anabatic::GCell*> gcells;
|
|
if (not getGCells(gcells)) {
|
|
cdebug_log(159,0) << "getGCell() has gone wrong." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
cdebug_log(159,0) << "Source: " << *gcells.begin () << endl;
|
|
cdebug_log(159,0) << "Target: " << *gcells.rbegin() << endl;
|
|
|
|
bool isGCellInside = false;
|
|
for ( size_t igcell=0 ; igcell<gcells.size() ; ++igcell ) {
|
|
if (doglegGCell != gcells[igcell]) continue;
|
|
|
|
isGCellInside = true;
|
|
if (igcell == 0) {
|
|
if (hasSourceDogleg()) {
|
|
if (flags & Flags::AllowDoglegReuse) return true;
|
|
|
|
cdebug_log(159,0) << "false: Cannot dogleg again in source GCell." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (hasTargetDogleg() and (igcell == gcells.size()-1)) {
|
|
if (flags & Flags::AllowDoglegReuse) {
|
|
cdebug_log(159,0) << "true" << endl;
|
|
cdebug_tabw(159,-1);
|
|
return true;
|
|
}
|
|
|
|
cdebug_log(159,0) << "false: Cannot dogleg again in target GCell." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (not isGCellInside) {
|
|
cdebug_log(159,0) << "false: dogleg GCell is outside segment support (go outside GCell active)." << endl;
|
|
cdebug_tabw(159,-1);
|
|
return false;
|
|
}
|
|
|
|
cdebug_log(159,0) << "true" << endl;
|
|
cdebug_tabw(159,-1);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool TrackSegment::canDogleg ( Interval interval )
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::canDogleg(Interval) " << interval << endl;
|
|
|
|
if (isFixed()) {
|
|
cdebug_log(159,0) << "Failed: is fixed" << endl;
|
|
return false;
|
|
}
|
|
|
|
if (isRouted()) {
|
|
cdebug_log(159,0) << "Failed: belongs to an already routed net" << endl;
|
|
return false;
|
|
}
|
|
|
|
if (not isLocal()) {
|
|
cdebug_log(159,0) << "Failed: is not local" << endl;
|
|
return false;
|
|
}
|
|
|
|
if (hasSourceDogleg() or hasTargetDogleg() or isSlackened()) {
|
|
cdebug_log(159,0) << "Failed: already has source and/or target dogleg or slackened." << endl;
|
|
return false;
|
|
}
|
|
|
|
if (getDoglegLevel() > 3) {
|
|
cdebug_log(159,0) << "Failed: maximum dogleg level reached (4)." << endl;
|
|
return false;
|
|
}
|
|
|
|
return _base->canDogleg(interval);
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::makeDogleg ()
|
|
{
|
|
Anabatic::AutoContact* source = _base->getAutoSource();
|
|
Anabatic::AutoContact* target = _base->getAutoTarget();
|
|
Anabatic::GCell* gcell = _base->getAutoSource()->getGCell();
|
|
|
|
TrackElement* dogleg = NULL;
|
|
TrackElement* parallel = NULL;
|
|
makeDogleg( gcell, dogleg, parallel );
|
|
|
|
if (dogleg) {
|
|
if (source->isTerminal() xor target->isTerminal()) {
|
|
if (target->isTerminal())
|
|
source = target;
|
|
|
|
DbU::Unit axis = (_base->isHorizontal()) ? source->getX() : source->getY();
|
|
|
|
cdebug_log(159,0) << "Setting dogleg axis @" << DbU::getValueString(axis) << endl;
|
|
dogleg->setAxis( axis );
|
|
}
|
|
}
|
|
return dogleg;
|
|
}
|
|
|
|
|
|
TrackElement* TrackSegment::makeDogleg ( Anabatic::GCell* dogLegGCell
|
|
, TrackElement*& perpandicular
|
|
, TrackElement*& parallel
|
|
)
|
|
{
|
|
cdebug_log(159,0) << "TrackSegment::makeDogleg(GCell*)" << endl;
|
|
cdebug_log(159,0) << "Break in: " << dogLegGCell << endl;
|
|
|
|
base()->makeDogleg( dogLegGCell );
|
|
_postDoglegs( perpandicular, parallel );
|
|
|
|
return perpandicular;
|
|
}
|
|
|
|
|
|
Flags TrackSegment::makeDogleg ( Interval interval, TrackElement*& perpandicular, TrackElement*& parallel, Flags flags )
|
|
{
|
|
perpandicular = NULL;
|
|
parallel = NULL;
|
|
|
|
cdebug_log(159,0) << "TrackSegment::makeDogleg(Interval)" << endl;
|
|
flags |= base()->makeDogleg( interval );
|
|
_postDoglegs( perpandicular, parallel );
|
|
|
|
if (flags & Flags::ShortDogleg) {
|
|
parallel->setFlags( TElemShortDogleg );
|
|
Session::addShortDogleg( this, parallel );
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
|
|
void TrackSegment::_postDoglegs ( TrackElement*& perpandicular, TrackElement*& parallel )
|
|
{
|
|
cdebug_log(159,1) << "TrackSegment::_postDoglegs()" << endl;
|
|
|
|
uint32_t doglegLevel = 0;
|
|
const vector<AutoSegment*>& doglegs = Session::getDoglegs();
|
|
vector<TrackElement*> segments;
|
|
|
|
if (not doglegs.empty()) {
|
|
if (doglegs.size()%3 != 0)
|
|
cerr << Error( "Session::_postDoglegs(): Number of created segments incoherent with pure doglegs (%u)."
|
|
, doglegs.size() ) << endl;
|
|
|
|
for ( size_t i=0 ; i<doglegs.size() ; i+=3 ) {
|
|
cdebug_log(159,0) << "Looking up original: " << doglegs[i] << endl;
|
|
segments.push_back( Session::getNegociateWindow()->createTrackSegment(doglegs[i],0) );
|
|
segments[i+0]->setFlags( TElemTargetDogleg );
|
|
segments[i+0]->getDataNegociate()->resetRipupCount();
|
|
//segments[i+0]->getDataNegociate()->resetStateCount();
|
|
segments[i+0]->getDataNegociate()->setState( DataNegociate::RipupPerpandiculars );
|
|
doglegLevel = segments[i+0]->getDoglegLevel();
|
|
segments[i+0]->setDoglegLevel( doglegLevel + (segments[i]->isLocal()?1:0) );
|
|
|
|
cdebug_log(159,0) << "Looking up new perpand: " << doglegs[i+1] << endl;
|
|
segments.push_back( Session::getNegociateWindow()->createTrackSegment(doglegs[i+1],0) );
|
|
segments[i+1]->setFlags( TElemSourceDogleg|TElemTargetDogleg );
|
|
segments[i+1]->setDoglegLevel( doglegLevel + 1 );
|
|
|
|
cdebug_log(159,0) << "Looking up new parallel: " << doglegs[i+2] << endl;
|
|
segments.push_back( Session::getNegociateWindow()->createTrackSegment(doglegs[i+2],0) );
|
|
segments[i+2]->setFlags( TElemSourceDogleg );
|
|
segments[i+2]->getDataNegociate()->resetStateCount();
|
|
segments[i+2]->getDataNegociate()->setState( segments[i+0]->getDataNegociate()->getState() );
|
|
segments[i+2]->setDoglegLevel( doglegLevel + (segments[i]->isLocal()?1:0) );
|
|
|
|
segments[i+0]->getDataNegociate()->setChildSegment( segments[i+2] );
|
|
|
|
perpandicular = segments[i+1];
|
|
parallel = segments[i+2];
|
|
}
|
|
|
|
// TO CHECK
|
|
// If the original TrackElement was inserted in a Track, must check
|
|
// if the new bit takes it's place or not.
|
|
//if ( getGCell() != originalGCell ) swapTrack ( segments[2] );
|
|
|
|
for ( size_t i=0 ; i<doglegs.size() ; ++i ) {
|
|
segments[i]->reschedule ( ((i%3==1) ? 0 : 1) );
|
|
const char* segPart = "Unknown";
|
|
switch ( i%3 ) {
|
|
case 0: segPart = "original "; break;
|
|
case 1: segPart = "perpand "; break;
|
|
case 2: segPart = "new paral"; break;
|
|
}
|
|
cdebug_log(159,0) << "[" << (i/3) << ":" << i << "] " << segPart << ": "
|
|
<< segments[i] << endl;
|
|
}
|
|
} else {
|
|
reschedule( 1 );
|
|
}
|
|
|
|
cdebug_tabw(159,-1);
|
|
|
|
Session::doglegReset();
|
|
}
|
|
|
|
|
|
bool TrackSegment::_check () const
|
|
{
|
|
if (not base()) return true;
|
|
|
|
bool coherency = true;
|
|
|
|
if (not base()->isCanonical()) {
|
|
cerr << "[CHECK] " << this << " supporting AutoSegment is not canonical." << endl;
|
|
coherency = false;
|
|
}
|
|
|
|
DbU::Unit min;
|
|
DbU::Unit max;
|
|
base()->checkPositions();
|
|
base()->getCanonical( min, max );
|
|
if (getSourceU() != min) {
|
|
cerr << "[CHECK] " << this << " has bad source position "
|
|
<< "cache:" << DbU::getValueString(getSourceU()) << " vs. "
|
|
<< "canon:" << DbU::getValueString(min) << "." << endl;
|
|
coherency = false;
|
|
}
|
|
if (getTargetU() != max) {
|
|
cerr << "[CHECK] " << this << " has bad target position "
|
|
<< "cache:" << DbU::getValueString(getTargetU()) << " vs. "
|
|
<< "canon:" << DbU::getValueString(max) << "." << endl;
|
|
coherency = false;
|
|
}
|
|
|
|
return coherency;
|
|
}
|
|
|
|
|
|
string TrackSegment::_getTypeName () const
|
|
{ return "TrackSegment"; }
|
|
|
|
|
|
string TrackSegment::_getString () const
|
|
{
|
|
string s1 = _base->_getString();
|
|
string s2 = " [" + DbU::getValueString(_sourceU)
|
|
+ ":" + DbU::getValueString(_targetU) + "]"
|
|
+ " " + DbU::getValueString(_targetU-_sourceU)
|
|
+ " " + getString(_dogLegLevel)
|
|
+ ((isRouted() ) ? "R" : "-")
|
|
+ ((isSlackened() ) ? "S" : "-")
|
|
+ ((_track ) ? "T" : "-")
|
|
+ ((canRipple() ) ? "r" : "-")
|
|
+ ((hasSourceDogleg()) ? "s" : "-")
|
|
+ ((hasTargetDogleg()) ? "t" : "-");
|
|
|
|
s1.insert( s1.size()-1, s2 );
|
|
|
|
return s1;
|
|
}
|
|
|
|
|
|
Record* TrackSegment::_getRecord () const
|
|
{
|
|
Record* record = TrackElement::_getRecord();
|
|
record->add( getSlot( "_base" , _base ) );
|
|
record->add( getSlot( "_symmetric", _symmetric ) );
|
|
record->add( getSlot( "_flags" , _flags ) );
|
|
return record;
|
|
}
|
|
|
|
|
|
} // Katana namespace.
|