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

Complete reorganization of where the routing stage is stored in Katana. 

* In KatanaEngine:
    - Former situation:
        Each RoutingEvent did store the routing stage it was in. And it
        was misnamed "mode".
    - New organization:
        The routing stage is stored in KatanaEngine itself. It can be
	accessed through a proxy in Session.
* Change: In DataNegociate::update(), when in Realign stage and computing
    non-preferred perpnadicular routing *do not* expand of one pitch
    outside the RoutingPad range.
This commit is contained in:
Jean-Paul Chaput 2021-04-21 13:51:08 +02:00
parent 493ed1ea11
commit a05bd81bab
14 changed files with 53 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
katana/src/DataNegociate.cpp
View File

@ -131,7 +131,7 @@ namespace Katana {
continue; continue;
} }
if (RoutingEvent::getStage() == RoutingEvent::Repair) if (RoutingEvent::getStage() == StageRepair)
perpandicular->base()->setFlagsOnAligneds( AutoSegment::SegUnbound ); perpandicular->base()->setFlagsOnAligneds( AutoSegment::SegUnbound );
//cerr << "perpandicular:" << perpandicular << endl; //cerr << "perpandicular:" << perpandicular << endl;
@ -169,7 +169,8 @@ namespace Katana {
if (not source->canDrag() and not target->canDrag()) if (not source->canDrag() and not target->canDrag())
perpandicular->base()->getCanonical( trackFree ); perpandicular->base()->getCanonical( trackFree );
trackFree.inflate( 1*pitch, 1*pitch ); if (Session::getStage() < StagePack)
trackFree.inflate( 1*pitch, 1*pitch );
cdebug_log(159,0) << "Non-Pref Track Perpandicular Free: " << trackFree << endl; cdebug_log(159,0) << "Non-Pref Track Perpandicular Free: " << trackFree << endl;
//_perpandicularFree.intersection //_perpandicularFree.intersection

1
katana/src/KatanaEngine.cpp
View File

@ -196,6 +196,7 @@ namespace Katana {
, _shortDoglegs () , _shortDoglegs ()
, _symmetrics () , _symmetrics ()
, _mode (DigitalMode) , _mode (DigitalMode)
, _stage (StageNegociate)
, _successState (0) , _successState (0)
{ {
//Entity::setMemoryLimit( 1024 ); // 1Gb. //Entity::setMemoryLimit( 1024 ); // 1Gb.

2
katana/src/Manipulator.cpp
View File

@ -1671,7 +1671,7 @@ namespace Katana {
if (not data) continue; if (not data) continue;
if (data->getState() >= DataNegociate::RepairFailed) continue; if (data->getState() >= DataNegociate::RepairFailed) continue;
if (RoutingEvent::getStage() == RoutingEvent::Repair) { if (RoutingEvent::getStage() == StageRepair) {
if (_segment->getDataNegociate()->getState() < DataNegociate::Repair) if (_segment->getDataNegociate()->getState() < DataNegociate::Repair)
_segment->getDataNegociate()->resetRipupCount(); _segment->getDataNegociate()->resetRipupCount();

11
katana/src/NegociateWindow.cpp
View File

@ -510,8 +510,7 @@ namespace Katana {
void NegociateWindow::_pack ( size_t& count, bool last ) void NegociateWindow::_pack ( size_t& count, bool last )
{ {
uint64_t limit = _katana->getEventsLimit(); uint64_t limit = _katana->getEventsLimit();
uint32_t pushStage = RoutingEvent::getStage(); _katana->setStage( StagePack );
RoutingEvent::setStage( RoutingEvent::Pack );
RoutingEventQueue packQueue; RoutingEventQueue packQueue;
//for ( size_t i = (count > 600) ? count-600 : 0 //for ( size_t i = (count > 600) ? count-600 : 0
@ -554,8 +553,6 @@ namespace Katana {
if (RoutingEvent::getProcesseds() >= limit) setInterrupt( true ); if (RoutingEvent::getProcesseds() >= limit) setInterrupt( true );
} }
// Count will be wrong! // Count will be wrong!
RoutingEvent::setStage( pushStage );
} }
@ -578,7 +575,7 @@ namespace Katana {
if (cdebug.enabled(9000)) _eventQueue.dump(); if (cdebug.enabled(9000)) _eventQueue.dump();
size_t count = 0; size_t count = 0;
RoutingEvent::setStage( RoutingEvent::Negociate ); _katana->setStage( StageNegociate );
while ( not _eventQueue.empty() and not isInterrupted() ) { while ( not _eventQueue.empty() and not isInterrupted() ) {
RoutingEvent* event = _eventQueue.pop(); RoutingEvent* event = _eventQueue.pop();
@ -642,7 +639,7 @@ namespace Katana {
cmess1 << " o Repair Stage." << endl; cmess1 << " o Repair Stage." << endl;
cdebug_log(159,0) << "Loadind Repair queue." << endl; cdebug_log(159,0) << "Loadind Repair queue." << endl;
RoutingEvent::setStage( RoutingEvent::Repair ); _katana->setStage( StageRepair );
for ( size_t i=0 ; (i<_eventHistory.size()) and not isInterrupted() ; i++ ) { for ( size_t i=0 ; (i<_eventHistory.size()) and not isInterrupted() ; i++ ) {
RoutingEvent* event = _eventHistory.getNth(i); RoutingEvent* event = _eventHistory.getNth(i);
@ -685,7 +682,7 @@ namespace Katana {
cmess1 << " o Realign Stage." << endl; cmess1 << " o Realign Stage." << endl;
cdebug_log(159,0) << "Loadind realign queue." << endl; cdebug_log(159,0) << "Loadind realign queue." << endl;
RoutingEvent::setStage( RoutingEvent::Realign ); _katana->setStage( StageRealign );
for ( size_t i=0 ; (i<_eventHistory.size()) and not isInterrupted() ; i++ ) { for ( size_t i=0 ; (i<_eventHistory.size()) and not isInterrupted() ; i++ ) {
RoutingEvent* event = _eventHistory.getNth(i); RoutingEvent* event = _eventHistory.getNth(i);
if (not event->isCloned() and event->getSegment()->canRealign()) if (not event->isCloned() and event->getSegment()->canRealign())

42
katana/src/RoutingEvent.cpp
View File

@ -173,21 +173,19 @@ namespace Katana {
uint32_t RoutingEvent::_idCounter = 0; uint32_t RoutingEvent::_idCounter = 0;
uint32_t RoutingEvent::_stage = RoutingEvent::Negociate;
uint32_t RoutingEvent::_allocateds = 0; uint32_t RoutingEvent::_allocateds = 0;
uint32_t RoutingEvent::_processeds = 0; uint32_t RoutingEvent::_processeds = 0;
uint32_t RoutingEvent::_cloneds = 0; uint32_t RoutingEvent::_cloneds = 0;
uint32_t RoutingEvent::getStage () { return _stage; } uint32_t RoutingEvent::getStage () { return Session::getStage(); }
uint32_t RoutingEvent::getAllocateds () { return _allocateds; } uint32_t RoutingEvent::getAllocateds () { return _allocateds; }
uint32_t RoutingEvent::getProcesseds () { return _processeds; } uint32_t RoutingEvent::getProcesseds () { return _processeds; }
uint32_t RoutingEvent::getCloneds () { return _cloneds; } uint32_t RoutingEvent::getCloneds () { return _cloneds; }
void RoutingEvent::setStage ( uint32_t stage ) { _stage = stage; }
void RoutingEvent::resetProcesseds () { _processeds = 0; } void RoutingEvent::resetProcesseds () { _processeds = 0; }
RoutingEvent::RoutingEvent ( TrackElement* segment, uint32_t mode ) RoutingEvent::RoutingEvent ( TrackElement* segment )
: _cloned (false) : _cloned (false)
, _processed (false) , _processed (false)
, _disabled (false) , _disabled (false)
@ -205,7 +203,6 @@ namespace Katana {
, _tracksNb (0) , _tracksNb (0)
, _tracksFree (0) , _tracksFree (0)
, _insertState (0) , _insertState (0)
, _mode (mode)
, _rippleState (0) , _rippleState (0)
, _eventLevel (0) , _eventLevel (0)
, _key (this) , _key (this)
@ -229,7 +226,7 @@ namespace Katana {
} }
RoutingEvent* RoutingEvent::create ( TrackElement* segment, uint32_t mode ) RoutingEvent* RoutingEvent::create ( TrackElement* segment )
{ {
// if (not dynamic_cast<TrackSegment*>(segment)) { // if (not dynamic_cast<TrackSegment*>(segment)) {
// cerr << Error( "RoutingEvent::create() Can only create event from TrackSegment:\n" // cerr << Error( "RoutingEvent::create() Can only create event from TrackSegment:\n"
@ -237,7 +234,7 @@ namespace Katana {
// ) << endl; // ) << endl;
// } // }
RoutingEvent* event = new RoutingEvent ( segment, mode ); RoutingEvent* event = new RoutingEvent ( segment );
++_allocateds; ++_allocateds;
return event; return event;
@ -286,10 +283,6 @@ namespace Katana {
{ return getState() == DataNegociate::Unimplemented; } { return getState() == DataNegociate::Unimplemented; }
void RoutingEvent::setMode ( uint32_t mode )
{ _mode = mode; }
uint32_t RoutingEvent::getState () const uint32_t RoutingEvent::getState () const
{ {
DataNegociate* data = _segment->getDataNegociate(); DataNegociate* data = _segment->getDataNegociate();
@ -313,7 +306,7 @@ namespace Katana {
void RoutingEvent::setAxisHintFromParent () void RoutingEvent::setAxisHintFromParent ()
{ {
if (getStage() == Repair) return; if (Session::getStage() == StageRepair) return;
TrackElement* parent = _segment->getParent(); TrackElement* parent = _segment->getParent();
if (not parent) return; if (not parent) return;
@ -348,7 +341,7 @@ namespace Katana {
return NULL; return NULL;
} }
if ( (getStage() != Repair) and isUnimplemented() ) { if ( (Session::getStage() != StageRepair) and isUnimplemented() ) {
cdebug_log(159,0) << "Reschedule: cancelled (Unimplemented) -> " << fork << endl; cdebug_log(159,0) << "Reschedule: cancelled (Unimplemented) -> " << fork << endl;
return NULL; return NULL;
} }
@ -370,15 +363,10 @@ namespace Katana {
if (fork->_eventLevel < eventLevel) if (fork->_eventLevel < eventLevel)
fork->_eventLevel = eventLevel; fork->_eventLevel = eventLevel;
if (getStage() == Repair) { if (Session::getStage() == StageRepair) {
fork->setMode( RoutingEvent::Repair );
if (_segment->getDataNegociate()->getState() < DataNegociate::Repair) if (_segment->getDataNegociate()->getState() < DataNegociate::Repair)
_segment->getDataNegociate()->resetRipupCount(); _segment->getDataNegociate()->resetRipupCount();
_segment->getDataNegociate()->setState( DataNegociate::Repair ); _segment->getDataNegociate()->setState( DataNegociate::Repair );
} else if (getStage() == RoutingEvent::Pack) {
fork->setMode( RoutingEvent::Pack );
} else if (getStage() == RoutingEvent::Realign) {
fork->setMode( RoutingEvent::Realign );
} }
queue.repush( fork ); queue.repush( fork );
@ -457,7 +445,7 @@ namespace Katana {
//_preCheck( _segment ); //_preCheck( _segment );
_eventLevel = 0; _eventLevel = 0;
if (_mode != Pack) history.push( this ); if (Session::getStage() != StagePack) history.push( this );
if ( isProcessed() or isDisabled() ) { if ( isProcessed() or isDisabled() ) {
cdebug_log(159,0) << "Already processed or disabled." << endl; cdebug_log(159,0) << "Already processed or disabled." << endl;
@ -468,13 +456,13 @@ namespace Katana {
setProcessed(); setProcessed();
setTimeStamp( _processeds ); setTimeStamp( _processeds );
switch ( _mode ) { switch ( Session::getStage() ) {
case Negociate: _processNegociate( queue, history ); break; case StageNegociate: _processNegociate( queue, history ); break;
case Pack: _processPack ( queue, history ); break; case StagePack: _processPack ( queue, history ); break;
case Repair: _processRepair ( queue, history ); break; case StageRepair: _processRepair ( queue, history ); break;
case Realign: _processRealign ( queue, history ); break; case StageRealign: _processRealign ( queue, history ); break;
default: default:
cerr << Bug( "RoutingEvent::process() - Unknown mode value:%d.", _mode ) << endl; cerr << Bug( "RoutingEvent::process() - Unknown stage value:%d.", Session::getStage() ) << endl;
break; break;
} }
} }
@ -707,7 +695,7 @@ namespace Katana {
_segment->base()->getOptimal ( _optimal ); _segment->base()->getOptimal ( _optimal );
cdebug_log(159,0) << "Stage:" << RoutingEvent::getStage() << endl; cdebug_log(159,0) << "Stage:" << RoutingEvent::getStage() << endl;
if (RoutingEvent::getStage() == RoutingEvent::Repair) { if (Session::getStage() == StageRepair) {
if (_segment->isStrongTerminal(Flags::Propagate)) { if (_segment->isStrongTerminal(Flags::Propagate)) {
cdebug_log(159,0) << "Not expanding on Terminals:" << _constraints << endl; cdebug_log(159,0) << "Not expanding on Terminals:" << _constraints << endl;
} else if ( _segment->base()->getAutoSource()->isFixed() } else if ( _segment->base()->getAutoSource()->isFixed()

2
katana/src/RoutingEventQueue.cpp
View File

@ -66,7 +66,7 @@ namespace Katana {
cinfo << "[INFO] Already in Track - " << segments[i] << endl; cinfo << "[INFO] Already in Track - " << segments[i] << endl;
continue; continue;
} }
RoutingEvent* event = RoutingEvent::create(segments[i]); RoutingEvent* event = RoutingEvent::create( segments[i] );
event->updateKey(); event->updateKey();
_events.insert( event ); _events.insert( event );
} }

11
katana/src/SegmentFsm.cpp
View File

@ -434,13 +434,6 @@ namespace Katana {
RoutingEvent* fork = event->reschedule( queue, eventLevel ); RoutingEvent* fork = event->reschedule( queue, eventLevel );
if (fork) {
uint32_t mode = RoutingEvent::Repair;
if (RoutingEvent::getStage() < RoutingEvent::Repair)
mode = (_type&PackingMode) ? RoutingEvent::Pack : RoutingEvent::Negociate;
fork->setMode( mode );
}
cdebug_tabw(159,-1); cdebug_tabw(159,-1);
DebugSession::close(); DebugSession::close();
return true; return true;
@ -636,8 +629,8 @@ namespace Katana {
and (_data1->getState() < DataNegociate::Minimize) and (_data1->getState() < DataNegociate::Minimize)
and (_data1->getRipupCount() < 5)) and (_data1->getRipupCount() < 5))
? TrackCost::DiscardGlobals : 0; ? TrackCost::DiscardGlobals : 0;
flags |= (RoutingEvent::getStage() == RoutingEvent::Repair ) ? TrackCost::IgnoreSharedLength : 0; flags |= (Session::getStage() == StageRepair ) ? TrackCost::IgnoreSharedLength : 0;
flags |= (RoutingEvent::getStage() == RoutingEvent::Realign) ? TrackCost::IgnoreTerminals : 0; flags |= (Session::getStage() == StageRealign) ? TrackCost::IgnoreTerminals : 0;
if (flags & TrackCost::DiscardGlobals) { if (flags & TrackCost::DiscardGlobals) {
cdebug_log(159,0) << "TrackCost::Compare() - DiscardGlobals" << endl; cdebug_log(159,0) << "TrackCost::Compare() - DiscardGlobals" << endl;

8
katana/src/Session.cpp
View File

@ -146,6 +146,10 @@ namespace Katana {
{ return Session::getKatanaEngine()->getConfiguration(); } { return Session::getKatanaEngine()->getConfiguration(); }
uint32_t Session::getStage ()
{ return get("getStage()")->_getKatanaEngine()->getStage(); }
AutoContact* Session::lookup ( Contact* contact ) AutoContact* Session::lookup ( Contact* contact )
{ return Super::lookup(contact); } { return Super::lookup(contact); }
@ -476,6 +480,10 @@ namespace Katana {
} }
void Session::setStage ( uint32_t stage )
{ get("setStage()")->_getKatanaEngine()->setStage(stage); }
string Session::_getTypeName () const string Session::_getTypeName () const
{ return "Katana::Session"; } { return "Katana::Session"; }

6
katana/src/katana/Constants.h
View File

@ -20,6 +20,12 @@
namespace Katana { namespace Katana {
static const uint32_t StageNegociate = 1;
static const uint32_t StagePack = 2;
static const uint32_t StageRepair = 3;
static const uint32_t StageRealign = 4;
class Flags : public Anabatic::Flags { class Flags : public Anabatic::Flags {
public: public:
typedef Anabatic::Flags Super; typedef Anabatic::Flags Super;

6
katana/src/katana/DataNegociate.h
View File

@ -14,9 +14,7 @@
// +-----------------------------------------------------------------+ // +-----------------------------------------------------------------+
#ifndef KATANA_DATA_NEGOCIATE_H #pragma once
#define KATANA_DATA_NEGOCIATE_H
#include <string> #include <string>
#include <iostream> #include <iostream>
@ -169,5 +167,3 @@ namespace Katana {
INSPECTOR_P_SUPPORT(Katana::DataNegociate); INSPECTOR_P_SUPPORT(Katana::DataNegociate);
#endif // KATANA_DATA_NEGOCIATE_H

5
katana/src/katana/KatanaEngine.h
View File

@ -84,6 +84,7 @@ namespace Katana {
inline Configuration* getKatanaConfiguration (); inline Configuration* getKatanaConfiguration ();
virtual Configuration* getConfiguration (); virtual Configuration* getConfiguration ();
inline uint32_t getSuccessState () const; inline uint32_t getSuccessState () const;
inline uint32_t getStage () const;
inline uint64_t getEventsLimit () const; inline uint64_t getEventsLimit () const;
inline uint32_t getRipupLimit ( uint32_t type ) const; inline uint32_t getRipupLimit ( uint32_t type ) const;
uint32_t getRipupLimit ( const TrackElement* ) const; uint32_t getRipupLimit ( const TrackElement* ) const;
@ -113,6 +114,7 @@ namespace Katana {
inline void setGlobalRoutingSuccess ( bool ) const; inline void setGlobalRoutingSuccess ( bool ) const;
inline void setDetailedRoutingSuccess ( bool ) const; inline void setDetailedRoutingSuccess ( bool ) const;
virtual void openSession (); virtual void openSession ();
inline void setStage ( uint32_t );
inline void setViewer ( CellViewer* ); inline void setViewer ( CellViewer* );
inline void setPostEventCb ( Configuration::PostEventCb_t ); inline void setPostEventCb ( Configuration::PostEventCb_t );
inline void setEventLimit ( uint64_t ); inline void setEventLimit ( uint64_t );
@ -170,6 +172,7 @@ namespace Katana {
TrackElementPairing _shortDoglegs; TrackElementPairing _shortDoglegs;
DataSymmetricMap _symmetrics; DataSymmetricMap _symmetrics;
uint32_t _mode; uint32_t _mode;
uint32_t _stage;
mutable uint32_t _successState; mutable uint32_t _successState;
protected: protected:
// Constructors & Destructors. // Constructors & Destructors.
@ -196,6 +199,7 @@ namespace Katana {
inline CellViewer* KatanaEngine::getViewer () const { return _viewer; } inline CellViewer* KatanaEngine::getViewer () const { return _viewer; }
inline AnabaticEngine* KatanaEngine::base () { return static_cast<AnabaticEngine*>(this); } inline AnabaticEngine* KatanaEngine::base () { return static_cast<AnabaticEngine*>(this); }
inline Configuration* KatanaEngine::getKatanaConfiguration () { return _configuration; } inline Configuration* KatanaEngine::getKatanaConfiguration () { return _configuration; }
inline uint32_t KatanaEngine::getStage () const { return _stage; }
inline Configuration::PostEventCb_t& KatanaEngine::getPostEventCb () { return _configuration->getPostEventCb(); } inline Configuration::PostEventCb_t& KatanaEngine::getPostEventCb () { return _configuration->getPostEventCb(); }
inline uint32_t KatanaEngine::getSuccessState () const { return _successState; } inline uint32_t KatanaEngine::getSuccessState () const { return _successState; }
inline uint64_t KatanaEngine::getEventsLimit () const { return _configuration->getEventsLimit(); } inline uint64_t KatanaEngine::getEventsLimit () const { return _configuration->getEventsLimit(); }
@ -213,6 +217,7 @@ namespace Katana {
inline NegociateWindow* KatanaEngine::getNegociateWindow () { return _negociateWindow; } inline NegociateWindow* KatanaEngine::getNegociateWindow () { return _negociateWindow; }
inline size_t KatanaEngine::getRoutingPlanesSize () const { return _routingPlanes.size(); } inline size_t KatanaEngine::getRoutingPlanesSize () const { return _routingPlanes.size(); }
inline void KatanaEngine::setViewer ( CellViewer* viewer ) { _viewer=viewer; } inline void KatanaEngine::setViewer ( CellViewer* viewer ) { _viewer=viewer; }
inline void KatanaEngine::setStage ( uint32_t stage ) { _stage=stage; }
inline void KatanaEngine::setEventLimit ( uint64_t limit ) { _configuration->setEventsLimit(limit); } inline void KatanaEngine::setEventLimit ( uint64_t limit ) { _configuration->setEventsLimit(limit); }
inline void KatanaEngine::setRipupLimit ( uint32_t type, uint32_t limit ) { _configuration->setRipupLimit(limit,type); } inline void KatanaEngine::setRipupLimit ( uint32_t type, uint32_t limit ) { _configuration->setRipupLimit(limit,type); }
inline void KatanaEngine::setRipupCost ( uint32_t cost ) { _configuration->setRipupCost(cost); } inline void KatanaEngine::setRipupCost ( uint32_t cost ) { _configuration->setRipupCost(cost); }

14
katana/src/katana/NegociateWindow.h
View File

@ -14,9 +14,7 @@
// +-----------------------------------------------------------------+ // +-----------------------------------------------------------------+
#ifndef KATANA_NEGOCIATE_WINDOW_H #pragma once
#define KATANA_NEGOCIATE_WINDOW_H
#include <set> #include <set>
#include <queue> #include <queue>
#include <vector> #include <vector>
@ -89,11 +87,6 @@ namespace Katana {
// Class : "Katana::NegociateWindow". // Class : "Katana::NegociateWindow".
class NegociateWindow { class NegociateWindow {
public:
enum Stage { Negociation = 1
, Packing = 2
};
public: public:
static NegociateWindow* create ( KatanaEngine* ); static NegociateWindow* create ( KatanaEngine* );
void destroy (); void destroy ();
@ -104,10 +97,8 @@ namespace Katana {
inline RoutingEventQueue& getEventQueue (); inline RoutingEventQueue& getEventQueue ();
inline RoutingEventHistory& getEventHistory (); inline RoutingEventHistory& getEventHistory ();
inline RoutingEventLoop& getEventLoop (); inline RoutingEventLoop& getEventLoop ();
inline Stage getStage () const;
void setGCells ( const vector<GCell*>& ); void setGCells ( const vector<GCell*>& );
inline void setInterrupt ( bool ); inline void setInterrupt ( bool );
inline void setStage ( Stage );
double computeWirelength (); double computeWirelength ();
TrackElement* createTrackSegment ( AutoSegment*, Flags flags ); TrackElement* createTrackSegment ( AutoSegment*, Flags flags );
void addRoutingEvent ( TrackElement*, uint32_t level ); void addRoutingEvent ( TrackElement*, uint32_t level );
@ -157,6 +148,3 @@ namespace Katana {
} // Katana namespace. } // Katana namespace.
#endif // KATANA_NEGOCIATE_WINDOW_H

11
katana/src/katana/RoutingEvent.h
View File

@ -91,18 +91,14 @@ namespace Katana {
}; };
friend class Compare; friend class Compare;
public:
enum Mode { Negociate=1, Pack=2, Repair=3, Realign=4 };
public: public:
static uint32_t getStage (); static uint32_t getStage ();
static uint32_t getAllocateds (); static uint32_t getAllocateds ();
static uint32_t getProcesseds (); static uint32_t getProcesseds ();
static uint32_t getCloneds (); static uint32_t getCloneds ();
static void resetProcesseds (); static void resetProcesseds ();
static void setStage ( uint32_t );
public: public:
static RoutingEvent* create ( TrackElement*, uint32_t mode=Negociate ); static RoutingEvent* create ( TrackElement* );
RoutingEvent* clone () const; RoutingEvent* clone () const;
void destroy (); void destroy ();
inline bool isCloned () const; inline bool isCloned () const;
@ -142,7 +138,6 @@ namespace Katana {
); );
void setSegment ( TrackElement* ); void setSegment ( TrackElement* );
RoutingEvent* reschedule ( RoutingEventQueue&, uint32_t eventLevel ); RoutingEvent* reschedule ( RoutingEventQueue&, uint32_t eventLevel );
void setMode ( uint32_t );
void setState ( uint32_t ); void setState ( uint32_t );
inline void setTimeStamp ( uint32_t ); inline void setTimeStamp ( uint32_t );
inline void setProcessed ( bool state=true ); inline void setProcessed ( bool state=true );
@ -166,7 +161,7 @@ namespace Katana {
string _getString () const; string _getString () const;
string _getTypeName () const; string _getTypeName () const;
private: private:
RoutingEvent ( TrackElement*, uint32_t mode ); RoutingEvent ( TrackElement* );
~RoutingEvent (); ~RoutingEvent ();
protected: protected:
@ -195,7 +190,6 @@ namespace Katana {
unsigned int _tracksNb :16; unsigned int _tracksNb :16;
unsigned int _tracksFree :16; unsigned int _tracksFree :16;
unsigned int _insertState : 6; unsigned int _insertState : 6;
unsigned int _mode : 4;
unsigned int _rippleState : 4; unsigned int _rippleState : 4;
uint32_t _eventLevel; uint32_t _eventLevel;
//vector<TrackElement*> _perpandiculars; //vector<TrackElement*> _perpandiculars;
@ -212,7 +206,6 @@ namespace Katana {
inline bool RoutingEvent::isOverConstrained () const { return _overConstrained; } inline bool RoutingEvent::isOverConstrained () const { return _overConstrained; }
inline uint32_t RoutingEvent::getId () const { return _id; } inline uint32_t RoutingEvent::getId () const { return _id; }
inline uint32_t RoutingEvent::getTimeStamp () const { return _timeStamp; } inline uint32_t RoutingEvent::getTimeStamp () const { return _timeStamp; }
inline bool RoutingEvent::getMode () const { return _mode; }
inline bool RoutingEvent::canMinimize () const { return not _minimized; } inline bool RoutingEvent::canMinimize () const { return not _minimized; }
inline const RoutingEvent::Key& RoutingEvent::getKey () const { return _key; } inline const RoutingEvent::Key& RoutingEvent::getKey () const { return _key; }
inline TrackElement* RoutingEvent::getSegment () const { return _segment; } inline TrackElement* RoutingEvent::getSegment () const { return _segment; }

8
katana/src/katana/Session.h
View File

@ -14,9 +14,7 @@
// +-----------------------------------------------------------------+ // +-----------------------------------------------------------------+
#ifndef KATANA_SESSION_H #pragma once
#define KATANA_SESSION_H
#include <set> #include <set>
#include <vector> #include <vector>
#include <string> #include <string>
@ -68,6 +66,7 @@ namespace Katana {
static Session* get ( const char* message=NULL ); static Session* get ( const char* message=NULL );
inline static Super* base (); inline static Super* base ();
inline static bool isEmpty (); inline static bool isEmpty ();
static uint32_t getStage ();
inline static KatanaEngine* getKatanaEngine (); inline static KatanaEngine* getKatanaEngine ();
static Configuration* getConfiguration (); static Configuration* getConfiguration ();
inline static Net* getBlockageNet (); inline static Net* getBlockageNet ();
@ -77,6 +76,7 @@ namespace Katana {
inline static const std::vector<TrackElement*>& inline static const std::vector<TrackElement*>&
getIndirectInvalids (); getIndirectInvalids ();
static void setInterrupt ( bool ); static void setInterrupt ( bool );
static void setStage ( uint32_t );
inline static Interval& toAxisInterval ( Interval&, size_t depth ); inline static Interval& toAxisInterval ( Interval&, size_t depth );
inline static void addIndirectInvalid ( TrackElement* ); inline static void addIndirectInvalid ( TrackElement* );
inline static void addInsertEvent ( TrackMarker* , Track* ); inline static void addInsertEvent ( TrackMarker* , Track* );
@ -220,5 +220,3 @@ namespace Katana {
} // Katana namespace. } // Katana namespace.
#endif // KATANA_SESSION_H