riscv
/
coriolis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Support for placing *one* block of a Cell in Etesian. 

* Change: In Hurricane::Cell_LeafInstanceOccurrences, add the ability to
    walkthrough the leaf of one specific top-level instance.
* Change: In Hurricane::Cell_NonLeafInstanceOccurrences, add the ability to
    walkthrough the leaf of one specific top-level instance.
* Change: In Hurricane::Cell:
    getLeafInstanceOccurrences() and getNonLeafInstanceOccurrences(), now
    have a parameter Instance* to select the leafs we want to walk through.
    If set NULL (default value) browse through all the instances,
    as before.
* Change: In Hurricane::DeepNet, add forgotten Inspector support.
* New: In EtesianEngine, add a "block" (and Instance) attribute to allow
    the placement of one specific bloc. If we want to place the core of
    a chip and take into account the external terminals (if they are not
    already fixed as Pins at the edge of *said* block). We must place
    the core *in the context* of it's instanciation in the corona.
      Note for G. Gouvine : Pin & external RP should be taken into account
    starting at line 629 of EtesianEngine.cpp...
* New: In cumulus/plugins/chip/Chip.py, make use of the new block
    placement feature of ETesian.
* Bug: In KatanaEngine::create(), perform a pre-check to prevent trying to
    route whole chip, which is forbidden an leads to annoying core-dumps.
    Routing must take place "at most" at Corona level.
* Bug: In KatanaEngine::PowerRails, create a plane for METAL1 blockage.
    Not completely sure this was a bug...
This commit is contained in:
Jean-Paul Chaput 2019-08-04 17:33:03 +02:00
parent 1b444d8f49
commit acc3a38f60
10 changed files with 501 additions and 442 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cumulus/src/plugins/chip/Chip.py
View File

@ -152,7 +152,8 @@ class PlaceRoute ( object ):
ht = clocktree.ClockTree.HTree.create( self.conf, coreCell, coreCk, coreCell.getAbutmentBox() ) ht = clocktree.ClockTree.HTree.create( self.conf, coreCell, coreCk, coreCell.getAbutmentBox() )
ht.addCloned( self.conf.cell ) ht.addCloned( self.conf.cell )
ht.addCloned( self.conf.corona ) ht.addCloned( self.conf.corona )
etesian = Etesian.EtesianEngine.create( coreCell ) etesian = Etesian.EtesianEngine.create( self.conf.corona )
etesian.setBlock( self.conf.icore )
etesian.setViewer( self.conf.viewer ) etesian.setViewer( self.conf.viewer )
etesian.place() etesian.place()
etesian.destroy() etesian.destroy()
@ -161,7 +162,8 @@ class PlaceRoute ( object ):
ht.route() ht.route()
ht.save( self.conf.cell ) ht.save( self.conf.cell )
else: else:
etesian = Etesian.EtesianEngine.create( coreCell ) etesian = Etesian.EtesianEngine.create( self.conf.corona )
etesian.setBlock( self.conf.icore )
etesian.place() etesian.place()
etesian.destroy() etesian.destroy()
return return

14
etesian/src/AddFeeds.cpp
View File

