riscv
/
coriolis
mirror of https://gitlab.lip6.fr/vlsi-eda/coriolis.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
coriolis/knik/src/Vertex.cpp

678 lines
23 KiB
C++
Raw Normal View History

Support for Windows/Cygwin, part 2. * Change: In bootstrap, in ccb, builder and coriolisEnv.py, correct detection of the windows architecture (32 or 64 bits). Under Cygwin, add the directory of the dll into the PATH also. Uses "site-package" as the location of Python modules (*not* "dist-package"). Use gnu++0x under Cygwin instead of c++11. * Change: In Etesian, if Coloquinte is not found, do not stop the compilation, just disable the tool altogether. * Change: In Hurricane, In Backtrace, disable backtrace under Cygwin as it uses features specific of the glibc. * Change: In Knik, use HUGE_VAL instead of HUGE (not present under Cygwin), add the <cmath> header. * Change: In Unicorn, Coloquinte no longer stops the compilation.
2014-07-22 17:55:50 -05:00
#include <cmath>
* ./hurricane/src/hviewer, ./coriolis/src/crlcore, ./coriolis/src/knik, ./coriolis/src/katabatic, ./coriolis/src/kite, ./coriolis/src/equinox, ./coriolis/src/solstice, ./coriolis/src/ispd: - SVN MOVE: Source tree simplification & uniformisation. Now all tools are at the same level, directly under the root of the repository. No more "coriolis/src".
2010-03-09 09:23:58 -06:00
#include <algorithm>
#include "hurricane/Technology.h"
#include "hurricane/DataBase.h"
#include "knik/Vertex.h"
#include "knik/Edge.h"
#include "knik/Graph.h"
namespace {
using namespace Knik;
struct EdgeToYComp : public binary_function<const Edge*, const Edge*, bool> {
public:
bool operator() ( Edge* edge1, Edge* edge2 ) const
{
return ( edge1->getTo()->getY() < edge2->getTo()->getY() );
}
};
struct EdgeToXComp : public binary_function<const Edge*, const Edge*, bool> {
public:
bool operator() ( Edge* edge1, Edge* edge2 ) const
{
return ( edge1->getTo()->getX() > edge2->getTo()->getX() );
}
};
struct EdgeFromYComp : public binary_function<const Edge*, const Edge*, bool> {
public:
bool operator() ( Edge* edge1, Edge* edge2 ) const
{
return ( edge1->getFrom()->getY() > edge2->getFrom()->getY() );
}
};
struct EdgeFromXComp : public binary_function<const Edge*, const Edge*, bool> {
public:
bool operator() ( Edge* edge1, Edge* edge2 ) const
{
return ( edge1->getFrom()->getX() < edge2->getFrom()->getX() );
}
};
}
namespace Knik {
extern unsigned __congestion__;
extern unsigned __precongestion__;
const Name Vertex::_extensionName = "Knik::Vertex";
// ********************************************************************
// VERTEX_Edges declaration
// ********************************************************************
class VERTEX_Edges : public Collection<Edge*> {
public:
typedef Collection<Edge*> Inherit;
public:
class Locator : public Hurricane::Locator<Edge*> {
public:
typedef Hurricane::Locator<Edge*> Inherit;
private:
const Vertex* _vertex;
Edge* _edge;
int _direction;
public:
Locator(const Vertex* vertex = NULL, Edge* edge = NULL, int direction = 0);
Locator(const Locator& locator);
Locator& operator=(const Locator& locator);
virtual Edge* getElement() const;
virtual Hurricane::Locator<Edge*>* getClone() const;
virtual bool isValid() const;
virtual void progress();
virtual string _getString() const;
};
private:
const Vertex* _vertex;
Edge* _edge;
int _direction;
public:
VERTEX_Edges(const Vertex* vertex);
VERTEX_Edges(const VERTEX_Edges& edges);
VERTEX_Edges& operator=(const VERTEX_Edges& edges);
virtual Collection<Edge*>* getClone() const;
virtual Hurricane::Locator<Edge*>* getLocator() const;
virtual string _getString() const;
};
Vertex::Vertex ( Graph* routingGraph, Point position, DbU::Unit halfWidth, DbU::Unit halfHeight )
// **********************************************************************************************
: Inherit (routingGraph->getCell())
, _routingGraph (routingGraph)
, _predecessor (NULL)
, _contact (NULL)
, _position (position)
, _vtuple (NULL)
Support for Windows/Cygwin, part 2. * Change: In bootstrap, in ccb, builder and coriolisEnv.py, correct detection of the windows architecture (32 or 64 bits). Under Cygwin, add the directory of the dll into the PATH also. Uses "site-package" as the location of Python modules (*not* "dist-package"). Use gnu++0x under Cygwin instead of c++11. * Change: In Etesian, if Coloquinte is not found, do not stop the compilation, just disable the tool altogether. * Change: In Hurricane, In Backtrace, disable backtrace under Cygwin as it uses features specific of the glibc. * Change: In Knik, use HUGE_VAL instead of HUGE (not present under Cygwin), add the <cmath> header. * Change: In Unicorn, Coloquinte no longer stops the compilation.
2014-07-22 17:55:50 -05:00
, _distance ((float)(HUGE_VAL))
* ./hurricane/src/hviewer, ./coriolis/src/crlcore, ./coriolis/src/knik, ./coriolis/src/katabatic, ./coriolis/src/kite, ./coriolis/src/equinox, ./coriolis/src/solstice, ./coriolis/src/ispd: - SVN MOVE: Source tree simplification & uniformisation. Now all tools are at the same level, directly under the root of the repository. No more "coriolis/src".
2010-03-09 09:23:58 -06:00
, _connexID (-1)
, _netStamp (0)
, _halfWidth (halfWidth)
, _halfHeight (halfHeight)
In Knik::Vertex, the _flags member was uninitialized. * Bug: In Knik, in Vertex the _flags attribute was unitialized. This flag is, in particular, telling if the vertex is blocked. That it was taking a random value, was leading to errors and unreproductible behaviors. I hope this will make the global router deterministic at last. This problem did show in the Stratus FIFO generator. * Bug: In Knik, in Vertex, remove the unused _boundingBox attribute.
2016-04-22 15:55:26 -05:00
, _flags(0)
* ./hurricane/src/hviewer, ./coriolis/src/crlcore, ./coriolis/src/knik, ./coriolis/src/katabatic, ./coriolis/src/kite, ./coriolis/src/equinox, ./coriolis/src/solstice, ./coriolis/src/ispd: - SVN MOVE: Source tree simplification & uniformisation. Now all tools are at the same level, directly under the root of the repository. No more "coriolis/src".
2010-03-09 09:23:58 -06:00
{
_firstEdges[0] = NULL;
_firstEdges[1] = NULL;
_firstEdges[2] = NULL;
_firstEdges[3] = NULL;
}
Vertex* Vertex::create ( Graph* routingGraph, Point position, DbU::Unit halfWidth, DbU::Unit halfHeight )
// *******************************************************************************************************
{
Vertex* vertex = new Vertex ( routingGraph, position, halfWidth, halfHeight );
vertex->_postCreate();
return vertex;
}
void Vertex::_postCreate()
// ***********************
{
Inherit::_postCreate();
}
Vertex::~Vertex()
// **************
{
}
void Vertex::destroy()
// ******************
{
_preDestroy();
delete this;
}
void Vertex::_preDestroy()
// **********************
{
Inherit::_preDestroy();
}
void Vertex::attachToLocalRing ( Component* component )
// ****************************************************
{
// XXX plus utilisée ? XXX
//assert ( component );
//Hook* hook = component->getBodyHook();
//hook->detach();
//if ( Hook* previousHook = getLocalRingHook() ) {
// //cerr << "Vertex::attachToLocalRingHook : going to attach " << previousHook << " to " << hook << endl;
// hook->attach ( previousHook );
//}
//setLocalRingHook ( hook );
}
void Vertex::sortEdges()
// *********************
{
vector<Edge*> hEdgesOut;
vector<Edge*> vEdgesOut;
vector<Edge*> hEdgesIn;
vector<Edge*> vEdgesIn;
Edge* currentEdge;
//ltracein(425);
if ( (currentEdge = getHEdgeOut()) ) { // si pas de HEdgeOut : rien a faire ^^
while ( currentEdge ) {
//ltrace(425) << "Pushing_back edge " << getString(currentEdge) << endl;
hEdgesOut.push_back ( currentEdge );
currentEdge = currentEdge->getNextFrom();
}
//ltrace(425) << "sorting vector..." << endl;
sort ( hEdgesOut.begin(), hEdgesOut.end(), EdgeToYComp() );
//ltrace(425) << "setting " << getString(hEdgesOut[0]) << " as hEdgeOut for vertex " << getString(this) << endl;
setHEdgeOut ( hEdgesOut[0] );
for ( unsigned i = 1 ; i < hEdgesOut.size() ; i++ ) {
//ltrace(425) << "next : " << getString(hEdgesOut[i]) << endl;
hEdgesOut[i-1]->setNextFrom ( hEdgesOut[i] );
}
hEdgesOut[hEdgesOut.size()-1]->setNextFrom ( NULL ); // si jamais avant en milieu de chaine ...
}
//ltraceout(425);
if ( (currentEdge = getVEdgeOut()) ) {
while ( currentEdge ) {
vEdgesOut.push_back ( currentEdge );
currentEdge = currentEdge->getNextFrom();
}
sort ( vEdgesOut.begin(), vEdgesOut.end(), EdgeToXComp() );
setVEdgeOut ( vEdgesOut[0]);
for ( unsigned i = 1 ; i < vEdgesOut.size() ; i++ ) {
vEdgesOut[i-1]->setNextFrom ( vEdgesOut[i] );
}
vEdgesOut[vEdgesOut.size()-1]->setNextFrom ( NULL );
}
if ( (currentEdge = getHEdgeIn()) ) {
while ( currentEdge ) {
hEdgesIn.push_back ( currentEdge );
currentEdge = currentEdge->getNextTo();
}
sort ( hEdgesIn.begin(), hEdgesIn.end(), EdgeFromYComp() );
setHEdgeIn ( hEdgesIn[0] );
for ( unsigned i = 1 ; i < hEdgesIn.size() ; i++ ) {
hEdgesIn[i-1]->setNextTo ( hEdgesIn[i] );
}
hEdgesIn[hEdgesIn.size()-1]->setNextTo ( NULL );
}
if ( (currentEdge = getVEdgeIn()) ) {
while ( currentEdge ) {
vEdgesIn.push_back ( currentEdge );
currentEdge = currentEdge->getNextTo();
}
sort ( vEdgesIn.begin(), vEdgesIn.end(), EdgeFromXComp() );
setVEdgeIn ( vEdgesIn[0] );
for ( unsigned i = 1 ; i < vEdgesIn.size() ; i++ ) {
vEdgesIn[i-1]->setNextTo ( vEdgesIn[i] );
}
vEdgesIn[vEdgesIn.size()-1]->setNextTo ( NULL );
}
}
Edges Vertex::getAdjacentEdges() const
// ***********************************
{
return VERTEX_Edges ( this );
}
Contact* Vertex::getContact ( Edge* arrivalEdge )
// **********************************************
{
if ( _contact ) {
// il y deja un contact associe au vertex XXX on verifie que le contact appartient bien au workingNet du routingGraph XXX
if ( _routingGraph->getWorkingNet() == _contact->getNet() )
return _contact;
_contact = NULL;
}
//assert ( arrivalEdge ); // ca change si on se decide quele vertex pointe sur le contact et pas le hook d'un routingPad ou autre
if ( arrivalEdge ) {
int arrivalConnexID = arrivalEdge->getConnexID();
bool createContact = false;
bool straightOn = false;
if ( arrivalEdge->isVertical() ) {
if ( _firstEdges[0] && ( _firstEdges[0]->getConnexID() == arrivalConnexID ) && ( _firstEdges[0]->getNetStamp() == _netStamp ) )
createContact = true;
else if ( _firstEdges[2] && ( _firstEdges[2]->getConnexID() == arrivalConnexID ) && ( _firstEdges[2]->getNetStamp() == _netStamp ) )
createContact = true;
else if ( ( _firstEdges[1] == arrivalEdge )
&& ( _firstEdges[3] && ( _firstEdges[3]->getConnexID() == arrivalConnexID ) && ( _firstEdges[3]->getNetStamp() == _netStamp ) ) )
straightOn = true;
else if ( ( _firstEdges[3] == arrivalEdge )
&& ( _firstEdges[1] && ( _firstEdges[1]->getConnexID() == arrivalConnexID ) && ( _firstEdges[1]->getNetStamp() == _netStamp ) ) )
straightOn = true;
else
throw Error ( "Vertex::getContact(): problem with edges configuration *1." );
}
else {
if ( _firstEdges[1] && ( _firstEdges[1]->getConnexID() == arrivalConnexID ) && ( _firstEdges[1]->getNetStamp() == _netStamp ) )
createContact = true;
else if ( _firstEdges[3] && ( _firstEdges[3]->getConnexID() == arrivalConnexID ) && ( _firstEdges[3]->getNetStamp() == _netStamp ) )
createContact = true;
else if ( ( _firstEdges[0] == arrivalEdge )
&& ( _firstEdges[2] && ( _firstEdges[2]->getConnexID() == arrivalConnexID ) && ( _firstEdges[2]->getNetStamp() == _netStamp ) ) )
straightOn = true;
else if ( ( _firstEdges[2] == arrivalEdge )
&& ( _firstEdges[0] && ( _firstEdges[0]->getConnexID() == arrivalConnexID ) && ( _firstEdges[0]->getNetStamp() == _netStamp ) ) )
straightOn = true;
else
throw Error ( "Vertex::getContact(): problem with Edges configuration *2." );
}
if ( createContact ) {
Contact* contact = Contact::create ( _routingGraph->getWorkingNet()
//, getLayer(1)
, DataBase::getDB()->getTechnology()->getLayer("metal2")
, _position.getX()
, _position.getY()
, _halfWidth/5
, _halfHeight/5
);
// on a besoin de tester si par routage précédent il n'y a pas un segment du net qui traverse le vertex ....
Segment* segment0 = NULL;
Segment* segment1 = NULL;
Segment* segment2 = NULL;
Segment* segment3 = NULL;
if ( _firstEdges[0] )
segment0 = _firstEdges[0]->getSegmentFor ( _routingGraph->getWorkingNet() );
if ( _firstEdges[1] )
segment1 = _firstEdges[1]->getSegmentFor ( _routingGraph->getWorkingNet() );
if ( _firstEdges[2] )
segment2 = _firstEdges[2]->getSegmentFor ( _routingGraph->getWorkingNet() );
if ( _firstEdges[3] )
segment3 = _firstEdges[3]->getSegmentFor ( _routingGraph->getWorkingNet() );
if ( (segment0 != NULL) && (segment0 == segment2) ) {
if ( !dynamic_cast<Contact*>(segment0->getSource()) ) throw Error ("Vertex::getContact(): does not consider Segment not based on Contact (source).");
if ( !dynamic_cast<Contact*>(segment0->getTarget()) ) throw Error ("Vertex::getContact(): does not consider Segment not based on Contact (target).");
Contact* targetContact = static_cast<Contact*>(segment0->getTarget());
_routingGraph->removeSegment(segment0);
segment0->getTargetHook()->detach();
segment0->getTargetHook()->attach(contact->getBodyHook());
_routingGraph->insertSegment(segment0);
Segment* newSeg = _routingGraph->createSegment(contact, targetContact);
_routingGraph->insertSegment(newSeg);
}
if ( (segment1 != NULL) && (segment1 == segment3) ) {
if ( !dynamic_cast<Contact*>(segment1->getSource()) ) throw Error ("Vertex::getContact(): does not consider Segment not based on Contact (Source).");
if ( !dynamic_cast<Contact*>(segment1->getTarget()) ) throw Error ("Vertex::getContact(): does not consider Segment not based on Contact (Target).");
Contact* targetContact = static_cast<Contact*>(segment1->getTarget());
_routingGraph->removeSegment(segment1);
segment1->getTargetHook()->detach();
segment1->getTargetHook()->attach(contact->getBodyHook());
_routingGraph->insertSegment(segment1);
Segment* newSeg = _routingGraph->createSegment(contact, targetContact);
_routingGraph->insertSegment(newSeg);
}
return contact;
}
if ( straightOn )
return NULL;
}
throw Error ( "Vertex::getContact(): what are you doing here O_o?" );
}
Edge* Vertex::getHEdgeLeadingTo ( Vertex* to )
// *******************************************
{
Edge* edge = getHEdgeOut();
while ( edge ) {
if ( edge->getTo() == to )
break;
edge = edge->getNextFrom();
}
return edge;
}
Edge* Vertex::getVEdgeLeadingTo ( Vertex* to )
// *******************************************
{
Edge* edge = getVEdgeOut();
while ( edge ) {
if ( edge->getTo() == to )
break;
edge = edge->getNextFrom();
}
return edge;
}
Edge* Vertex::getHEdgeComingFrom ( Vertex* from )
// **********************************************
{
Edge* edge = getHEdgeIn();
while ( edge ) {
if ( edge->getFrom() == from )
break;
edge = edge->getNextTo();
}
return edge;
}
Edge* Vertex::getVEdgeComingFrom ( Vertex* from )
// **********************************************
{
Edge* edge = getVEdgeIn();
while ( edge ) {
if ( edge->getFrom() == from )
break;
edge = edge->getNextTo();
}
return edge;
}
Edge* Vertex::getBestHEdgeOut ( DbU::Unit yDest )
// *****************************************
{
Edge* bestEdge = getHEdgeOut();
Edge* currentEdge = bestEdge;
while ( (currentEdge = currentEdge->getNextFrom()) ) {
if ( abs(currentEdge->getTo()->getY() - yDest) < abs(bestEdge->getTo()->getY() - yDest) )
bestEdge = currentEdge;
}
return bestEdge;
}
Edge* Vertex::getBestVEdgeOut ( DbU::Unit xDest )
// *****************************************
{
Edge* bestEdge = getVEdgeOut();
Edge* currentEdge = bestEdge;
while ( (currentEdge = currentEdge->getNextFrom()) ) {
if ( abs(currentEdge->getTo()->getX() - xDest) < abs(bestEdge->getTo()->getX() - xDest) )
bestEdge = currentEdge;
}
return bestEdge;
}
Edge* Vertex::getBestHEdgeIn ( DbU::Unit yDest )
// ****************************************
{
Edge* bestEdge = getHEdgeIn();
Edge* currentEdge = bestEdge;
while ( (currentEdge = currentEdge->getNextTo()) ) {
if ( abs(currentEdge->getFrom()->getY() - yDest) < abs(bestEdge->getFrom()->getY() - yDest) )
bestEdge = currentEdge;
}
return bestEdge;
}
Edge* Vertex::getBestVEdgeIn ( DbU::Unit xDest )
// ****************************************
{
Edge* bestEdge = getVEdgeIn();
Edge* currentEdge = bestEdge;
while ( (currentEdge = currentEdge->getNextTo()) ) {
if ( abs(currentEdge->getFrom()->getX() - xDest) < abs(bestEdge->getFrom()->getX() - xDest) )
bestEdge = currentEdge;
}
return bestEdge;
}
bool Vertex::hasInfo() const
// *************************
{
return (_netStamp == _routingGraph->getNetStamp());
}
void Vertex::translate ( const DbU::Unit& dx, const DbU::Unit& dy )
// ****************************************************************
{
_position.translate ( dx, dy );
}
Cell* Vertex::getCell() const
// **************************
{
return _routingGraph->getCell();
}
// void Vertex::_Draw ( View* view, BasicLayer* basicLayer, const Box& updateArea, const Transformation& transformation )
// // *******************************************************************************************************************
// {
// DbU::Unit size = DbU::lambda(5);
// view->FillCircle ( transformation.getPoint ( getPosition() ), size );
Support for Windows/Cygwin, part 2. * Change: In bootstrap, in ccb, builder and coriolisEnv.py, correct detection of the windows architecture (32 or 64 bits). Under Cygwin, add the directory of the dll into the PATH also. Uses "site-package" as the location of Python modules (*not* "dist-package"). Use gnu++0x under Cygwin instead of c++11. * Change: In Etesian, if Coloquinte is not found, do not stop the compilation, just disable the tool altogether. * Change: In Hurricane, In Backtrace, disable backtrace under Cygwin as it uses features specific of the glibc. * Change: In Knik, use HUGE_VAL instead of HUGE (not present under Cygwin), add the <cmath> header. * Change: In Unicorn, Coloquinte no longer stops the compilation.
2014-07-22 17:55:50 -05:00
// //if ( _distance < (float)(HUGE_VAL) )
// if ( _netStamp == _routingGraph->getNetStamp() && _distance < (float)(HUGE_VAL) )
* ./hurricane/src/hviewer, ./coriolis/src/crlcore, ./coriolis/src/knik, ./coriolis/src/katabatic, ./coriolis/src/kite, ./coriolis/src/equinox, ./coriolis/src/solstice, ./coriolis/src/ispd: - SVN MOVE: Source tree simplification & uniformisation. Now all tools are at the same level, directly under the root of the repository. No more "coriolis/src".
2010-03-09 09:23:58 -06:00
// view->DrawString ( getString(_distance), getXMax() - (_halfWidth), getYMax() - (_halfHeight/2) );
// if ( _connexID != -1 )
// view->DrawString ( getString(_connexID)+","+getString(_netStamp), getXMax() - (_halfWidth), getYMin() + (_halfHeight/2) );
// //if ( _predecessor ) {
// // Vertex* oppositeVertex = _predecessor->getOpposite ( this );
// // Point position = transformation.getPoint ( _position );
// // Point oppPos = transformation.getPoint ( oppositeVertex->getPosition() );
// // DbU::Unit origX = position.getX();
// // DbU::Unit origY = position.getY();
// // DbU::Unit destX = position.getX() + (4*(oppPos.getX() - position.getX()))/5;
// // DbU::Unit destY = position.getY() + (4*(oppPos.getY() - position.getY()))/5;
// // view->DrawLine ( origX, origY, destX, destY );
// //}
// }
// void Vertex::_Highlight ( View* view, const Box& updateArea, const Transformation& transformation )
// // ************************************************************************************************
// {
// DbU::Unit size = DbU::lambda(5);
// view->FillCircle ( transformation.getPoint ( getPosition() ), size );
// }
// bool Vertex::_IsInterceptedBy ( View* view, const Point& point, const DbU::Unit& aperture ) const
// // *****************************************************************************************
// {
// Box area ( point );
// area.inflate(aperture);
// return getBoundingBox().intersect ( area );
// // return false;
// }
void Vertex::invalidate ( bool propagateFlag )
// *******************************************
{
Inherit::invalidate ( false );
// Invalider toutes les Edges associées ?
}
string Vertex::_getString() const
// ******************************
{
return "<" + _TName ( "Vertex" )
Improved UpdateSession & exception catching. Start of RoutingGauge implem. Miscellaneous: * Change: In <crlcore>, in display.conf use the same display threshold for both METAL2 & METAL3. In alliance.conf, the side of VIAs in the gauge is 2l (not 3l). In kite.conf, separate edge densities for H/V. * Change: In <Cell>, in flattenNets() use flag as argument, not a boolean. Do not create rings for clock or supply nets. * Change: In <DeepNet>, in _createRoutingPads() do not create rings for clock or supply net (duplicated policy as in Cell::flattenNets()). * Bug: In <ControllerWidget>, at last find the bad signal disconnect that was causing ungraceful messages. * Change: In <knik>, in Edge display occupancy/capacity in the string name. Improved display progress and debugging capabilities. Improved exception catch & breakpoint managment: * Bug: In <PaletteWidget>, in updateExtensions() replace the calls to deleteLayer() by delete. This cause the widget to be immediatly erased instead of waiting for the event queue to be completly processed. This was causing the widget to be left in a incoherent state when stoping at a breakpoint. * Bug: In <BreakpointWidget>, in execNoModal(), flush the main event loop (QApplication::flush()) *before* lauching the *local* event loop. This is to ensure all widgets are in their final state when waiting (especially <PaletteWidget>). * Change: In <ExceptionWidget>, new method catchAllWrapper() to execute any std::function< void() > function/method with a "try"/ "catch" wraparound and lauch the widget in case something is catch. * New: In <hurricane>, support for a oberver pattern, backported from <katabatic> with an Obervable capable of being linked to any number of Obervers. * New: In <Cell>, made it observable to detect Cell change, currently emit two kind of signals: - Cell::CellAboutToChange : *before* any change. - Cell::CellChanged : *after* the change has been completed. * New: In <UpdateSession>, in Go::invalidate() add the Cell owning the Go to the UPDATOR_STACK (of course the cell is added only once). In addition, when the Cell is added, send a notification of Cell::CellAboutToChange to all it's observers. The slave instances are also invalidated. Conversely in UpdateSession::_preDestroy() for each invalidated Cell send a Cell::CellChanged notification to all observer. The UPDATOR_STACK has been slightly amended to accept Cell which are not Gos. Prior to this, the Cell where completly excluded from the UpdateSession mechanism, so it's instances where never actualised of anything referring to the Cell for that matter. Note: we use two different mechanisms to transmit a Cell change, observers and the slave instance map. I think at some point it should be unificated. * Change: In <CellViewer>, make it a Cell observer to redraw when the cell is modificated (also update the palette). Uses the catchAllWrapper() to protect all critical actions. * Change: In <GraphicTool>, no longer need of cellPreModificated and cellPostModificated signals. Now done through the Cell obersvers. * Change: In <mauka>, <etesian> & <kite> now uses the catchAllWrapper method for protection (need to split methods in two, to be able to pass it as argument). No longer emit cellPreModificated and cellPostModificated. Support for RoutingGauge in P&R: * Bug: In <placeandroute.py>, the connection from the internal power ring to the connectors was not done correctly. Wrong contact layers leading to a gap. * Change: In <BuildPowerRails>, detection of the corona signals based on how the "pck_px" pad is connected. No longer based on name matching. * Change: In <placeandroute.py>, support for 2 routing metal only (3 metal in the technology). * Change: In <katabatic> & <kite> support for a "top layer" limitation on the routing gauge, this allows to use only two routing metals (METAL2 & METAL3). Work in progress.
2014-04-20 12:25:08 -05:00
+ " id:" + getString ( _connexID )
+ " s:" + getString ( _netStamp )
+ " " + getString ( DbU::getValueString(_position.getX()) )
+ " " + getString ( DbU::getValueString(_position.getY()) ) + ">";
* ./hurricane/src/hviewer, ./coriolis/src/crlcore, ./coriolis/src/knik, ./coriolis/src/katabatic, ./coriolis/src/kite, ./coriolis/src/equinox, ./coriolis/src/solstice, ./coriolis/src/ispd: - SVN MOVE: Source tree simplification & uniformisation. Now all tools are at the same level, directly under the root of the repository. No more "coriolis/src".
2010-03-09 09:23:58 -06:00
}
Record* Vertex::_getRecord() const
// *************************
{
Record* record = Inherit::_getRecord();
if ( !record )
record = new Record ( getString ( this ) );
record->add ( getSlot ( "hEdgeOut", getHEdgeOut() ) );
record->add ( getSlot ( "vEdgeOut", getVEdgeOut() ) );
record->add ( getSlot ( "hEdgeIn", getHEdgeIn() ) );
record->add ( getSlot ( "vEdgeIn", getVEdgeIn() ) );
record->add ( getSlot ( "predecessor", _predecessor ) );
//if ( _localRingHook) record->add ( getSlot ( "localRingHook", _localRingHook ) );
record->add ( getSlot ( "contact", _contact ) );
record->add ( getSlot ( "connexID", _connexID ) );
record->add ( getSlot ( "position", _position ) );
record->add ( getSlot ( "distance", _distance ) );
record->add ( getSlot ( "netStamp", _netStamp ) );
record->add ( getSlot ( "halfWidth", _halfWidth ) );
record->add ( getSlot ( "halfHeight", _halfHeight ) );
return record;
}
// ************************************************************************************************
// VERTEX_Edges implementation
// ************************************************************************************************
VERTEX_Edges::VERTEX_Edges ( const Vertex* vertex )
// ************************************************
: Inherit()
, _vertex(vertex)
, _edge(NULL)
, _direction(0)
{
// _direction represents one of the four direction in the routing graph. these ditections are set as follow :
// 0 = East
// 1 = North
// 2 = West
// 3 = South
for ( _direction = 0 ; _direction < 4 ; _direction++ ) {
if ( (_edge = _vertex->getFirstEdges(_direction)) )
return;
}
}
VERTEX_Edges::VERTEX_Edges ( const VERTEX_Edges& edges )
// *****************************************************
: Inherit()
, _vertex(edges._vertex)
, _edge(edges._edge)
, _direction(edges._direction)
{
}
VERTEX_Edges& VERTEX_Edges::operator=(const VERTEX_Edges& edges)
// *************************************************************
{
_vertex = edges._vertex;
_edge = edges._edge;
_direction = edges._direction;
return *this;
}
Collection<Edge*>* VERTEX_Edges::getClone() const
// **********************************************
{
return new VERTEX_Edges(*this);
}
Locator<Edge*>* VERTEX_Edges::getLocator() const
// *********************************************
{
return new Locator(_vertex, _edge, _direction);
}
string VERTEX_Edges::_getString() const
// ************************************
{
string s = "<" + _TName("Vertex::Edges");
if (_vertex) s += " " + getString(_vertex);
s += ">";
return s;
}
// ************************************************************************************************
// VERTEX_Edges::Locator implementation
// ************************************************************************************************
VERTEX_Edges::Locator::Locator(const Vertex* vertex, Edge* edge, int direction)
// ****************************************************************************
: Inherit()
, _vertex(vertex)
, _edge(edge)
, _direction(direction)
{
}
VERTEX_Edges::Locator::Locator(const Locator& locator)
// ***************************************************
: Inherit()
, _vertex(locator._vertex)
, _edge(locator._edge)
, _direction(locator._direction)
{
}
VERTEX_Edges::Locator& VERTEX_Edges::Locator::operator=(const Locator& locator)
// ****************************************************************************
{
_vertex = locator._vertex;
_edge = locator._edge;
_direction = locator._direction;
return *this;
}
Edge* VERTEX_Edges::Locator::getElement() const
// ********************************************
{
return _edge;
}
Locator<Edge*>* VERTEX_Edges::Locator::getClone() const
// ****************************************************
{
return new Locator(*this);
}
bool VERTEX_Edges::Locator::isValid() const
// ****************************************
{
return (_edge != NULL );
}
void VERTEX_Edges::Locator::progress()
// ***********************************
{
if ( !_edge )
return;
if ( _direction == 0 || _direction == 1 )
_edge = _edge->getNextFrom();
else
_edge = _edge->getNextTo();
while ( !_edge ) {
if ( _direction == 3 )
return;
_direction++;
_edge = _vertex->getFirstEdges(_direction);
}
}
string VERTEX_Edges::Locator::_getString() const
// *********************************************
{
string s = "<" + _TName("Vertex::Edges::Locator");
if (_vertex) s += " " + getString(_vertex);
s += ">";
return s;
}
} // namespace Knik