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

Added analog type on segment NetRoutingProperty. 

* New: In Anabatic_AutoSegments collection, added a Flag to the constructors
    to allow different behavior between digital and analog modes.
      For "Aligneds" and "Perpandiculars" collections, now manage a new
    Flag WithDoglegs to follow aligned globals through local doglegs
    (for analog nets).
      Adjust the log level of collections to 144 (formerly 145).
* New: In Anabatic::AutoSegment, new flag SegAnalog for segments that are
    part of an analog net.
      Note that with this flag, we reach the 32 bits limit...
* Change: In Anabatic::Constants, Flags are now declared as BaseFlags
    objects and *not* uint64_t. This avoids overload resolution problems with
    arithmetical overload of the operators.
      The BaseFlags/Flags types are now completly "isolated" from the
    uint64_t, it has the advantage of showing where unwanted previous implicit
    conversions where occuring.
* Change: In Katana::Constants, Flags values are now of BaseFlags type instead
    of uint64_t.
* Change: In Anabatic::Dijkstra, lots of log cleanup.
* Change: In Anabatic::GCell::getSide(), make the "shrink" parameter visible
    to allow to substract the topmost and rightmost track for axis span
    computation in AutoSegment::computeOptimal(). Used for analog mode.
* Change: In NetRoutingState, added a flag for analog mode. Use uint32_t
    for the flags type.
* New: In Isobar, export the NetRoutingState and NetRoutingExtension objects.
This commit is contained in:
Jean-Paul Chaput 2017-05-20 12:33:12 +02:00
parent c1be52f0e2
commit e78c3f21ef
35 changed files with 1155 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
anabatic/src/AutoHorizontal.cpp
View File