@ -210,7 +210,7 @@ namespace {
if (feed == NULL) break; if (feed == NULL) break;
} }
Instance::create ( getEtesian()->getCell() Instance::create ( getEtesian()->getBlockCell()
, getEtesian()->getFeedCells().getUniqueInstanceName().c_str() , getEtesian()->getFeedCells().getUniqueInstanceName().c_str()
, feed , feed
, getTransformation( feed->getAbutmentBox() , getTransformation( feed->getAbutmentBox()
@ -245,7 +245,7 @@ namespace {
SliceHoles::SliceHoles ( EtesianEngine* etesian ) SliceHoles::SliceHoles ( EtesianEngine* etesian )
: _etesian (etesian) : _etesian (etesian)
, _cellAb (etesian->getCell()->getAbutmentBox()) , _cellAb (etesian->getBlockCell()->getAbutmentBox())
, _sliceHeight(_etesian->getSliceHeight()) , _sliceHeight(_etesian->getSliceHeight())
, _slices () , _slices ()
{ {
@ -308,10 +308,10 @@ namespace Etesian {
_ySpinSet = false; _ySpinSet = false;
_yspinSlice0 = 0; _yspinSlice0 = 0;
Box topCellAb = getCell()->getAbutmentBox(); Box topCellAb = getBlockCell()->getAbutmentBox();
if (not topCellAb.isEmpty()) { if (not topCellAb.isEmpty()) {
for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences() ) for ( Occurrence occurrence : getBlockCell()->getLeafInstanceOccurrences() )
{ {
Instance* instance = static_cast<Instance*>(occurrence.getEntity()); Instance* instance = static_cast<Instance*>(occurrence.getEntity());
Cell* masterCell = instance->getMasterCell(); Cell* masterCell = instance->getMasterCell();
@ -325,7 +325,7 @@ namespace Etesian {
_ySpinSet = true; _ySpinSet = true;
int islice = (instanceAb.getYMin() - getCell()->getAbutmentBox().getYMin()) / getSliceHeight(); int islice = (instanceAb.getYMin() - getBlockCell()->getAbutmentBox().getYMin()) / getSliceHeight();
switch ( instanceTransf.getOrientation() ) { switch ( instanceTransf.getOrientation() ) {
case Transformation::Orientation::ID: case Transformation::Orientation::ID:
@ -366,11 +366,11 @@ namespace Etesian {
UpdateSession::open(); UpdateSession::open();
SliceHoles sliceHoles ( this ); SliceHoles sliceHoles ( this );
Box topCellAb = getCell()->getAbutmentBox(); Box topCellAb = getBlockCell()->getAbutmentBox();
sliceHoles.setSpinSlice0( _yspinSlice0 ); sliceHoles.setSpinSlice0( _yspinSlice0 );
for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences() ) for ( Occurrence occurrence : getBlockCell()->getLeafInstanceOccurrences() )
{ {
Instance* instance = static_cast<Instance*>(occurrence.getEntity()); Instance* instance = static_cast<Instance*>(occurrence.getEntity());
Cell* masterCell = instance->getMasterCell(); Cell* masterCell = instance->getMasterCell();

158
etesian/src/EtesianEngine.cpp
View File

@ -31,6 +31,7 @@
#include "hurricane/Layer.h" #include "hurricane/Layer.h"
#include "hurricane/Net.h" #include "hurricane/Net.h"
#include "hurricane/Pad.h" #include "hurricane/Pad.h"
#include "hurricane/Pin.h"
#include "hurricane/Plug.h" #include "hurricane/Plug.h"
#include "hurricane/Cell.h" #include "hurricane/Cell.h"
#include "hurricane/Occurrence.h" #include "hurricane/Occurrence.h"
@ -208,6 +209,7 @@ namespace Etesian {
using Hurricane::Layer; using Hurricane::Layer;
using Hurricane::Cell; using Hurricane::Cell;
using Hurricane::Instance; using Hurricane::Instance;
using Hurricane::Pin;
using Hurricane::RoutingPad; using Hurricane::RoutingPad;
using Hurricane::Net; using Hurricane::Net;
using Hurricane::Occurrence; using Hurricane::Occurrence;
@ -254,7 +256,9 @@ namespace Etesian {
EtesianEngine::EtesianEngine ( Cell* cell ) EtesianEngine::EtesianEngine ( Cell* cell )
: Super (cell) : Super (cell)
, _configuration(new Configuration()) , _configuration(new Configuration())
, _block (NULL)
, _placed (false) , _placed (false)
, _ySpinSet (false)
, _flatDesign (false) , _flatDesign (false)
, _surface () , _surface ()
, _circuit () , _circuit ()
@ -426,7 +430,7 @@ namespace Etesian {
UpdateSession::open(); UpdateSession::open();
vector<Occurrence> feedOccurrences; vector<Occurrence> feedOccurrences;
for( Occurrence occurrence : getCell()->getLeafInstanceOccurrences() ) for( Occurrence occurrence : getCell()->getLeafInstanceOccurrences(getBlockInstance()) )
{ {
dots.dot(); dots.dot();
@ -444,7 +448,7 @@ namespace Etesian {
for ( auto ioccurrence : feedOccurrences ) { for ( auto ioccurrence : feedOccurrences ) {
cerr << " Destroy: " << ioccurrence.getCompactString() << endl; cerr << " Destroy: " << ioccurrence.getCompactString() << endl;
Instance* instance = static_cast<Instance*>(ioccurrence.getEntity()); Instance* instance = static_cast<Instance*>(ioccurrence.getEntity());
instance->destroy(); instance->destroy();
} }
UpdateSession::close(); UpdateSession::close();
@ -473,7 +477,7 @@ namespace Etesian {
if (not cmess2.enabled()) dots.disable(); if (not cmess2.enabled()) dots.disable();
size_t instancesNb = 0; size_t instancesNb = 0;
for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences() ) { for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences(getBlockInstance()) ) {
Instance* instance = static_cast<Instance*>(occurrence.getEntity()); Instance* instance = static_cast<Instance*>(occurrence.getEntity());
Cell* masterCell = instance->getMasterCell(); Cell* masterCell = instance->getMasterCell();
@ -497,11 +501,14 @@ namespace Etesian {
cmess1 << " - Converting " << instancesNb << " instances" << endl; cmess1 << " - Converting " << instancesNb << " instances" << endl;
cout.flush(); cout.flush();
Box topAb = getCell()->getAbutmentBox(); Box topAb = getBlockCell()->getAbutmentBox();
Transformation topTransformation;
if (getBlockInstance()) topTransformation = getBlockInstance()->getTransformation();
topTransformation.applyOn( topAb );
UpdateSession::open(); UpdateSession::open();
for ( Occurrence occurrence : getCell()->getNonLeafInstanceOccurrences() ) for ( Occurrence occurrence : getBlockCell()->getNonLeafInstanceOccurrences() )
{ {
Instance* instance = static_cast<Instance*>(occurrence.getEntity()); Instance* instance = static_cast<Instance*>(occurrence.getEntity());
Cell* masterCell = instance->getMasterCell(); Cell* masterCell = instance->getMasterCell();
@ -530,10 +537,10 @@ namespace Etesian {
cmess1 << " - Building RoutingPads (transhierarchical) ..." << endl; cmess1 << " - Building RoutingPads (transhierarchical) ..." << endl;
//getCell()->flattenNets( Cell::Flags::BuildRings|Cell::Flags::NoClockFlatten ); //getCell()->flattenNets( Cell::Flags::BuildRings|Cell::Flags::NoClockFlatten );
getCell()->flattenNets( Cell::Flags::NoClockFlatten ); getCell()->flattenNets( getBlockInstance(), Cell::Flags::NoClockFlatten );
index_t instanceId = 0; index_t instanceId = 0;
for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences() ) for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences(getBlockInstance()) )
{ {
Instance* instance = static_cast<Instance*>(occurrence.getEntity()); Instance* instance = static_cast<Instance*>(occurrence.getEntity());
Cell* masterCell = instance->getMasterCell(); Cell* masterCell = instance->getMasterCell();
@ -618,8 +625,23 @@ namespace Etesian {
nets[netId] = temporary_net( netId, 1 ); nets[netId] = temporary_net( netId, 1 );
//cerr << "+ " << net << endl; //cerr << "+ " << net << endl;
for ( Pin* pin : net->getPins() ) {
//cerr << "Outside Pin: " << pin << endl;
// For Gabriel Gouvine : the position of this pin should be added as a fixed
// attractor in Coloquinte. May be outside the placement area.
}
for ( RoutingPad* rp : net->getRoutingPads() ) { for ( RoutingPad* rp : net->getRoutingPads() ) {
if (getBlockInstance() and (rp->getOccurrence().getPath().getHeadInstance() != getBlockInstance())) {
//cerr << "Outside RP: " << rp << endl;
// For Gabriel Gouvine : if there are multiple blocks (i.e. we have a true
// floorplan, there may be RoutingPad that are elsewhere. We should check
// that the RP is placed or is inside a define area (the abutment box of
// it's own block). No example yet of that case, though.
continue;
}
string insName = extractInstanceName( rp ); string insName = extractInstanceName( rp );
Point offset = extractRpOffset ( rp ); Point offset = extractRpOffset ( rp );
@ -640,10 +662,10 @@ namespace Etesian {
} }
dots.finish( Dots::Reset ); dots.finish( Dots::Reset );
_surface = box<int_t>( (int_t)(getCell()->getAbutmentBox().getXMin() / vpitch) _surface = box<int_t>( (int_t)(topAb.getXMin() / vpitch)
, (int_t)(getCell()->getAbutmentBox().getXMax() / vpitch) , (int_t)(topAb.getXMax() / vpitch)
, (int_t)(getCell()->getAbutmentBox().getYMin() / hpitch) , (int_t)(topAb.getYMin() / hpitch)
, (int_t)(getCell()->getAbutmentBox().getYMax() / hpitch) , (int_t)(topAb.getYMax() / hpitch)
); );
_circuit = netlist( instances, nets, pins ); _circuit = netlist( instances, nets, pins );
_circuit.selfcheck(); _circuit.selfcheck();
@ -888,14 +910,16 @@ namespace Etesian {
void EtesianEngine::place () void EtesianEngine::place ()
{ {
if(getCell()->isPlaced()){ if (getBlockCell()->isPlaced()) {
cmess2 << Warning("The cell is already placed; returning") << std::endl; cerr << Warning( "EtesianEngine::place(): The cell \"%s\" is already placed (aborting)"
return; , getString(getBlockCell()->getName()).c_str()
) << std::endl;
return;
} }
getCell()->uniquify(); getBlockCell()->uniquify();
getConfiguration()->print( getCell() ); getConfiguration()->print( getCell() );
if (getCell()->getAbutmentBox().isEmpty()) setDefaultAb(); if (getBlockCell()->getAbutmentBox().isEmpty()) setDefaultAb();
findYSpin(); findYSpin();
toColoquinte(); toColoquinte();
@ -919,44 +943,41 @@ namespace Etesian {
int detailedIterations, detailedEffort; int detailedIterations, detailedEffort;
unsigned globalOptions=0, detailedOptions=0; unsigned globalOptions=0, detailedOptions=0;
if(placementUpdate == UpdateAll){ if (placementUpdate == UpdateAll) {
globalOptions |= (UpdateUB | UpdateLB); globalOptions |= (UpdateUB | UpdateLB);
detailedOptions |= UpdateDetailed; detailedOptions |= UpdateDetailed;
} }
else if(placementUpdate == LowerBound){ else if (placementUpdate == LowerBound) {
globalOptions |= UpdateLB; globalOptions |= UpdateLB;
} }
if(densityConf == ForceUniform) if (densityConf == ForceUniform)
globalOptions |= ForceUniformDensity; globalOptions |= ForceUniformDensity;
if(placementEffort == Fast){ if (placementEffort == Fast) {
minPenaltyIncrease = 0.005f; minPenaltyIncrease = 0.005f;
maxPenaltyIncrease = 0.08f; maxPenaltyIncrease = 0.08f;
targetImprovement = 0.05f; // 5/100 per iteration targetImprovement = 0.05f; // 5/100 per iteration
detailedIterations = 1; detailedIterations = 1;
detailedEffort = 0; detailedEffort = 0;
} } else if (placementEffort == Standard) {
else if(placementEffort == Standard){ minPenaltyIncrease = 0.001f;
minPenaltyIncrease = 0.001f; maxPenaltyIncrease = 0.04f;
maxPenaltyIncrease = 0.04f; targetImprovement = 0.02f; // 2/100 per iteration
targetImprovement = 0.02f; // 2/100 per iteration detailedIterations = 2;
detailedIterations = 2; detailedEffort = 1;
detailedEffort = 1; } else if (placementEffort == High) {
} minPenaltyIncrease = 0.0005f;
else if(placementEffort == High){ maxPenaltyIncrease = 0.02f;
minPenaltyIncrease = 0.0005f; targetImprovement = 0.01f; // 1/100 per iteration
maxPenaltyIncrease = 0.02f; detailedIterations = 4;
targetImprovement = 0.01f; // 1/100 per iteration detailedEffort = 2;
detailedIterations = 4; } else {
detailedEffort = 2; minPenaltyIncrease = 0.0002f;
} maxPenaltyIncrease = 0.01f;
else{ targetImprovement = 0.005f; // 5/1000 per iteration
minPenaltyIncrease = 0.0002f; detailedIterations = 7;
maxPenaltyIncrease = 0.01f; detailedEffort = 3;
targetImprovement = 0.005f; // 5/1000 per iteration
detailedIterations = 7;
detailedEffort = 3;
} }
cmess1 << " o Global placement." << endl; cmess1 << " o Global placement." << endl;
@ -1014,6 +1035,37 @@ namespace Etesian {
} }
#if DISABLED
void EtesianEngine::place ( Instance* instance )
{
setBlock( instance );
if (getCell()->getAbutmentBox().isEmpty()) {
cmess2 << Error( "EtesianEngine::place(): Cell \"%s\" must have an abutment box."
, getString(getCell()->getName()).c_str()
) << std::endl;
return;
}
if (getBlockCell()->getAbutmentBox().isEmpty()) {
cmess2 << Error( "EtesianEngine::place(): Instance \"%s\" must have an abutment box."
, getString(instance->getName()).c_str()
) << std::endl;
return;
}
if(getBlockCell()->isPlaced()){
cmess2 << Error( "EtesianEngine::place(): The instance \"%s\" is already placed."
, getString(instance->getName()).c_str()
) << std::endl;
return;
}
getBlockCell()->uniquify();
getConfiguration()->print( getCell() );
findYSpin();
}
#endif
void EtesianEngine::_progressReport1 ( string label ) const void EtesianEngine::_progressReport1 ( string label ) const
{ {
size_t w = label.size(); size_t w = label.size();
@ -1054,7 +1106,12 @@ namespace Etesian {
{ {
UpdateSession::open(); UpdateSession::open();
for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences() ) Box topAb = getBlockCell()->getAbutmentBox();
Transformation topTransformation;
if (getBlockInstance()) topTransformation = getBlockInstance()->getTransformation();
topTransformation.invert();
for ( Occurrence occurrence : getCell()->getLeafInstanceOccurrences(getBlockInstance()) )
{ {
DbU::Unit hpitch = getHorizontalPitch(); DbU::Unit hpitch = getHorizontalPitch();
DbU::Unit vpitch = getVerticalPitch(); DbU::Unit vpitch = getVerticalPitch();
@ -1083,6 +1140,7 @@ namespace Etesian {
// This is temporary as it's not trans-hierarchic: we ignore the positions // This is temporary as it's not trans-hierarchic: we ignore the positions
// of all the intermediary instances. // of all the intermediary instances.
topTransformation.applyOn( trans );
instance->setTransformation( trans ); instance->setTransformation( trans );
instance->setPlacementStatus( Instance::PlacementStatus::PLACED ); instance->setPlacementStatus( Instance::PlacementStatus::PLACED );
} }

21
etesian/src/PyEtesianEngine.cpp
View File

@ -15,6 +15,7 @@
#include "hurricane/isobar/PyCell.h" #include "hurricane/isobar/PyCell.h"
#include "hurricane/isobar/PyInstance.h"
#include "hurricane/viewer/PyCellViewer.h" #include "hurricane/viewer/PyCellViewer.h"
#include "hurricane/Cell.h" #include "hurricane/Cell.h"
#include "hurricane/viewer/ExceptionWidget.h" #include "hurricane/viewer/ExceptionWidget.h"
@ -48,6 +49,8 @@ namespace Etesian {
using Isobar::ParseTwoArg; using Isobar::ParseTwoArg;
using Isobar::PyCell; using Isobar::PyCell;
using Isobar::PyCell_Link; using Isobar::PyCell_Link;
using Isobar::PyInstance;
using Isobar::PyInstance_Link;
using Isobar::PyCellViewer; using Isobar::PyCellViewer;
using Isobar::PyTypeCellViewer; using Isobar::PyTypeCellViewer;
using CRL::PyToolEngine; using CRL::PyToolEngine;
@ -149,6 +152,22 @@ extern "C" {
} }
static PyObject* PyEtesianEngine_setBlock ( PyEtesianEngine *self, PyObject* args )
{
cdebug_log(34,0) << "PyEtesianEngine_setBlock()" << endl;
HTRY
METHOD_HEAD ( "EtesianEngine.setBlock()" )
PyInstance* pyInstance = NULL;
if (not ParseOneArg("EtesianEngine.setBlock",args,INST_ARG,(PyObject**)&pyInstance) )
return NULL;
etesian->setBlock( PYINSTANCE_O(pyInstance) );
HCATCH
Py_RETURN_NONE;
}
static PyObject* PyEtesianEngine_place ( PyEtesianEngine* self ) static PyObject* PyEtesianEngine_place ( PyEtesianEngine* self )
{ {
cdebug_log(34,0) << "PyEtesianEngine_place()" << endl; cdebug_log(34,0) << "PyEtesianEngine_place()" << endl;
@ -183,6 +202,8 @@ extern "C" {
, "Associate a Viewer to this EtesianEngine." } , "Associate a Viewer to this EtesianEngine." }
, { "selectBloat" , (PyCFunction)PyEtesianEngine_selectBloat , METH_VARARGS , { "selectBloat" , (PyCFunction)PyEtesianEngine_selectBloat , METH_VARARGS
, "Select the Cell bloating profile." } , "Select the Cell bloating profile." }
, { "setBlock" , (PyCFunction)PyEtesianEngine_setBlock , METH_VARARGS
, "Set the sub-block (Instance) to place." }
, { "setDefaultAb" , (PyCFunction)PyEtesianEngine_setDefaultAb , METH_NOARGS , { "setDefaultAb" , (PyCFunction)PyEtesianEngine_setDefaultAb , METH_NOARGS
, "Compute and set the abutment box using the aspect ratio and the space margin." } , "Compute and set the abutment box using the aspect ratio and the space margin." }
, { "place" , (PyCFunction)PyEtesianEngine_place , METH_NOARGS , { "place" , (PyCFunction)PyEtesianEngine_place , METH_NOARGS

11
etesian/src/etesian/EtesianEngine.h
View File

@ -77,19 +77,18 @@ namespace Etesian {
inline const FeedCells& getFeedCells () const; inline const FeedCells& getFeedCells () const;
inline Hurricane::CellViewer* getViewer () const; inline Hurricane::CellViewer* getViewer () const;
inline void setViewer ( Hurricane::CellViewer* ); inline void setViewer ( Hurricane::CellViewer* );
inline Cell* getBlockCell () const;
inline Instance* getBlockInstance () const;
inline void setBlock ( Instance* );
void setDefaultAb (); void setDefaultAb ();
void resetPlacement (); void resetPlacement ();
void toColoquinte (); void toColoquinte ();
void preplace (); void preplace ();
void roughLegalize ( float minDisruption, unsigned options ); void roughLegalize ( float minDisruption, unsigned options );
void globalPlace ( float initPenalty, float minDisruption, float targetImprovement, float minInc, float maxInc, unsigned options=0 ); void globalPlace ( float initPenalty, float minDisruption, float targetImprovement, float minInc, float maxInc, unsigned options=0 );
void detailedPlace ( int iterations, int effort, unsigned options=0 ); void detailedPlace ( int iterations, int effort, unsigned options=0 );
void feedRoutingBack (); void feedRoutingBack ();
void place (); void place ();
inline void useFeed ( Cell* ); inline void useFeed ( Cell* );
size_t findYSpin (); size_t findYSpin ();
void addFeeds (); void addFeeds ();
@ -102,6 +101,7 @@ namespace Etesian {
static Name _toolName; static Name _toolName;
protected: protected:
Configuration* _configuration; Configuration* _configuration;
Instance* _block;
bool _placed; bool _placed;
bool _ySpinSet; bool _ySpinSet;
bool _flatDesign; bool _flatDesign;
@ -151,6 +151,9 @@ namespace Etesian {
inline const FeedCells& EtesianEngine::getFeedCells () const { return _feedCells; } inline const FeedCells& EtesianEngine::getFeedCells () const { return _feedCells; }
inline void EtesianEngine::selectBloat ( std::string profile ) { _bloatCells.select(profile); } inline void EtesianEngine::selectBloat ( std::string profile ) { _bloatCells.select(profile); }
inline Cell* EtesianEngine::getBlockCell () const { return (_block) ? _block->getMasterCell() : getCell(); }
inline Instance* EtesianEngine::getBlockInstance () const { return _block; }
inline void EtesianEngine::setBlock ( Instance* block ) { _block = block; }
// Variables. // Variables.
extern const char* missingEtesian; extern const char* missingEtesian;

708
hurricane/src/hurricane/CellCollections.cpp
View File

@ -994,72 +994,46 @@ class Cell_OccurrencesUnder : public Collection<Occurrence> {
}; };
// ****************************************************************************************************
// Cell_LeafInstanceOccurrences declaration // -------------------------------------------------------------------
// **************************************************************************************************** // class : "Cell_LeafInstanceOccurrences".
class Cell_LeafInstanceOccurrences : public Collection<Occurrence> { class Cell_LeafInstanceOccurrences : public Collection<Occurrence> {
// ***************************************************************** public:
typedef Collection<Occurrence> Inherit;
// Types
// *****
public: typedef Collection<Occurrence> Inherit;
public: class Locator : public Hurricane::Locator<Occurrence> {
// *********************************************************
public: typedef Hurricane::Locator<Occurrence> Inherit;
private: const Cell* _cell;
private: int _state;
private: InstanceLocator _leafInstanceLocator;
private: InstanceLocator _nonLeafInstanceLocator;
private: OccurrenceLocator _occurrenceLocator;
public: Locator(const Cell* cell = NULL);
public: Locator(const Locator& locator);
public: Locator& operator=(const Locator& locator);
public: virtual Occurrence getElement() const;
public: virtual Hurricane::Locator<Occurrence>* getClone() const;
public: virtual bool isValid() const;
public: virtual void progress();
public: virtual string _getString() const;
public:
class Locator : public Hurricane::Locator<Occurrence> {
public:
typedef Hurricane::Locator<Occurrence> Inherit;
public:
Locator ( const Cell* cell=NULL, const Instance* topInstance=NULL );
Locator ( const Locator& );
Locator& operator= ( const Locator& );
virtual Occurrence getElement () const;
virtual Hurricane::Locator<Occurrence>* getClone () const;
virtual bool isValid () const;
virtual void progress ();
virtual string _getString () const;
private:
const Cell* _cell;
const Instance* _topInstance;
int _state;
InstanceLocator _leafInstanceLocator;
InstanceLocator _nonLeafInstanceLocator;
OccurrenceLocator _occurrenceLocator;
}; };
// Attributes public:
// ********** Cell_LeafInstanceOccurrences ( const Cell* cell=NULL, const Instance* topInstance=NULL );
Cell_LeafInstanceOccurrences ( const Cell_LeafInstanceOccurrences& );
private: const Cell* _cell; Cell_LeafInstanceOccurrences& operator= ( const Cell_LeafInstanceOccurrences& );
virtual Collection<Occurrence>* getClone () const;
// Constructors virtual Hurricane::Locator<Occurrence>* getLocator () const;
// ************ virtual string _getString () const;
private:
public: Cell_LeafInstanceOccurrences(const Cell* cell = NULL); const Cell* _cell;
public: Cell_LeafInstanceOccurrences(const Cell_LeafInstanceOccurrences& occurrences); const Instance* _topInstance;
// Operators
// *********
public: Cell_LeafInstanceOccurrences& operator=(const Cell_LeafInstanceOccurrences& occurrences);
// Accessors
// *********
public: virtual Collection<Occurrence>* getClone() const;
public: virtual Hurricane::Locator<Occurrence>* getLocator() const;
// Others
// ******
public: virtual string _getString() const;
}; };
@ -1136,71 +1110,46 @@ class Cell_LeafInstanceOccurrencesUnder : public Collection<Occurrence> {
}; };
// ****************************************************************************************************
// Cell_NonLeafInstanceOccurrences declaration // -------------------------------------------------------------------
// **************************************************************************************************** // class : "Cell_NonLeafInstanceOccurrences".
class Cell_NonLeafInstanceOccurrences : public Collection<Occurrence> { class Cell_NonLeafInstanceOccurrences : public Collection<Occurrence> {
// ******************************************************************** public:
typedef Collection<Occurrence> Inherit;
// Types
// *****
public: typedef Collection<Occurrence> Inherit;
public: class Locator : public Hurricane::Locator<Occurrence> {
// ************************************************************
public: typedef Hurricane::Locator<Occurrence> Inherit;
private: const Cell* _cell;
private: int _state;
private: InstanceLocator _nonLeafInstanceLocator;
private: OccurrenceLocator _occurrenceLocator;
public: Locator(const Cell* cell = NULL);
public: Locator(const Locator& locator);
public: Locator& operator=(const Locator& locator);
public: virtual Occurrence getElement() const;
public: virtual Hurricane::Locator<Occurrence>* getClone() const;
public: virtual bool isValid() const;
public: virtual void progress();
public: virtual string _getString() const;
public:
class Locator : public Hurricane::Locator<Occurrence> {
public:
typedef Hurricane::Locator<Occurrence> Inherit;
public:
Locator ( const Cell* cell=NULL, const Instance* topInstance=NULL );
Locator ( const Locator& );
Locator& operator= ( const Locator& );
virtual Occurrence getElement () const;
virtual Hurricane::Locator<Occurrence>* getClone () const;
virtual bool isValid () const;
virtual void progress ();
void _nonLeafProgress ( bool inCTOR );
virtual string _getString () const;
private:
const Cell* _cell;
const Instance* _topInstance;
int _state;
InstanceLocator _nonLeafInstanceLocator;
OccurrenceLocator _occurrenceLocator;
}; };
// Attributes public:
// ********** Cell_NonLeafInstanceOccurrences ( const Cell* cell=NULL, const Instance* topInstance=NULL );
Cell_NonLeafInstanceOccurrences ( const Cell_NonLeafInstanceOccurrences& );
private: const Cell* _cell; Cell_NonLeafInstanceOccurrences& operator= ( const Cell_NonLeafInstanceOccurrences& );
virtual Collection<Occurrence>* getClone () const;
// Constructors virtual Hurricane::Locator<Occurrence>* getLocator () const;
// ************ virtual string _getString () const;
private:
public: Cell_NonLeafInstanceOccurrences(const Cell* cell = NULL); const Cell* _cell;
public: Cell_NonLeafInstanceOccurrences(const Cell_NonLeafInstanceOccurrences& occurrences); const Instance* _topInstance;
// Operators
// *********
public: Cell_NonLeafInstanceOccurrences& operator=(const Cell_NonLeafInstanceOccurrences& occurrences);
// Accessors
// *********
public: virtual Collection<Occurrence>* getClone() const;
public: virtual Hurricane::Locator<Occurrence>* getLocator() const;
// Others
// ******
public: virtual string _getString() const;
}; };
@ -2022,10 +1971,10 @@ Occurrences Cell::getTerminalInstanceOccurrencesUnder(const Box& area) const
return Cell_TerminalInstanceOccurrencesUnder(this, area); return Cell_TerminalInstanceOccurrencesUnder(this, area);
} }
Occurrences Cell::getLeafInstanceOccurrences() const Occurrences Cell::getLeafInstanceOccurrences( const Instance* topInstance ) const
// *********************************************** // ******************************************************************************
{ {
return Cell_LeafInstanceOccurrences(this); return Cell_LeafInstanceOccurrences( this, topInstance );
} }
Occurrences Cell::getLeafInstanceOccurrencesUnder(const Box& area) const Occurrences Cell::getLeafInstanceOccurrencesUnder(const Box& area) const
@ -2034,10 +1983,10 @@ Occurrences Cell::getLeafInstanceOccurrencesUnder(const Box& area) const
return Cell_LeafInstanceOccurrencesUnder(this, area); return Cell_LeafInstanceOccurrencesUnder(this, area);
} }
Occurrences Cell::getNonLeafInstanceOccurrences() const Occurrences Cell::getNonLeafInstanceOccurrences( const Instance* topInstance ) const
// *********************************************** // *********************************************************************************
{ {
return Cell_NonLeafInstanceOccurrences(this); return Cell_NonLeafInstanceOccurrences(this,topInstance);
} }
Occurrences Cell::getComponentOccurrences(const Layer::Mask& mask) const Occurrences Cell::getComponentOccurrences(const Layer::Mask& mask) const
@ -3203,189 +3152,194 @@ string Cell_OccurrencesUnder::Locator::_getString() const
return s; return s;
} }
// ****************************************************************************************************
// Cell_LeafInstanceOccurrences implementation
// ****************************************************************************************************
Cell_LeafInstanceOccurrences::Cell_LeafInstanceOccurrences(const Cell* cell) // -------------------------------------------------------------------
// ******************************************************************************* // Class : "Cell_LeafInstanceOccurrences".
: Inherit(),
_cell(cell)
{
}
Cell_LeafInstanceOccurrences::Cell_LeafInstanceOccurrences(const Cell_LeafInstanceOccurrences& occurrences) Cell_LeafInstanceOccurrences::Cell_LeafInstanceOccurrences ( const Cell* cell, const Instance* topInstance )
// **************************************************************************************************** : Inherit()
: Inherit(), , _cell (cell)
_cell(occurrences._cell) , _topInstance(topInstance)
{ { }
}
Cell_LeafInstanceOccurrences& Cell_LeafInstanceOccurrences::operator=(const Cell_LeafInstanceOccurrences& occurrences)
// ****************************************************************************************************
{
_cell = occurrences._cell;
return *this;
}
Collection<Occurrence>* Cell_LeafInstanceOccurrences::getClone() const Cell_LeafInstanceOccurrences::Cell_LeafInstanceOccurrences ( const Cell_LeafInstanceOccurrences& occurrences )
// ********************************************************************* : Inherit()
{ , _cell (occurrences._cell)
return new Cell_LeafInstanceOccurrences(*this); , _topInstance(occurrences._topInstance)
} { }
Locator<Occurrence>* Cell_LeafInstanceOccurrences::getLocator() const
// ********************************************************************
{
return new Locator(_cell);
}
string Cell_LeafInstanceOccurrences::_getString() const Cell_LeafInstanceOccurrences& Cell_LeafInstanceOccurrences::operator= ( const Cell_LeafInstanceOccurrences& occurrences )
// *******************************************************
{ {
string s = "<" + _TName("Cell::LeafInstanceOccurrences"); _cell = occurrences._cell;
if (_cell) s += " " + getString(_cell); _topInstance = occurrences._topInstance;
s += ">"; return *this;
return s;
} }
Collection<Occurrence>* Cell_LeafInstanceOccurrences::getClone () const
{ return new Cell_LeafInstanceOccurrences( *this ); }
// ****************************************************************************************************
// Cell_LeafInstanceOccurrences::Locator implementation
// ****************************************************************************************************
Cell_LeafInstanceOccurrences::Locator::Locator(const Cell* cell) Locator<Occurrence>* Cell_LeafInstanceOccurrences::getLocator () const
// **************************************************************** { return new Locator ( _cell, _topInstance ); }
: Inherit(),
_cell(cell),
_state(0), string Cell_LeafInstanceOccurrences::_getString () const
_leafInstanceLocator(),
_nonLeafInstanceLocator(),
_occurrenceLocator()
{ {
if (_cell) { string s = "<" + _TName("Cell::LeafInstanceOccurrences");
_leafInstanceLocator = _cell->getLeafInstances().getLocator(); if (_cell) s += " " + getString(_cell);
if (_leafInstanceLocator.isValid()) if (_topInstance) s += " " + getString(_topInstance);
_state = 1; s += ">";
else { return s;
_nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator(); }
while (!_state && _nonLeafInstanceLocator.isValid()) {
// -------------------------------------------------------------------
// Class : "Cell_LeafInstanceOccurrences::Locator".
Cell_LeafInstanceOccurrences::Locator::Locator ( const Cell* cell, const Instance* topInstance )
: Inherit()
, _cell (cell)
, _topInstance (topInstance)
, _state (0)
, _leafInstanceLocator ()
, _nonLeafInstanceLocator()
, _occurrenceLocator ()
{
if (not _cell) return;
if (not _topInstance) _leafInstanceLocator = _cell->getLeafInstances().getLocator();
if (_leafInstanceLocator.isValid())
_state = 1;
else {
_nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator();
while (not _state and _nonLeafInstanceLocator.isValid()) {
Instance* nonLeaf = _nonLeafInstanceLocator.getElement();
if (not _topInstance or (nonLeaf == _topInstance)) {
Cell* masterCell = nonLeaf->getMasterCell();
_occurrenceLocator = masterCell->getLeafInstanceOccurrences().getLocator();
if (_occurrenceLocator.isValid()) {
_state = 2;
break;
}
}
_nonLeafInstanceLocator.progress();
}
}
}
Cell_LeafInstanceOccurrences::Locator::Locator ( const Locator& locator )
: Inherit()
, _cell (locator._cell)
, _topInstance (locator._topInstance)
, _state (locator._state)
, _leafInstanceLocator (locator._leafInstanceLocator)
, _nonLeafInstanceLocator(locator._nonLeafInstanceLocator)
, _occurrenceLocator (locator._occurrenceLocator)
{ }
Cell_LeafInstanceOccurrences::Locator& Cell_LeafInstanceOccurrences::Locator::operator= ( const Locator& locator )
{
_cell = locator._cell;
_topInstance = locator._topInstance;
_state = locator._state;
_leafInstanceLocator = locator._leafInstanceLocator;
_nonLeafInstanceLocator = locator._nonLeafInstanceLocator;
_occurrenceLocator = locator._occurrenceLocator;
return *this;
}
Occurrence Cell_LeafInstanceOccurrences::Locator::getElement () const
{
if (_state) {
switch (_state) {
case 1 : return Occurrence( _leafInstanceLocator.getElement() );
case 2 : {
Occurrence occurrence = _occurrenceLocator.getElement();
Entity* entity = occurrence.getEntity();
Path path = Path( _nonLeafInstanceLocator.getElement(), occurrence.getPath() );
return Occurrence( entity, path );
}
}
}
return Occurrence();
}
Locator<Occurrence>* Cell_LeafInstanceOccurrences::Locator::getClone () const
{ return new Locator( *this ); }
bool Cell_LeafInstanceOccurrences::Locator::isValid () const
{ return (_state != 0); }
void Cell_LeafInstanceOccurrences::Locator::progress ()
{
if (_state) {
switch (_state) {
case 1 :
_leafInstanceLocator.progress();
if (!_leafInstanceLocator.isValid()) {
_state = 0;
_nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator();
while (!_state && _nonLeafInstanceLocator.isValid()) {
Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell();
_occurrenceLocator = masterCell->getLeafInstanceOccurrences().getLocator();
if (_occurrenceLocator.isValid())
_state = 2;
else
_nonLeafInstanceLocator.progress();
}
}
break;
case 2 :
_occurrenceLocator.progress();
if (not _occurrenceLocator.isValid()) {
_state = 0;
if (_nonLeafInstanceLocator.isValid()) {
_nonLeafInstanceLocator.progress();
while (not _state and _nonLeafInstanceLocator.isValid()) {
Instance* nonLeaf = _nonLeafInstanceLocator.getElement();
if (not _topInstance or (nonLeaf == _topInstance)) {
Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell(); Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell();
_occurrenceLocator = masterCell->getLeafInstanceOccurrences().getLocator(); _occurrenceLocator = masterCell->getLeafInstanceOccurrences().getLocator();
if (_occurrenceLocator.isValid()) if (_occurrenceLocator.isValid()) {
_state = 2; _state = 2;
else break;
_nonLeafInstanceLocator.progress();
}
}
}
}
Cell_LeafInstanceOccurrences::Locator::Locator(const Locator& locator)
// **********************************************************************
: Inherit(),
_cell(locator._cell),
_state(locator._state),
_leafInstanceLocator(locator._leafInstanceLocator),
_nonLeafInstanceLocator(locator._nonLeafInstanceLocator),
_occurrenceLocator(locator._occurrenceLocator)
{
}
Cell_LeafInstanceOccurrences::Locator& Cell_LeafInstanceOccurrences::Locator::operator=(const Locator& locator)
// ****************************************************************************************************
{
_cell = locator._cell;
_state = locator._state;
_leafInstanceLocator = locator._leafInstanceLocator;
_nonLeafInstanceLocator = locator._nonLeafInstanceLocator;
_occurrenceLocator = locator._occurrenceLocator;
return *this;
}
Occurrence Cell_LeafInstanceOccurrences::Locator::getElement() const
// *******************************************************************
{
if (_state) {
switch (_state) {
case 1 : return Occurrence(_leafInstanceLocator.getElement());
case 2 : {
Occurrence occurrence = _occurrenceLocator.getElement();
Entity* entity = occurrence.getEntity();
Path path = Path(_nonLeafInstanceLocator.getElement(), occurrence.getPath());
return Occurrence(entity, path);
}
}
}
return Occurrence();
}
Locator<Occurrence>* Cell_LeafInstanceOccurrences::Locator::getClone() const
// ***************************************************************************
{
return new Locator(*this);
}
bool Cell_LeafInstanceOccurrences::Locator::isValid() const
// ***********************************************************
{
return (_state != 0);
}
void Cell_LeafInstanceOccurrences::Locator::progress()
// ******************************************************
{
if (_state) {
switch (_state) {
case 1 :
_leafInstanceLocator.progress();
if (!_leafInstanceLocator.isValid()) {
_state = 0;
_nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator();
while (!_state && _nonLeafInstanceLocator.isValid()) {
Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell();
_occurrenceLocator = masterCell->getLeafInstanceOccurrences().getLocator();
if (_occurrenceLocator.isValid())
_state = 2;
else
_nonLeafInstanceLocator.progress();
}
} }
break; }
case 2 :
_occurrenceLocator.progress(); _nonLeafInstanceLocator.progress();
if (!_occurrenceLocator.isValid()) { }
_state = 0; }
if (_nonLeafInstanceLocator.isValid()) {
_nonLeafInstanceLocator.progress();
while (!_state && _nonLeafInstanceLocator.isValid()) {
Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell();
_occurrenceLocator =
masterCell->getLeafInstanceOccurrences().getLocator();
if (_occurrenceLocator.isValid())
_state = 2;
else
_nonLeafInstanceLocator.progress();
}
}
}
break;
} }
break;
} }
}
} }
string Cell_LeafInstanceOccurrences::Locator::_getString() const string Cell_LeafInstanceOccurrences::Locator::_getString () const
// ****************************************************************
{ {
string s = "<" + _TName("Cell::LeafInstanceOccurrences::Locator"); string s = "<" + _TName("Cell::LeafInstanceOccurrences::Locator");
if (_cell) s += " " + getString(_cell); if (_cell) s += " " + getString(_cell);
if (_topInstance) s += " " + getString(_topInstance);
s += ">"; s += ">";
return s; return s;
} }
// **************************************************************************************************** // ****************************************************************************************************
// Cell_LeafInstanceOccurrencesUnder implementation // Cell_LeafInstanceOccurrencesUnder implementation
// **************************************************************************************************** // ****************************************************************************************************
@ -3611,138 +3565,142 @@ string Cell_LeafInstanceOccurrencesUnder::Locator::_getString() const
} }
// -------------------------------------------------------------------
// class : "Cell_NonLeafInstanceOccurrences".
// **************************************************************************************************** Cell_NonLeafInstanceOccurrences::Cell_NonLeafInstanceOccurrences ( const Cell* cell, const Instance* topInstance )
// Cell_NonLeafInstanceOccurrences implementation : Inherit()
// **************************************************************************************************** , _cell (cell)
, _topInstance(topInstance)
{ }
Cell_NonLeafInstanceOccurrences::Cell_NonLeafInstanceOccurrences(const Cell* cell)
// ******************************************************************************* Cell_NonLeafInstanceOccurrences::Cell_NonLeafInstanceOccurrences ( const Cell_NonLeafInstanceOccurrences& occurrences )
: Inherit(), : Inherit()
_cell(cell) , _cell (occurrences._cell)
, _topInstance(occurrences._topInstance)
{ }
Cell_NonLeafInstanceOccurrences& Cell_NonLeafInstanceOccurrences::operator= ( const Cell_NonLeafInstanceOccurrences& occurrences )
{ {
} _cell = occurrences._cell;
_topInstance = occurrences._topInstance;
Cell_NonLeafInstanceOccurrences::Cell_NonLeafInstanceOccurrences(const Cell_NonLeafInstanceOccurrences& occurrences) return *this;
// ****************************************************************************************************
: Inherit(),
_cell(occurrences._cell)
{
}
Cell_NonLeafInstanceOccurrences& Cell_NonLeafInstanceOccurrences::operator=(const Cell_NonLeafInstanceOccurrences& occurrences)
// ****************************************************************************************************
{
_cell = occurrences._cell;
return *this;
}
Collection<Occurrence>* Cell_NonLeafInstanceOccurrences::getClone() const
// *********************************************************************
{
return new Cell_NonLeafInstanceOccurrences(*this);
}
Locator<Occurrence>* Cell_NonLeafInstanceOccurrences::getLocator() const
// ********************************************************************
{
return new Locator(_cell);
}
string Cell_NonLeafInstanceOccurrences::_getString() const
// *******************************************************
{
string s = "<" + _TName("Cell::NonLeafInstanceOccurrences");
if (_cell) s += " " + getString(_cell);
s += ">";
return s;
} }
Collection<Occurrence>* Cell_NonLeafInstanceOccurrences::getClone () const
{ return new Cell_NonLeafInstanceOccurrences(*this); }
// ****************************************************************************************************
// Cell_NonLeafInstanceOccurrences::Locator implementation
// ****************************************************************************************************
Cell_NonLeafInstanceOccurrences::Locator::Locator(const Cell* cell) Locator<Occurrence>* Cell_NonLeafInstanceOccurrences::getLocator () const
// **************************************************************** { return new Locator ( _cell, _topInstance ); }
string Cell_NonLeafInstanceOccurrences::_getString () const
{
string s = "<" + _TName("Cell::NonLeafInstanceOccurrences");
if (_cell) s += " " + getString(_cell);
if (_topInstance) s += " " + getString(_topInstance);
s += ">";
return s;
}
// -------------------------------------------------------------------
// class : "Cell_NonLeafInstanceOccurrences::Locator".
Cell_NonLeafInstanceOccurrences::Locator::Locator ( const Cell* cell, const Instance* topInstance )
: Inherit () : Inherit ()
, _cell (cell) , _cell (cell)
, _topInstance (topInstance)
, _state (0) , _state (0)
, _nonLeafInstanceLocator() , _nonLeafInstanceLocator()
, _occurrenceLocator () , _occurrenceLocator ()
{ {
if ( _cell ) { if (_cell) {
_nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator(); _nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator();
if ( _nonLeafInstanceLocator.isValid() ) { _nonLeafProgress( true );
_state = 1; if (_nonLeafInstanceLocator.isValid()) _state = 1;
}
} }
} }
Cell_NonLeafInstanceOccurrences::Locator::Locator(const Locator& locator)
// ********************************************************************** Cell_NonLeafInstanceOccurrences::Locator::Locator ( const Locator& locator )
: Inherit () : Inherit ()
, _cell (locator._cell) , _cell (locator._cell)
, _topInstance (locator._topInstance)
, _state (locator._state) , _state (locator._state)
, _nonLeafInstanceLocator(locator._nonLeafInstanceLocator) , _nonLeafInstanceLocator(locator._nonLeafInstanceLocator)
, _occurrenceLocator (locator._occurrenceLocator) , _occurrenceLocator (locator._occurrenceLocator)
{ } { }
Cell_NonLeafInstanceOccurrences::Locator& Cell_NonLeafInstanceOccurrences::Locator::operator=(const Locator& locator)
// ******************************************************************************************************************** Cell_NonLeafInstanceOccurrences::Locator& Cell_NonLeafInstanceOccurrences::Locator::operator= ( const Locator& locator )
{ {
_cell = locator._cell; _cell = locator._cell;
_topInstance = locator._topInstance;
_state = locator._state; _state = locator._state;
_nonLeafInstanceLocator = locator._nonLeafInstanceLocator; _nonLeafInstanceLocator = locator._nonLeafInstanceLocator;
_occurrenceLocator = locator._occurrenceLocator; _occurrenceLocator = locator._occurrenceLocator;
return *this; return *this;
} }
Occurrence Cell_NonLeafInstanceOccurrences::Locator::getElement() const inline void Cell_NonLeafInstanceOccurrences::Locator::_nonLeafProgress ( bool inCTOR )
// *********************************************************************
{ {
if ( _state ) { if (not _nonLeafInstanceLocator.isValid()) return;
if (not inCTOR) _nonLeafInstanceLocator.progress();
if (not _topInstance) return;
while ( _nonLeafInstanceLocator.isValid() ) {
Instance* nonLeaf = _nonLeafInstanceLocator.getElement();
if (nonLeaf == _topInstance) break;
_nonLeafInstanceLocator.progress();
}
}
Occurrence Cell_NonLeafInstanceOccurrences::Locator::getElement () const
{
if (_state) {
switch ( _state ) { switch ( _state ) {
case 1 : return Occurrence(_nonLeafInstanceLocator.getElement()); case 1 : return Occurrence(_nonLeafInstanceLocator.getElement());
case 2 : case 2 : {
{
Occurrence occurrence = _occurrenceLocator.getElement(); Occurrence occurrence = _occurrenceLocator.getElement();
Entity* entity = occurrence.getEntity(); Entity* entity = occurrence.getEntity();
Path path = Path(_nonLeafInstanceLocator.getElement(), occurrence.getPath()); Path path = Path(_nonLeafInstanceLocator.getElement(), occurrence.getPath());
return Occurrence(entity, path); return Occurrence(entity, path);
} }
} }
} }
return Occurrence(); return Occurrence();
} }
Locator<Occurrence>* Cell_NonLeafInstanceOccurrences::Locator::getClone() const
// *****************************************************************************
{
return new Locator(*this);
}
bool Cell_NonLeafInstanceOccurrences::Locator::isValid() const Locator<Occurrence>* Cell_NonLeafInstanceOccurrences::Locator::getClone () const
// ************************************************************ { return new Locator( *this ); }
{
return ( _state != 0 );
}
void Cell_NonLeafInstanceOccurrences::Locator::progress()
// ******************************************************* bool Cell_NonLeafInstanceOccurrences::Locator::isValid () const
{ return (_state != 0); }
void Cell_NonLeafInstanceOccurrences::Locator::progress ()
{ {
if ( _state ) { if ( _state ) {
switch ( _state ) { switch ( _state ) {
case 1: case 1: {
{ _nonLeafProgress( false );
_nonLeafInstanceLocator.progress(); if (_nonLeafInstanceLocator.isValid()) break;
if ( _nonLeafInstanceLocator.isValid() ) break;
_state = 2; _state = 2;
_nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator(); _nonLeafInstanceLocator = _cell->getNonLeafInstances().getLocator();
if ( not _nonLeafInstanceLocator.isValid() ) { _nonLeafProgress( true );
if (not _nonLeafInstanceLocator.isValid()) {
_state = 0; _state = 0;
break; break;
} }
@ -3750,14 +3708,14 @@ void Cell_NonLeafInstanceOccurrences::Locator::progress()
Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell(); Cell* masterCell = _nonLeafInstanceLocator.getElement()->getMasterCell();
_occurrenceLocator = masterCell->getNonLeafInstanceOccurrences().getLocator(); _occurrenceLocator = masterCell->getNonLeafInstanceOccurrences().getLocator();
if ( _occurrenceLocator.isValid() ) break; if (_occurrenceLocator.isValid()) break;
} }
case 2: case 2:
_occurrenceLocator.progress (); _occurrenceLocator.progress();
while ( (_state != 0) and not _occurrenceLocator.isValid() ) { while ( _state and not _occurrenceLocator.isValid() ) {
_nonLeafInstanceLocator.progress(); _nonLeafProgress( false );
if ( not _nonLeafInstanceLocator.isValid() ) { if (not _nonLeafInstanceLocator.isValid()) {
_state = 0; _state = 0;
break; break;
} }
@ -3769,15 +3727,15 @@ void Cell_NonLeafInstanceOccurrences::Locator::progress()
} }
} }
string Cell_NonLeafInstanceOccurrences::Locator::_getString() const
// ****************************************************************
{
string s = "<" + _TName("Cell::NonLeafInstanceOccurrences::Locator");
if (_cell) s += " " + getString(_cell);
s += ">";
return s;
}
string Cell_NonLeafInstanceOccurrences::Locator::_getString () const
{
string s = "<" + _TName("Cell::NonLeafInstanceOccurrences::Locator");
if (_cell) s += " " + getString(_cell);
if (_topInstance) s += " " + getString(_topInstance);
s += ">";
return s;
}
// **************************************************************************************************** // ****************************************************************************************************

4
hurricane/src/hurricane/hurricane/Cell.h
View File

@ -462,9 +462,9 @@ class Cell : public Entity {
public: Occurrences getOccurrencesUnder(const Box& area, unsigned searchDepth = std::numeric_limits<unsigned int>::max()) const; public: Occurrences getOccurrencesUnder(const Box& area, unsigned searchDepth = std::numeric_limits<unsigned int>::max()) const;
public: Occurrences getTerminalInstanceOccurrences() const; public: Occurrences getTerminalInstanceOccurrences() const;
public: Occurrences getTerminalInstanceOccurrencesUnder(const Box& area) const; public: Occurrences getTerminalInstanceOccurrencesUnder(const Box& area) const;
public: Occurrences getLeafInstanceOccurrences() const; public: Occurrences getLeafInstanceOccurrences( const Instance* topInstance=NULL ) const;
public: Occurrences getLeafInstanceOccurrencesUnder(const Box& area) const; public: Occurrences getLeafInstanceOccurrencesUnder(const Box& area) const;
public: Occurrences getNonLeafInstanceOccurrences() const; public: Occurrences getNonLeafInstanceOccurrences( const Instance* topInstance=NULL ) const;
public: Occurrences getComponentOccurrences(const Layer::Mask& mask = ~0) const; public: Occurrences getComponentOccurrences(const Layer::Mask& mask = ~0) const;
public: Occurrences getComponentOccurrencesUnder(const Box& area, const Layer::Mask& mask = ~0) const; public: Occurrences getComponentOccurrencesUnder(const Box& area, const Layer::Mask& mask = ~0) const;
public: Occurrences getHyperNetRootNetOccurrences() const; public: Occurrences getHyperNetRootNetOccurrences() const;

2
hurricane/src/hurricane/hurricane/DeepNet.h
View File

@ -82,4 +82,6 @@ namespace Hurricane {
} // Hurricane namespace. } // Hurricane namespace.
INSPECTOR_P_SUPPORT(Hurricane::DeepNet);
#endif #endif

15
katana/src/KatanaEngine.cpp
View File

@ -38,6 +38,7 @@
#include "hurricane/RoutingPad.h" #include "hurricane/RoutingPad.h"
#include "hurricane/viewer/Script.h" #include "hurricane/viewer/Script.h"
#include "crlcore/Measures.h" #include "crlcore/Measures.h"
#include "crlcore/AllianceFramework.h"
#include "anabatic/AutoContact.h" #include "anabatic/AutoContact.h"
#include "katana/Block.h" #include "katana/Block.h"
#include "katana/DataNegociate.h" #include "katana/DataNegociate.h"
@ -148,7 +149,9 @@ namespace Katana {
using Hurricane::NetRoutingState; using Hurricane::NetRoutingState;
using Hurricane::NetRoutingExtension; using Hurricane::NetRoutingExtension;
using Hurricane::Cell; using Hurricane::Cell;
using Hurricane::Instance;
using CRL::System; using CRL::System;
using CRL::AllianceFramework;
using CRL::addMeasure; using CRL::addMeasure;
using CRL::Measures; using CRL::Measures;
using CRL::MeasuresSet; using CRL::MeasuresSet;
@ -311,6 +314,18 @@ namespace Katana {
KatanaEngine* KatanaEngine::create ( Cell* cell ) KatanaEngine* KatanaEngine::create ( Cell* cell )
{ {
AllianceFramework* af = AllianceFramework::get();
for ( Instance* instance : cell->getInstances() ) {
if (af->isPad(instance->getMasterCell())) {
throw Error( "KatanaEngine::create(): Must not be run at chip level, but a corona level.\n"
" Guessing \"%s\" is a chip because instance \"%s\" is a pad (\"%s\")."
, getString(cell->getName()).c_str()
, getString(instance->getName()).c_str()
, getString(instance->getMasterCell()->getName()).c_str()
);
}
}
KatanaEngine* katana = new KatanaEngine ( cell ); KatanaEngine* katana = new KatanaEngine ( cell );
katana->_postCreate(); katana->_postCreate();

4
katana/src/PowerRails.cpp
View File

@ -824,7 +824,7 @@ namespace {
_planes.insert( make_pair(regular->getBasicLayer(),new Plane(regular,rp)) ); _planes.insert( make_pair(regular->getBasicLayer(),new Plane(regular,rp)) );
if (lg->getType() == Constant::PinOnly) continue; //if (lg->getType() == Constant::PinOnly) continue;
const BasicLayer* blockageLayer = regular->getBasicLayer()->getBlockageLayer(); const BasicLayer* blockageLayer = regular->getBasicLayer()->getBlockageLayer();
if (not blockageLayer) continue; if (not blockageLayer) continue;
@ -1182,7 +1182,7 @@ namespace Katana {
QueryPowerRails query ( this ); QueryPowerRails query ( this );
Technology* technology = DataBase::getDB()->getTechnology(); Technology* technology = DataBase::getDB()->getTechnology();
for( BasicLayer* layer : technology->getBasicLayers() ) { for ( BasicLayer* layer : technology->getBasicLayers() ) {
if ( (layer->getMaterial() != BasicLayer::Material::metal) if ( (layer->getMaterial() != BasicLayer::Material::metal)
and (layer->getMaterial() != BasicLayer::Material::blockage) ) and (layer->getMaterial() != BasicLayer::Material::blockage) )
continue; continue;