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

778 lines
24 KiB
C++
Raw Normal View History

Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2008-2016, All Rights Reserved
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | A n a b a t i c - Routing Toolbox |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@lip6.fr |
// | =============================================================== |
// | C++ Module : "./AutoSegments.cpp" |
// +-----------------------------------------------------------------+
#include "hurricane/Error.h"
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
#include "hurricane/RoutingPad.h"
#include "anabatic/AutoContactTerminal.h"
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
#include "anabatic/AutoSegment.h"
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.
2017-05-20 05:33:12 -05:00
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.
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
namespace Anabatic {
using namespace std;
using Hurricane::tab;
using Hurricane::_TName;
using Hurricane::Error;
using Hurricane::ForEachIterator;
using Hurricane::Hook;
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
using Hurricane::RoutingPad;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
// -------------------------------------------------------------------
// Class : "Anabatic::AutoSegmentStack".
void AutoSegmentStack::push ( AutoContact* contact, AutoSegment* segment )
{
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "Stacking " << contact << " + " << segment << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
push_back( make_pair(contact,segment) );
}
// -------------------------------------------------------------------
// Class : "Anabatic::AutoSegments_OnContact".
AutoSegments_OnContact::Locator::Locator ( AutoSegment* master, Contact* contact )
: AutoSegmentHL()
, _master (master)
, _element (NULL)
{
_hook = contact->getBodyHook()->getPreviousMasterHook();
progress();
}
AutoSegmentHL* AutoSegments_OnContact::Locator::getClone () const
{ return new Locator(*this); }
AutoSegment* AutoSegments_OnContact::Locator::getElement () const
{ return _element; }
bool AutoSegments_OnContact::Locator::isValid () const
{ return !_hook; }
void AutoSegments_OnContact::Locator::progress ()
{
cdebug_log(145,0) << "AutoSegments_OnContact::Locator::progress()" << endl;
while (_hook and not _hook->isMaster()) {
_hook = _hook->getNextHook();
_element = NULL;
if ( _hook->isMaster() ) { _hook = NULL; break; }
Segment* segment = dynamic_cast<Segment*>( _hook->getComponent() );
if (segment) _element = Session::lookup( segment );
if (not _element or (_element == _master)) continue;
break;
}
}
string AutoSegments_OnContact::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_OnContact::Locator")
+ getString(_element)
+ ">";
return s;
}
AutoSegmentHC* AutoSegments_OnContact::getClone () const
{ return new AutoSegments_OnContact(*this); }
AutoSegmentHL* AutoSegments_OnContact::getLocator () const
{ return new Locator(_master,_contact); }
string AutoSegments_OnContact::_getString () const
{
string s = "<" + _TName("AutoSegments_OnContact") + " "
+ getString(_master)
+ ">";
return s;
}
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
// -------------------------------------------------------------------
// Class : "Anabatic::AutoSegments_OnRoutingPad".
AutoSegments_OnRoutingPad::Locator::Locator ( RoutingPad* rp, const AutoContactTerminal* contact )
: AutoSegmentHL()
, _elements ({NULL,NULL,NULL,NULL})
, _index (0)
{
if (rp) {
for ( Component* component : rp->getSlaveComponents() ) {
AutoSegment* segment = Session::lookup( dynamic_cast<Segment*>(component) );
if (not segment) continue;
size_t offset = 2;
if (contact and (contact->getSegment() == segment)) offset = 0;
if (segment->isHorizontal()) _elements[offset ] = segment;
else _elements[offset+1] = segment;
}
}
while ( (_index < 4) and not _elements[_index] ) ++_index;
}
AutoSegmentHL* AutoSegments_OnRoutingPad::Locator::getClone () const
{ return new Locator(*this); }
AutoSegment* AutoSegments_OnRoutingPad::Locator::getElement () const
{ return (_index < 4) ? _elements[_index] : NULL; }
bool AutoSegments_OnRoutingPad::Locator::isValid () const
{ return (_index < 4); }
void AutoSegments_OnRoutingPad::Locator::progress ()
{
cdebug_log(145,0) << "AutoSegments_OnRoutingPad::Locator::progress()" << endl;
++_index;
while ( (_index < 4) and not _elements[_index] ) ++_index;
}
string AutoSegments_OnRoutingPad::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_OnRoutingPad::Locator")
+ getString(_index)
+ ">";
return s;
}
AutoSegments_OnRoutingPad::AutoSegments_OnRoutingPad ( const AutoContact* contact )
: AutoSegmentHC()
, _routingPad(NULL)
, _contact (dynamic_cast<const AutoContactTerminal*>(contact))
{
if (_contact)
_routingPad = dynamic_cast<RoutingPad*>(_contact->getAnchor());
}
AutoSegmentHC* AutoSegments_OnRoutingPad::getClone () const
{ return new AutoSegments_OnRoutingPad(*this); }
AutoSegmentHL* AutoSegments_OnRoutingPad::getLocator () const
{ return new Locator(_routingPad,_contact); }
string AutoSegments_OnRoutingPad::_getString () const
{
string s = "<" + _TName("AutoSegments_OnRoutingPad") + " "
+ getString(_routingPad)
+ ">";
return s;
}
// -------------------------------------------------------------------
// Class : "AutoSegments_Connecteds".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_Connecteds::Locator::Locator ( AutoSegment* segment, Flags flags )
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
: AutoSegmentHL()
, _stack ()
{
cdebug_log(145,0) << "AutoSegments_Connecteds::Locator::Locator()" << endl;
if (flags & Flags::Source) {
AutoContact* contact = segment->getAutoSource();
if (contact) _stack.push( contact, segment );
}
if (flags & Flags::Target) {
AutoContact* contact = segment->getAutoTarget();
if (contact) _stack.push( contact, segment );
}
}
AutoSegmentHL* AutoSegments_Connecteds::Locator::getClone () const
{ return new Locator(*this); }
bool AutoSegments_Connecteds::Locator::isValid () const
{ return not _stack.isEmpty(); }
void AutoSegments_Connecteds::Locator::progress ()
{
cdebug_log(145,0) << "AutoSegments_Connecteds::Locator::progress()" << endl;
while (not _stack.isEmpty()) {
AutoContact* sourceContact = _stack.getAutoContact ();
AutoSegment* sourceSegment = _stack.getAutoSegment ();
_stack.pop ();
AutoContactTerminal* sourceTerminal = dynamic_cast<AutoContactTerminal*>( sourceContact );
if (sourceTerminal) {
for ( AutoSegment* currentSegment : sourceTerminal->getRpConnecteds() ) {
cdebug_log(145,0) << "Looking at: " << currentSegment << endl;
if (currentSegment == sourceSegment) continue;
AutoContact* targetContact = currentSegment->getAutoSource();
if (not targetContact->isTerminal()) _stack.push( targetContact, currentSegment );
targetContact = currentSegment->getAutoTarget();
if (not targetContact->isTerminal()) _stack.push( targetContact, currentSegment );
}
} else {
LocatorHelper helper (sourceContact,Flags::WithPerpands);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
cdebug_log(145,0) << "Looking at: " << currentSegment << endl;
if (currentSegment == sourceSegment) continue;
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
if (targetContact) _stack.push( targetContact, currentSegment );
}
}
break;
}
}
string AutoSegments_Connecteds::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_Connecteds::Locator") + ">";
return s;
}
AutoSegmentHC* AutoSegments_Connecteds::getClone () const
{ return new AutoSegments_Connecteds(*this); }
AutoSegmentHL* AutoSegments_Connecteds::getLocator () const
{ return new Locator(_segment,_flags); }
AutoSegment* AutoSegments_Connecteds::Locator::getElement () const
{ return _stack.getAutoSegment(); }
string AutoSegments_Connecteds::_getString () const
{
string s = "<" + _TName("AutoSegments_Connecteds") + " "
+ getString(_segment)
+ ">";
return s;
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
// -------------------------------------------------------------------
// Class : "AutoSegments_Aligneds".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_Aligneds::Locator::Locator ( AutoSegment* segment, Flags flags )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: AutoSegmentHL()
, _flags (flags)
, _master(segment)
, _stack ()
{
if (not _master) return;
Select S/T in AutoSegments_Aligneds. Priority moved to TrackSegment. * In Katana::AutoSegments_Aligneds, allow the the caller to select if we are propagating through source or target only (or both). Note that if no flag is given, it is assumed that we want to propagate the old way on both source and target. * In Katana::TrackElement, Katana::TrackSegment and Katana::RoutingEvent, move the event priority from RoutingEvent to TrackSegment. Add accessor and mutators associated in TrackElement (virtual methods).
2017-05-27 13:35:28 -05:00
if (not _flags.intersect(Flags::Source|Flags::Target))
_flags |= Flags::Source | Flags::Target;
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.
2017-05-20 05:33:12 -05:00
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
_flags |= (_master->isHorizontal()) ? Flags::Horizontal : Flags::Vertical;
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.
2017-05-20 05:33:12 -05:00
if (_flags & Flags::WithDoglegs) _flags |= Flags::WithPerpands;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "AutoSegments_Aligneds::Locator::Locator() _flags:" << _flags.asString(FlagsFunction) << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
Select S/T in AutoSegments_Aligneds. Priority moved to TrackSegment. * In Katana::AutoSegments_Aligneds, allow the the caller to select if we are propagating through source or target only (or both). Note that if no flag is given, it is assumed that we want to propagate the old way on both source and target. * In Katana::TrackElement, Katana::TrackSegment and Katana::RoutingEvent, move the event priority from RoutingEvent to TrackSegment. Add accessor and mutators associated in TrackElement (virtual methods).
2017-05-27 13:35:28 -05:00
if (_flags & Flags::Source) {
AutoContact* contact = segment->getAutoSource();
if (contact) _stack.push( contact, segment );
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
Select S/T in AutoSegments_Aligneds. Priority moved to TrackSegment. * In Katana::AutoSegments_Aligneds, allow the the caller to select if we are propagating through source or target only (or both). Note that if no flag is given, it is assumed that we want to propagate the old way on both source and target. * In Katana::TrackElement, Katana::TrackSegment and Katana::RoutingEvent, move the event priority from RoutingEvent to TrackSegment. Add accessor and mutators associated in TrackElement (virtual methods).
2017-05-27 13:35:28 -05:00
if (_flags & Flags::Target) {
AutoContact* contact = segment->getAutoTarget();
if (contact) _stack.push( contact, segment );
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah! * Bug: In Hurricane, in StaticObservable::getObserver(), if the slot pointer is NULL, do not try to access the owner. Returns NULL, so the caller can be aware of the situation... * Change: In Hurricane, in BreakpointWidget & ExceptionWidget some cosmetic changes (fonts and window sizes). * Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account the constraints from the source AutoContact, as it holds the constraints transmitted by the RoutingPads and sets up by propageConstraintsFromRp(). It is likely to be a bug affecting the original Katabatic as well. * Change: In Anabatic, in RawGCellsUnder(), check that the segment is not completly oustside the cell abutment box and truncate the coordinates to the part that is inside. Use the "shrink" if we reach the east/north border. * Change: In Anabatic, in Configuration, no more decorator because we will use a true derived relationship. Katana *derives* from *Anabatic* and do not *decorate* it, so the Configuration can do the same. It also implies that we directly create a Katana engine, not an Anabatic one. * Change: In Anabatic, in Session, do not allow the opening of the Session in a standalone fashion (with a static method). Instead it must be opened using the relevant method of the Anabatic/Katana engine. This ensure we are opening the right Session type. * Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment is not part of the collection by default, but will be included if the Flags::WithSelf is set. * Change: In Configuration, all the flags value are now defined in two steps. Declared in the header and initialized in the module. This is to prevent the fact that on some cases, in relation with the Python "extern C" part modules, we need a true allocated variable. It was causing weird linking problems. A side effect is that they can no longer be used as entry is switches, have to replace them by if/else. * New: In Anabatic, new GCell::getNeighborAt() utility function. * Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with the grid type... Back annote all the edges capacity (north & east) with the reserved local capacity. * New: Complete portage of Kite over Anabatic. The new engine is christened "Katana" for Kite-Analogic. When it's capabilities and performances will be on a part with Kite, it is to completly replace it (and take back the "Kite" name). Preliminary tests seems to show that, contrary to intuition (because built on a more complex/slower grid), it is even slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
if (not (_flags & Flags::WithSelf)) progress();
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
AutoSegmentHL* AutoSegments_Aligneds::Locator::getClone () const
{ return new Locator(*this); }
bool AutoSegments_Aligneds::Locator::isValid () const
{ return not _stack.isEmpty(); }
void AutoSegments_Aligneds::Locator::progress ()
{
Katana routing algorithm adjustements for analog routing. * Bug: In Hurricane::Interval, the ::getSize() method was returning a negative length when the Interval was empty. Now return zero. This was causing slight cost functions side effect when computing the overlap of a segment with another one belonging to the same net (i.e. shareDelta) * Bug: In Katana::AutoSegment::computeOptimal(), checks that the optimal position for the axis is indeed inside the GCell interval. * Bug: In Katana::DataSymmetric::getSymmetrical(Interval&), reverse the shrink applied to GCells sides. Interval are of the type [min:max[ so after symmetric transformation they become ]smax:smin]. Apply a correction so that they are [smax:smin[ and could be merged with the paired interval (the one without symmetry applied). * Bug: In katana::TrackCost::consolidate(), the overlap (now) always positive, and must be *substracted* to the "delta" (not *added*). * Bug: In Katana::_computeNetOptimals(), now skip the already processeds AutoSegments instead of re-processing them. * New: In Katana::AutoSegment::computeOptimal(), improved computation of the axis hint: - For analog net, propagate through the simple doglegs to find attractors. - Restrict the allowed interval to the union of GCell sides and segments constraints that are terminals. - Consider a local as "long" if it's length exceed 20 the P-pitch. (maybe make that a tool parameter).
2017-05-22 17:20:31 -05:00
cdebug_log(144,0) << "AutoSegments_Aligneds::Locator::progress()" << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
while (not _stack.isEmpty()) {
AutoContact* sourceContact = _stack.getAutoContact ();
AutoSegment* sourceSegment = _stack.getAutoSegment ();
_stack.pop ();
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,1) << "Iterate over: " << sourceContact << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
LocatorHelper helper (sourceContact, _flags);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "| " << currentSegment << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (currentSegment == sourceSegment) continue;
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.
2017-05-20 05:33:12 -05:00
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;
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
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.
2017-05-20 05:33:12 -05:00
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;
}
}
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
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.
2017-05-20 05:33:12 -05:00
cdebug_tabw(144,-1);
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (_stack.getAutoSegment() == _master) continue;
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.
2017-05-20 05:33:12 -05:00
if (not AutoSegment::areAligneds(_stack.getAutoSegment(),_master)) continue;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
break;
}
}
string AutoSegments_Aligneds::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_Aligneds::Locator") + ">";
return s;
}
AutoSegmentHC* AutoSegments_Aligneds::getClone () const
{ return new AutoSegments_Aligneds(*this); }
AutoSegmentHL* AutoSegments_Aligneds::getLocator () const
{ return new Locator(_segment,_flags); }
AutoSegment* AutoSegments_Aligneds::Locator::getElement () const
{ return _stack.getAutoSegment(); }
string AutoSegments_Aligneds::_getString () const
{
string s = "<" + _TName("AutoSegments_Aligneds") + " "
+ getString(_segment)
+ ">";
return s;
}
// -------------------------------------------------------------------
// Class : "AutoSegments_Perpandiculars".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_Perpandiculars::Locator::Locator ( AutoSegment* master, Flags flags )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: AutoSegmentHL()
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
//, _flags (Flags::WithPerpands|Flags::WithDoglegs)
, _flags (Flags::WithPerpands|flags)
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
, _master (master)
, _stack ()
, _perpandiculars()
{
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "AutoSegments_Perpandiculars::Locator::Locator(): _flags:" << _flags.asString(FlagsFunction) << endl;
cdebug_log(144,0) << " " << _master << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (not _master) return;
if (_master->isHorizontal()) _flags |= Flags::Horizontal;
else _flags |= Flags::Vertical;
AutoContact* contact = _master->getAutoSource();
if ( contact ) _stack.push( contact, _master );
contact = _master->getAutoTarget();
if ( contact ) _stack.push( contact, _master );
progress();
}
AutoSegment* AutoSegments_Perpandiculars::Locator::getElement () const
{
if (_perpandiculars.empty()) return NULL;
return _perpandiculars.back();
}
void AutoSegments_Perpandiculars::Locator::progress ()
{
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,1) << "AutoSegments_Perpandiculars::Locator::progress()" << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (not _perpandiculars.empty()) _perpandiculars.pop_back();
if (not _perpandiculars.empty()) return;
while ( not _stack.isEmpty() ) {
AutoContact* sourceContact = _stack.getAutoContact();
AutoSegment* sourceSegment = _stack.getAutoSegment();
_stack.pop();
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "Iterate over: " << sourceContact << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
LocatorHelper helper (sourceContact, _flags);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
if (currentSegment == sourceSegment) continue;
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "| " << currentSegment << endl;
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (AutoSegment::areAligneds(currentSegment,_master)) {
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
if (targetContact) {
if (_master->getLayer() != currentSegment->getLayer()) {
continue;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "Stacking target. " << endl;
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
_stack.push( targetContact, currentSegment );
// if ( (_master->isHorizontal() and sourceContact->isHTee())
// or (_master->isVertical () and sourceContact->isVTee()) ) {
// if (AutoSegment::areAlignedsAndDiffLayer(currentSegment,_master)) {
// cerr << Error("Aligned segments not in same layer (perpandicular locator)\n"
// " %s\n"
// " %s."
// ,getString(_master).c_str()
// ,getString(currentSegment).c_str()) << endl;
// continue;
// }
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.
2017-05-20 05:33:12 -05:00
// cdebug_log(144,0) << "Stacking target. " << endl;
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
// _stack.push( targetContact, currentSegment );
// }
} else {
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "No opposite anchor to: " << sourceContact << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
} else {
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
if ( (_flags & Flags::WithDoglegs) and currentSegment->isLocal() and sourceContact->isTurn() ) {
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
if (targetContact->isTurn()) {
AutoSegment* targetGlobal = targetContact->getPerpandicular( currentSegment );
if (targetGlobal->isGlobal() and (_master->getLayer() == targetGlobal->getLayer())) {
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "Global aligned though dogleg:" << targetGlobal << endl;
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
Interval masterConstraints;
Interval targetConstraints;
_master ->getConstraints( masterConstraints );
targetGlobal->getConstraints( targetConstraints );
if (targetConstraints.intersect(masterConstraints)) {
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.
2017-05-20 05:33:12 -05:00
cdebug_log(144,0) << "Stacking dogleg global. " << endl;
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
_stack.push( targetContact, currentSegment );
continue;
}
}
}
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
_perpandiculars.push_back( currentSegment );
}
}
if (_stack.isEmpty()) break;
if (_stack.getAutoSegment() == _master) continue;
if (not _perpandiculars.empty()) break;
}
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
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.
2017-05-20 05:33:12 -05:00
cdebug_tabw(144,-1);
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
AutoSegmentHL* AutoSegments_Perpandiculars::Locator::getClone () const
{ return new Locator(*this); }
bool AutoSegments_Perpandiculars::Locator::isValid () const
{ return not _perpandiculars.empty(); }
AutoSegmentHC* AutoSegments_Perpandiculars::getClone () const
{ return new AutoSegments_Perpandiculars(*this); }
AutoSegmentHL* AutoSegments_Perpandiculars::getLocator () const
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
{ return new Locator(_master,_flags); }
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
string AutoSegments_Perpandiculars::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_Perpandiculars::Locator") + ">";
return s;
}
string AutoSegments_Perpandiculars::_getString () const
{
string s = "<" + _TName("AutoSegments_Perpandiculars") + " "
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
+ getString(_master)
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
+ ">";
return s;
}
// -------------------------------------------------------------------
// Class : "AutoSegments_AnchorOnGCell".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_AnchorOnGCell::Locator::Locator ( GCell* fcell, Flags flags )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: AutoSegmentHL()
, _flags (flags)
, _itContact (fcell->getContacts().begin())
, _itEnd (fcell->getContacts().end())
, _hookLocator(NULL)
, _element (NULL)
{ progress(); }
AutoSegments_AnchorOnGCell::Locator::~Locator ()
{ if (_hookLocator) delete _hookLocator; }
AutoSegment* AutoSegments_AnchorOnGCell::Locator::getElement () const
{ return _element; }
AutoSegmentHL* AutoSegments_AnchorOnGCell::Locator::getClone () const
{ return new Locator(*this); }
bool AutoSegments_AnchorOnGCell::Locator::isValid () const
{ return _element != NULL; }
void AutoSegments_AnchorOnGCell::Locator::progress ()
{
cdebug_log(145,1) << "AutoSegments_AnchorOnGCell::Locator::progress()" << endl;
while ( true ) {
if (_hookLocator == NULL) {
if (_itContact == _itEnd) {
cdebug_log(145,0) << "No more AutoContacts" << endl;
cdebug_tabw(145,-1);
return;
}
cdebug_log(145,0) << *_itContact << endl;
_hookLocator = (*_itContact)->getBodyHook()->getSlaveHooks().getLocator();
_itContact++;
} else {
_hookLocator->progress();
}
while ( _hookLocator->isValid() ) {
cdebug_log(145,0) << _hookLocator->getElement() << endl;
Hook* hook = dynamic_cast<Segment::SourceHook*>(_hookLocator->getElement());
if (hook) {
if ( ((_flags & Flags::Source) and (dynamic_cast<Segment::SourceHook*>(hook)))
or ((_flags & Flags::Target) and (dynamic_cast<Segment::TargetHook*>(hook))) ) {
_element = Session::lookup( static_cast<Segment*>(hook->getComponent()) );
if (_element->isHorizontal()) {
if (_flags & Flags::Horizontal) { cdebug_tabw(145,-1); return; }
} else
if (_flags & Flags::Vertical) { cdebug_tabw(145,-1); return; }
}
}
_hookLocator->progress();
}
_hookLocator = NULL;
_element = NULL;
}
cdebug_tabw(145,-1);
}
string AutoSegments_AnchorOnGCell::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_AnchorOnGCell::Locator") + ">";
return s;
}
AutoSegmentHC* AutoSegments_AnchorOnGCell::getClone () const
{ return new AutoSegments_AnchorOnGCell(*this); }
AutoSegmentHL* AutoSegments_AnchorOnGCell::getLocator () const
{ return new Locator(_fcell,_flags); }
string AutoSegments_AnchorOnGCell::_getString () const
{
string s = "<" + _TName("AutoSegments_AnchorOnGCell") + " "
+ getString(_fcell)
+ ">";
return s;
}
// -------------------------------------------------------------------
// Class : "Anabatic::AutoSegments_CachedOnContact".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_CachedOnContact::Locator::Locator ( AutoContact* sourceContact, Flags direction )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: AutoSegmentHL()
, _helper(new LocatorHelper(sourceContact,direction))
{ }
AutoSegments_CachedOnContact::Locator::~Locator ()
{ delete _helper; }
AutoSegment* AutoSegments_CachedOnContact::Locator::getElement () const
{ return _helper->getSegment(); }
AutoSegmentHL* AutoSegments_CachedOnContact::Locator::getClone () const
{ return new Locator(*this); }
bool AutoSegments_CachedOnContact::Locator::isValid () const
{ return _helper->isValid(); }
void AutoSegments_CachedOnContact::Locator::progress ()
{
cdebug_log(145,0) << "AutoSegments_CachedOnContact::Locator::progress()" << endl;
_helper->progress();
}
AutoSegmentHL* AutoSegments_CachedOnContact::getLocator () const
{ return new Locator(_sourceContact,_direction); }
AutoSegmentHC* AutoSegments_CachedOnContact::getClone () const
{ return new AutoSegments_CachedOnContact(*this); }
string AutoSegments_CachedOnContact::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_CachedOnContact::Locator") + ">";
return s;
}
string AutoSegments_CachedOnContact::_getString () const
{
string s = "<" + _TName("AutoSegments_CachedOnContact") + " "
+ getString(_sourceContact)
+ ">";
return s;
}
// -------------------------------------------------------------------
// Class : "AutoSegments_IsAccountable".
AutoSegmentHF* AutoSegments_IsAccountable::getClone () const
{ return new AutoSegments_IsAccountable(); }
bool AutoSegments_IsAccountable::accept ( AutoSegment* segment ) const
{ return segment->isCanonical(); }
string AutoSegments_IsAccountable::_getString () const
{ return "<AutoSegments_IsAccountable>"; }
// -------------------------------------------------------------------
// Class : "AutoSegments_InDirection".
AutoSegmentHF* AutoSegments_InDirection::getClone () const
{ return new AutoSegments_InDirection(_direction); }
bool AutoSegments_InDirection::accept ( AutoSegment* segment ) const
{
return ( segment->isHorizontal() and (_direction & Flags::Horizontal) )
or ( segment->isVertical () and (_direction & Flags::Vertical ) );
}
string AutoSegments_InDirection::_getString () const
{ return "<AutoSegments_InDirection>"; }
} // Anabatic namespace.