@ -185,7 +185,7 @@ namespace Anabatic {
GCell* gcell = getAutoSource()->getGCell();
GCell* end = getAutoTarget()->getGCell();
cdebug_log(149,0) << "yprobe: " << DbU::getValueString(yprobe) << endl;
cdebug_log(144,0) << "yprobe: " << DbU::getValueString(yprobe) << endl;
if (gcell->getXMin() > end->getXMin()) std::swap( gcell, end );
if (yprobe == gcell->getConstraintYMax()) yprobe--;
@ -808,6 +808,11 @@ namespace Anabatic {
segment2->setFlags( SegWeakTerminal1 );
}
if (isAnalog()) {
segment1->setFlags( SegAnalog );
segment2->setFlags( SegAnalog );
}
cdebug_log(149,0) << "Session::dogleg[x+1] perpand: " << segment1 << endl;
cdebug_log(149,0) << "Session::dogleg[x+2] new paral: " << segment2 << endl;
cdebug_log(149,0) << "Session::dogleg[x+0] original: " << this << endl;

95
anabatic/src/AutoSegment.cpp
View File

@ -303,9 +303,13 @@ namespace Anabatic {
// Class : "Anabatic::AutoSegment".
size_t AutoSegment::_allocateds = 0;
size_t AutoSegment::_globalsCount = 0;
unsigned long AutoSegment::_maxId = 0;
size_t AutoSegment::_allocateds = 0;
size_t AutoSegment::_globalsCount = 0;
bool AutoSegment::_analogMode = false;
void AutoSegment::setAnalogMode ( bool state ) { _analogMode = state; }
bool AutoSegment::getAnalogMode () { return _analogMode; }
AutoSegment::AutoSegment ( Segment* segment )
@ -334,6 +338,7 @@ namespace Anabatic {
if (source->isTerminal()) setFlags( SegSourceTerminal );
if (target->isTerminal()) setFlags( SegTargetTerminal );
if (_analogMode) setFlags( SegAnalog );
source->invalidate( Flags::Topology );
}
@ -630,20 +635,20 @@ namespace Anabatic {
AutoSegments AutoSegment::getAligneds ( Flags flags )
{
cdebug_log(145,0) << "AutoSegment::getAligneds() - flags:" << flags << endl;
cdebug_log(145,0) << "AutoSegment::getAligneds() - flags:" << flags.asString(FlagsFunction) << endl;
return AutoSegments_Aligneds( this, flags );
}
AutoSegments AutoSegment::getConnecteds ( Flags flags )
{
cdebug_log(145,0) << "AutoSegment::getConnecteds() - flags:" << flags << endl;
cdebug_log(145,0) << "AutoSegment::getConnecteds() - flags:" << flags.asString(FlagsFunction) << endl;
return AutoSegments_Connecteds( this, flags );
}
AutoSegments AutoSegment::getPerpandiculars ()
{ return AutoSegments_Perpandiculars( this ); }
AutoSegments AutoSegment::getPerpandiculars ( Flags flags )
{ return AutoSegments_Perpandiculars( this, flags ); }
bool AutoSegment::checkDepthSpin () const
@ -916,21 +921,50 @@ namespace Anabatic {
{
cdebug_log(145,1) << "computeOptimal() - " << this << endl;
DbU::Unit optimalMin;
DbU::Unit optimalMax;
DbU::Unit constraintMin;
DbU::Unit constraintMax;
DbU::Unit optimalMin;
DbU::Unit optimalMax;
DbU::Unit constraintMin;
DbU::Unit constraintMax;
vector<AutoSegment*> aligneds;
getConstraints( constraintMin, constraintMax );
if (isUserDefined()) {
optimalMin = optimalMax = getAxis();
aligneds.push_back( this );
} else {
DbU::Unit minGCell = getOrigin();
DbU::Unit maxGCell = getExtremity();
DbU::Unit terminalMin;
DbU::Unit terminalMax;
AttractorsMap attractors;
Flags flags = (isAnalog() ? Flags::WithDoglegs : Flags::NoFlags);
Flags f2 = flags | Flags::WithSelf;
cdebug_log(145,0) << "Test | :" << flags.asString(FlagsFunction) << endl;
getAligneds( Flags::WithSelf|flags ).fill( aligneds );
if (not getGCell()->isMatrix()) {
Flags direction = (isHorizontal()) ? Flags::Vertical : Flags::Horizontal;
Interval gcellSide ( false );
vector<GCell*> gcells;
DbU::Unit pitch = getPitch();
cdebug_log(145,0) << "Using pitch for L/T shrink:" << DbU::getValueString(pitch) << endl;
for ( AutoSegment* aligned : aligneds ) {
aligned->getGCells( gcells );
for ( GCell* gcell : gcells ) {
gcellSide.intersection( gcell->getSide(direction,pitch) );
cdebug_log(145,0) << "| gcellSide:" << gcellSide << " (from " << gcell << ")" << endl;
}
}
minGCell = gcellSide.getVMin();
maxGCell = gcellSide.getVMax();
}
cdebug_log(145,0) << "GCell interval [" << DbU::getValueString(minGCell)
<< ":" << DbU::getValueString(maxGCell) << "]" << endl;
AutoContact* anchor = getAutoSource();
if (anchor->isTerminal()) {
@ -964,9 +998,11 @@ namespace Anabatic {
attractors.addAttractor( terminalMax );
}
forEach( AutoSegment*, autoSegment, getPerpandiculars() ) {
cdebug_log(145,1) << "| Perpandicular " << *autoSegment << endl;
for ( AutoSegment* autoSegment : getPerpandiculars(flags) ) {
cdebug_log(145,1) << "| Perpandicular " << autoSegment << endl;
if (autoSegment->isGlobal()) {
cdebug_log(145,0) << "Used as global." << endl;
// Sloppy implentation.
DbU::Unit perpandMin = autoSegment->getSourceU();
DbU::Unit perpandMax = autoSegment->getTargetU();
@ -980,7 +1016,7 @@ namespace Anabatic {
DbU::Unit terminalMin;
DbU::Unit terminalMax;
if (getTerminalInterval( *autoSegment
if (getTerminalInterval( autoSegment
, NULL
, isHorizontal()
, terminalMin
@ -1022,19 +1058,26 @@ namespace Anabatic {
setInBound( constraintMin, constraintMax, optimalMin );
setInBound( constraintMin, constraintMax, optimalMax );
cdebug_log(145,0) << "Applying constraint on: " << this << endl;
setOptimalMin( optimalMin );
setOptimalMax( optimalMax );
processeds.insert( this );
if (not isNotAligned()) {
for ( AutoSegment* autoSegment : getAligneds() ) {
cdebug_log(145,0) << "Applying constraint on: " << autoSegment << endl;
autoSegment->setOptimalMin( optimalMin );
autoSegment->setOptimalMax( optimalMax );
processeds.insert( autoSegment );
}
for ( AutoSegment* aligned : aligneds ) {
cdebug_log(145,0) << "Applying constraint on: " << aligned << endl;
aligned->setOptimalMin( optimalMin );
aligned->setOptimalMax( optimalMax );
processeds.insert( aligned );
}
// cdebug_log(145,0) << "Applying constraint on: " << this << endl;
// setOptimalMin( optimalMin );
// setOptimalMax( optimalMax );
// processeds.insert( this );
// if (not isNotAligned()) {
// for ( AutoSegment* autoSegment : getAligneds() ) {
// cdebug_log(145,0) << "Applying constraint on: " << autoSegment << endl;
// autoSegment->setOptimalMin( optimalMin );
// autoSegment->setOptimalMax( optimalMax );
// processeds.insert( autoSegment );
// }
// }
cdebug_tabw(145,-1);
}
@ -2295,7 +2338,7 @@ namespace Anabatic {
continue;
}
if (autoSegment->isHorizontal() xor (flags & Flags::Horizontal)) continue;
if (autoSegment->isHorizontal() xor (bool)(flags & Flags::Horizontal)) continue;
cdebug_log(145,0) << "| " << autoSegment << endl;

102
anabatic/src/AutoSegments.cpp
View File

@ -20,6 +20,36 @@
#include "anabatic/AutoSegment.h"
namespace {
using namespace Anabatic;
AutoContact* isLocalDogleg ( AutoSegment* current, AutoContact* from, AutoSegment* master )
{
if (not current->isLocal() or not from->isTurn()) return NULL;
AutoContact* to = current->getOppositeAnchor( from );
if (not to->isTurn()) return NULL;
AutoSegment* targetGlobal = to->getPerpandicular( current );
if (not targetGlobal->isGlobal() or (master->getLayer() != targetGlobal->getLayer())) return NULL;
cdebug_log(144,0) << "Global aligned though dogleg:" << targetGlobal << endl;
Interval masterConstraints;
Interval targetConstraints;
master ->getConstraints( masterConstraints );
targetGlobal->getConstraints( targetConstraints );
if (not targetConstraints.intersect(masterConstraints)) return NULL;
return to;
}
} // Anonymous namespace.
namespace Anabatic {
using namespace std;
@ -36,7 +66,7 @@ namespace Anabatic {
void AutoSegmentStack::push ( AutoContact* contact, AutoSegment* segment )
{
cdebug_log(145,0) << "Stacking " << contact << " + " << segment << endl;
cdebug_log(144,0) << "Stacking " << contact << " + " << segment << endl;
push_back( make_pair(contact,segment) );
}
@ -299,9 +329,13 @@ namespace Anabatic {
, _stack ()
{
if (not _master) return;
_flags |= (_master->isHorizontal()) ? Flags::Horizontal : Flags::Vertical;
cdebug_log(145,0) << "AutoSegments_Aligneds::Locator::Locator() - _flags:" << _flags << endl;
cdebug_log(145,0) << "Flags:" << _flags.asString(FlagsFunction) << endl;
_flags |= (_master->isHorizontal()) ? Flags::Horizontal : Flags::Vertical;
if (_flags & Flags::WithDoglegs) _flags |= Flags::WithPerpands;
cdebug_log(144,0) << "AutoSegments_Aligneds::Locator::Locator() _flags:" << _flags.asString(FlagsFunction) << endl;
AutoContact* contact = segment->getAutoSource();
if (contact) _stack.push( contact, segment );
@ -330,29 +364,45 @@ namespace Anabatic {
AutoSegment* sourceSegment = _stack.getAutoSegment ();
_stack.pop ();
cdebug_log(144,1) << "Iterate over: " << sourceContact << endl;
LocatorHelper helper (sourceContact, _flags);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
cdebug_log(145,0) << "Looking at: " << currentSegment << endl;
cdebug_log(144,0) << "| " << currentSegment << endl;
if (currentSegment == sourceSegment) continue;
if ( (not (_flags & Flags::NoCheckLayer))
and AutoSegment::areAlignedsAndDiffLayer(currentSegment,_master)) {
cerr << Error("Aligned segments not in same layer (aligneds locator)\n"
" %s\n"
" %s."
,getString(_master).c_str()
,getString(currentSegment).c_str()) << endl;
continue;
}
if (AutoSegment::areAligneds(currentSegment,_master)) {
if ( (not (_flags & Flags::NoCheckLayer))
and AutoSegment::areAlignedsAndDiffLayer(currentSegment,_master)) {
cerr << Error( "Aligned segments not in same layer (aligneds locator)\n"
" %s\n"
" %s."
,getString(_master).c_str()
,getString(currentSegment).c_str() ) << endl;
continue;
}
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
if (targetContact) _stack.push( targetContact, currentSegment );
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
if (targetContact) _stack.push( targetContact, currentSegment );
} else {
if (_flags & Flags::WithDoglegs) {
AutoContact* targetContact = isLocalDogleg( currentSegment, sourceContact, _master );
if (targetContact) {
cdebug_log(144,0) << "Stacking dogleg global. " << endl;
_stack.push( targetContact, currentSegment );
continue;
}
}
}
}
cdebug_tabw(144,-1);
if (_stack.getAutoSegment() == _master) continue;
if (not AutoSegment::areAligneds(_stack.getAutoSegment(),_master)) continue;
break;
}
}
@ -397,8 +447,8 @@ namespace Anabatic {
, _stack ()
, _perpandiculars()
{
cdebug_log(145,0) << "AutoSegments_Perpandiculars::Locator::Locator()" << endl;
cdebug_log(145,0) << " " << _master << endl;
cdebug_log(144,0) << "AutoSegments_Perpandiculars::Locator::Locator(): _flags:" << _flags.asString(FlagsFunction) << endl;
cdebug_log(144,0) << " " << _master << endl;
if (not _master) return;
if (_master->isHorizontal()) _flags |= Flags::Horizontal;
@ -423,7 +473,7 @@ namespace Anabatic {
void AutoSegments_Perpandiculars::Locator::progress ()
{
cdebug_log(145,1) << "AutoSegments_Perpandiculars::Locator::progress()" << endl;
cdebug_log(144,1) << "AutoSegments_Perpandiculars::Locator::progress()" << endl;
if (not _perpandiculars.empty()) _perpandiculars.pop_back();
if (not _perpandiculars.empty()) return;
@ -433,14 +483,14 @@ namespace Anabatic {
AutoSegment* sourceSegment = _stack.getAutoSegment();
_stack.pop();
cdebug_log(145,0) << "Iterate over: " << sourceContact << endl;
cdebug_log(144,0) << "Iterate over: " << sourceContact << endl;
LocatorHelper helper (sourceContact, _flags);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
if (currentSegment == sourceSegment) continue;
cdebug_log(145,0) << "| " << currentSegment << endl;
cdebug_log(144,0) << "| " << currentSegment << endl;
if (AutoSegment::areAligneds(currentSegment,_master)) {
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
@ -449,7 +499,7 @@ namespace Anabatic {
if (_master->getLayer() != currentSegment->getLayer()) {
continue;
}
cdebug_log(145,0) << "Stacking target. " << endl;
cdebug_log(144,0) << "Stacking target. " << endl;
_stack.push( targetContact, currentSegment );
// if ( (_master->isHorizontal() and sourceContact->isHTee())
@ -463,11 +513,11 @@ namespace Anabatic {
// continue;
// }
// cdebug_log(145,0) << "Stacking target. " << endl;
// cdebug_log(144,0) << "Stacking target. " << endl;
// _stack.push( targetContact, currentSegment );
// }
} else {
cdebug_log(145,0) << "No opposite anchor to: " << sourceContact << endl;
cdebug_log(144,0) << "No opposite anchor to: " << sourceContact << endl;
}
} else {
if ( (_flags & Flags::WithDoglegs) and currentSegment->isLocal() and sourceContact->isTurn() ) {
@ -475,13 +525,13 @@ namespace Anabatic {
if (targetContact->isTurn()) {
AutoSegment* targetGlobal = targetContact->getPerpandicular( currentSegment );
if (targetGlobal->isGlobal() and (_master->getLayer() == targetGlobal->getLayer())) {
cdebug_log(145,0) << "Global aligned though dogleg:" << targetGlobal << endl;
cdebug_log(144,0) << "Global aligned though dogleg:" << targetGlobal << endl;
Interval masterConstraints;
Interval targetConstraints;
_master ->getConstraints( masterConstraints );
targetGlobal->getConstraints( targetConstraints );
if (targetConstraints.intersect(masterConstraints)) {
cdebug_log(145,0) << "Stacking dogleg global. " << endl;
cdebug_log(144,0) << "Stacking dogleg global. " << endl;
_stack.push( targetContact, currentSegment );
continue;
}
@ -497,7 +547,7 @@ namespace Anabatic {
if (not _perpandiculars.empty()) break;
}
cdebug_tabw(145,-1);
cdebug_tabw(144,-1);
}

7
anabatic/src/AutoVertical.cpp
View File

@ -181,7 +181,7 @@ namespace Anabatic {
GCell* gcell = getAutoSource()->getGCell();
GCell* end = getAutoTarget()->getGCell();
cdebug_log(149,0) << "xprobe: " << DbU::getValueString(xprobe) << endl;
cdebug_log(144,0) << "xprobe: " << DbU::getValueString(xprobe) << endl;
if (gcell->getYMin() > end->getYMin()) std::swap( gcell, end );
if (xprobe == gcell->getConstraintXMax()) xprobe--;
@ -722,6 +722,11 @@ namespace Anabatic {
segment2->setFlags( SegWeakTerminal1 );
}
if (isAnalog()) {
segment1->setFlags( SegAnalog );
segment2->setFlags( SegAnalog );
}
cdebug_log(149,0) << "Session::dogleg[x+1] perpand: " << segment1 << endl;
cdebug_log(149,0) << "Session::dogleg[x+2] new paral: " << segment2 << endl;
cdebug_log(149,0) << "Session::dogleg[x+0] original: " << this << endl;

189
anabatic/src/Constants.cpp
View File

@ -14,82 +14,131 @@
// +-----------------------------------------------------------------+
#include <string>
#include "anabatic/Constants.h"
namespace Anabatic {
using std::string;
using std::ostringstream;
using Hurricane::BaseFlags;
const uint64_t Flags::NoFlags = 0;
const BaseFlags Flags::NoFlags = 0;
// Flags used for both objects states & functions arguments.
const uint64_t Flags::Horizontal = (1L << 0);
const uint64_t Flags::Vertical = (1L << 1);
const uint64_t Flags::Source = (1L << 2);
const uint64_t Flags::Target = (1L << 3);
const uint64_t Flags::Invalidated = (1L << 4);
const BaseFlags Flags::Horizontal = (1L << 0);
const BaseFlags Flags::Vertical = (1L << 1);
const BaseFlags Flags::Source = (1L << 2);
const BaseFlags Flags::Target = (1L << 3);
const BaseFlags Flags::Invalidated = (1L << 4);
// Flags for GCell objects states only.
const uint64_t Flags::DeviceGCell = (1L << 5);
const uint64_t Flags::HChannelGCell = (1L << 6);
const uint64_t Flags::VChannelGCell = (1L << 7);
const uint64_t Flags::StrutGCell = (1L << 8);
const uint64_t Flags::MatrixGCell = (1L << 9);
const uint64_t Flags::IoPadGCell = (1L << 10);
const uint64_t Flags::Saturated = (1L << 11);
const BaseFlags Flags::DeviceGCell = (1L << 5);
const BaseFlags Flags::HChannelGCell = (1L << 6);
const BaseFlags Flags::VChannelGCell = (1L << 7);
const BaseFlags Flags::StrutGCell = (1L << 8);
const BaseFlags Flags::MatrixGCell = (1L << 9);
const BaseFlags Flags::IoPadGCell = (1L << 10);
const BaseFlags Flags::Saturated = (1L << 11);
// Flags for Anabatic objects states only.
const uint64_t Flags::DemoMode = (1L << 5);
const uint64_t Flags::WarnOnGCellOverload = (1L << 6);
const uint64_t Flags::DestroyGCell = (1L << 7);
const uint64_t Flags::DestroyBaseContact = (1L << 8);
const uint64_t Flags::DestroyBaseSegment = (1L << 9);
const BaseFlags Flags::DemoMode = (1L << 5);
const BaseFlags Flags::WarnOnGCellOverload = (1L << 6);
const BaseFlags Flags::DestroyGCell = (1L << 7);
const BaseFlags Flags::DestroyBaseContact = (1L << 8);
const BaseFlags Flags::DestroyBaseSegment = (1L << 9);
// Flags for NetDatas objects states only.
const uint64_t Flags::GlobalRouted = (1L << 5);
const BaseFlags Flags::GlobalRouted = (1L << 5);
// Masks.
const uint64_t Flags::WestSide = Horizontal|Target;
const uint64_t Flags::EastSide = Horizontal|Source;
const uint64_t Flags::SouthSide = Vertical |Target;
const uint64_t Flags::NorthSide = Vertical |Source;
const uint64_t Flags::AllSides = WestSide|EastSide|SouthSide|NorthSide ;
const uint64_t Flags::EndsMask = Source|Target;
const uint64_t Flags::DirectionMask = Horizontal|Vertical;
const uint64_t Flags::DestroyMask = DestroyGCell|DestroyBaseContact|DestroyBaseSegment;
const uint64_t Flags::GCellTypeMask = DeviceGCell|HChannelGCell|VChannelGCell|StrutGCell|MatrixGCell|IoPadGCell;
const BaseFlags Flags::WestSide = Horizontal|Target;
const BaseFlags Flags::EastSide = Horizontal|Source;
const BaseFlags Flags::SouthSide = Vertical |Target;
const BaseFlags Flags::NorthSide = Vertical |Source;
const BaseFlags Flags::AllSides = WestSide|EastSide|SouthSide|NorthSide ;
const BaseFlags Flags::EndsMask = Source|Target;
const BaseFlags Flags::DirectionMask = Horizontal|Vertical;
const BaseFlags Flags::DestroyMask = DestroyGCell|DestroyBaseContact|DestroyBaseSegment;
const BaseFlags Flags::GCellTypeMask = DeviceGCell|HChannelGCell|VChannelGCell|StrutGCell|MatrixGCell|IoPadGCell;
// Flags for functions arguments only.
const uint64_t Flags::Create = (1L << 5);
const uint64_t Flags::WithPerpands = (1L << 6);
const uint64_t Flags::WithDoglegs = (1L << 7);
const uint64_t Flags::WithSelf = (1L << 8);
const uint64_t Flags::AboveLayer = (1L << 9);
const uint64_t Flags::BelowLayer = (1L << 10);
const uint64_t Flags::OpenSession = (1L << 11);
const uint64_t Flags::Realignate = (1L << 12);
const uint64_t Flags::NativeConstraints = (1L << 13);
const uint64_t Flags::ForceMove = (1L << 14);
const uint64_t Flags::WarnOnError = (1L << 15);
const uint64_t Flags::Topology = (1L << 16);
const uint64_t Flags::GlobalSegment = (1L << 17);
const uint64_t Flags::AllowTerminal = (1L << 18);
const uint64_t Flags::AllowLocal = (1L << 19);
const uint64_t Flags::IgnoreContacts = (1L << 20);
const uint64_t Flags::Propagate = (1L << 21);
const uint64_t Flags::Superior = (1L << 22);
const uint64_t Flags::DoglegOnLeft = (1L << 23);
const uint64_t Flags::DoglegOnRight = (1L << 24);
const uint64_t Flags::WithNeighbors = (1L << 25);
const uint64_t Flags::NoCheckLayer = (1L << 26);
const uint64_t Flags::HalfSlacken = (1L << 27);
const uint64_t Flags::NoGCellShrink = (1L << 28);
const uint64_t Flags::CParanoid = (1L << 29);
const uint64_t Flags::CheckLowDensity = (1L << 30);
const uint64_t Flags::CheckLowUpDensity = (1L << 31);
const uint64_t Flags::NoUpdate = (1L << 32);
const BaseFlags Flags::Create = (1L << 5);
const BaseFlags Flags::WithPerpands = (1L << 6);
const BaseFlags Flags::WithDoglegs = (1L << 7);
const BaseFlags Flags::WithSelf = (1L << 8);
const BaseFlags Flags::AboveLayer = (1L << 9);
const BaseFlags Flags::BelowLayer = (1L << 10);
const BaseFlags Flags::OpenSession = (1L << 11);
const BaseFlags Flags::Realignate = (1L << 12);
const BaseFlags Flags::NativeConstraints = (1L << 13);
const BaseFlags Flags::ForceMove = (1L << 14);
const BaseFlags Flags::WarnOnError = (1L << 15);
const BaseFlags Flags::Topology = (1L << 16);
const BaseFlags Flags::GlobalSegment = (1L << 17);
const BaseFlags Flags::AllowTerminal = (1L << 18);
const BaseFlags Flags::AllowLocal = (1L << 19);
const BaseFlags Flags::IgnoreContacts = (1L << 20);
const BaseFlags Flags::Propagate = (1L << 21);
const BaseFlags Flags::Superior = (1L << 22);
const BaseFlags Flags::DoglegOnLeft = (1L << 23);
const BaseFlags Flags::DoglegOnRight = (1L << 24);
const BaseFlags Flags::WithNeighbors = (1L << 25);
const BaseFlags Flags::NoCheckLayer = (1L << 26);
const BaseFlags Flags::HalfSlacken = (1L << 27);
const BaseFlags Flags::NoGCellShrink = (1L << 28);
const BaseFlags Flags::CParanoid = (1L << 29);
const BaseFlags Flags::CheckLowDensity = (1L << 30);
const BaseFlags Flags::CheckLowUpDensity = (1L << 31);
const BaseFlags Flags::NoUpdate = (1L << 32);
Flags::~Flags ()
{ }
string Flags::asString ( uint32_t mode ) const
{
ostringstream s;
s << ((_flags & (uint64_t)Horizontal ) ? "h" : "-");
s << ((_flags & (uint64_t)Vertical ) ? "v" : "-");
s << ((_flags & (uint64_t)Source ) ? "S" : "-");
s << ((_flags & (uint64_t)Target ) ? "T" : "-");
s << ((_flags & (uint64_t)Invalidated) ? "i" : "-");
switch ( mode ) {
case FlagsFunction:
s << ((_flags & (uint64_t)Create ) ? "C" : "-");
s << ((_flags & (uint64_t)WithPerpands ) ? "P" : "-");
s << ((_flags & (uint64_t)WithDoglegs ) ? "D" : "-");
s << ((_flags & (uint64_t)WithSelf ) ? "s" : "-");
s << ((_flags & (uint64_t)AboveLayer ) ? "a" : "-");
s << ((_flags & (uint64_t)BelowLayer ) ? "b" : "-");
s << ((_flags & (uint64_t)OpenSession ) ? "o" : "-");
s << ((_flags & (uint64_t)Realignate ) ? "R" : "-");
s << ((_flags & (uint64_t)NativeConstraints) ? "N" : "-");
s << ((_flags & (uint64_t)ForceMove ) ? "m" : "-");
s << ((_flags & (uint64_t)WarnOnError ) ? "w" : "-");
s << ((_flags & (uint64_t)Topology ) ? "t" : "-");
s << ((_flags & (uint64_t)GlobalSegment ) ? "G" : "-");
s << ((_flags & (uint64_t)AllowTerminal ) ? "t" : "-");
s << ((_flags & (uint64_t)AllowLocal ) ? "l" : "-");
s << ((_flags & (uint64_t)IgnoreContacts ) ? "i" : "-");
s << ((_flags & (uint64_t)Propagate ) ? "p" : "-");
s << ((_flags & (uint64_t)Superior ) ? "S" : "-");
s << ((_flags & (uint64_t)DoglegOnLeft ) ? "L" : "-");
s << ((_flags & (uint64_t)DoglegOnRight ) ? "R" : "-");
s << ((_flags & (uint64_t)WithNeighbors ) ? "N" : "-");
s << ((_flags & (uint64_t)NoCheckLayer ) ? "L" : "-");
s << ((_flags & (uint64_t)HalfSlacken ) ? "h" : "-");
s << ((_flags & (uint64_t)NoGCellShrink ) ? "s" : "-");
s << ((_flags & (uint64_t)CParanoid ) ? "p" : "-");
s << ((_flags & (uint64_t)CheckLowDensity ) ? "l" : "-");
s << ((_flags & (uint64_t)CheckLowUpDensity) ? "u" : "-");
s << ((_flags & (uint64_t)NoUpdate ) ? "u" : "-");
break;
}
s << " (" << value() << ")";
return s.str();
}
string Flags::_getTypeName () const
{ return "Anabatic::Flags"; }
@ -97,20 +146,20 @@ namespace Anabatic {
string Flags::_getString () const
{
string s = "";
s += (_flags & Horizontal ) ? 'h' : '-';
s += (_flags & Vertical ) ? 'v' : '-';
s += (_flags & Source ) ? 'S' : '-';
s += (_flags & Target ) ? 'T' : '-';
s += (_flags & DeviceGCell ) ? 'd' : '-';
s += (_flags & HChannelGCell) ? 'c' : '-';
s += (_flags & VChannelGCell) ? 'c' : '-';
s += (_flags & StrutGCell ) ? 's' : '-';
s += (_flags & MatrixGCell ) ? 'm' : '-';
s += (_flags & (uint64_t)Horizontal ) ? 'h' : '-';
s += (_flags & (uint64_t)Vertical ) ? 'v' : '-';
s += (_flags & (uint64_t)Source ) ? 'S' : '-';
s += (_flags & (uint64_t)Target ) ? 'T' : '-';
s += (_flags & (uint64_t)DeviceGCell ) ? 'd' : '-';
s += (_flags & (uint64_t)HChannelGCell) ? 'c' : '-';
s += (_flags & (uint64_t)VChannelGCell) ? 'c' : '-';
s += (_flags & (uint64_t)StrutGCell ) ? 's' : '-';
s += (_flags & (uint64_t)MatrixGCell ) ? 'm' : '-';
s += ",";
s += (_flags & Invalidated ) ? 'i' : '-';
s += (_flags & DestroyGCell ) ? 'D' : '-';
s += (_flags & AboveLayer ) ? 'A' : '-';
s += (_flags & BelowLayer ) ? 'B' : '-';
s += (_flags & (uint64_t)Invalidated ) ? 'i' : '-';
s += (_flags & (uint64_t)DestroyGCell ) ? 'D' : '-';
s += (_flags & (uint64_t)AboveLayer ) ? 'A' : '-';
s += (_flags & (uint64_t)BelowLayer ) ? 'B' : '-';
return s;
}

174
anabatic/src/Dijkstra.cpp
View File

@ -1106,21 +1106,22 @@ namespace Anabatic {
+ "-" + DbU::getValueString(_gcell->getYMin())
+ "-" + DbU::getValueString(_gcell->getXMax())
+ "-" + DbU::getValueString(_gcell->getYMax()) + ")"
/*+ " rps:" + getString(_rpCount)
+ " deg:" + getString(_degree)
+ " connexId:" + ((_connexId >= 0) ? getString(_connexId) : "None")*/
//+ " rps:" + getString(_rpCount)
//+ " deg:" + getString(_degree)
+ " connexId:" + ((_connexId >= 0) ? getString(_connexId) : "None")
+ " d:" + ((_distance == unreached) ? "unreached"
: ((_distance == unreachable) ? "unreachable"
: DbU::getValueString(_distance)) )
/*+ "+" + getString(_branchId)
+ " stamp:" + (hasValidStamp() ? "valid" : "outdated")*/
//+ "+" + getString(_branchId)
//+ " stamp:" + (hasValidStamp() ? "valid" : "outdated")
+ " from:" + ((_from) ? "set" : "NULL")
//+ " from2:" + ((_adata) ? _adata->getFrom2() : "NULL")
+ " restricted:" + (isNRestricted() ? "N" : "-")
//+ " from2:" + ((_adata) ? _adata->getFrom2() : "NULL")
+ " restricted:"
+ (isNRestricted() ? "N" : "-")
+ (isSRestricted() ? "S" : "-")
+ (isERestricted() ? "E" : "-")
+ (isWRestricted() ? "W" : "-")
//+ " isiSet:" +(isiSet() ? "1" : "0")
//+ " isiSet:" +(isiSet() ? "1" : "0")
+ ">";
return s;
}
@ -1241,9 +1242,10 @@ namespace Anabatic {
for ( Component* component : _net->getComponents() ) {
RoutingPad* rp = dynamic_cast<RoutingPad*>( component );
if (rp) {
if ( _attachSymContactsHook( rp ) ) continue; // ANALOG
rps.push_back( rp );
if (_attachSymContactsHook(rp)) continue; // ANALOG
cdebug_log(112,0) << "| " << rp << endl;
rps.push_back( rp );
continue;
}
}
@ -1267,9 +1269,9 @@ namespace Anabatic {
continue;
}
cdebug_log(112,0) << "Current Search area: " << _searchArea << ", gcell: " << gcell << endl;
cdebug_log(112,0) << "Merge search area: " << _searchArea << ", gcell: " << gcell << endl;
_searchArea.merge( gcell->getBoundingBox() );
cdebug_log(112,0) << "New Search area: " << _searchArea << endl;
cdebug_log(112,0) << "Search area: " << _searchArea << endl;
Vertex* seed = gcell->getObserver<Vertex>(GCell::Observable::Vertex);
GCell* gseed = seed->getGCell();
@ -1302,6 +1304,7 @@ namespace Anabatic {
}
_searchArea.inflate( _searchAreaHalo );
cdebug_log(112,0) << "Search halo: " << _searchAreaHalo << endl;
cdebug_log(112,0) << "Search area: " << _searchArea << endl;
setAxisTargets();
@ -1514,95 +1517,109 @@ namespace Anabatic {
{
cdebug_log(112,1) << "Dijkstra::_propagate() " << _net << endl;
while ( not _queue.empty() ) {
cdebug_log(111,0) << "Number of targets left: " << _targets.size() << " and needaxis? " << needAxisTarget() << endl;
cdebug_log(111,0) << "Number of targets left: " << _targets.size()
<< " and needaxis? " << needAxisTarget() << endl;
_queue.dump();
Vertex* current = _queue.top();
GCell* gcurrent = current->getGCell();
cdebug_log(111,0) << endl << "[Current Vertex]: " << current << ", current->getConnexId() == _connectedsId):" << (current->getConnexId() == _connectedsId)<< ", (current->getConnexId() < 0): " << current->getConnexId() << endl;
cdebug_log(111,1) << "Current:" << current << endl;
_queue.pop();
if ( current->isAxisTarget() and needAxisTarget()) unsetFlags(Mode::AxisTarget);
else if ((current->getConnexId() == _connectedsId) or (current->getConnexId() < 0)) {
cdebug_log(111,1) << "Looking for neighbors:" << endl;
for ( Edge* edge : current->getGCell()->getEdges() ) {
cdebug_log(111,0) << endl << "===================================================================================" << endl << endl;
cdebug_log(111,0) << "@ Edge " << edge << endl;
if (edge == current->getFrom()) {
cdebug_log(111,0) << "edge == current->getFrom()" << endl;
cdebug_log(111,0) << "| Reject: edge == current->getFrom()" << endl;
continue;
} else cdebug_log(111,0) << "edge != current->getFrom()" << endl;
}
if (_checkFrom2(edge, current)) continue; // ANALOG
if (_checkFrom2(edge, current)) { // ANALOG
cdebug_log(111,0) << "| Reject: _checkFrom2()" << endl;
continue;
}
GCell* gneighbor = edge->getOpposite(current->getGCell());
Vertex* vneighbor = gneighbor->getObserver<Vertex>(GCell::Observable::Vertex);
if (!gneighbor->isMatrix()) vneighbor->createAData();
Vertex* vneighbor = gneighbor->getObserver<Vertex>( GCell::Observable::Vertex );
if (not gneighbor->isMatrix()) vneighbor->createAData();
cdebug_log(111,0) << "+ Neighbor:" << vneighbor << endl;
if (vneighbor->getConnexId() == _connectedsId) {
cdebug_log(111,0) << "ConnectedsId" << endl;
cdebug_log(111,0) << "| Reject: Neighbor already reached (has connectedsId)" << endl;
continue;
}
if (not _searchArea.intersect(gneighbor->getBoundingBox())) {
cdebug_log(111,0) << "not in _searchArea: " << _searchArea << ", gneighbor area: " << gneighbor->getBoundingBox() << endl;
cdebug_log(111,0) << "| Reject: not in _searchArea: " << _searchArea << ", gneighbor area: " << gneighbor->getBoundingBox() << endl;
continue;
}
////////////////////////////////////// DEBUG //////////////////////////////////////
cdebug_log(111,0) << "| Net : " << _net << endl;
cdebug_log(111,0) << "| [Curr]: " << current << endl;
cdebug_tabw(111,1);
if (current->getFrom()) {
cdebug_log(111,0) << "| From: " << current->getFrom()->getOpposite(gcurrent) << endl;
current->getIntervFrom().print();
}
if (current->getFrom2()) {
cdebug_log(111,0) << "| FROM2: " << current->getFrom2()->getOpposite(gcurrent) << endl;
cdebug_log(111,0) << "| From2: " << current->getFrom2()->getOpposite(gcurrent) << endl;
current->getIntervFrom2().print();
}
cdebug_log(111,0) << "| Edge " << edge << endl;
cdebug_log(111,0) << "+ Neighbor: " << vneighbor << endl;
if ((vneighbor->getFrom() != NULL)&&(vneighbor->hasValidStamp())) {
if ( (vneighbor->getFrom() != NULL) and (vneighbor->hasValidStamp()) ) {
cdebug_log(111,0) << "| Neighbor GETFROM:" << vneighbor->getFrom()->getOpposite( gneighbor ) << endl;
cdebug_log(111,0) << "Distance prev : " << DbU::getValueString(vneighbor->getDistance()) << endl;
}
///////////////////////////////////////////////////////////////////////////////////
cdebug_log(111,0) << "Calc distance1" << endl;
DbU::Unit distance = _distanceCb( current, vneighbor, edge );
bool isDistance2shorter = _isDistance2Shorter ( distance, current, vneighbor, edge ); // ANALOG
if ( (distance == vneighbor->getDistance()) and ((!gcurrent->isMatrix()) and (!gneighbor->isMatrix())) ){
if ( (distance == vneighbor->getDistance())
and ( (not gcurrent->isMatrix()) and (not gneighbor->isMatrix()) ) ) {
_pushEqualDistance( distance, isDistance2shorter, current, vneighbor, edge ); // ANALOG
} else if ( (distance < vneighbor->getDistance()) and (distance != Vertex::unreachable) ){
if (vneighbor->getDistance() != Vertex::unreached) _queue.erase( vneighbor );
else {
if (not vneighbor->hasValidStamp()) {
cdebug_log(111,0) << "[case: Distance FIRST]" << endl;
vneighbor->setConnexId( -1 );
vneighbor->setStamp ( _stamp );
vneighbor->setDegree ( 1 );
vneighbor->setRpCount ( 0 );
vneighbor->unsetFlags(Vertex::AxisTarget);
} else
if ( (distance < vneighbor->getDistance()) and (distance != Vertex::unreachable) ) {
if (vneighbor->getDistance() != Vertex::unreached) _queue.erase( vneighbor );
else {
if (not vneighbor->hasValidStamp()) {
cdebug_log(111,0) << "Vertex reached for the first time" << endl;
vneighbor->setConnexId( -1 );
vneighbor->setStamp ( _stamp );
vneighbor->setDegree ( 1 );
vneighbor->setRpCount ( 0 );
vneighbor->unsetFlags(Vertex::AxisTarget);
}
}
cdebug_log(111,0) << "Vertex reached through a shorter path" << endl;
_updateGRAData( vneighbor, isDistance2shorter, current ); // ANALOG
vneighbor->setBranchId( current->getBranchId() );
vneighbor->setDistance( distance );
vneighbor->setFrom ( edge );
_queue.push( vneighbor );
cdebug_log(111,0) << "Push: (size:" << _queue.size() << ") " << vneighbor << endl;
} else {
cdebug_log(111,0) << "Reject: Vertex reached through a *longer* path" << endl;
}
cdebug_log(111,0) << "[case: Distance INFERIOR]" << endl;
_updateGRAData ( vneighbor, isDistance2shorter, current ); // ANALOG
vneighbor->setBranchId( current->getBranchId() );
vneighbor->setDistance( distance );
vneighbor->setFrom ( edge );
_queue.push( vneighbor );
cdebug_log(111,0) << "Push: (size:" << _queue.size() << ") " << vneighbor << endl;
}
cdebug_tabw(111,-1);
}
cdebug_tabw(111,-2);
continue;
}
cdebug_tabw(111,-1);
// We did reach another target (different <connexId>).
// Tag back the path, with a higher <branchId>.
_traceback( current );
cdebug_tabw(112,-1);
return true;
}
@ -1611,11 +1628,9 @@ namespace Anabatic {
, getString(_net).c_str()
) << endl;
cdebug_tabw(112, 0) << "Targets are: " << endl;
for ( Vertex* v : _targets ) {
cdebug_tabw(112, 0) << v << endl;
}
cdebug_tabw(112, 0) << "End Targets are." << endl;
cdebug_log(112, 0) << "Unreached targets:" << endl;
for ( Vertex* v : _targets )
cdebug_log(112, 0) << "| " << v << endl;
cdebug_tabw(112,-1);
return false;
@ -1792,7 +1807,7 @@ namespace Anabatic {
void Dijkstra::run ( Dijkstra::Mode mode )
{
DebugSession::open( _net, 112, 120 );
DebugSession::open( _net, 111, 120 );
cdebug_log(112,1) << "Dijkstra::run() on " << _net << " mode:" << mode << endl;
_mode = mode;
@ -2029,14 +2044,14 @@ namespace Anabatic {
{
if (current->getFrom2()){
if (edge == current->getFrom2()) {
cdebug_log(111,0) << "edge == current->getFrom2()" << endl;
//cdebug_log(111,0) << "edge == current->getFrom2()" << endl;
return true;
} else {
cdebug_log(111,0) << "edge != current->getFrom2(): " << current->getFrom2() << endl;
//cdebug_log(111,0) << "edge != current->getFrom2(): " << current->getFrom2() << endl;
return false;
}
} else {
cdebug_log(111,0) << "current->getFrom2() = NULL" << endl;
//cdebug_log(111,0) << "current->getFrom2() = NULL" << endl;
return false;
}
}
@ -2044,42 +2059,53 @@ namespace Anabatic {
bool Dijkstra::_isDistance2Shorter ( DbU::Unit& distance, Vertex* current, Vertex* vneighbor, Edge* edge )
{
cdebug_log(111,1) << "Dijkstra::_isDistance2Shorter()" << endl;
DbU::Unit distance2 = Vertex::unreachable;
bool isDistance2shorter = false;
GCell* gneighbor = edge->getOpposite(current->getGCell());
if (current->getFrom2()) {
cdebug_log(111,0) << "HAS 2nd getfrom" << edge << endl;
cdebug_log(111,0) << "Has second ::getFrom()" << edge << endl;
current->setFlags(Vertex::From2Mode);
cdebug_log(111,0) << "Calc distance2" << endl;
distance2 = _distanceCb( current, vneighbor, edge );
current->unsetFlags(Vertex::From2Mode);
cdebug_log(111,0) << "Distance1 curr: " << DbU::getValueString(distance) << endl;
cdebug_log(111,0) << "Distance2 curr: " << DbU::getValueString(distance2) << endl;
if (distance > distance2){
cdebug_log(111,0) << "=> distance2 is shorter" << endl;
cdebug_log(111,0) << "Distance 1 from current: " << DbU::getValueString(distance) << endl;
cdebug_log(111,0) << "Distance 2 from current: " << DbU::getValueString(distance2) << endl;
if (distance > distance2) {
cdebug_log(111,0) << "* Distance 2 is shorter" << endl;
isDistance2shorter = true;
distance = distance2;
} else if (distance == distance2) {
cdebug_log(111,0) << "distance == distance2" << endl;
cdebug_log(111,0) << "* Distance 1 equal Distance 2" << endl;
Point pcurr = current->getStartPathPoint(vneighbor);
current->setFlags(Vertex::From2Mode);
current->setFlags( Vertex::From2Mode );
Point pcurr2 = current->getStartPathPoint(vneighbor);
current->unsetFlags(Vertex::From2Mode);
current->unsetFlags( Vertex::From2Mode );
Point pnext = gneighbor->getCenter();
if (calcDistance(pcurr, pnext) > calcDistance(pcurr2, pnext)) {
cdebug_log(111,0) << "=> distance2 is shorter" << endl;
if (calcDistance(pcurr,pnext) > calcDistance(pcurr2,pnext)) {
cdebug_log(111,0) << "* Distance 2 is shorter" << endl;
isDistance2shorter = true;
distance = distance2;
} else {
cdebug_log(111,0) << "=> distance1 is shorter" << endl;
cdebug_log(111,0) << "* Distance 1 is shorter" << endl;
}
} else {
cdebug_log(111,0) << "=> distance1 is shorter" << endl;
cdebug_log(111,0) << "* Distance 1 is shorter" << endl;
}
} else {
cdebug_log(111,0) << "NO 2nd getfrom" << endl;
cdebug_log(111,0) << "Distance1 curr: " << DbU::getValueString(distance) << endl;
cdebug_log(111,0) << "No second ::getFrom()" << endl;
cdebug_log(111,0) << "Distance 1 from current: " << DbU::getValueString(distance) << endl;
}
cdebug_tabw(111,-1);
return isDistance2shorter;
}
@ -2245,6 +2271,8 @@ namespace Anabatic {
, _net->getCell()->getAbutmentBox().getYMax()
)
);
} else if (gcell->isDevice()){
_searchArea.merge( _net->getCell()->getAbutmentBox() );
}
} else if (gcell->isDevice()){
_searchArea.merge( _net->getCell()->getAbutmentBox() );

8
anabatic/src/GCell.cpp
View File

@ -581,10 +581,10 @@ namespace Anabatic {
Box GCell::getBorder ( const GCell* s, const GCell* t )
{
Flags flags = Flags::NoFlags;
flags |= (s->getXMax() == t->getXMin()) ? Flags::EastSide : 0;
flags |= (t->getXMax() == s->getXMin()) ? Flags::WestSide : 0;
flags |= (s->getYMax() == t->getYMin()) ? Flags::NorthSide : 0;
flags |= (t->getYMax() == s->getYMin()) ? Flags::SouthSide : 0;
flags |= (s->getXMax() == t->getXMin()) ? Flags::EastSide : Flags::NoFlags;
flags |= (t->getXMax() == s->getXMin()) ? Flags::WestSide : Flags::NoFlags;
flags |= (s->getYMax() == t->getYMin()) ? Flags::NorthSide : Flags::NoFlags;
flags |= (t->getYMax() == s->getYMin()) ? Flags::SouthSide : Flags::NoFlags;
if (flags & Flags::Vertical) {
if (flags & Flags::Horizontal) return Box();

5
anabatic/src/LoadGlobalRouting.cpp
View File

@ -3411,12 +3411,15 @@ namespace Anabatic {
for ( Net* net : getCell()->getNets() ) {
if (NetRoutingExtension::isAutomaticGlobalRoute(net)) {
DebugSession::open( net, 145, 150 );
DebugSession::open( net, 144, 150 );
AutoSegment::setAnalogMode( NetRoutingExtension::isAnalog(net) );
cerr << net << " AnalogMode:" << NetRoutingExtension::get(net) << endl;
_loadNetGlobalRouting( net );
Session::revalidate();
DebugSession::close();
}
}
AutoSegment::setAnalogMode( false );
#if defined(CHECK_DATABASE)
_check ( "after Anabatic loading" );

2
anabatic/src/NetOptimals.cpp
View File

@ -37,7 +37,7 @@ namespace Anabatic {
void AnabaticEngine::_computeNetOptimals ( Net* net )
{
DebugSession::open( net, 140, 150 );
DebugSession::open( net, 144, 150 );
cdebug_log(149,0) << "Anabatic::_computeNetOptimals( " << net << " )" << endl;
cdebug_tabw(145,1);

22
anabatic/src/anabatic/AutoContact.h
View File

@ -294,13 +294,13 @@ namespace Anabatic {
inline LocatorHelper::LocatorHelper ( AutoContact* contact, Flags flags )
: _flags(flags), _index(_min()), _contact(contact)
{
cdebug_tabw(145,1);
cdebug_log(145,0) << "CTOR LocatorHelper " << contact->_getString() << endl;
cdebug_log(145,0) << "+ _min():" << _min() << endl;
cdebug_log(145,0) << "+ _max():" << _max() << endl;
cdebug_log(145,0) << "+ getSegment(_min()):" << _contact->getSegment(_min()) << endl;
cdebug_tabw(144,1);
cdebug_log(144,0) << "CTOR LocatorHelper " << contact->_getString() << endl;
cdebug_log(144,0) << "+ _min():" << _min() << endl;
cdebug_log(144,0) << "+ _max():" << _max() << endl;
cdebug_log(144,0) << "+ getSegment(_min()):" << _contact->getSegment(_min()) << endl;
if (not _contact->getSegment(_index)) progress();
cdebug_tabw(145,-1);
cdebug_tabw(144,-1);
}
inline bool LocatorHelper::isValid () const
@ -314,20 +314,20 @@ namespace Anabatic {
inline AutoSegment* LocatorHelper::getSegment () const
{
cdebug_log(145,0) << " LocatorHelper::getSegment(" << _index << ") - " << _contact->getSegment(_index) << endl;
cdebug_log(144,0) << " LocatorHelper::getSegment(" << _index << ") - " << _contact->getSegment(_index) << endl;
return (_index < _max()) ? _contact->getSegment(_index) : NULL;
}
inline void LocatorHelper::progress ()
{
cdebug_tabw(145,1);
cdebug_tabw(144,1);
++_index;
cdebug_log(145,0) << "LocatorHelper::progress() [" << _index << "] " << _contact->getSegment(_index) << endl;
cdebug_log(144,0) << "LocatorHelper::progress() [" << _index << "] " << _contact->getSegment(_index) << endl;
while ((_index < _max()) and (_contact->getSegment(_index) == NULL)) {
++_index;
cdebug_log(145,0) << "LocatorHelper::progress() [" << _index << "] " << _contact->getSegment(_index) << endl;
cdebug_log(144,0) << "LocatorHelper::progress() [" << _index << "] " << _contact->getSegment(_index) << endl;
}
cdebug_tabw(145,-1);
cdebug_tabw(144,-1);
}

17
anabatic/src/anabatic/AutoSegment.h
View File

@ -93,6 +93,7 @@ namespace Anabatic {
, SegInvalidatedLayer = (1<<28)
, SegCreated = (1<<29)
, SegUserDefined = (1<<30)
, SegAnalog = (1<<31)
// Masks.
, SegWeakTerminal = SegStrongTerminal|SegWeakTerminal1|SegWeakTerminal2
, SegNotAligned = SegNotSourceAligned|SegNotTargetAligned
@ -127,7 +128,8 @@ namespace Anabatic {
public:
typedef std::function< void(AutoSegment*) > RevalidateCb_t;
public:
static void setDestroyMode ( bool );
static void setAnalogMode ( bool );
static bool getAnalogMode ();
static AutoSegment* create ( AutoContact* source
, AutoContact* target
, Segment* hurricaneSegment
@ -201,6 +203,7 @@ namespace Anabatic {
inline bool isUserDefined () const;
bool isReduceCandidate () const;
bool isUTurn () const;
inline bool isAnalog () const;
virtual bool _canSlacken () const = 0;
bool canReduce () const;
bool mustRaise () const;
@ -312,7 +315,7 @@ namespace Anabatic {
AutoSegments getCachedOnTargetContact ( Flags direction );
AutoSegments getAligneds ( Flags flags=Flags::NoFlags );
AutoSegments getConnecteds ( Flags flags=Flags::NoFlags );
AutoSegments getPerpandiculars ();
AutoSegments getPerpandiculars ( Flags flags=Flags::NoFlags );
size_t getAlignedContacts ( map<AutoContact*,int>& ) const ;
// Observers.
template< typename OwnerT >
@ -337,9 +340,7 @@ namespace Anabatic {
// Internal: Static Attributes.
static size_t _allocateds;
static size_t _globalsCount;
static bool _destroyBase;
static bool _destroyTool;
static unsigned long _maxId;
static bool _analogMode;
// Internal: Attributes.
const unsigned long _id;
GCell* _gcell;
@ -492,6 +493,7 @@ namespace Anabatic {
inline bool AutoSegment::isInvalidatedLayer () const { return _flags & SegInvalidatedLayer; }
inline bool AutoSegment::isCreated () const { return _flags & SegCreated; }
inline bool AutoSegment::isUserDefined () const { return _flags & SegUserDefined; }
inline bool AutoSegment::isAnalog () const { return _flags & SegAnalog; }
inline void AutoSegment::setFlags ( uint32_t flags ) { _flags |= flags; }
inline void AutoSegment::unsetFlags ( uint32_t flags ) { _flags &= ~flags; }
@ -519,10 +521,7 @@ namespace Anabatic {
inline bool AutoSegment::CompareId::operator() ( const AutoSegment* lhs, const AutoSegment* rhs ) const
{ return lhs->getId() < rhs->getId(); }
inline unsigned long AutoSegment::getMaxId ()
{ return _maxId; }
inline uint32_t AutoSegment::swapSourceTargetFlags ( AutoSegment* segment )
{
uint32_t segFlags = segment->getFlags();

4
anabatic/src/anabatic/AutoSegments.h
View File

@ -258,7 +258,9 @@ namespace Anabatic {
: AutoSegmentHC()
, _flags (flags)
, _segment(segment)
{ }
{
cdebug_log(145,0) << "Flags:" << _flags.asString(FlagsFunction) << std::endl;
}
inline AutoSegments_Aligneds::AutoSegments_Aligneds ( const AutoSegments_Aligneds& autosegments )

117
anabatic/src/anabatic/Constants.h
View File

@ -24,72 +24,73 @@ namespace Anabatic {
class Flags : public Hurricane::BaseFlags {
public:
static const uint64_t NoFlags ; // = 0;
static const BaseFlags NoFlags ; // = 0;
// Flags used for both objects states & functions arguments.
static const uint64_t Horizontal ; // = (1 << 0);
static const uint64_t Vertical ; // = (1 << 1);
static const uint64_t Source ; // = (1 << 2);
static const uint64_t Target ; // = (1 << 3);
static const uint64_t Invalidated ; // = (1 << 4);
static const BaseFlags Horizontal ; // = (1 << 0);
static const BaseFlags Vertical ; // = (1 << 1);
static const BaseFlags Source ; // = (1 << 2);
static const BaseFlags Target ; // = (1 << 3);
static const BaseFlags Invalidated ; // = (1 << 4);
// Flags for GCell objects states only.
static const uint64_t DeviceGCell ; // = (1 << 5);
static const uint64_t HChannelGCell ; // = (1 << 6);
static const uint64_t VChannelGCell ; // = (1 << 7);
static const uint64_t StrutGCell ; // = (1 << 8);
static const uint64_t MatrixGCell ; // = (1 << 9);
static const uint64_t IoPadGCell ; // = (1 << 10);
static const uint64_t Saturated ; // = (1 << 11);
static const BaseFlags DeviceGCell ; // = (1 << 5);
static const BaseFlags HChannelGCell ; // = (1 << 6);
static const BaseFlags VChannelGCell ; // = (1 << 7);
static const BaseFlags StrutGCell ; // = (1 << 8);
static const BaseFlags MatrixGCell ; // = (1 << 9);
static const BaseFlags IoPadGCell ; // = (1 << 10);
static const BaseFlags Saturated ; // = (1 << 11);
// Flags for Anabatic objects states only.
static const uint64_t DemoMode ; // = (1 << 5);
static const uint64_t WarnOnGCellOverload ; // = (1 << 6);
static const uint64_t DestroyGCell ; // = (1 << 7);
static const uint64_t DestroyBaseContact ; // = (1 << 8);
static const uint64_t DestroyBaseSegment ; // = (1 << 9);
static const BaseFlags DemoMode ; // = (1 << 5);
static const BaseFlags WarnOnGCellOverload ; // = (1 << 6);
static const BaseFlags DestroyGCell ; // = (1 << 7);
static const BaseFlags DestroyBaseContact ; // = (1 << 8);
static const BaseFlags DestroyBaseSegment ; // = (1 << 9);
// Flags for NetDatas objects states only.
static const uint64_t GlobalRouted ; // = (1 << 5);
static const BaseFlags GlobalRouted ; // = (1 << 5);
// Masks.
static const uint64_t WestSide ; // = Horizontal|Target;
static const uint64_t EastSide ; // = Horizontal|Source;
static const uint64_t SouthSide ; // = Vertical |Target;
static const uint64_t NorthSide ; // = Vertical |Source;
static const uint64_t AllSides ; // = WestSide|EastSide|SouthSide|NorthSide ;
static const uint64_t EndsMask ; // = Source|Target;
static const uint64_t DirectionMask ; // = Horizontal|Vertical;
static const uint64_t DestroyMask ; // = DestroyGCell|DestroyBaseContact|DestroyBaseSegment;
static const uint64_t GCellTypeMask ; // = DeviceGCell|HChannelGCell|VChannelGCell|StrutGCell|MatrixGCell|IoPadGCell;
static const BaseFlags WestSide ; // = Horizontal|Target;
static const BaseFlags EastSide ; // = Horizontal|Source;
static const BaseFlags SouthSide ; // = Vertical |Target;
static const BaseFlags NorthSide ; // = Vertical |Source;
static const BaseFlags AllSides ; // = WestSide|EastSide|SouthSide|NorthSide ;
static const BaseFlags EndsMask ; // = Source|Target;
static const BaseFlags DirectionMask ; // = Horizontal|Vertical;
static const BaseFlags DestroyMask ; // = DestroyGCell|DestroyBaseContact|DestroyBaseSegment;
static const BaseFlags GCellTypeMask ; // = DeviceGCell|HChannelGCell|VChannelGCell|StrutGCell|MatrixGCell|IoPadGCell;
// Flags for functions arguments only.
static const uint64_t Create ; // = (1 << 5);
static const uint64_t WithPerpands ;
static const uint64_t WithDoglegs ;
static const uint64_t WithSelf ;
static const uint64_t AboveLayer ;
static const uint64_t BelowLayer ;
static const uint64_t OpenSession ;
static const uint64_t Realignate ;
static const uint64_t NativeConstraints ;
static const uint64_t ForceMove ;
static const uint64_t WarnOnError ;
static const uint64_t Topology ;
static const uint64_t GlobalSegment ;
static const uint64_t AllowTerminal ;
static const uint64_t AllowLocal ;
static const uint64_t IgnoreContacts ;
static const uint64_t Propagate ;
static const uint64_t Superior ;
static const uint64_t DoglegOnLeft ;
static const uint64_t DoglegOnRight ;
static const uint64_t WithNeighbors ;
static const uint64_t NoCheckLayer ;
static const uint64_t HalfSlacken ;
static const uint64_t NoGCellShrink ;
static const uint64_t CParanoid ;
static const uint64_t CheckLowDensity ;
static const uint64_t CheckLowUpDensity ;
static const uint64_t NoUpdate ;
static const BaseFlags Create ; // = (1 << 5);
static const BaseFlags WithPerpands ;
static const BaseFlags WithDoglegs ;
static const BaseFlags WithSelf ;
static const BaseFlags AboveLayer ;
static const BaseFlags BelowLayer ;
static const BaseFlags OpenSession ;
static const BaseFlags Realignate ;
static const BaseFlags NativeConstraints ;
static const BaseFlags ForceMove ;
static const BaseFlags WarnOnError ;
static const BaseFlags Topology ;
static const BaseFlags GlobalSegment ;
static const BaseFlags AllowTerminal ;
static const BaseFlags AllowLocal ;
static const BaseFlags IgnoreContacts ;
static const BaseFlags Propagate ;
static const BaseFlags Superior ;
static const BaseFlags DoglegOnLeft ;
static const BaseFlags DoglegOnRight ;
static const BaseFlags WithNeighbors ;
static const BaseFlags NoCheckLayer ;
static const BaseFlags HalfSlacken ;
static const BaseFlags NoGCellShrink ;
static const BaseFlags CParanoid ;
static const BaseFlags CheckLowDensity ;
static const BaseFlags CheckLowUpDensity ;
static const BaseFlags NoUpdate ;
public:
inline Flags ( uint64_t flags = NoFlags );
inline Flags ( const Hurricane::BaseFlags& );
virtual ~Flags ();
virtual std::string asString ( uint32_t mode ) const;
virtual std::string _getTypeName () const;
virtual std::string _getString () const;
};
@ -99,6 +100,10 @@ namespace Anabatic {
Flags::Flags ( const Hurricane::BaseFlags& flags ) : BaseFlags(flags) { }
enum FlagsMode { FlagsFunction = 1
};
enum EngineState { EngineCreation = 1
, EngineGlobalLoaded = 2
, EngineActive = 3

22
anabatic/src/anabatic/GCell.h
View File

@ -155,9 +155,9 @@ namespace Anabatic {
inline DbU::Unit getYMax ( int shrink=0 ) const;
inline DbU::Unit getXCenter () const;
inline DbU::Unit getYCenter () const;
inline DbU::Unit getConstraintXMax () const;
inline DbU::Unit getConstraintYMax () const;
inline Interval getSide ( Flags direction ) const;
inline DbU::Unit getConstraintXMax ( int shrink=0 ) const;
inline DbU::Unit getConstraintYMax ( int shrink=0 ) const;
inline Interval getSide ( Flags direction, int shrink=0 ) const;
inline Point getCenter () const;
inline Box getConstraintBox () const;
inline const vector<Edge*>& getWestEdges () const;
@ -340,7 +340,7 @@ namespace Anabatic {
inline Flags& GCell::flags () { return _flags; }
inline DbU::Unit GCell::getXMax ( int shrink ) const
{ return _eastEdges.empty() ? getCell()->getAbutmentBox().getXMax() - shrink
{ return _eastEdges.empty() ? getCell()->getAbutmentBox().getXMax() - shrink
: _eastEdges[0]->getOpposite(this)->getXMin() - shrink; }
inline DbU::Unit GCell::getYMax ( int shrink ) const
@ -350,11 +350,11 @@ namespace Anabatic {
inline DbU::Unit GCell::getXCenter () const { return (getXMin()+getXMax())/2; }
inline DbU::Unit GCell::getYCenter () const { return (getYMin()+getYMax())/2; }
inline DbU::Unit GCell::getConstraintXMax () const
{ return getXMax( _eastEdges.empty() ? 0 : 1 ); }
inline DbU::Unit GCell::getConstraintXMax ( int shrink ) const
{ return getXMax( shrink + (_eastEdges.empty() ? 0 : 1) ); }
inline DbU::Unit GCell::getConstraintYMax () const
{ return getYMax( _northEdges.empty() ? 0 : 1 ); }
inline DbU::Unit GCell::getConstraintYMax ( int shrink ) const
{ return getYMax( shrink + (_northEdges.empty() ? 0 : 1) ); }
inline Point GCell::getCenter () const
{ return Point( (getXMin()+getXMax())/2, (getYMin()+getYMax())/2); }
@ -362,10 +362,10 @@ namespace Anabatic {
inline Box GCell::getConstraintBox () const
{ return Box( getXMin(), getYMin(), getConstraintXMax(), getConstraintYMax() ); }
inline Interval GCell::getSide ( Flags direction ) const
inline Interval GCell::getSide ( Flags direction, int shrink ) const
{
if (direction.isset(Flags::Vertical)) return Interval( getYMin(), getConstraintYMax() );
return Interval( getXMin(), getConstraintXMax() );
if (direction.isset(Flags::Vertical)) return Interval( getYMin(), getConstraintYMax(shrink) );
return Interval( getXMin(), getConstraintXMax(shrink) );
}
inline void GCell::setObserver ( size_t slot, BaseObserver* observer )

2
crlcore/src/cyclop/Cyclop.cpp
View File

@ -71,7 +71,7 @@ namespace CRL {
connect ( openAction, SIGNAL(triggered()), this, SLOT(openCell()) );
}
QMenu* debugMenu = createDebugMenu ();
/*QMenu* debugMenu =*/ createDebugMenu ();
_stressDisplayAction = new QAction ( tr("Stress Display"), this );
_stressDisplayAction->setObjectName ( "viewer.menuBar.debug.stressDisplay" );
_stressDisplayAction->setStatusTip ( tr("Intensive use of display redrawing") );

8
hurricane/src/hurricane/Flags.cpp
View File

@ -41,6 +41,14 @@ namespace Hurricane {
{ }
string BaseFlags::asString ( uint32_t ) const
{
std::ostringstream formatted;
formatted << _flags;
return formatted.str();
}
string BaseFlags::_getTypeName () const
{ return "Flags"; }

5
hurricane/src/hurricane/Net.cpp
View File

@ -32,6 +32,7 @@
#include "hurricane/Pad.h"
#include "hurricane/UpdateSession.h"
#include "hurricane/NetExternalComponents.h"
#include "hurricane/NetRoutingProperty.h"
namespace Hurricane {
@ -514,6 +515,10 @@ void Net::setDirection(const Direction& direction)
_direction = direction;
}
void Net::setRoutingState(uint32_t state)
// **************************************
{ NetRoutingExtension::get(this)->setFlags( state ); }
bool Net::hasAlias(const Name& name) const
// ***************************************
{

21
hurricane/src/hurricane/NetRoutingProperty.cpp
View File

@ -49,6 +49,7 @@ namespace Hurricane {
s += (isSymHorizontal ()) ? 'h' : '-';
s += (isSymVertical ()) ? 'v' : '-';
s += (isSymMaster ()) ? 'M' : '-';
s += (isAnalog ()) ? 'A' : '-';
return s;
}
@ -164,8 +165,8 @@ namespace Hurricane {
{
check( stack, "JsonNetRoutingProperty::toData" );
string sflags = get<string>( stack, "_state" );
unsigned int flags = 0;
string sflags = get<string>( stack, "_state" );
uint32_t flags = 0;
flags |= (sflags[0] == 'e') ? NetRoutingState::Excluded : 0;
flags |= (sflags[1] == 'f') ? NetRoutingState::Fixed : 0;
@ -176,6 +177,7 @@ namespace Hurricane {
flags |= (sflags[6] == 'h') ? NetRoutingState::Horizontal : 0;
flags |= (sflags[7] == 'v') ? NetRoutingState::Vertical : 0;
flags |= (sflags[8] == 'M') ? NetRoutingState::SymmetricMaster : 0;
flags |= (sflags[9] == 'A') ? NetRoutingState::Analog : 0;
NetRoutingProperty* property = NULL;
DBo* dbo = stack.back_dbo();
@ -188,7 +190,7 @@ namespace Hurricane {
, getString(net).c_str()
) << endl;
NetRoutingState* state = property->getState();
state->unsetFlags( (unsigned int)-1 );
state->unsetFlags( (uint32_t)-1 );
state->setFlags ( flags );
state->setSymAxis( DbU::fromDb( get<int64_t>(stack,"_axis") ) );
} else {
@ -231,15 +233,16 @@ namespace Hurricane {
}
NetRoutingState* NetRoutingExtension::create ( Net* net )
NetRoutingState* NetRoutingExtension::create ( Net* net, uint32_t flags )
{
get( net );
if (_cache) return _cache;
if (not _cache) {
NetRoutingProperty* property = new NetRoutingProperty( net );
net->put( property );
NetRoutingProperty* property = new NetRoutingProperty( net );
net->put( property );
_cache = property->getState();
_cache = property->getState();
}
_cache->setFlags( flags );
return _cache;
}

16
hurricane/src/hurricane/hurricane/Flags.h
View File

@ -85,6 +85,9 @@ namespace Hurricane {
inline bool operator < ( uint64_t ) const;
inline bool operator > ( uint64_t ) const;
inline operator bool () const;
inline uint64_t value () const;
virtual std::string asString ( uint32_t mode ) const;
inline operator uint64_t () const;
//inline operator unsigned int () const;
// Hurricane Managment.
virtual std::string _getTypeName () const;
@ -97,7 +100,7 @@ namespace Hurricane {
// Inline Functions.
inline BaseFlags::BaseFlags ( uint64_t flags ) : _flags(flags) { }
inline BaseFlags::BaseFlags ( uint64_t flags ) : _flags(flags) { }
inline bool BaseFlags::zero () const { return _flags == 0; }
inline BaseFlags& BaseFlags::reset ( BaseFlags flags ) { _flags &= ~flags._flags; return *this; }
inline bool BaseFlags::isset ( BaseFlags flags ) const { return _flags & flags._flags; }
@ -137,6 +140,8 @@ namespace Hurricane {
inline bool BaseFlags::operator < ( uint64_t flags ) const { return _flags < flags; }
inline bool BaseFlags::operator > ( uint64_t flags ) const { return _flags > flags; }
inline BaseFlags::operator bool () const { return _flags != 0; }
inline uint64_t BaseFlags::value () const { return _flags; }
inline BaseFlags::operator uint64_t () const { return _flags; }
//inline BaseFlags::operator unsigned int () const { return _flags; }
//inline BaseFlags::operator unsigned int () const { return _flags; }
@ -164,6 +169,15 @@ namespace Hurricane {
return record;
}
// inline BaseFlags operator bitor ( const BaseFlags& lhs, const BaseFlags& rhs ) { BaseFlags r( lhs ); r |= rhs; return r; }
// inline BaseFlags operator bitor ( const BaseFlags& lhs, uint64_t rhs ) { BaseFlags r( lhs ); r |= rhs; return r; }
// inline BaseFlags operator bitor ( uint64_t lhs, const BaseFlags& rhs ) { BaseFlags r( rhs ); r |= lhs; return r; }
// inline BaseFlags operator bitand ( const BaseFlags& lhs, const BaseFlags& rhs ) { BaseFlags r( lhs ); r &= rhs; return r; }
// inline BaseFlags operator bitand ( const BaseFlags& lhs, uint64_t rhs ) { BaseFlags r( lhs ); r &= rhs; return r; }
// inline BaseFlags operator bitand ( uint64_t lhs, const BaseFlags& rhs ) { BaseFlags r( rhs ); r &= lhs; return r; }
// inline BaseFlags operator^ ( const BaseFlags& lhs, const BaseFlags& rhs ) { BaseFlags r( lhs ); r ^= rhs; return r; }
// inline BaseFlags operator^ ( const BaseFlags& lhs, uint64_t rhs ) { BaseFlags r( lhs ); r ^= rhs; return r; }
// inline BaseFlags operator^ ( uint64_t lhs, const BaseFlags& rhs ) { BaseFlags r( rhs ); r ^= lhs; return r; }
} // Hurricane namespace.

1
hurricane/src/hurricane/hurricane/Net.h
View File

@ -233,6 +233,7 @@ class Net : public Entity {
public: void setType(const Type& type);
public: void setDirection(const Direction& direction);
public: void setPosition(const Point& position);
public: void setRoutingState(uint32_t state);
public: void materialize();
public: void unmaterialize();
public: bool addAlias(const Name& name);

47
hurricane/src/hurricane/hurricane/NetRoutingProperty.h
View File

@ -48,6 +48,7 @@ namespace Hurricane {
, Vertical = (1<< 6)
, Symmetric = (1<< 7)
, SymmetricMaster = (1<< 8)
, Analog = (1<< 9)
};
public:
inline bool isExcluded () const;
@ -61,31 +62,32 @@ namespace Hurricane {
inline bool isSymVertical () const;
inline bool isSymMaster () const;
inline bool isSymSlave () const;
inline bool isAnalog () const;
inline Net* getNet () const;
inline Net* getSymNet () const;
inline DbU::Unit getSymAxis () const;
inline unsigned int getFlags () const;
inline uint32_t getFlags () const;
inline void setSymNet ( Net* );
inline void setSymAxis ( DbU::Unit );
inline void setFlags ( unsigned int mask );
inline void unsetFlags ( unsigned int mask );
inline void setFlags ( uint32_t mask );
inline void unsetFlags ( uint32_t mask );
inline bool isSelfSym () const;
DbU::Unit getSymValue ( DbU::Unit ) const;
std::string _getString () const;
Record* _getRecord () const;
private:
inline NetRoutingState ( Net*, unsigned int flags=0 );
inline NetRoutingState ( Net*, uint32_t flags=0 );
NetRoutingState ( const NetRoutingState& ) = delete;
inline void setNet ( Net* );
private:
Net* _net;
Net* _symNet;
unsigned int _flags;
uint32_t _flags;
DbU::Unit _axis;
};
inline NetRoutingState::NetRoutingState ( Net* net, unsigned int flags ) : _net(net), _symNet(NULL), _flags(flags), _axis(0) { }
inline NetRoutingState::NetRoutingState ( Net* net, uint32_t flags ) : _net(net), _symNet(NULL), _flags(flags), _axis(0) { }
inline bool NetRoutingState::isExcluded () const { return _flags & Excluded; };
inline bool NetRoutingState::isFixed () const { return _flags & Fixed; };
@ -97,17 +99,18 @@ namespace Hurricane {
inline bool NetRoutingState::isSymHorizontal () const { return _flags & Horizontal; }
inline bool NetRoutingState::isSymVertical () const { return _flags & Vertical; }
inline bool NetRoutingState::isSymMaster () const { return _flags & SymmetricMaster; }
inline bool NetRoutingState::isAnalog () const { return _flags & Analog; }
inline Net* NetRoutingState::getSymNet () const { return _symNet; }
inline DbU::Unit NetRoutingState::getSymAxis () const { return _axis; }
inline unsigned int NetRoutingState::getFlags () const { return _flags; };
inline uint32_t NetRoutingState::getFlags () const { return _flags; };
inline Net* NetRoutingState::getNet () const { return _net; }
inline void NetRoutingState::setFlags ( unsigned int mask ) { _flags |= mask; }
inline void NetRoutingState::unsetFlags ( unsigned int mask ) { _flags &= ~mask; }
inline void NetRoutingState::setFlags ( uint32_t mask ) { _flags |= mask; }
inline void NetRoutingState::unsetFlags ( uint32_t mask ) { _flags &= ~mask; }
inline void NetRoutingState::setNet ( Net* net ) { _net = net; }
inline void NetRoutingState::setSymNet ( Net* symNet ) { _symNet = symNet; }
inline void NetRoutingState::setSymAxis ( DbU::Unit axis ) { _axis = axis; }
inline bool NetRoutingState::isSelfSym () const { return ( (_symNet == NULL) and (isSymmetric()) ); }
inline bool NetRoutingState::isSymSlave () const { return ( (_symNet != NULL) and (!isSymMaster()) ); }
inline bool NetRoutingState::isSelfSym () const { return (_symNet == NULL) and (isSymmetric()); }
inline bool NetRoutingState::isSymSlave () const { return (_symNet != NULL) and (not isSymMaster()); }
// -------------------------------------------------------------------
@ -169,15 +172,16 @@ namespace Hurricane {
static inline bool isSymHorizontal ( const Net* );
static inline bool isSymVertical ( const Net* );
static inline bool isSymMaster ( const Net* );
static inline unsigned int getFlags ( const Net* );
static inline bool isAnalog ( const Net* );
static inline uint32_t getFlags ( const Net* );
static inline Net* getSymNet ( const Net* );
static inline DbU::Unit getSymAxis ( const Net* );
static inline void setSymNet ( const Net*, Net* );
static inline void setSymAxis ( const Net*, DbU::Unit );
static inline void setFlags ( const Net*, unsigned int mask );
static inline void unsetFlags ( const Net*, unsigned int mask );
static inline void setFlags ( const Net*, uint32_t mask );
static inline void unsetFlags ( const Net*, uint32_t mask );
static NetRoutingState* get ( const Net* );
static NetRoutingState* create ( Net* );
static NetRoutingState* create ( Net*, uint32_t flags=0 );
private:
static const Net* _owner;
static NetRoutingState* _cache;
@ -247,7 +251,14 @@ namespace Hurricane {
}
inline unsigned int NetRoutingExtension::getFlags ( const Net* net )
inline bool NetRoutingExtension::isAnalog ( const Net* net )
{
NetRoutingState* state = get( net );
return (state == NULL) ? false : state->isAnalog();
}
inline uint32_t NetRoutingExtension::getFlags ( const Net* net )
{
NetRoutingState* state = get( net );
return (state == NULL) ? 0 : state->getFlags();
@ -268,7 +279,7 @@ namespace Hurricane {
}
inline void NetRoutingExtension::setFlags ( const Net* net, unsigned int mask )
inline void NetRoutingExtension::setFlags ( const Net* net, uint32_t mask )
{
NetRoutingState* state = get( net );
if (state != NULL) state->setFlags( mask );
@ -289,7 +300,7 @@ namespace Hurricane {
}
inline void NetRoutingExtension::unsetFlags ( const Net* net, unsigned int mask )
inline void NetRoutingExtension::unsetFlags ( const Net* net, uint32_t mask )
{
NetRoutingState* state = get( net );
if (state != NULL) state->unsetFlags( mask );

4
hurricane/src/isobar/CMakeLists.txt
View File

@ -44,6 +44,8 @@
PyNetDirection.cpp
PyNetCollection.cpp
PyNetExternalComponents.cpp
PyNetRoutingState.cpp
PyNetRoutingProperty.cpp
PyOccurrence.cpp
PyOccurrenceCollection.cpp
PyHook.cpp
@ -108,6 +110,8 @@
hurricane/isobar/PyNetDirection.h
hurricane/isobar/PyNetCollection.h
hurricane/isobar/PyNetExternalComponents.h
hurricane/isobar/PyNetRoutingState.h
hurricane/isobar/PyNetRoutingProperty.h
hurricane/isobar/PyOccurrence.h
hurricane/isobar/PyOccurrenceCollection.h
hurricane/isobar/PyHook.h

11
hurricane/src/isobar/PyHurricane.cpp
View File

@ -56,6 +56,8 @@
#include "hurricane/isobar/PyNetDirection.h"
#include "hurricane/isobar/PyNetCollection.h"
#include "hurricane/isobar/PyNetExternalComponents.h"
#include "hurricane/isobar/PyNetRoutingState.h"
#include "hurricane/isobar/PyNetRoutingProperty.h"
#include "hurricane/isobar/PyHyperNet.h"
#include "hurricane/isobar/PyHook.h"
#include "hurricane/isobar/PyHookCollection.h"
@ -539,6 +541,8 @@ extern "C" {
PyPlugCollection_LinkPyType ();
PyNetCollection_LinkPyType ();
PyNetExternalComponents_LinkPyType ();
PyNetRoutingState_LinkPyType ();
PyNetRoutingExtension_LinkPyType ();
PyCellCollection_LinkPyType ();
PyPinPlacementStatus_LinkPyType ();
PyPinDirection_LinkPyType ();
@ -606,6 +610,8 @@ extern "C" {
PYTYPE_READY ( NetDirection )
PYTYPE_READY ( NetCollection )
PYTYPE_READY ( NetCollectionLocator )
PYTYPE_READY ( NetRoutingState )
PYTYPE_READY ( NetRoutingExtension )
PYTYPE_READY ( CellCollection )
PYTYPE_READY ( CellCollectionLocator )
PYTYPE_READY ( PinPlacementStatus )
@ -762,6 +768,10 @@ extern "C" {
PyModule_AddObject ( module, "ViaLayer" , (PyObject*)&PyTypeViaLayer );
Py_INCREF ( &PyTypeNetExternalComponents );
PyModule_AddObject ( module, "NetExternalComponents", (PyObject*)&PyTypeNetExternalComponents );
Py_INCREF ( &PyTypeNetRoutingState );
PyModule_AddObject ( module, "NetRoutingState" , (PyObject*)&PyTypeNetRoutingState );
Py_INCREF ( &PyTypeNetRoutingExtension );
PyModule_AddObject ( module, "NetRoutingExtension" , (PyObject*)&PyTypeNetRoutingExtension );
Py_INCREF ( &PyTypeDebugSession );
PyModule_AddObject ( module, "DebugSession" , (PyObject*)&PyTypeDebugSession );
Py_INCREF ( &PyTypeUpdateSession );
@ -813,6 +823,7 @@ extern "C" {
PyPin_postModuleInit();
PyRoutingPad_postModuleInit();
PyNet_postModuleInit();
PyNetRoutingState_postModuleInit();
PyInstance_postModuleInit();
PyQuery_postModuleInit();

89
hurricane/src/isobar/PyNet.cpp
View File

@ -46,20 +46,12 @@ extern "C" {
Py_DECREF ( constant );
// x=================================================================x
// +=================================================================+
// | "PyNet" Python Module Code Part |
// x=================================================================x
// +=================================================================+
#if defined(__PYTHON_MODULE__)
// x-------------------------------------------------------------x
// | "PyNet" Local Functions |
// x-------------------------------------------------------------x
// ---------------------------------------------------------------
// Local Function : "PyInt_AsType ()"
static Net::Type PyInt_AsType ( PyObject* object ) {
switch ( PyAny_AsLong(object) ) {
@ -75,10 +67,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Local Function : "PyInt_AsDirection ()"
static Net::Direction PyInt_AsDirection ( PyObject* object )
{
switch ( PyAny_AsLong(object) ) {
@ -93,9 +81,9 @@ extern "C" {
}
// x-------------------------------------------------------------x
// +-------------------------------------------------------------+
// | "PyNet" Attribute Methods |
// x-------------------------------------------------------------x
// +-------------------------------------------------------------+
// Standart Accessors (Attributes).
@ -112,20 +100,15 @@ extern "C" {
DirectGetBoolAttribute(PyNet_isSupply ,isSupply ,PyNet,Net)
GetBoundStateAttribute(PyNet_IsPyBound ,PyNet,Net)
GetNameMethod(Net, net)
// Standart modificators.
DirectSetUInt32Attribute(PyNet_setRoutingState,setRoutingState,PyNet,Net)
// Standart destroy (Attribute).
DBoDestroyAttribute(PyNet_destroy, PyNet)
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getName ()"
GetNameMethod(Net, net)
// ---------------------------------------------------------------
// Attribute Method : "PyNet_create ()"
static PyObject* PyNet_create ( PyObject*, PyObject *args ) {
cdebug_log(20,0) << "PyNet_create()" << endl;
@ -146,9 +129,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getType ()"
static PyObject* PyNet_getType ( PyNet *self )
{
cdebug_log(20,0) << "PyNet_getType ()" << endl;
@ -159,10 +139,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getDirection ()"
static PyObject* PyNet_getDirection ( PyNet *self )
{
cdebug_log(20,0) << "PyNet_getDirection ()" << endl;
@ -173,9 +149,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getPlugs()"
static PyObject* PyNet_getPlugs(PyNet *self) {
cdebug_log(20,0) << "PyNet_getPlugs()" << endl;
@ -198,9 +171,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getSegments()"
static PyObject* PyNet_getSegments(PyNet *self) {
cdebug_log(20,0) << "PyNet_getSegments()" << endl;
@ -223,9 +193,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getPins()"
static PyObject* PyNet_getPins(PyNet *self) {
cdebug_log(20,0) << "PyNet_getPins()" << endl;
@ -248,9 +215,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getComponents()"
static PyObject* PyNet_getComponents(PyNet *self) {
cdebug_log(20,0) << "PyNet_getComponents()" << endl;
@ -271,9 +235,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_getExternalComponents()"
static PyObject* PyNet_getExternalComponents(PyNet *self) {
cdebug_log(20,0) << "PyNet_getExternalComponents()" << endl;
@ -294,15 +255,9 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_setName ()"
SetNameMethod(Net, net)
// ---------------------------------------------------------------
// Attribute Method : "PyNet_setGlobal ()"
static PyObject* PyNet_setGlobal ( PyNet *self, PyObject* args ) {
cdebug_log(20,0) << "PyNet_setGlobal()" << endl;
@ -321,10 +276,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_setExternal ()"
static PyObject* PyNet_setExternal ( PyNet *self, PyObject* args ) {
cdebug_log(20,0) << "PyNet_setExternal()" << endl;
@ -343,10 +294,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_setType ()"
static PyObject* PyNet_setType ( PyNet *self, PyObject* args )
{
cdebug_log(20,0) << "PyNet_setType()" << endl;
@ -369,10 +316,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_setDirection ()"
static PyObject* PyNet_setDirection ( PyNet *self, PyObject* args )
{
cdebug_log(20,0) << "PyNet_setDirection()" << endl;
@ -392,9 +335,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_addAlias ()"
static PyObject* PyNet_addAlias ( PyNet *self, PyObject* args )
{
cdebug_log(20,0) << "PyNet_addAlias()" << endl;
@ -416,9 +356,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_removeAlias ()"
static PyObject* PyNet_removeAlias ( PyNet *self, PyObject* args )
{
cdebug_log(20,0) << "PyNet_removeAlias()" << endl;
@ -440,9 +377,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_setPosition ()"
static PyObject* PyNet_setPosition ( PyNet *self, PyObject* args )
{
cdebug_log(20,0) << "PyNet_setPosition()" << endl;
@ -462,9 +396,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_merge ()"
static PyObject* PyNet_merge ( PyNet *self, PyObject* args ) {
cdebug_log(20,0) << "PyNet_merge()" << endl;
@ -482,9 +413,6 @@ extern "C" {
}
// ---------------------------------------------------------------
// Attribute Method : "PyNet_merge ()"
static PyObject* PyNet_getClone ( PyNet *self, PyObject* args ) {
cdebug_log(20,0) << "PyNet_getClone()" << endl;
@ -534,6 +462,7 @@ extern "C" {
, { "setType" , (PyCFunction)PyNet_setType , METH_VARARGS, "set the type of the net." }
, { "setDirection" , (PyCFunction)PyNet_setDirection , METH_VARARGS, "set the direction of the net." }
, { "setPosition" , (PyCFunction)PyNet_setPosition , METH_VARARGS, "set the X,Y location of the net." }
, { "setRoutingState" , (PyCFunction)PyNet_setRoutingState , METH_VARARGS, "set the NetRoutingstate flag (proxy method)." }
, { "addAlias" , (PyCFunction)PyNet_addAlias , METH_VARARGS, "Add an alias name to the net." }
, { "removeAlias" , (PyCFunction)PyNet_removeAlias , METH_VARARGS, "Remove an alias name from the net." }
, { "merge" , (PyCFunction)PyNet_merge , METH_VARARGS, "Merges the net <net> to the net <this> which keeps its characteristics (arity, global, external and direction)." }

240
hurricane/src/isobar/PyNetRoutingProperty.cpp Normal file
View File

@ -0,0 +1,240 @@
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2017-2017, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | I s o b a r - Hurricane / Python Interface |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Module : "./PyNetRoutingProperty.cpp" |
// +-----------------------------------------------------------------+
#include "hurricane/isobar/PyNetRoutingProperty.h"
#include "hurricane/isobar/PyNetRoutingState.h"
#include "hurricane/isobar/PyNet.h"
namespace Isobar {
using std::cerr;
using std::endl;
using std::hex;
using std::ostringstream;
using Hurricane::tab;
using Hurricane::Error;
using Hurricane::Warning;
extern "C" {
#define METHOD_HEAD(function) GENERIC_METHOD_HEAD(NetRoutingExtension,extension,function)
// +=================================================================+
// | "PyNetRoutingExtension" Python Module Code Part |
// +=================================================================+
#if defined(__PYTHON_MODULE__)
# define ExtensionGetBoolFunction(FUNC_NAME,SELF_TYPE) \
static PyObject* Py##SELF_TYPE##_##FUNC_NAME ( PyObject*, PyObject* args ) \
{ \
cdebug_log(20,0) << "Py"#FUNC_NAME"()" << endl; \
bool flag = false; \
HTRY \
PyObject* arg0; \
if (not ParseOneArg(#SELF_TYPE"."#FUNC_NAME"()", args, NET_ARG, &arg0)) return NULL; \
flag = SELF_TYPE::FUNC_NAME( PYNET_O(arg0) ); \
HCATCH \
if (flag) Py_RETURN_TRUE; \
Py_RETURN_FALSE; \
}
# define ExtensionGetUIntFunction(FUNC_NAME,SELF_TYPE) \
static PyObject* Py##SELF_TYPE##_##FUNC_NAME ( PyObject*, PyObject* args ) \
{ \
cdebug_log(20,0) << "Py"#FUNC_NAME"()" << endl; \
uint32_t value = 0; \
HTRY \
PyObject* arg0; \
if (not ParseOneArg(#SELF_TYPE"."#FUNC_NAME"()", args, NET_ARG, &arg0)) return NULL; \
value = SELF_TYPE::FUNC_NAME( PYNET_O(arg0) ); \
HCATCH \
return Py_BuildValue( "I", value ); \
}
# define ExtensionGetLongFunction(FUNC_NAME,SELF_TYPE) \
static PyObject* Py##SELF_TYPE##_##FUNC_NAME ( PyObject*, PyObject* args ) \
{ \
cdebug_log(20,0) << "Py"#FUNC_NAME"()" << endl; \
long value = 0; \
HTRY \
PyObject* arg0; \
if (not ParseOneArg(#SELF_TYPE"."#FUNC_NAME"()", args, NET_ARG, &arg0)) return NULL; \
value = SELF_TYPE::FUNC_NAME( PYNET_O(arg0) ); \
HCATCH \
return Py_BuildValue("L",value); \
}
# define ExtensionSetUIntFunction(FUNC_NAME,SELF_TYPE) \
static PyObject* Py##SELF_TYPE##_##FUNC_NAME ( PyObject*, PyObject* args ) \
{ \
cdebug_log(20,0) << "Py"#FUNC_NAME"()" << endl; \
HTRY \
PyObject* arg0 = NULL; \
PyObject* pyNet = NULL; \
if (not PyArg_ParseTuple(args,"OO:"#SELF_TYPE"."#FUNC_NAME"()", &pyNet, &arg0)) return NULL; \
if (not IsPyNet(pyNet)) return NULL; \
SELF_TYPE::FUNC_NAME( PYNET_O(pyNet), Isobar::PyAny_AsUInt32(arg0) ); \
HCATCH \
Py_RETURN_NONE; \
}
# define ExtensionSetLongFunction(FUNC_NAME,SELF_TYPE) \
static PyObject* Py##SELF_TYPE##_##FUNC_NAME ( PyObject*, PyObject* args ) \
{ \
cdebug_log(20,0) << "Py"#FUNC_NAME"()" << endl; \
HTRY \
PyObject* arg0 = NULL; \
PyObject* pyNet = NULL; \
if (not PyArg_ParseTuple(args,"OO:"#SELF_TYPE"."#FUNC_NAME"()", &pyNet, &arg0)) return NULL; \
if (not IsPyNet(pyNet)) return NULL; \
SELF_TYPE::FUNC_NAME( PYNET_O(pyNet), Isobar::PyAny_AsLong(arg0) ); \
HCATCH \
Py_RETURN_NONE; \
}
static void PyNetRoutingExtension_DeAlloc ( PyNetRoutingExtension* self )
{
cdebug_log(20,0) << "PySingletonObject_DeAlloc(" << hex << self << ")" << endl;
}
//ExtensionGetBoolFunction(isExcluded ,NetRoutingExtension)
ExtensionGetBoolFunction(isFixed ,NetRoutingExtension)
ExtensionGetBoolFunction(isUnconnected ,NetRoutingExtension)
ExtensionGetBoolFunction(isManualGlobalRoute ,NetRoutingExtension)
ExtensionGetBoolFunction(isAutomaticGlobalRoute,NetRoutingExtension)
ExtensionGetBoolFunction(isMixedPreRoute ,NetRoutingExtension)
ExtensionGetBoolFunction(isSymmetric ,NetRoutingExtension)
ExtensionGetBoolFunction(isSymHorizontal ,NetRoutingExtension)
ExtensionGetBoolFunction(isSymVertical ,NetRoutingExtension)
ExtensionGetBoolFunction(isSymMaster ,NetRoutingExtension)
//ExtensionGetBoolFunction(isSymSlave ,NetRoutingExtension)
//ExtensionGetBoolFunction(isSelfSym ,NetRoutingExtension)
ExtensionGetBoolFunction(isAnalog ,NetRoutingExtension)
ExtensionGetUIntFunction(getFlags ,NetRoutingExtension)
ExtensionGetLongFunction(getSymAxis ,NetRoutingExtension)
ExtensionSetUIntFunction(setFlags ,NetRoutingExtension)
ExtensionSetUIntFunction(unsetFlags ,NetRoutingExtension)
ExtensionSetLongFunction(setSymAxis ,NetRoutingExtension)
static PyObject* PyNetRoutingExtension_getSymNet ( PyObject*, PyObject* args )
{
cdebug_log(20,0) << "PyNetRoutingExtension_getSymNet()" << endl;
Net* symNet = NULL;
HTRY
PyObject* arg0;
if (not ParseOneArg("NetRoutingExtension.getSymNet()", args, NET_ARG, &arg0)) return NULL;
symNet = NetRoutingExtension::getSymNet( PYNET_O(arg0) );
HCATCH
return PyNet_Link(symNet);
}
static PyObject* PyNetRoutingExtension_get ( PyObject*, PyObject* args )
{
cdebug_log(20,0) << "PyNetRoutingExtension_get()" << endl;
NetRoutingState* state = NULL;
PyObject* arg0 = NULL;
HTRY
if (not ParseOneArg("NetRoutingExtension.get", args, ":ent", &arg0)) return NULL;
state = NetRoutingExtension::get( PYNET_O(arg0) );
HCATCH
return PyNetRoutingState_Link( state );
}
static PyObject* PyNetRoutingExtension_create ( PyObject*, PyObject* args )
{
cdebug_log(20,0) << "PyNetRoutingExtension_create()" << endl;
NetRoutingState* state = NULL;
HTRY
PyObject* pyNet = NULL;
PyObject* pyFlags = NULL;
__cs.init( "NetRoutingExtension.create" );
if (not PyArg_ParseTuple(args,"O&|O&:NetRoutingExtension.create",
Converter, &pyNet,
Converter, &pyFlags))
return NULL;
if (__cs.getObjectIds() == ":ent" ) { state = NetRoutingExtension::create( PYNET_O(pyNet) ); }
else if (__cs.getObjectIds() == ":ent:int") { state = NetRoutingExtension::create( PYNET_O(pyNet), PyAny_AsLong(pyFlags) ); }
else {
PyErr_SetString( ConstructorError, "invalid/bad number of parameters for NetRoutingExtension.create()." );
return NULL;
}
HCATCH
return PyNetRoutingState_Link( state );
}
PyMethodDef PyNetRoutingExtension_Methods[] =
{ { "isFixed" , (PyCFunction)PyNetRoutingExtension_isFixed , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isUnconnected" , (PyCFunction)PyNetRoutingExtension_isUnconnected , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isManualGlobalRoute" , (PyCFunction)PyNetRoutingExtension_isManualGlobalRoute , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isAutomaticGlobalRoute", (PyCFunction)PyNetRoutingExtension_isAutomaticGlobalRoute, METH_NOARGS |METH_CLASS , "To be documented." }
, { "isMixedPreRoute" , (PyCFunction)PyNetRoutingExtension_isMixedPreRoute , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isSymmetric" , (PyCFunction)PyNetRoutingExtension_isSymmetric , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isSymHorizontal" , (PyCFunction)PyNetRoutingExtension_isSymHorizontal , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isSymVertical" , (PyCFunction)PyNetRoutingExtension_isSymVertical , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isSymMaster" , (PyCFunction)PyNetRoutingExtension_isSymMaster , METH_NOARGS |METH_CLASS , "To be documented." }
//, { "isSymSlave" , (PyCFunction)PyNetRoutingExtension_isSymSlave , METH_NOARGS |METH_CLASS , "To be documented." }
//, { "isSelfSym" , (PyCFunction)PyNetRoutingExtension_isSelfSym , METH_NOARGS |METH_CLASS , "To be documented." }
, { "isAnalog" , (PyCFunction)PyNetRoutingExtension_isAnalog , METH_NOARGS |METH_CLASS , "To be documented." }
, { "getFlags" , (PyCFunction)PyNetRoutingExtension_getFlags , METH_NOARGS |METH_CLASS , "To be documented." }
, { "getSymAxis" , (PyCFunction)PyNetRoutingExtension_getSymAxis , METH_NOARGS |METH_CLASS , "To be documented." }
, { "setFlags" , (PyCFunction)PyNetRoutingExtension_setFlags , METH_VARARGS|METH_CLASS , "To be documented." }
, { "unsetFlags" , (PyCFunction)PyNetRoutingExtension_unsetFlags , METH_VARARGS|METH_CLASS , "To be documented." }
, { "setSymAxis" , (PyCFunction)PyNetRoutingExtension_setSymAxis , METH_VARARGS|METH_CLASS , "To be documented." }
, { "getSymNet" , (PyCFunction)PyNetRoutingExtension_getSymNet , METH_VARARGS|METH_CLASS , "To be documented." }
, { "get" , (PyCFunction)PyNetRoutingExtension_get , METH_VARARGS|METH_CLASS
, "Returns the NetRoutingState, or None has not been created yet." }
, { "create" , (PyCFunction)PyNetRoutingExtension_create , METH_VARARGS|METH_CLASS
, "Returns the NetRoutingState, create it if needs be." }
, {NULL, NULL, 0, NULL} /* sentinel */
};
PyTypeObjectLinkPyTypeWithoutObject(NetRoutingExtension,NetRoutingExtension)
#else // End of Python Module Code Part.
// +=================================================================+
// | "PyNetRoutingExtension" Shared Library Code Part |
// +=================================================================+
// Link/Creation Method.
PyTypeObjectDefinitions(NetRoutingExtension)
#endif // Shared Library Code Part.
} // extern "C".
} // Isobar namespace.

159
hurricane/src/isobar/PyNetRoutingState.cpp Normal file
View File

@ -0,0 +1,159 @@
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2017-2017, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | I s o b a r - Hurricane / Python Interface |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Module : "./PyNetRoutingState.cpp" |
// +-----------------------------------------------------------------+
#include "hurricane/isobar/PyNetRoutingState.h"
#include "hurricane/isobar/PyNet.h"
namespace Isobar {
using std::cerr;
using std::endl;
using std::hex;
using std::ostringstream;
using Hurricane::tab;
using Hurricane::Error;
using Hurricane::Warning;
extern "C" {
#define METHOD_HEAD(function) GENERIC_METHOD_HEAD(NetRoutingState,state,function)
// +=================================================================+
// | "PyNetRoutingState" Python Module Code Part |
// +=================================================================+
#if defined(__PYTHON_MODULE__)
static PyObject* PyNetRoutingState_getNet ( PyNetRoutingState *self )
{
cdebug_log(20,0) << "PyNetRoutingState_getNet()" << endl;
Net* net = NULL;
HTRY
METHOD_HEAD( "NetRoutingState.getNet()" )
net = state->getNet();
HCATCH
return PyNet_Link( net );
}
static PyObject* PyNetRoutingState_getSymNet ( PyNetRoutingState *self )
{
cdebug_log(20,0) << "PyNetRoutingState_getSymNet()" << endl;
Net* net = NULL;
HTRY
METHOD_HEAD( "NetRoutingState.getSymNet()" )
net = state->getSymNet();
HCATCH
return PyNet_Link( net );
}
// Standart Accessors (Attributes).
DirectGetBoolAttribute(PyNetRoutingState_isExcluded ,isExcluded ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isFixed ,isFixed ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isUnconnected ,isUnconnected ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isManualGlobalRoute ,isManualGlobalRoute ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isAutomaticGlobalRoute,isAutomaticGlobalRoute,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isMixedPreRoute ,isMixedPreRoute ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isSymmetric ,isSymmetric ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isSymHorizontal ,isSymHorizontal ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isSymVertical ,isSymVertical ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isSymMaster ,isSymMaster ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isSymSlave ,isSymSlave ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isSelfSym ,isSelfSym ,PyNetRoutingState,NetRoutingState)
DirectGetBoolAttribute(PyNetRoutingState_isAnalog ,isAnalog ,PyNetRoutingState,NetRoutingState)
DirectGetUIntAttribute(PyNetRoutingState_getFlags ,getFlags ,PyNetRoutingState,NetRoutingState)
DirectGetLongAttribute(PyNetRoutingState_getSymAxis ,getSymAxis ,PyNetRoutingState,NetRoutingState)
// Standart Mutators (Attributes).
DirectSetUInt32Attribute(PyNetRoutingState_setFlags ,setFlags ,PyNetRoutingState,NetRoutingState)
DirectSetUInt32Attribute(PyNetRoutingState_unsetFlags,unsetFlags,PyNetRoutingState,NetRoutingState)
DirectSetLongAttribute (PyNetRoutingState_setSymAxis,setSymAxis,PyNetRoutingState,NetRoutingState)
PyMethodDef PyNetRoutingState_Methods[] =
{ { "isExcluded" , (PyCFunction)PyNetRoutingState_isExcluded , METH_NOARGS , "To be documented." }
, { "isFixed" , (PyCFunction)PyNetRoutingState_isFixed , METH_NOARGS , "To be documented." }
, { "isUnconnected" , (PyCFunction)PyNetRoutingState_isUnconnected , METH_NOARGS , "To be documented." }
, { "isManualGlobalRoute" , (PyCFunction)PyNetRoutingState_isManualGlobalRoute , METH_NOARGS , "To be documented." }
, { "isAutomaticGlobalRoute", (PyCFunction)PyNetRoutingState_isAutomaticGlobalRoute, METH_NOARGS , "To be documented." }
, { "isMixedPreRoute" , (PyCFunction)PyNetRoutingState_isMixedPreRoute , METH_NOARGS , "To be documented." }
, { "isSymmetric" , (PyCFunction)PyNetRoutingState_isSymmetric , METH_NOARGS , "To be documented." }
, { "isSymHorizontal" , (PyCFunction)PyNetRoutingState_isSymHorizontal , METH_NOARGS , "To be documented." }
, { "isSymVertical" , (PyCFunction)PyNetRoutingState_isSymVertical , METH_NOARGS , "To be documented." }
, { "isSymMaster" , (PyCFunction)PyNetRoutingState_isSymMaster , METH_NOARGS , "To be documented." }
, { "isSymSlave" , (PyCFunction)PyNetRoutingState_isSymSlave , METH_NOARGS , "To be documented." }
, { "isSelfSym" , (PyCFunction)PyNetRoutingState_isSelfSym , METH_NOARGS , "To be documented." }
, { "isAnalog" , (PyCFunction)PyNetRoutingState_isAnalog , METH_NOARGS , "To be documented." }
, { "getFlags" , (PyCFunction)PyNetRoutingState_getFlags , METH_NOARGS , "To be documented." }
, { "getSymAxis" , (PyCFunction)PyNetRoutingState_getSymAxis , METH_NOARGS , "To be documented." }
, { "setFlags" , (PyCFunction)PyNetRoutingState_setFlags , METH_VARARGS , "To be documented." }
, { "unsetFlags" , (PyCFunction)PyNetRoutingState_unsetFlags , METH_VARARGS , "To be documented." }
, { "setSymAxis" , (PyCFunction)PyNetRoutingState_setSymAxis , METH_VARARGS , "To be documented." }
, { "getNet" , (PyCFunction)PyNetRoutingState_getNet , METH_VARARGS , "To be documented." }
, { "getSymNet" , (PyCFunction)PyNetRoutingState_getSymNet , METH_VARARGS , "To be documented." }
, {NULL, NULL, 0, NULL} /* sentinel */
};
PythonOnlyDeleteMethod(NetRoutingState)
PyTypeObjectLinkPyType(NetRoutingState)
#else // End of Python Module Code Part.
// +=================================================================+
// | "PyNetRoutingState" Shared Library Code Part |
// +=================================================================+
// Link/Creation Method.
PyTypeObjectDefinitions(NetRoutingState)
// Link/Creation Method.
LinkCreateMethod(NetRoutingState)
extern void PyNetRoutingState_postModuleInit ()
{
PyObject* constant;
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Excluded ,"Excluded" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Fixed ,"Fixed" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Unconnected ,"Unconnected" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::ManualGlobalRoute ,"ManualGlobalRoute" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::AutomaticGlobalRoute,"AutomaticGlobalRoute");
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::MixedPreRoute ,"MixedPreRoute" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Horizontal ,"Horizontal" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Vertical ,"Vertical" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Symmetric ,"Symmetric" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::SymmetricMaster ,"SymmetricMaster" );
LoadObjectConstant(PyTypeNetRoutingState.tp_dict,NetRoutingState::Analog ,"Analog" );
}
#endif // Shared Library Code Part.
} // extern "C".
} // Isobar namespace.

31
hurricane/src/isobar/hurricane/isobar/PyHurricane.h
View File

@ -119,6 +119,15 @@ namespace Isobar {
}
inline uint32_t PyAny_AsUInt32 ( PyObject* object )
{
int64_t value = 0;
if (PyObject_IsInstance(object,(PyObject*)&PyInt_Type )) value = PyInt_AsLong ( object );
else if (PyObject_IsInstance(object,(PyObject*)&PyLong_Type)) value = PyLong_AsLong( object );
return (uint32_t)value;
}
template< typename T = DbU::Unit, typename enable_if< is_same<T,long>::value, T >::type = 0 >
inline T PyAny_AsLong ( PyObject* object )
{
@ -609,15 +618,33 @@ extern "C" {
\
HTRY \
PyObject* arg0; \
if ( ! PyArg_ParseTuple ( args, "O:" #SELF_TYPE"."#FUNC_NAME"()", &arg0 ) ) \
if (not PyArg_ParseTuple ( args, "O:" #SELF_TYPE"."#FUNC_NAME"()", &arg0 ) ) \
return ( NULL ); \
cobject->FUNC_NAME ( Isobar::PyAny_AsInt(arg0) ); \
cobject->FUNC_NAME ( Isobar::PyAny_AsInt(arg0) ); \
HCATCH \
\
Py_RETURN_NONE; \
}
// -------------------------------------------------------------------
// Attribute Method Macro For uint32_t.
#define DirectSetUInt32Attribute(PY_FUNC_NAME,FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_FUNC_NAME ( PY_SELF_TYPE *self, PyObject* args ) \
{ \
GENERIC_METHOD_HEAD(SELF_TYPE,cobject,#FUNC_NAME"()") \
\
HTRY \
PyObject* arg0; \
if (not PyArg_ParseTuple ( args, "O:" #SELF_TYPE"."#FUNC_NAME"()", &arg0 ) ) \
return ( NULL ); \
cobject->FUNC_NAME ( Isobar::PyAny_AsUInt32(arg0) ); \
HCATCH \
\
Py_RETURN_NONE; \
}
// -------------------------------------------------------------------
// Attribute Method Macro For Long.

59
hurricane/src/isobar/hurricane/isobar/PyNetRoutingProperty.h Normal file
View File

@ -0,0 +1,59 @@
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2017-2017, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | I s o b a r - Hurricane / Python Interface |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Header : "./hurricane/isobar/PyNetRoutingProperty.h" |
// +-----------------------------------------------------------------+
#ifndef PY_NET_ROUTING_PROPERTY_H
#define PY_NET_ROUTING_PROPERTY_H
#include "hurricane/isobar/PyHurricane.h"
#include "hurricane/NetRoutingProperty.h"
namespace Isobar {
extern "C" {
// -------------------------------------------------------------------
// Python Object : "PyNetRoutingExtension".
typedef struct {
PyObject_HEAD
Hurricane::NetRoutingExtension* _object;
} PyNetRoutingExtension;
// -------------------------------------------------------------------
// Functions & Types exported to "PyHurricane.ccp".
extern PyTypeObject PyTypeNetRoutingExtension;
extern PyMethodDef PyNetRoutingExtension_Methods[];
extern PyObject* PyNetRoutingExtension_Link ( Hurricane::NetRoutingExtension* );
extern void PyNetRoutingExtension_LinkPyType ();
extern void PyNetRoutingExtension_postModuleInit ();
# define IsPyNetRoutingExtension(v) ( (v)->ob_type == &PyTypeNetRoutingExtension )
# define PYNETROUTINGEXTENSION(v) ( (PyNetRoutingExtension*)(v) )
# define PYNETROUTINGEXTENSION_O(v) ( PYNETROUTINGEXTENSION(v)->_object )
} // extern "C".
} // Isobar namespace.
#endif // PY_NET_ROUTING_PROPERTY_H

59
hurricane/src/isobar/hurricane/isobar/PyNetRoutingState.h Normal file
View File

@ -0,0 +1,59 @@
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2017-2017, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | I s o b a r - Hurricane / Python Interface |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Header : "./hurricane/isobar/PyNetRoutingState.h" |
// +-----------------------------------------------------------------+
#ifndef PY_NET_ROUTING_STATE_H
#define PY_NET_ROUTING_STATE_H
#include "hurricane/isobar/PyHurricane.h"
#include "hurricane/NetRoutingProperty.h"
namespace Isobar {
extern "C" {
// -------------------------------------------------------------------
// Python Object : "PyNetRoutingState".
typedef struct {
PyObject_HEAD
Hurricane::NetRoutingState* _object;
} PyNetRoutingState;
// -------------------------------------------------------------------
// Functions & Types exported to "PyHurricane.ccp".
extern PyTypeObject PyTypeNetRoutingState;
extern PyMethodDef PyNetRoutingState_Methods[];
extern PyObject* PyNetRoutingState_Link ( Hurricane::NetRoutingState* );
extern void PyNetRoutingState_LinkPyType ();
extern void PyNetRoutingState_postModuleInit ();
# define IsPyNetRoutingState(v) ( (v)->ob_type == &PyTypeNetRoutingState )
# define PYNETROUTINGSTATE(v) ( (PyNetRoutingState*)(v) )
# define PYNETROUTINGSTATE_O(v) ( PYNETROUTINGSTATE(v)->_object )
} // extern "C".
} // Isobar namespace.
#endif // PY_NET_ROUTING_STATE_H

24
katana/src/Constants.cpp
View File

@ -21,18 +21,18 @@
namespace Katana {
const uint64_t Flags::AllowDoglegReuse = (1 << 20);
const uint64_t Flags::DataSelf = (1 << 21);
const uint64_t Flags::Nearest = (1 << 22);
const uint64_t Flags::Force = (1 << 23);
const uint64_t Flags::ResetCount = (1 << 24);
const uint64_t Flags::WithConstraints = (1 << 25);
const uint64_t Flags::MoveToLeft = (1 << 26);
const uint64_t Flags::MoveToRight = (1 << 27);
const uint64_t Flags::LoadingStage = (1 << 28);
const uint64_t Flags::SlowMotion = (1 << 29);
const uint64_t Flags::PreRoutedStage = (1 << 30);
const uint64_t Flags::SymmetricStage = (1 << 31);
const Hurricane::BaseFlags Flags::AllowDoglegReuse = (1 << 20);
const Hurricane::BaseFlags Flags::DataSelf = (1 << 21);
const Hurricane::BaseFlags Flags::Nearest = (1 << 22);
const Hurricane::BaseFlags Flags::Force = (1 << 23);
const Hurricane::BaseFlags Flags::ResetCount = (1 << 24);
const Hurricane::BaseFlags Flags::WithConstraints = (1 << 25);
const Hurricane::BaseFlags Flags::MoveToLeft = (1 << 26);
const Hurricane::BaseFlags Flags::MoveToRight = (1 << 27);
const Hurricane::BaseFlags Flags::LoadingStage = (1 << 28);
const Hurricane::BaseFlags Flags::SlowMotion = (1 << 29);
const Hurricane::BaseFlags Flags::PreRoutedStage = (1 << 30);
const Hurricane::BaseFlags Flags::SymmetricStage = (1 << 31);
} // Anabatic namespace.

2
katana/src/KatanaEngine.cpp
View File

@ -212,7 +212,7 @@ namespace Katana {
Super::chipPrep();
setupGlobalGraph( Flags::NoFlags );
setupGlobalGraph( 0 );
setupRoutingPlanes();
setupSpecialNets();
setupPreRouteds();

4
katana/src/Manipulator.cpp
View File

@ -1087,8 +1087,8 @@ namespace Katana {
Flags kflags = Flags::WithNeighbors;
//kflags |= (flags & AllowLocalMoveUp ) ? Flags::AutoSegment::AllowLocal : 0;
kflags |= (flags & AllowTerminalMoveUp) ? Flags::AllowTerminal : 0;
kflags |= (flags & IgnoreContacts ) ? Flags::IgnoreContacts : 0;
kflags |= (flags & AllowTerminalMoveUp) ? Flags::AllowTerminal : Flags::NoFlags;
kflags |= (flags & IgnoreContacts ) ? Flags::IgnoreContacts : Flags::NoFlags;
if (_segment->isFixed()) return false;
if (not (flags & AllowLocalMoveUp)) {

8
katana/src/PyKatanaFlags.cpp
View File

@ -92,10 +92,10 @@ extern "C" {
{
PyObject* constant;
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,Katana::Flags::NoFlags ,"NoFlags" );
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,Katana::Flags::SlowMotion ,"SlowMotion" );
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,Katana::Flags::PreRoutedStage,"PreRoutedStage");
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,Katana::Flags::SymmetricStage,"SymmetricStage");
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,(uint64_t)Katana::Flags::NoFlags ,"NoFlags" );
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,(uint64_t)Katana::Flags::SlowMotion ,"SlowMotion" );
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,(uint64_t)Katana::Flags::PreRoutedStage,"PreRoutedStage");
LoadObjectConstant(PyTypeKatanaFlags.tp_dict,(uint64_t)Katana::Flags::SymmetricStage,"SymmetricStage");
}

5
katana/src/RoutingEvent.cpp
View File

@ -53,6 +53,7 @@ namespace Katana {
using Hurricane::DebugSession;
using Hurricane::Bug;
using Hurricane::Error;
using Hurricane::BaseFlags;
using Hurricane::ForEachIterator;
using Hurricane::Net;
using Hurricane::Layer;
@ -91,8 +92,8 @@ namespace Katana {
if (lhs._length > rhs._length) return false;
if (lhs._length < rhs._length) return true;
if ((lhs._segFlags & Flags::Horizontal) xor (rhs._segFlags & Flags::Horizontal))
return (rhs._segFlags & Flags::Horizontal);
if ((lhs._segFlags & Anabatic::SegHorizontal) xor (rhs._segFlags & Anabatic::SegHorizontal))
return (rhs._segFlags & Anabatic::SegHorizontal);
if (lhs._axis > rhs._axis) return true;
if (lhs._axis < rhs._axis) return false;

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

@ -26,18 +26,18 @@ namespace Katana {
public:
typedef Anabatic::Flags Super;
public:
static const uint64_t AllowDoglegReuse;
static const uint64_t DataSelf;
static const uint64_t Nearest;
static const uint64_t Force;
static const uint64_t ResetCount;
static const uint64_t WithConstraints;
static const uint64_t MoveToLeft;
static const uint64_t MoveToRight;
static const uint64_t LoadingStage;
static const uint64_t SlowMotion;
static const uint64_t PreRoutedStage;
static const uint64_t SymmetricStage;
static const Hurricane::BaseFlags AllowDoglegReuse;
static const Hurricane::BaseFlags DataSelf;
static const Hurricane::BaseFlags Nearest;
static const Hurricane::BaseFlags Force;
static const Hurricane::BaseFlags ResetCount;
static const Hurricane::BaseFlags WithConstraints;
static const Hurricane::BaseFlags MoveToLeft;
static const Hurricane::BaseFlags MoveToRight;
static const Hurricane::BaseFlags LoadingStage;
static const Hurricane::BaseFlags SlowMotion;
static const Hurricane::BaseFlags PreRoutedStage;
static const Hurricane::BaseFlags SymmetricStage;
public:
inline Flags ( uint64_t );
inline Flags ( const Super& );