// -*- 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.