jcarr
/
coriolis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
coriolis/katana/src/TrackElement.cpp

298 lines
11 KiB
C++
Raw Normal View History

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
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
Happy New Year 2018 ! Update license years...
2018-01-06 10:55:44 -06:00
// Copyright (c) UPMC 2008-2018, All Rights Reserved
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
//
// +-----------------------------------------------------------------+
// | C O R I O L I S |
// | K i t e - D e t a i l e d R o u t e r |
// | |
// | Author : Jean-Paul CHAPUT |
// | E-mail : Jean-Paul.Chaput@asim.lip6.fr |
// | =============================================================== |
// | C++ Module : "./TrackElement.cpp" |
// +-----------------------------------------------------------------+
#include <limits>
#include <sstream>
#include "hurricane/Bug.h"
#include "hurricane/Warning.h"
#include "hurricane/Net.h"
#include "hurricane/Name.h"
#include "anabatic/AutoContact.h"
#include "anabatic/GCell.h"
#include "crlcore/RoutingGauge.h"
#include "katana/DataNegociate.h"
#include "katana/TrackElement.h"
#include "katana/TrackCost.h"
#include "katana/Track.h"
#include "katana/Session.h"
#include "katana/RoutingEvent.h"
#include "katana/NegociateWindow.h"
namespace {
using namespace std;
using namespace Hurricane;
using namespace CRL;
using namespace Katana;
void dummyOverlapCost ( const TrackElement* segment, TrackCost& cost )
{
cerr << Warning("No overlapCost callback has been set (%s)."
,getString(segment).c_str()) << endl;
}
} // Anonymous namespace.
namespace Katana {
using Hurricane::tab;
using Hurricane::Bug;
using Hurricane::Net;
using Hurricane::Name;
using Anabatic::GCell;
// -------------------------------------------------------------------
// Comparison Classes.
//
// Return: lhs < rhs.
bool Compare::operator() ( TrackElement* lhs, TrackElement* rhs )
{ return lhs->getFreedomDegree() > rhs->getFreedomDegree(); }
bool CompareByPosition::operator() ( const TrackElement* lhs, const TrackElement* rhs ) const
{
if (lhs == rhs) return false;
if (lhs->isBlockage() xor rhs->isBlockage()) return lhs->isBlockage();
if (lhs->getLength() < rhs->getLength()) return true;
if (lhs->getLength() > rhs->getLength()) return false;
if (lhs->isHorizontal() xor rhs->isHorizontal()) return rhs->isHorizontal();
if (lhs->getAxis() > rhs->getAxis()) return true;
if (lhs->getAxis() < rhs->getAxis()) return false;
if (lhs->getSourceU() > rhs->getSourceU()) return true;
if (lhs->getSourceU() < rhs->getSourceU()) return false;
if (lhs->isBlockage() and rhs->isBlockage()) return false;
return lhs->getId() < rhs->getId();
}
// -------------------------------------------------------------------
// Class : "TrackElement".
SegmentOverlapCostCB* TrackElement::_overlapCostCallback = dummyOverlapCost;
SegmentOverlapCostCB* TrackElement::setOverlapCostCB ( SegmentOverlapCostCB* cb )
{
SegmentOverlapCostCB* oldCb = _overlapCostCallback;
_overlapCostCallback = cb;
return oldCb;
}
void TrackElement::notify ( TrackElement* segment, unsigned int flags )
{
if (flags & AutoSegment::Invalidate) {
if (not segment->isInvalidated()) {
cdebug_log(159,0) << "::notify() <Invalidate> on " << segment << endl;
segment->invalidate();
}
}
if (flags & AutoSegment::Revalidate) {
// Revalidation must be delayed until *all* the AutoSegments have been revalidated.
// if (segment->isInvalidated()) {
// cdebug_log(159,0) << "::notify() <Revalidate> on " << segment << endl;
// segment->revalidate( true );
// }
}
if (flags & AutoSegment::RevalidatePPitch) {
segment->updatePPitch();
}
}
// Wrapped AutoSegment Functions.
AutoSegment* TrackElement::base () const { return NULL; }
bool TrackElement::isFixed () const { return false; }
Basic support for FreePDK 45 completed. * New: In Commons, inspector support for std::pair<T,U>. * New: In Hurricane::Layer, ContactLayer & ViaLayer, support for non square VIAs. The hole (cut) remains square, but the various metal extensions can now be different in X and Y. The ::getEnclosure() method now takes a flag EnclosureH / EnclosureV. * New: In Hurricane::DbU, inspector support for: std::pair<DbU::Unit,DbU::Unit> std::array<DbU::Unit,3> Must be defined here as DbU do not exists yet in Commons.h * Bug: In Hurricane::Interval::getSize(), when the interval is "full span", do not return the difference between min and max, but directly DbU::Max. (the previous result was -1 !) * New: In CRL Core Python/Technology.py, support for non square VIAs in the configuration files. Applied to FreePDK 45. * New: In CRL::RoutingGauge, added a "symbolic" flag to tell if a gauge is for symbolic layout or not. Exported to Python. * New: In Anabatic::AutoHorizontal::updatePosition(), differentiated computation for soure or target taking account of the VIA extension in the right segment metal (due to non-square VIAs). * Change: In Anabatic::AutoHorizontal::_makeDogleg(), the dogleg is UP for HV gauges and DOWN for VH. * New: In Anabatic::AutoSegment::_initialize(), create a cache of the various extension length for each layer (viaToTop, viaToBottom, viaToSame). New implementation of getExtensionCap() using the previous cached extension table. See updatePositions(). New static functions to access the extension cache in the header: getViaTotopCap() ... * Change: In Anabatic::AutoSegment, in various update methods, updateOrient() must always be called *before* updatePositions() as extensions are dependant on source/target. * New: In Anabatic::AutoSegment::getEndAxes() compute the position of the first source and last target position (center/axes) on an *aligned* set of segments. * New: In Anabatic::AutoSegment, add a new state flag SegAxisFixed to signal segments that can be put on only one track. Specific case to VH gauge for a M1 vertical terminal with a M2 vertical segment. The M2 is effectively bound to the M1 axis position. * Bug: In Anabatic::NetBuilderVH::_do_xG_xM1_xM3(), in case of E/W global and only one RoutingPad the connexion to the RoutingPad was duplicated. It was valid, but totally stupid. * Bug: In Anabatic::Session::_canonize(), for an aligned segment set, intersect the user constraints from all segments instead of only considering the canonical one. Issue a warning about too tight constraints only for symbolic gauges. It may be correct for the real ones. * New: In Katata::DataNegociate::update(), more accurate computation of the perpandicular free interval. Use segment extension cap calculation. Create a special case for fixed axis segments allowing them to find alternative free interval, try under source and under target as they are likely to be draggable segments. * Change: In Katana::Manipulator::relax(), use the extension cap value to compute the axis of the perpandicular segemnts. * Change: In Katana::Manipulator::moveUp(), now move up the whole set of aligned segments instead of just the canonical one. * Change: In Katana::NegociateWindow::loadRoutingPads(), more accurate TrackMarkers insertions for fixed terminals. * New: In Katana::RoutingEvent::Key::Compare::operator(), segments with fixed axis are processed prior to any others. * New: In Katana::RoutingEventLoop, store segment pointers instead of ids to generate more accurate error messages. * Change: In Katana::RoutingPlane::create(), perform local track assignment only for HV gauges. * Change: In Katana::SegmentFsm::_slackenLocal(), add a "dragMinimize" step in the automaton. Mutliple states transitions can occurs in a row if an action fails. * New: In Katana::Session::_toIntervalAxis(), normalize interval bounds so they are on track positions (by shrinking the interval). * Bug: In Katana::TrackMarker CTOR, the weigh computation was wrong.
2018-02-17 13:27:38 -06:00
bool TrackElement::isFixedAxis () const { return false; }
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
bool TrackElement::isLocal () const { return true; }
bool TrackElement::isGlobal () const { return not isLocal(); }
bool TrackElement::isBipoint () const { return false; }
bool TrackElement::isTerminal () const { return false; }
Improved management of AutoContactTerminal for VH gauges (real ones). * New: In Anabatic & Katana, add the new "drag" feature. With VH gauges used by real technologies (M1-H, M2-V, M3-H) a new routing configuration that was not efficiently handled did appear. While the preferred routing direction for metal1 is officially horizontal, due to the way the standard cell must be designed, their metal1 terminals are still verticals (or punctuals). Thus, when connecting to them, we face the case where the metal1 terminal (RoutingPad) is vertical *and* the metal2 wire is also vertical. With that setup, the position of the AutoContactTerminal via12 cannot be deduced, it may range all the way over the metal1 RoutingPad. What may define it's position is the metal3 the metal2 finally connects to. That, is, when we have one horizontal (the metal3) and one vertical (the metal1 RoutingPad). The intermediate wire of metal2 can be kept to a minimum size by "dragging" the via12 close to the via23 when the metal3 wire is moved. * New: In Anabatic & Katana, problem of closely vertically aligneds RoutingPads in metal1 is managed first in PreProcess by restricting the span of the connecteds metal3 and in _makeDogleg also by restricting the span even more tightly (to the RoutingPad itself). * New: In Anabatic::AutoContactTerminal, add the "drag" support. Automatically check if the connecting segment is in the same direction as the RoutingPad, if so, sets the "SegDrag" flag. The dragging state can be known with the "::canDrag()" predicate. * New: In Anabatic::AutoHorizontal, add the "drag" support. The drag state can be known with the "::isDrag()" predicate. In "::_makeDogleg()", when making a dogleg on a dragable segment pass the drag state correctly and restrict the perpandicular span of the perpandicular to the RoutingPad (though segment user constraints). If we make a dogleg on the metal2 is it likely than we cannot go straigth out vertically from the RoutingPad, so the new perpandicular *is* restricted to the RoutingPad span. Idem for AutoVertical. * New: In Katana::Manipulator, add method "::dragMinimize()" which find a hole where to minimize a draggable segment. We finally did not use it, but keep it for potential further use. * New: In Katana::PreProcess, adds a "protectAlignedaccesses()" local function to check for vertically aligned metal1 RoutingPads, in that case setup user constraints on the metal3 segments so they cannot completly cover the other RoutingPad with metal2. We also keep a "metal2protect()" function that create a fixed segment to lock/protect a RoutingPad. Not used for now. * New: In Katana::Session, add a RoutingPad locking event mechanism. This allows us to request the creation of a locking (fixed segment) over a draggable segment. Not used for now. Lock events are processeds before all others as they create new TrackElements. * New: In Katana::Track, "::getNextFree()" and "::getPreviousFree()" method to find the nearest free interval in a Track after/before a position. * Bug: In Anabatic::AutoHorizontal::getConstraints(), merge with user constraints *only* if it's not an empty interval (as we use min/max functions). Idem for AutoVertical. * Bug: In AutoSegments_OnContacts::Locator::isValid(), the boolean test must be inverted. Seems it never worked, but we never used it until now...
2018-01-25 04:58:04 -06:00
bool TrackElement::isDrag () const { return false; }
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
bool TrackElement::isStrongTerminal ( Flags ) const { return false; }
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
bool TrackElement::isStrap () const { return false; }
Upgrade of Katana detailed router to support Arlet 6502. * Change: In Hurricane::SharedName, replace the incremental Id by a hash key. This is to ensure better deterministic properties. Between use cases, additional strings may have to be allocated, shitfing the ids. Even if hash can be duplicated, we should be able to ensure that the absolute order in map table should be preserved. Supplemental strings are inserted in a way that keep the previous order. * Change: In CRL/etc/symbolic/cmos/kite.conf, add "katabatic.routingGauge" default parameter value ("sxlib"). * Change: In CRL/etc/common/technology.conf, define minimal spacing for symbolic layers too (added for METAL4 only for now). * Change: In CRL::Histogram, extend support to dynamically sized histograms. Add a text pretty print with table and pseudo-curve. * Change: In Cumulus/plugins/ClockTreePlugin, create blockage under the block corona corners so the global router do not draw wire under them. This was creating deadlock for the detailed router. When the abutment has to be computed, directly use Etesian to do it instead of duplicating the computation in the Python plugin. * New: In Etesian, as Coloquinte seems reluctant to evenly spread the standard cells, we trick it by making them bigger during the placement stage. Furthermore, we do not not uniformely increase the size of the cells but create a "bloating profile" based on cell size, cell name or it's density of terminals. Currently only two profiles are defined, "disabled" which does nothing and "nsxlib" targeted on 4 metal layer technologies (aka AMS 350nm, c35b4). * Bug: In Knik::MatrixVertex, load the default routing gauge using the configuration parameter "katabatic.routingGauge" as the default one may not be the first registered one. * New: In AnabaticEngine::setupNetDatas(), build a dynamic historgram of the nets terminal numbers. * Bug: In Anabatic::AutoContact::Invalidate(), always invalidate the contact cache when topology is invalidated. In case of multiple invalidations, if the first did not invalidate the cache, later one that may need it where not allowed to do so. The end result was correct nonetheless, but it did generate annoying error messages. * Bug: In Anabatic::AutoContactTurn::updateTopology(), bad computation of the contact's depth when delta == 2. * Bug: In Anabatic::Gcell::getCapacity(), was always returning the west edge capacity, even for the westermost GCell, should be the east edge in that case. * New: In Anabatic::AutoSegment, introduce a new measure "distance to terminal". This is the minimal number of segments separating the current one from the nearest RoutingPad. This replace the previous "strong terminal" and "weak terminal" flags. This distance is used by Katana to sort the events, we route the segments *from* the RoutingPads *outward*. The idea being that if we cannot event connect to the RoutingPad, there is no points continuing as thoses segments are the more constraineds. This gives an order close to the simple ascending metals but with better results. * New: In Anabatic::AutoSegment, introduce a new flag "Unbreakable", disable dogleg making on those segments. mainly intended for local segments directly connecteds to RoutingPads (distance == 0). * New: In Anabatic::AutoSegment, more aggressive reducing of segments. Now the only case where a segment cannot be reduced is when it is one horizontal branch in a HTee or a vertical on a VTee. Check if, when not accounted the source & target VIAs are still connex, if so, allow reducing. * New: In Anabatic::AutoContact, new state flags CntVDogleg & CntHDogleg mainly to prevent making doglegs twice on a turn contact. This is to limit over-fragmentation. If one dogleg doesn't solve the problem, making a second one will make things worse only... * Bug: In Anabatic::Configuration::selectRpcomponent(), we were choosing the component with the *smallest* span instead of the *bigger* one. * New: In Anabatic::GCell, introduce a new flag "GoStraight" to tell that no turn go be made inside those GCells. Mainly used underneath a block corona. * New: In AnabaticEngine::layerAssign(), new GCellRps & RpsInRow to manage GCells with too many terminals. Slacken at least one RoutingPad access when there is more than 8 RoutingPad in the GCell (slacken or change a vertical METAL2 (non-preferred) into a METAL3). * Change: In Anabatic::NetBuilderHV, allow the use of terminal connection in non-preferred direction. That is, vertical METAL2 directly connected to the RoutingPad (then a horizontal METAL2). This alllows for short dogleg without clutering the METAL3 layer (critical for AMS c35b4). Done in NetBuilderHV::doRp_Access(), with a new UseNonPref flag. Perform some other tweaking on METAL1 access topologies, to also minimize METAL3 use. * New: In AnabaticEngine::computeNetConstraints(), also compute the distance to RoutingPad for segments. Set the Unbreakable flag, based on the distance and segment length (local, short global or long global). New local function "propagateDistanceFromRp()". * Change: In AnabaticEngine.h, the sorting class for NetData, SparsityOrder, is modificated so net with a degree superior to 10 are sorted first, whatever their sparsity. This is to work in tandem with GlobalRouting. * New: In Katana::TrackSegmentNonPref, introduce a class to manage segment in non-preferred routing direction. Mostly intended for small METAL2 vertical directly connected to RoutingPad. Modifications to manage this new variant all through Katana. * Change: In Katana::GlobalRoute, DigitalDistance honor the GoStraight flag of the GCell. Do not make bend inside thoses GCells. * Change: In KatanaEngine::runGlobalRouter(), high degree nets (>= 10) are routed first and whitout the global routing estimation. There should be few of them so they wont create saturations and we want them as straight as possible. Detour are for long be-points. Set the saerch halo to one GCell in the initial routing stage (before ripup). * Bug: In KatanaEngine & NegociateWindow, call _computeCagedconstraints() inside NegociateWindow::run(), as segments are inserted into tracks only at that point so we cannot make the computation earlier. * Change: In Katana::Manipulator::repackPerpandiculars(), add a flag to select whether to replace the perpandiculars *after* or *before* the current segment. * Change: In Katana::NegociateWindow::NegociateOverlapCost(), when the segment is fully enclosed inside a global, the longest overlap cost is set to the shortest global hoverhang (before or after). When the cost is for a global, set an infinite cost if the overlapping segment has a RP distance less or equal to 1 (this is an access segment). * Bug: In Katana::PowerRailsPlane::Rail::doLayout(), correct computation of the segments extension cap. * New: In Katana::QueryPowerRails::addToPowerRail(), add support for Pad. * Change: In Katana/PreProcess::protectCagedTerminals(), apply the contraints to any turn connected to the first segment of the RoutingPad so the perpandicular constraints got propagated to the perpandicular segment... * Change: In RoutingEvent, cache the "distance to RP" value. * Change: In RoutingEvent::Key::compare(), sort *first* on distance to RoutingPad, then layer depth. If both distance to RoutingPad is null, then sort on segment length. * Change: In RoutingEvent::_processRepair(), try a repack perpandicular with perpandiculars first (then with perpandicular last, then give up). * Change: In SegmentFsm::bindToTrack() and moveToTrack(), set an axis hint when creating the insertion event. * Change: In SegmentFsm::_slackenStrap(), add a step through slacken between minimize and maximum slack (wihch directly end up in unimplemented). * Change: In Session::_addInsertEvent(), add an axis parameter needed when the axis of the segment is not the one of the track (case of wide segments or non-preferred direction). * Bug: In Track::_preDestroy(), bad management of the TrackElement reference count. Destroy the segment only when reaching zero... * Bug: In Track::expandFreeIneterval(), forgotten to manage case when there is a set of overlaping segments at the "end" of the track, the EndIsTrackMax was not set. * Change: In TrackCost::Compare, increase the cost when an overlaping segment is at it's ripup limit. We should try *not* to rip it up if we can. Add a dedicated flag "AtRipupLimit". * Change: In TrackElement, add proxies for isUnbreakable(), new function updateTrackSpan(). * New: In TrackFixedSegment CTOR, when a supply wire of METAL2 or above is found, make the underlying GCells "GoStraight". * New: In TrackElement::canDogleg(GCell*), check for already done perpandicular dogleg on source/target (reject if so).
2019-07-28 16:20:00 -05:00
bool TrackElement::isUnbreakable () const { return false; }
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
bool TrackElement::isSlackened () const { return false; }
bool TrackElement::isDogleg () const { return false; }
Improved handling of short nets (fully included in one GCell). The short net mode degrade the routing in some cases. This will be fixed in a next batch of commits. * New: In Hurricane::NetRoutingProperty, added "ShortNet" flag for Nets that are completly inside *one* GCell. * Bug: In CRL::BlifParser::Model::staticInit(), when looking for the output of zero and one cell, also skip the blockage net (as well as automatic and supplies). * New: In Anabatic::AutoSegment, added "ShortNet" flag to know if the segment is part of a short net (fully included in *one* GCell). Also add accessor/mutators for the _analogMode flag (was it ever used before?). * New: In Anabatic::NetBuilder::singleGCell(), if a RoutingPad is vertically small, add a vertical segment to give it some slack. * New: In Anabatic::Dijkstra::_materialize(), detect "short net" as they have only one GCell in their source list... * Bug: In AnabaticEngine::_loadGrbyNet(), reset the AutoSegment "short net" and "analog mode" creation flags between two different nets. * New: In Katana::Configuration, added dedicated ripup for short net segmnts. * New: In Katana: partially implemented support for "short dogleg", that is dogleg that are always kept in same metal because they connect neighboring perpandicular tracks. Not finished neither activated yet. * New: In Katana::TreckElement and derived, export the the *short net* support from AutoSegment. * Bug: In Katana::RoutingEvent::_processRepair(), when a segment is successfully inserted, re-process any perpandicular that is in repair state, as it may have a new chance to be placed. * New: In Katana::SegmentFsm::slackenTopology(), always reject short nets. * Bug: In Katana::Track::check(), correctly handle wide segments instead of issuing false check messages.
2018-07-16 04:16:51 -05:00
bool TrackElement::isShortDogleg () const { return false; }
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
bool TrackElement::isReduced () const { return false; }
bool TrackElement::isUTurn () const { return false; }
bool TrackElement::isUserDefined () const { return false; }
Synchronize priority of TrackSegments connecteds through doglegs. * Bug: In Anabatic::Dijsktra, correct the indentation in cdebug calls (lots of them causing a big shift right). * New: In Anabatic::TrackSegment, new helper structure SideStack to manage a set of aligned GCells and their various sides sizes. * Change: In Anabatic::TrackSegment::computeOptimal(), more accurate computation of attractors from global segments and variable size GCells using SideStack. * Change: In Katana::DataSymmetric::checkPairing(), increase the tolerance for misaligned symmetrics from 2 to 5 tracks (should be enough for our narrow channel routing). * New: In Katana::TrackSegment, add a first flag to enable locking of priority. If it is set, calls to either "computePriority()" or "forcePriority()" will have no effect. Added the uint32_t flags paraphernalia. * New: In ::computeNetPriority(), overall function to control the call of TrackSegment::computeAlignedPriority(). The call is done from NegociateWindow::run(). * New: Katana::TrackSegment::computeAlignedPriority(), order the TrackSegments aligneds through doglegs to the one with the highest priority is routed first and others progressively from him. Done by forcing an ever decreasing priority on the aligneds ones. The amount of decrease is small so the aligned segments got routed (ordered) in close, if not contiguous, sequence. Priority is locked for the order to remain. * Bug: In Katana::TrackSegment::computePriority(), correct computation of the priority when there is more than 10 free tracks (a DbU::toLambda() call was missing, leading to very big priorities). * Change: In katana::TrackCost CTOR, do not compute a distance to fixed in the case of analog segments, this is backfiring. Slight change of the compare function when delta differs. Seems to improve a little.
2017-05-30 15:33:06 -05:00
bool TrackElement::isAnalog () const { return false; }
Katana manage wide wires, and they can also be symmetric. * New: In Anabatic::AutoContact and the derived classes, manages wide wires. The contact self dimension itself according to the segments it is connected to. Special case for the AutoContactTerminal which also read the size of the component it is anchored upon. New refresh method "updateSize()" and flag CntInvalidatedWidth. to compute the size. In AutoContactTerminal, compute the constraint box according to the width of the segment. * New: In Anabatic::AutoSegment, flags are now implemented as "static const" attributes of the class. The flags are stored into a uint64_t as they are more than 32. Added new flag "SegWide" and associated predicates. * Change: In GCellTopology::_doHChannel() and GCellTopology::_doVChannel(), uses the simpler overload of AutoSegment::create() in order to detect the wire width automatically. * New: In Katana::Manipulator, split insertToTrack() and forceToTrack() into a one-track method and a segment level method that iterate over the track span of the segment. * New: In Katana::SegmentFsm, for each cost in the table, now allow access to a specific track. So the base functions have now two parameters: "icost" and "itrack" (has a cost can have multiple tracks in the case of wide segments). * Change: In Katana::TrackElement, remove the index of the element inside it's track, as for a wide segment it will not be meaningful for the non-base track. This means that we have to use the Track::find() method each time instead. Remove the wide flag, as it is a duplicate of the one in AutoSegment. Added a getTrackCount() method to tell the number of track the segment is inserted into. Needed in the Track destroy step to delete a segment only when the last track that refers it is destroyed. Added getSymmetricAxis() to correct the computation of the symmetric base track in case of wide segment as the base track is not centered but the the leftmost one. * Change: In Track::insert() insert wide segments in their whole track span. * Change: In TrackCost, create an array of costs according to the segment track span. * Change: In TrackSegment::create(), now activate the factory and create wide segments. * Bug: In Katana::AutoSegments_Perpandicular, correct the debug indentation problem (ever shifting to the right).
2017-07-28 08:30:22 -05:00
bool TrackElement::isWide () const { return false; }
Upgrade of Katana detailed router to support Arlet 6502. * Change: In Hurricane::SharedName, replace the incremental Id by a hash key. This is to ensure better deterministic properties. Between use cases, additional strings may have to be allocated, shitfing the ids. Even if hash can be duplicated, we should be able to ensure that the absolute order in map table should be preserved. Supplemental strings are inserted in a way that keep the previous order. * Change: In CRL/etc/symbolic/cmos/kite.conf, add "katabatic.routingGauge" default parameter value ("sxlib"). * Change: In CRL/etc/common/technology.conf, define minimal spacing for symbolic layers too (added for METAL4 only for now). * Change: In CRL::Histogram, extend support to dynamically sized histograms. Add a text pretty print with table and pseudo-curve. * Change: In Cumulus/plugins/ClockTreePlugin, create blockage under the block corona corners so the global router do not draw wire under them. This was creating deadlock for the detailed router. When the abutment has to be computed, directly use Etesian to do it instead of duplicating the computation in the Python plugin. * New: In Etesian, as Coloquinte seems reluctant to evenly spread the standard cells, we trick it by making them bigger during the placement stage. Furthermore, we do not not uniformely increase the size of the cells but create a "bloating profile" based on cell size, cell name or it's density of terminals. Currently only two profiles are defined, "disabled" which does nothing and "nsxlib" targeted on 4 metal layer technologies (aka AMS 350nm, c35b4). * Bug: In Knik::MatrixVertex, load the default routing gauge using the configuration parameter "katabatic.routingGauge" as the default one may not be the first registered one. * New: In AnabaticEngine::setupNetDatas(), build a dynamic historgram of the nets terminal numbers. * Bug: In Anabatic::AutoContact::Invalidate(), always invalidate the contact cache when topology is invalidated. In case of multiple invalidations, if the first did not invalidate the cache, later one that may need it where not allowed to do so. The end result was correct nonetheless, but it did generate annoying error messages. * Bug: In Anabatic::AutoContactTurn::updateTopology(), bad computation of the contact's depth when delta == 2. * Bug: In Anabatic::Gcell::getCapacity(), was always returning the west edge capacity, even for the westermost GCell, should be the east edge in that case. * New: In Anabatic::AutoSegment, introduce a new measure "distance to terminal". This is the minimal number of segments separating the current one from the nearest RoutingPad. This replace the previous "strong terminal" and "weak terminal" flags. This distance is used by Katana to sort the events, we route the segments *from* the RoutingPads *outward*. The idea being that if we cannot event connect to the RoutingPad, there is no points continuing as thoses segments are the more constraineds. This gives an order close to the simple ascending metals but with better results. * New: In Anabatic::AutoSegment, introduce a new flag "Unbreakable", disable dogleg making on those segments. mainly intended for local segments directly connecteds to RoutingPads (distance == 0). * New: In Anabatic::AutoSegment, more aggressive reducing of segments. Now the only case where a segment cannot be reduced is when it is one horizontal branch in a HTee or a vertical on a VTee. Check if, when not accounted the source & target VIAs are still connex, if so, allow reducing. * New: In Anabatic::AutoContact, new state flags CntVDogleg & CntHDogleg mainly to prevent making doglegs twice on a turn contact. This is to limit over-fragmentation. If one dogleg doesn't solve the problem, making a second one will make things worse only... * Bug: In Anabatic::Configuration::selectRpcomponent(), we were choosing the component with the *smallest* span instead of the *bigger* one. * New: In Anabatic::GCell, introduce a new flag "GoStraight" to tell that no turn go be made inside those GCells. Mainly used underneath a block corona. * New: In AnabaticEngine::layerAssign(), new GCellRps & RpsInRow to manage GCells with too many terminals. Slacken at least one RoutingPad access when there is more than 8 RoutingPad in the GCell (slacken or change a vertical METAL2 (non-preferred) into a METAL3). * Change: In Anabatic::NetBuilderHV, allow the use of terminal connection in non-preferred direction. That is, vertical METAL2 directly connected to the RoutingPad (then a horizontal METAL2). This alllows for short dogleg without clutering the METAL3 layer (critical for AMS c35b4). Done in NetBuilderHV::doRp_Access(), with a new UseNonPref flag. Perform some other tweaking on METAL1 access topologies, to also minimize METAL3 use. * New: In AnabaticEngine::computeNetConstraints(), also compute the distance to RoutingPad for segments. Set the Unbreakable flag, based on the distance and segment length (local, short global or long global). New local function "propagateDistanceFromRp()". * Change: In AnabaticEngine.h, the sorting class for NetData, SparsityOrder, is modificated so net with a degree superior to 10 are sorted first, whatever their sparsity. This is to work in tandem with GlobalRouting. * New: In Katana::TrackSegmentNonPref, introduce a class to manage segment in non-preferred routing direction. Mostly intended for small METAL2 vertical directly connected to RoutingPad. Modifications to manage this new variant all through Katana. * Change: In Katana::GlobalRoute, DigitalDistance honor the GoStraight flag of the GCell. Do not make bend inside thoses GCells. * Change: In KatanaEngine::runGlobalRouter(), high degree nets (>= 10) are routed first and whitout the global routing estimation. There should be few of them so they wont create saturations and we want them as straight as possible. Detour are for long be-points. Set the saerch halo to one GCell in the initial routing stage (before ripup). * Bug: In KatanaEngine & NegociateWindow, call _computeCagedconstraints() inside NegociateWindow::run(), as segments are inserted into tracks only at that point so we cannot make the computation earlier. * Change: In Katana::Manipulator::repackPerpandiculars(), add a flag to select whether to replace the perpandiculars *after* or *before* the current segment. * Change: In Katana::NegociateWindow::NegociateOverlapCost(), when the segment is fully enclosed inside a global, the longest overlap cost is set to the shortest global hoverhang (before or after). When the cost is for a global, set an infinite cost if the overlapping segment has a RP distance less or equal to 1 (this is an access segment). * Bug: In Katana::PowerRailsPlane::Rail::doLayout(), correct computation of the segments extension cap. * New: In Katana::QueryPowerRails::addToPowerRail(), add support for Pad. * Change: In Katana/PreProcess::protectCagedTerminals(), apply the contraints to any turn connected to the first segment of the RoutingPad so the perpandicular constraints got propagated to the perpandicular segment... * Change: In RoutingEvent, cache the "distance to RP" value. * Change: In RoutingEvent::Key::compare(), sort *first* on distance to RoutingPad, then layer depth. If both distance to RoutingPad is null, then sort on segment length. * Change: In RoutingEvent::_processRepair(), try a repack perpandicular with perpandiculars first (then with perpandicular last, then give up). * Change: In SegmentFsm::bindToTrack() and moveToTrack(), set an axis hint when creating the insertion event. * Change: In SegmentFsm::_slackenStrap(), add a step through slacken between minimize and maximum slack (wihch directly end up in unimplemented). * Change: In Session::_addInsertEvent(), add an axis parameter needed when the axis of the segment is not the one of the track (case of wide segments or non-preferred direction). * Bug: In Track::_preDestroy(), bad management of the TrackElement reference count. Destroy the segment only when reaching zero... * Bug: In Track::expandFreeIneterval(), forgotten to manage case when there is a set of overlaping segments at the "end" of the track, the EndIsTrackMax was not set. * Change: In TrackCost::Compare, increase the cost when an overlaping segment is at it's ripup limit. We should try *not* to rip it up if we can. Add a dedicated flag "AtRipupLimit". * Change: In TrackElement, add proxies for isUnbreakable(), new function updateTrackSpan(). * New: In TrackFixedSegment CTOR, when a supply wire of METAL2 or above is found, make the underlying GCells "GoStraight". * New: In TrackElement::canDogleg(GCell*), check for already done perpandicular dogleg on source/target (reject if so).
2019-07-28 16:20:00 -05:00
bool TrackElement::isNonPref () const { return false; }
Improved handling of short nets (fully included in one GCell). The short net mode degrade the routing in some cases. This will be fixed in a next batch of commits. * New: In Hurricane::NetRoutingProperty, added "ShortNet" flag for Nets that are completly inside *one* GCell. * Bug: In CRL::BlifParser::Model::staticInit(), when looking for the output of zero and one cell, also skip the blockage net (as well as automatic and supplies). * New: In Anabatic::AutoSegment, added "ShortNet" flag to know if the segment is part of a short net (fully included in *one* GCell). Also add accessor/mutators for the _analogMode flag (was it ever used before?). * New: In Anabatic::NetBuilder::singleGCell(), if a RoutingPad is vertically small, add a vertical segment to give it some slack. * New: In Anabatic::Dijkstra::_materialize(), detect "short net" as they have only one GCell in their source list... * Bug: In AnabaticEngine::_loadGrbyNet(), reset the AutoSegment "short net" and "analog mode" creation flags between two different nets. * New: In Katana::Configuration, added dedicated ripup for short net segmnts. * New: In Katana: partially implemented support for "short dogleg", that is dogleg that are always kept in same metal because they connect neighboring perpandicular tracks. Not finished neither activated yet. * New: In Katana::TreckElement and derived, export the the *short net* support from AutoSegment. * Bug: In Katana::RoutingEvent::_processRepair(), when a segment is successfully inserted, re-process any perpandicular that is in repair state, as it may have a new chance to be placed. * New: In Katana::SegmentFsm::slackenTopology(), always reject short nets. * Bug: In Katana::Track::check(), correctly handle wide segments instead of issuing false check messages.
2018-07-16 04:16:51 -05:00
bool TrackElement::isShortNet () const { return false; }
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
// Predicates.
Support for symmetric routing in Anabatic/Katabatic. * New: In Katana::SegmentFsm, the object is now able to handle two events at the same time. The master and it's symmetric. When there is no symmetric, the corresponing data is just left blank. This makes a bigger object, but as there is only one when running, it is not an issue. Candidates tracks are now an vector of array<2> (pairs), the TrackCost::Compare() functor has to be wrapped through CompareCostArray. The compined TrackCost of the two tracks is accumulated into the first element. Everything related to events gets duplicated: _event is now _event1 and _event2, and so on. As there can be now two Manipulator actions done with SegmentFsm, this class now completly hide the Manipulator level from the RoutingEvent processing. New function ::bindToTrack() to perform the track insertion. * New: In Katana::TrackCost, add a new ::merge() function. * New: In Katana::TrackElement and Katana::TrackSegment, add symmetric management. Allows to know if a TrackElement has a symmetric and to access it. * New: In Katana::DataSymmetric, add new overload for ::getSymmetrical() to handle DbU::Unit and intervals. * Change: In Katana::RoutingEvent, remove all direct uses of Manipulator objects. Now any change to the event associated segment must go through call to Segment Fsm. * Change: In Katana, adjust the debug level so internal informations are put below level 156. * New: In Hurricane::DbU, in ::getValueString(), special display when the value is Min or Max (more helpful than a gigantic number).
2017-04-30 16:46:33 -05:00
bool TrackElement::hasSymmetric () const { return false; }
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
bool TrackElement::canSlacken () const { return false; }
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
bool TrackElement::canPivotUp ( float, Flags ) const { return false; };
bool TrackElement::canPivotDown ( float, Flags ) const { return false; };
bool TrackElement::canMoveUp ( float, Flags ) const { return false; };
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
bool TrackElement::canDogleg () { return false; };
bool TrackElement::canDogleg ( Interval ) { return false; };
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
bool TrackElement::canDogleg ( Anabatic::GCell*, Flags ) { return false; };
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
// Accessors.
unsigned long TrackElement::getId () const { return 0; }
unsigned long TrackElement::getFreedomDegree () const { return 0; }
Katana manage wide wires, and they can also be symmetric. * New: In Anabatic::AutoContact and the derived classes, manages wide wires. The contact self dimension itself according to the segments it is connected to. Special case for the AutoContactTerminal which also read the size of the component it is anchored upon. New refresh method "updateSize()" and flag CntInvalidatedWidth. to compute the size. In AutoContactTerminal, compute the constraint box according to the width of the segment. * New: In Anabatic::AutoSegment, flags are now implemented as "static const" attributes of the class. The flags are stored into a uint64_t as they are more than 32. Added new flag "SegWide" and associated predicates. * Change: In GCellTopology::_doHChannel() and GCellTopology::_doVChannel(), uses the simpler overload of AutoSegment::create() in order to detect the wire width automatically. * New: In Katana::Manipulator, split insertToTrack() and forceToTrack() into a one-track method and a segment level method that iterate over the track span of the segment. * New: In Katana::SegmentFsm, for each cost in the table, now allow access to a specific track. So the base functions have now two parameters: "icost" and "itrack" (has a cost can have multiple tracks in the case of wide segments). * Change: In Katana::TrackElement, remove the index of the element inside it's track, as for a wide segment it will not be meaningful for the non-base track. This means that we have to use the Track::find() method each time instead. Remove the wide flag, as it is a duplicate of the one in AutoSegment. Added a getTrackCount() method to tell the number of track the segment is inserted into. Needed in the Track destroy step to delete a segment only when the last track that refers it is destroyed. Added getSymmetricAxis() to correct the computation of the symmetric base track in case of wide segment as the base track is not centered but the the leftmost one. * Change: In Track::insert() insert wide segments in their whole track span. * Change: In TrackCost, create an array of costs according to the segment track span. * Change: In TrackSegment::create(), now activate the factory and create wide segments. * Bug: In Katana::AutoSegments_Perpandicular, correct the debug indentation problem (ever shifting to the right).
2017-07-28 08:30:22 -05:00
uint32_t TrackElement::getTrackCount () const { return 0; }
Improved handling of short nets (fully included in one GCell). The short net mode degrade the routing in some cases. This will be fixed in a next batch of commits. * New: In Hurricane::NetRoutingProperty, added "ShortNet" flag for Nets that are completly inside *one* GCell. * Bug: In CRL::BlifParser::Model::staticInit(), when looking for the output of zero and one cell, also skip the blockage net (as well as automatic and supplies). * New: In Anabatic::AutoSegment, added "ShortNet" flag to know if the segment is part of a short net (fully included in *one* GCell). Also add accessor/mutators for the _analogMode flag (was it ever used before?). * New: In Anabatic::NetBuilder::singleGCell(), if a RoutingPad is vertically small, add a vertical segment to give it some slack. * New: In Anabatic::Dijkstra::_materialize(), detect "short net" as they have only one GCell in their source list... * Bug: In AnabaticEngine::_loadGrbyNet(), reset the AutoSegment "short net" and "analog mode" creation flags between two different nets. * New: In Katana::Configuration, added dedicated ripup for short net segmnts. * New: In Katana: partially implemented support for "short dogleg", that is dogleg that are always kept in same metal because they connect neighboring perpandicular tracks. Not finished neither activated yet. * New: In Katana::TreckElement and derived, export the the *short net* support from AutoSegment. * Bug: In Katana::RoutingEvent::_processRepair(), when a segment is successfully inserted, re-process any perpandicular that is in repair state, as it may have a new chance to be placed. * New: In Katana::SegmentFsm::slackenTopology(), always reject short nets. * Bug: In Katana::Track::check(), correctly handle wide segments instead of issuing false check messages.
2018-07-16 04:16:51 -05:00
unsigned int TrackElement::getDepth () const { return 0; }
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
DbU::Unit TrackElement::getPitch () const { return 0; }
DbU::Unit TrackElement::getPPitch () const { return 0; }
Basic support for FreePDK 45 completed. * New: In Commons, inspector support for std::pair<T,U>. * New: In Hurricane::Layer, ContactLayer & ViaLayer, support for non square VIAs. The hole (cut) remains square, but the various metal extensions can now be different in X and Y. The ::getEnclosure() method now takes a flag EnclosureH / EnclosureV. * New: In Hurricane::DbU, inspector support for: std::pair<DbU::Unit,DbU::Unit> std::array<DbU::Unit,3> Must be defined here as DbU do not exists yet in Commons.h * Bug: In Hurricane::Interval::getSize(), when the interval is "full span", do not return the difference between min and max, but directly DbU::Max. (the previous result was -1 !) * New: In CRL Core Python/Technology.py, support for non square VIAs in the configuration files. Applied to FreePDK 45. * New: In CRL::RoutingGauge, added a "symbolic" flag to tell if a gauge is for symbolic layout or not. Exported to Python. * New: In Anabatic::AutoHorizontal::updatePosition(), differentiated computation for soure or target taking account of the VIA extension in the right segment metal (due to non-square VIAs). * Change: In Anabatic::AutoHorizontal::_makeDogleg(), the dogleg is UP for HV gauges and DOWN for VH. * New: In Anabatic::AutoSegment::_initialize(), create a cache of the various extension length for each layer (viaToTop, viaToBottom, viaToSame). New implementation of getExtensionCap() using the previous cached extension table. See updatePositions(). New static functions to access the extension cache in the header: getViaTotopCap() ... * Change: In Anabatic::AutoSegment, in various update methods, updateOrient() must always be called *before* updatePositions() as extensions are dependant on source/target. * New: In Anabatic::AutoSegment::getEndAxes() compute the position of the first source and last target position (center/axes) on an *aligned* set of segments. * New: In Anabatic::AutoSegment, add a new state flag SegAxisFixed to signal segments that can be put on only one track. Specific case to VH gauge for a M1 vertical terminal with a M2 vertical segment. The M2 is effectively bound to the M1 axis position. * Bug: In Anabatic::NetBuilderVH::_do_xG_xM1_xM3(), in case of E/W global and only one RoutingPad the connexion to the RoutingPad was duplicated. It was valid, but totally stupid. * Bug: In Anabatic::Session::_canonize(), for an aligned segment set, intersect the user constraints from all segments instead of only considering the canonical one. Issue a warning about too tight constraints only for symbolic gauges. It may be correct for the real ones. * New: In Katata::DataNegociate::update(), more accurate computation of the perpandicular free interval. Use segment extension cap calculation. Create a special case for fixed axis segments allowing them to find alternative free interval, try under source and under target as they are likely to be draggable segments. * Change: In Katana::Manipulator::relax(), use the extension cap value to compute the axis of the perpandicular segemnts. * Change: In Katana::Manipulator::moveUp(), now move up the whole set of aligned segments instead of just the canonical one. * Change: In Katana::NegociateWindow::loadRoutingPads(), more accurate TrackMarkers insertions for fixed terminals. * New: In Katana::RoutingEvent::Key::Compare::operator(), segments with fixed axis are processed prior to any others. * New: In Katana::RoutingEventLoop, store segment pointers instead of ids to generate more accurate error messages. * Change: In Katana::RoutingPlane::create(), perform local track assignment only for HV gauges. * Change: In Katana::SegmentFsm::_slackenLocal(), add a "dragMinimize" step in the automaton. Mutliple states transitions can occurs in a row if an action fails. * New: In Katana::Session::_toIntervalAxis(), normalize interval bounds so they are on track positions (by shrinking the interval). * Bug: In Katana::TrackMarker CTOR, the weigh computation was wrong.
2018-02-17 13:27:38 -06:00
DbU::Unit TrackElement::getExtensionCap ( Flags ) const { return 0; }
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
float TrackElement::getMaxUnderDensity ( Flags ) const { return 0.0; };
uint32_t TrackElement::getDoglegLevel () const { return 0; }
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
TrackElement* TrackElement::getParent () const { return NULL; }
Interval TrackElement::getSourceConstraints () const { return Interval(); }
Interval TrackElement::getTargetConstraints () const { return Interval(); }
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
DataNegociate* TrackElement::getDataNegociate ( Flags ) const { return NULL; }
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
TrackElements TrackElement::getPerpandiculars () { return new TrackElements_Perpandiculars(NULL); }
void TrackElement::invalidate () { }
TrackElement* TrackElement::getSourceDogleg () { return NULL; }
TrackElement* TrackElement::getTargetDogleg () { return NULL; }
Support for symmetric routing in Anabatic/Katabatic. * New: In Katana::SegmentFsm, the object is now able to handle two events at the same time. The master and it's symmetric. When there is no symmetric, the corresponing data is just left blank. This makes a bigger object, but as there is only one when running, it is not an issue. Candidates tracks are now an vector of array<2> (pairs), the TrackCost::Compare() functor has to be wrapped through CompareCostArray. The compined TrackCost of the two tracks is accumulated into the first element. Everything related to events gets duplicated: _event is now _event1 and _event2, and so on. As there can be now two Manipulator actions done with SegmentFsm, this class now completly hide the Manipulator level from the RoutingEvent processing. New function ::bindToTrack() to perform the track insertion. * New: In Katana::TrackCost, add a new ::merge() function. * New: In Katana::TrackElement and Katana::TrackSegment, add symmetric management. Allows to know if a TrackElement has a symmetric and to access it. * New: In Katana::DataSymmetric, add new overload for ::getSymmetrical() to handle DbU::Unit and intervals. * Change: In Katana::RoutingEvent, remove all direct uses of Manipulator objects. Now any change to the event associated segment must go through call to Segment Fsm. * Change: In Katana, adjust the debug level so internal informations are put below level 156. * New: In Hurricane::DbU, in ::getValueString(), special display when the value is Min or Max (more helpful than a gigantic number).
2017-04-30 16:46:33 -05:00
TrackElement* TrackElement::getSymmetric () { return NULL; }
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
// Mutators.
Katana manage wide wires, and they can also be symmetric. * New: In Anabatic::AutoContact and the derived classes, manages wide wires. The contact self dimension itself according to the segments it is connected to. Special case for the AutoContactTerminal which also read the size of the component it is anchored upon. New refresh method "updateSize()" and flag CntInvalidatedWidth. to compute the size. In AutoContactTerminal, compute the constraint box according to the width of the segment. * New: In Anabatic::AutoSegment, flags are now implemented as "static const" attributes of the class. The flags are stored into a uint64_t as they are more than 32. Added new flag "SegWide" and associated predicates. * Change: In GCellTopology::_doHChannel() and GCellTopology::_doVChannel(), uses the simpler overload of AutoSegment::create() in order to detect the wire width automatically. * New: In Katana::Manipulator, split insertToTrack() and forceToTrack() into a one-track method and a segment level method that iterate over the track span of the segment. * New: In Katana::SegmentFsm, for each cost in the table, now allow access to a specific track. So the base functions have now two parameters: "icost" and "itrack" (has a cost can have multiple tracks in the case of wide segments). * Change: In Katana::TrackElement, remove the index of the element inside it's track, as for a wide segment it will not be meaningful for the non-base track. This means that we have to use the Track::find() method each time instead. Remove the wide flag, as it is a duplicate of the one in AutoSegment. Added a getTrackCount() method to tell the number of track the segment is inserted into. Needed in the Track destroy step to delete a segment only when the last track that refers it is destroyed. Added getSymmetricAxis() to correct the computation of the symmetric base track in case of wide segment as the base track is not centered but the the leftmost one. * Change: In Track::insert() insert wide segments in their whole track span. * Change: In TrackCost, create an array of costs according to the segment track span. * Change: In TrackSegment::create(), now activate the factory and create wide segments. * Bug: In Katana::AutoSegments_Perpandicular, correct the debug indentation problem (ever shifting to the right).
2017-07-28 08:30:22 -05:00
void TrackElement::addTrackCount ( int32_t ) { }
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
void TrackElement::setTrack ( Track* track ) { _track = track; }
Support for symmetric routing in Anabatic/Katabatic. * New: In Katana::SegmentFsm, the object is now able to handle two events at the same time. The master and it's symmetric. When there is no symmetric, the corresponing data is just left blank. This makes a bigger object, but as there is only one when running, it is not an issue. Candidates tracks are now an vector of array<2> (pairs), the TrackCost::Compare() functor has to be wrapped through CompareCostArray. The compined TrackCost of the two tracks is accumulated into the first element. Everything related to events gets duplicated: _event is now _event1 and _event2, and so on. As there can be now two Manipulator actions done with SegmentFsm, this class now completly hide the Manipulator level from the RoutingEvent processing. New function ::bindToTrack() to perform the track insertion. * New: In Katana::TrackCost, add a new ::merge() function. * New: In Katana::TrackElement and Katana::TrackSegment, add symmetric management. Allows to know if a TrackElement has a symmetric and to access it. * New: In Katana::DataSymmetric, add new overload for ::getSymmetrical() to handle DbU::Unit and intervals. * Change: In Katana::RoutingEvent, remove all direct uses of Manipulator objects. Now any change to the event associated segment must go through call to Segment Fsm. * Change: In Katana, adjust the debug level so internal informations are put below level 156. * New: In Hurricane::DbU, in ::getValueString(), special display when the value is Min or Max (more helpful than a gigantic number).
2017-04-30 16:46:33 -05:00
void TrackElement::setSymmetric ( TrackElement* ) { }
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
void TrackElement::updateFreedomDegree () { }
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
void TrackElement::setDoglegLevel ( uint32_t ) { }
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
void TrackElement::swapTrack ( TrackElement* ) { }
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
void TrackElement::reschedule ( uint32_t ) { }
Upgrade of Katana detailed router to support Arlet 6502. * Change: In Hurricane::SharedName, replace the incremental Id by a hash key. This is to ensure better deterministic properties. Between use cases, additional strings may have to be allocated, shitfing the ids. Even if hash can be duplicated, we should be able to ensure that the absolute order in map table should be preserved. Supplemental strings are inserted in a way that keep the previous order. * Change: In CRL/etc/symbolic/cmos/kite.conf, add "katabatic.routingGauge" default parameter value ("sxlib"). * Change: In CRL/etc/common/technology.conf, define minimal spacing for symbolic layers too (added for METAL4 only for now). * Change: In CRL::Histogram, extend support to dynamically sized histograms. Add a text pretty print with table and pseudo-curve. * Change: In Cumulus/plugins/ClockTreePlugin, create blockage under the block corona corners so the global router do not draw wire under them. This was creating deadlock for the detailed router. When the abutment has to be computed, directly use Etesian to do it instead of duplicating the computation in the Python plugin. * New: In Etesian, as Coloquinte seems reluctant to evenly spread the standard cells, we trick it by making them bigger during the placement stage. Furthermore, we do not not uniformely increase the size of the cells but create a "bloating profile" based on cell size, cell name or it's density of terminals. Currently only two profiles are defined, "disabled" which does nothing and "nsxlib" targeted on 4 metal layer technologies (aka AMS 350nm, c35b4). * Bug: In Knik::MatrixVertex, load the default routing gauge using the configuration parameter "katabatic.routingGauge" as the default one may not be the first registered one. * New: In AnabaticEngine::setupNetDatas(), build a dynamic historgram of the nets terminal numbers. * Bug: In Anabatic::AutoContact::Invalidate(), always invalidate the contact cache when topology is invalidated. In case of multiple invalidations, if the first did not invalidate the cache, later one that may need it where not allowed to do so. The end result was correct nonetheless, but it did generate annoying error messages. * Bug: In Anabatic::AutoContactTurn::updateTopology(), bad computation of the contact's depth when delta == 2. * Bug: In Anabatic::Gcell::getCapacity(), was always returning the west edge capacity, even for the westermost GCell, should be the east edge in that case. * New: In Anabatic::AutoSegment, introduce a new measure "distance to terminal". This is the minimal number of segments separating the current one from the nearest RoutingPad. This replace the previous "strong terminal" and "weak terminal" flags. This distance is used by Katana to sort the events, we route the segments *from* the RoutingPads *outward*. The idea being that if we cannot event connect to the RoutingPad, there is no points continuing as thoses segments are the more constraineds. This gives an order close to the simple ascending metals but with better results. * New: In Anabatic::AutoSegment, introduce a new flag "Unbreakable", disable dogleg making on those segments. mainly intended for local segments directly connecteds to RoutingPads (distance == 0). * New: In Anabatic::AutoSegment, more aggressive reducing of segments. Now the only case where a segment cannot be reduced is when it is one horizontal branch in a HTee or a vertical on a VTee. Check if, when not accounted the source & target VIAs are still connex, if so, allow reducing. * New: In Anabatic::AutoContact, new state flags CntVDogleg & CntHDogleg mainly to prevent making doglegs twice on a turn contact. This is to limit over-fragmentation. If one dogleg doesn't solve the problem, making a second one will make things worse only... * Bug: In Anabatic::Configuration::selectRpcomponent(), we were choosing the component with the *smallest* span instead of the *bigger* one. * New: In Anabatic::GCell, introduce a new flag "GoStraight" to tell that no turn go be made inside those GCells. Mainly used underneath a block corona. * New: In AnabaticEngine::layerAssign(), new GCellRps & RpsInRow to manage GCells with too many terminals. Slacken at least one RoutingPad access when there is more than 8 RoutingPad in the GCell (slacken or change a vertical METAL2 (non-preferred) into a METAL3). * Change: In Anabatic::NetBuilderHV, allow the use of terminal connection in non-preferred direction. That is, vertical METAL2 directly connected to the RoutingPad (then a horizontal METAL2). This alllows for short dogleg without clutering the METAL3 layer (critical for AMS c35b4). Done in NetBuilderHV::doRp_Access(), with a new UseNonPref flag. Perform some other tweaking on METAL1 access topologies, to also minimize METAL3 use. * New: In AnabaticEngine::computeNetConstraints(), also compute the distance to RoutingPad for segments. Set the Unbreakable flag, based on the distance and segment length (local, short global or long global). New local function "propagateDistanceFromRp()". * Change: In AnabaticEngine.h, the sorting class for NetData, SparsityOrder, is modificated so net with a degree superior to 10 are sorted first, whatever their sparsity. This is to work in tandem with GlobalRouting. * New: In Katana::TrackSegmentNonPref, introduce a class to manage segment in non-preferred routing direction. Mostly intended for small METAL2 vertical directly connected to RoutingPad. Modifications to manage this new variant all through Katana. * Change: In Katana::GlobalRoute, DigitalDistance honor the GoStraight flag of the GCell. Do not make bend inside thoses GCells. * Change: In KatanaEngine::runGlobalRouter(), high degree nets (>= 10) are routed first and whitout the global routing estimation. There should be few of them so they wont create saturations and we want them as straight as possible. Detour are for long be-points. Set the saerch halo to one GCell in the initial routing stage (before ripup). * Bug: In KatanaEngine & NegociateWindow, call _computeCagedconstraints() inside NegociateWindow::run(), as segments are inserted into tracks only at that point so we cannot make the computation earlier. * Change: In Katana::Manipulator::repackPerpandiculars(), add a flag to select whether to replace the perpandiculars *after* or *before* the current segment. * Change: In Katana::NegociateWindow::NegociateOverlapCost(), when the segment is fully enclosed inside a global, the longest overlap cost is set to the shortest global hoverhang (before or after). When the cost is for a global, set an infinite cost if the overlapping segment has a RP distance less or equal to 1 (this is an access segment). * Bug: In Katana::PowerRailsPlane::Rail::doLayout(), correct computation of the segments extension cap. * New: In Katana::QueryPowerRails::addToPowerRail(), add support for Pad. * Change: In Katana/PreProcess::protectCagedTerminals(), apply the contraints to any turn connected to the first segment of the RoutingPad so the perpandicular constraints got propagated to the perpandicular segment... * Change: In RoutingEvent, cache the "distance to RP" value. * Change: In RoutingEvent::Key::compare(), sort *first* on distance to RoutingPad, then layer depth. If both distance to RoutingPad is null, then sort on segment length. * Change: In RoutingEvent::_processRepair(), try a repack perpandicular with perpandiculars first (then with perpandicular last, then give up). * Change: In SegmentFsm::bindToTrack() and moveToTrack(), set an axis hint when creating the insertion event. * Change: In SegmentFsm::_slackenStrap(), add a step through slacken between minimize and maximum slack (wihch directly end up in unimplemented). * Change: In Session::_addInsertEvent(), add an axis parameter needed when the axis of the segment is not the one of the track (case of wide segments or non-preferred direction). * Bug: In Track::_preDestroy(), bad management of the TrackElement reference count. Destroy the segment only when reaching zero... * Bug: In Track::expandFreeIneterval(), forgotten to manage case when there is a set of overlaping segments at the "end" of the track, the EndIsTrackMax was not set. * Change: In TrackCost::Compare, increase the cost when an overlaping segment is at it's ripup limit. We should try *not* to rip it up if we can. Add a dedicated flag "AtRipupLimit". * Change: In TrackElement, add proxies for isUnbreakable(), new function updateTrackSpan(). * New: In TrackFixedSegment CTOR, when a supply wire of METAL2 or above is found, make the underlying GCells "GoStraight". * New: In TrackElement::canDogleg(GCell*), check for already done perpandicular dogleg on source/target (reject if so).
2019-07-28 16:20:00 -05:00
//void TrackElement::detach () { }
Correcting non-deterministic behavior in Anabatic/Katana (again). This non-deterministic behavior was showing only in the ARMv2a benchmark around event 180k... * Bug: In Anabatic::Session::_netInvalidateds & _netRevalidateds, the set<> was still sorted on pointers. As contacts & segments can be created to maintain connexity after a layer change, we got a discrepency in objects Ids that may generate a change in ordering later. * Bug: In Katana::Session::_doRemovalEvents(), the set of Tracks that got elements deleted was still using pointers. Now we use a TrackSet sorted on (direction,depth,axis). This should not have created a change in the results, as destructions do not change Ids, but it genereate extra differences in traces.
2019-08-20 09:30:03 -05:00
//void TrackElement::detach ( TrackSet& ) { }
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
void TrackElement::revalidate () { }
void TrackElement::updatePPitch () { }
Upgrade of Katana detailed router to support Arlet 6502. * Change: In Hurricane::SharedName, replace the incremental Id by a hash key. This is to ensure better deterministic properties. Between use cases, additional strings may have to be allocated, shitfing the ids. Even if hash can be duplicated, we should be able to ensure that the absolute order in map table should be preserved. Supplemental strings are inserted in a way that keep the previous order. * Change: In CRL/etc/symbolic/cmos/kite.conf, add "katabatic.routingGauge" default parameter value ("sxlib"). * Change: In CRL/etc/common/technology.conf, define minimal spacing for symbolic layers too (added for METAL4 only for now). * Change: In CRL::Histogram, extend support to dynamically sized histograms. Add a text pretty print with table and pseudo-curve. * Change: In Cumulus/plugins/ClockTreePlugin, create blockage under the block corona corners so the global router do not draw wire under them. This was creating deadlock for the detailed router. When the abutment has to be computed, directly use Etesian to do it instead of duplicating the computation in the Python plugin. * New: In Etesian, as Coloquinte seems reluctant to evenly spread the standard cells, we trick it by making them bigger during the placement stage. Furthermore, we do not not uniformely increase the size of the cells but create a "bloating profile" based on cell size, cell name or it's density of terminals. Currently only two profiles are defined, "disabled" which does nothing and "nsxlib" targeted on 4 metal layer technologies (aka AMS 350nm, c35b4). * Bug: In Knik::MatrixVertex, load the default routing gauge using the configuration parameter "katabatic.routingGauge" as the default one may not be the first registered one. * New: In AnabaticEngine::setupNetDatas(), build a dynamic historgram of the nets terminal numbers. * Bug: In Anabatic::AutoContact::Invalidate(), always invalidate the contact cache when topology is invalidated. In case of multiple invalidations, if the first did not invalidate the cache, later one that may need it where not allowed to do so. The end result was correct nonetheless, but it did generate annoying error messages. * Bug: In Anabatic::AutoContactTurn::updateTopology(), bad computation of the contact's depth when delta == 2. * Bug: In Anabatic::Gcell::getCapacity(), was always returning the west edge capacity, even for the westermost GCell, should be the east edge in that case. * New: In Anabatic::AutoSegment, introduce a new measure "distance to terminal". This is the minimal number of segments separating the current one from the nearest RoutingPad. This replace the previous "strong terminal" and "weak terminal" flags. This distance is used by Katana to sort the events, we route the segments *from* the RoutingPads *outward*. The idea being that if we cannot event connect to the RoutingPad, there is no points continuing as thoses segments are the more constraineds. This gives an order close to the simple ascending metals but with better results. * New: In Anabatic::AutoSegment, introduce a new flag "Unbreakable", disable dogleg making on those segments. mainly intended for local segments directly connecteds to RoutingPads (distance == 0). * New: In Anabatic::AutoSegment, more aggressive reducing of segments. Now the only case where a segment cannot be reduced is when it is one horizontal branch in a HTee or a vertical on a VTee. Check if, when not accounted the source & target VIAs are still connex, if so, allow reducing. * New: In Anabatic::AutoContact, new state flags CntVDogleg & CntHDogleg mainly to prevent making doglegs twice on a turn contact. This is to limit over-fragmentation. If one dogleg doesn't solve the problem, making a second one will make things worse only... * Bug: In Anabatic::Configuration::selectRpcomponent(), we were choosing the component with the *smallest* span instead of the *bigger* one. * New: In Anabatic::GCell, introduce a new flag "GoStraight" to tell that no turn go be made inside those GCells. Mainly used underneath a block corona. * New: In AnabaticEngine::layerAssign(), new GCellRps & RpsInRow to manage GCells with too many terminals. Slacken at least one RoutingPad access when there is more than 8 RoutingPad in the GCell (slacken or change a vertical METAL2 (non-preferred) into a METAL3). * Change: In Anabatic::NetBuilderHV, allow the use of terminal connection in non-preferred direction. That is, vertical METAL2 directly connected to the RoutingPad (then a horizontal METAL2). This alllows for short dogleg without clutering the METAL3 layer (critical for AMS c35b4). Done in NetBuilderHV::doRp_Access(), with a new UseNonPref flag. Perform some other tweaking on METAL1 access topologies, to also minimize METAL3 use. * New: In AnabaticEngine::computeNetConstraints(), also compute the distance to RoutingPad for segments. Set the Unbreakable flag, based on the distance and segment length (local, short global or long global). New local function "propagateDistanceFromRp()". * Change: In AnabaticEngine.h, the sorting class for NetData, SparsityOrder, is modificated so net with a degree superior to 10 are sorted first, whatever their sparsity. This is to work in tandem with GlobalRouting. * New: In Katana::TrackSegmentNonPref, introduce a class to manage segment in non-preferred routing direction. Mostly intended for small METAL2 vertical directly connected to RoutingPad. Modifications to manage this new variant all through Katana. * Change: In Katana::GlobalRoute, DigitalDistance honor the GoStraight flag of the GCell. Do not make bend inside thoses GCells. * Change: In KatanaEngine::runGlobalRouter(), high degree nets (>= 10) are routed first and whitout the global routing estimation. There should be few of them so they wont create saturations and we want them as straight as possible. Detour are for long be-points. Set the saerch halo to one GCell in the initial routing stage (before ripup). * Bug: In KatanaEngine & NegociateWindow, call _computeCagedconstraints() inside NegociateWindow::run(), as segments are inserted into tracks only at that point so we cannot make the computation earlier. * Change: In Katana::Manipulator::repackPerpandiculars(), add a flag to select whether to replace the perpandiculars *after* or *before* the current segment. * Change: In Katana::NegociateWindow::NegociateOverlapCost(), when the segment is fully enclosed inside a global, the longest overlap cost is set to the shortest global hoverhang (before or after). When the cost is for a global, set an infinite cost if the overlapping segment has a RP distance less or equal to 1 (this is an access segment). * Bug: In Katana::PowerRailsPlane::Rail::doLayout(), correct computation of the segments extension cap. * New: In Katana::QueryPowerRails::addToPowerRail(), add support for Pad. * Change: In Katana/PreProcess::protectCagedTerminals(), apply the contraints to any turn connected to the first segment of the RoutingPad so the perpandicular constraints got propagated to the perpandicular segment... * Change: In RoutingEvent, cache the "distance to RP" value. * Change: In RoutingEvent::Key::compare(), sort *first* on distance to RoutingPad, then layer depth. If both distance to RoutingPad is null, then sort on segment length. * Change: In RoutingEvent::_processRepair(), try a repack perpandicular with perpandiculars first (then with perpandicular last, then give up). * Change: In SegmentFsm::bindToTrack() and moveToTrack(), set an axis hint when creating the insertion event. * Change: In SegmentFsm::_slackenStrap(), add a step through slacken between minimize and maximum slack (wihch directly end up in unimplemented). * Change: In Session::_addInsertEvent(), add an axis parameter needed when the axis of the segment is not the one of the track (case of wide segments or non-preferred direction). * Bug: In Track::_preDestroy(), bad management of the TrackElement reference count. Destroy the segment only when reaching zero... * Bug: In Track::expandFreeIneterval(), forgotten to manage case when there is a set of overlaping segments at the "end" of the track, the EndIsTrackMax was not set. * Change: In TrackCost::Compare, increase the cost when an overlaping segment is at it's ripup limit. We should try *not* to rip it up if we can. Add a dedicated flag "AtRipupLimit". * Change: In TrackElement, add proxies for isUnbreakable(), new function updateTrackSpan(). * New: In TrackFixedSegment CTOR, when a supply wire of METAL2 or above is found, make the underlying GCells "GoStraight". * New: In TrackElement::canDogleg(GCell*), check for already done perpandicular dogleg on source/target (reject if so).
2019-07-28 16:20:00 -05:00
void TrackElement::updateTrackSpan () { }
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
void TrackElement::setAxis ( DbU::Unit, uint32_t flags ) { }
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
TrackElement* TrackElement::makeDogleg () { return NULL; }
Improved handling of short nets (fully included in one GCell). The short net mode degrade the routing in some cases. This will be fixed in a next batch of commits. * New: In Hurricane::NetRoutingProperty, added "ShortNet" flag for Nets that are completly inside *one* GCell. * Bug: In CRL::BlifParser::Model::staticInit(), when looking for the output of zero and one cell, also skip the blockage net (as well as automatic and supplies). * New: In Anabatic::AutoSegment, added "ShortNet" flag to know if the segment is part of a short net (fully included in *one* GCell). Also add accessor/mutators for the _analogMode flag (was it ever used before?). * New: In Anabatic::NetBuilder::singleGCell(), if a RoutingPad is vertically small, add a vertical segment to give it some slack. * New: In Anabatic::Dijkstra::_materialize(), detect "short net" as they have only one GCell in their source list... * Bug: In AnabaticEngine::_loadGrbyNet(), reset the AutoSegment "short net" and "analog mode" creation flags between two different nets. * New: In Katana::Configuration, added dedicated ripup for short net segmnts. * New: In Katana: partially implemented support for "short dogleg", that is dogleg that are always kept in same metal because they connect neighboring perpandicular tracks. Not finished neither activated yet. * New: In Katana::TreckElement and derived, export the the *short net* support from AutoSegment. * Bug: In Katana::RoutingEvent::_processRepair(), when a segment is successfully inserted, re-process any perpandicular that is in repair state, as it may have a new chance to be placed. * New: In Katana::SegmentFsm::slackenTopology(), always reject short nets. * Bug: In Katana::Track::check(), correctly handle wide segments instead of issuing false check messages.
2018-07-16 04:16:51 -05:00
Flags TrackElement::makeDogleg ( Interval, TrackElement*&, TrackElement*&, Flags ) { return Flags::NoFlags; }
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
TrackElement* TrackElement::makeDogleg ( Anabatic::GCell*, TrackElement*&, TrackElement*& ) { return NULL; }
void TrackElement::_postDoglegs ( TrackElement*&, TrackElement*& ) { }
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
bool TrackElement::moveAside ( Flags ) { return false; }
bool TrackElement::slacken ( Flags ) { return false; }
bool TrackElement::moveUp ( Flags ) { return false; }
bool TrackElement::moveDown ( Flags ) { return false; }
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 THIS_IS_DISABLED
void TrackElement::desalignate () { }
#endif
bool TrackElement::_check () const { return true; }
TrackElement::TrackElement ( Track* track )
: _flags (0)
, _track (track)
, _sourceU (0)
, _targetU (0)
, _observer(this)
{ }
void TrackElement::_postCreate ()
{ }
TrackElement::~TrackElement ()
{ }
void TrackElement::_preDestroy ()
{ }
void TrackElement::destroy ()
{
_preDestroy ();
delete this;
}
TrackElement* TrackElement::getNext () const
{
Katana manage wide wires, and they can also be symmetric. * New: In Anabatic::AutoContact and the derived classes, manages wide wires. The contact self dimension itself according to the segments it is connected to. Special case for the AutoContactTerminal which also read the size of the component it is anchored upon. New refresh method "updateSize()" and flag CntInvalidatedWidth. to compute the size. In AutoContactTerminal, compute the constraint box according to the width of the segment. * New: In Anabatic::AutoSegment, flags are now implemented as "static const" attributes of the class. The flags are stored into a uint64_t as they are more than 32. Added new flag "SegWide" and associated predicates. * Change: In GCellTopology::_doHChannel() and GCellTopology::_doVChannel(), uses the simpler overload of AutoSegment::create() in order to detect the wire width automatically. * New: In Katana::Manipulator, split insertToTrack() and forceToTrack() into a one-track method and a segment level method that iterate over the track span of the segment. * New: In Katana::SegmentFsm, for each cost in the table, now allow access to a specific track. So the base functions have now two parameters: "icost" and "itrack" (has a cost can have multiple tracks in the case of wide segments). * Change: In Katana::TrackElement, remove the index of the element inside it's track, as for a wide segment it will not be meaningful for the non-base track. This means that we have to use the Track::find() method each time instead. Remove the wide flag, as it is a duplicate of the one in AutoSegment. Added a getTrackCount() method to tell the number of track the segment is inserted into. Needed in the Track destroy step to delete a segment only when the last track that refers it is destroyed. Added getSymmetricAxis() to correct the computation of the symmetric base track in case of wide segment as the base track is not centered but the the leftmost one. * Change: In Track::insert() insert wide segments in their whole track span. * Change: In TrackCost, create an array of costs according to the segment track span. * Change: In TrackSegment::create(), now activate the factory and create wide segments. * Bug: In Katana::AutoSegments_Perpandicular, correct the debug indentation problem (ever shifting to the right).
2017-07-28 08:30:22 -05:00
size_t dummy = _track->find( this );
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
return _track->getNext( dummy, getNet() );
}
TrackElement* TrackElement::getPrevious () const
{
Katana manage wide wires, and they can also be symmetric. * New: In Anabatic::AutoContact and the derived classes, manages wide wires. The contact self dimension itself according to the segments it is connected to. Special case for the AutoContactTerminal which also read the size of the component it is anchored upon. New refresh method "updateSize()" and flag CntInvalidatedWidth. to compute the size. In AutoContactTerminal, compute the constraint box according to the width of the segment. * New: In Anabatic::AutoSegment, flags are now implemented as "static const" attributes of the class. The flags are stored into a uint64_t as they are more than 32. Added new flag "SegWide" and associated predicates. * Change: In GCellTopology::_doHChannel() and GCellTopology::_doVChannel(), uses the simpler overload of AutoSegment::create() in order to detect the wire width automatically. * New: In Katana::Manipulator, split insertToTrack() and forceToTrack() into a one-track method and a segment level method that iterate over the track span of the segment. * New: In Katana::SegmentFsm, for each cost in the table, now allow access to a specific track. So the base functions have now two parameters: "icost" and "itrack" (has a cost can have multiple tracks in the case of wide segments). * Change: In Katana::TrackElement, remove the index of the element inside it's track, as for a wide segment it will not be meaningful for the non-base track. This means that we have to use the Track::find() method each time instead. Remove the wide flag, as it is a duplicate of the one in AutoSegment. Added a getTrackCount() method to tell the number of track the segment is inserted into. Needed in the Track destroy step to delete a segment only when the last track that refers it is destroyed. Added getSymmetricAxis() to correct the computation of the symmetric base track in case of wide segment as the base track is not centered but the the leftmost one. * Change: In Track::insert() insert wide segments in their whole track span. * Change: In TrackCost, create an array of costs according to the segment track span. * Change: In TrackSegment::create(), now activate the factory and create wide segments. * Bug: In Katana::AutoSegments_Perpandicular, correct the debug indentation problem (ever shifting to the right).
2017-07-28 08:30:22 -05:00
size_t dummy = _track->find( this );
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
return _track->getPrevious( dummy, getNet() );
}
Interval TrackElement::getFreeInterval () const
{
if (not _track) return Interval(false);
Katana manage wide wires, and they can also be symmetric. * New: In Anabatic::AutoContact and the derived classes, manages wide wires. The contact self dimension itself according to the segments it is connected to. Special case for the AutoContactTerminal which also read the size of the component it is anchored upon. New refresh method "updateSize()" and flag CntInvalidatedWidth. to compute the size. In AutoContactTerminal, compute the constraint box according to the width of the segment. * New: In Anabatic::AutoSegment, flags are now implemented as "static const" attributes of the class. The flags are stored into a uint64_t as they are more than 32. Added new flag "SegWide" and associated predicates. * Change: In GCellTopology::_doHChannel() and GCellTopology::_doVChannel(), uses the simpler overload of AutoSegment::create() in order to detect the wire width automatically. * New: In Katana::Manipulator, split insertToTrack() and forceToTrack() into a one-track method and a segment level method that iterate over the track span of the segment. * New: In Katana::SegmentFsm, for each cost in the table, now allow access to a specific track. So the base functions have now two parameters: "icost" and "itrack" (has a cost can have multiple tracks in the case of wide segments). * Change: In Katana::TrackElement, remove the index of the element inside it's track, as for a wide segment it will not be meaningful for the non-base track. This means that we have to use the Track::find() method each time instead. Remove the wide flag, as it is a duplicate of the one in AutoSegment. Added a getTrackCount() method to tell the number of track the segment is inserted into. Needed in the Track destroy step to delete a segment only when the last track that refers it is destroyed. Added getSymmetricAxis() to correct the computation of the symmetric base track in case of wide segment as the base track is not centered but the the leftmost one. * Change: In Track::insert() insert wide segments in their whole track span. * Change: In TrackCost, create an array of costs according to the segment track span. * Change: In TrackSegment::create(), now activate the factory and create wide segments. * Bug: In Katana::AutoSegments_Perpandicular, correct the debug indentation problem (ever shifting to the right).
2017-07-28 08:30:22 -05:00
size_t begin = _track->find( this );
size_t end = begin;
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
return _track->expandFreeInterval( begin, end, Track::InsideElement, getNet() );
}
size_t TrackElement::getGCells ( vector<GCell*>& gcells ) const
{
vector<GCell*>().swap( gcells );
return gcells.size();
}
TrackCost clean support for symmetric and wide segments. * New: In Katana::TrackCost, the TrackElement and it's optional symmetric are now kept as attribute of a TrackCost. The cost is completly computed inside the constructor. TrackCost now support any mix of symmetric event and wide segments. The cost is now computed by adding directly to the current one instead of creating secondaries that are merged afterwards. As a consequence, remove all copy construction and merge capabilities. All the various methods used to compute the cost are renamed "addOverlapcost()" in all the various related objects. As a reminder, the overal cost method call is as follow: 1. TrackCost constructor on a TrackElement. 2. Call TrackElement::addOverlapcost() 3. For all Track under the TrackElement, call Track::addOverlapCost() 4. For all other TrackElement intersecting with the overlap interval call: TrackElement::incOverlapCost() 5. The callback overlap function for segments is called (defined in NegociateWidow). Don't confuse: - TrackElement::addOverlapCost(), which compute the cost of inserting the segment inside a track (or a set of). - TrackElement::incOverlapCost(), which compute the cost of overlaping with this already inserted segment. It is the other way around of the previous one. * Change: In Katana::SegmentFsm, use a vector of pointer to TrackCost instead of an object to avoid copy construction.
2017-06-10 05:27:25 -05:00
void TrackElement::incOverlapCost ( TrackCost& cost ) const
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
{
TrackCost clean support for symmetric and wide segments. * New: In Katana::TrackCost, the TrackElement and it's optional symmetric are now kept as attribute of a TrackCost. The cost is completly computed inside the constructor. TrackCost now support any mix of symmetric event and wide segments. The cost is now computed by adding directly to the current one instead of creating secondaries that are merged afterwards. As a consequence, remove all copy construction and merge capabilities. All the various methods used to compute the cost are renamed "addOverlapcost()" in all the various related objects. As a reminder, the overal cost method call is as follow: 1. TrackCost constructor on a TrackElement. 2. Call TrackElement::addOverlapcost() 3. For all Track under the TrackElement, call Track::addOverlapCost() 4. For all other TrackElement intersecting with the overlap interval call: TrackElement::incOverlapCost() 5. The callback overlap function for segments is called (defined in NegociateWidow). Don't confuse: - TrackElement::addOverlapCost(), which compute the cost of inserting the segment inside a track (or a set of). - TrackElement::incOverlapCost(), which compute the cost of overlaping with this already inserted segment. It is the other way around of the previous one. * Change: In Katana::SegmentFsm, use a vector of pointer to TrackCost instead of an object to avoid copy construction.
2017-06-10 05:27:25 -05:00
if (not _track or (getNet() == cost.getNet())) return;
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
_overlapCostCallback( this, cost );
}
string TrackElement::_getTypeName () const
{ return "TrackElement"; }
string TrackElement::_getString () const
{ return "<"+_getTypeName()+">"; }
Record* TrackElement::_getRecord () const
{
Record* record = new Record( _getString() );
record->add( getSlot( "_flags", _track ) );
record->add( getSlot( "_track", _track ) );
record->add( DbU::getValueSlot( "_sourceU", &_sourceU ) );
record->add( DbU::getValueSlot( "_targetU", &_targetU ) );
return record;
}
} // Katana namespace.