Translation rules to build detailed routing from global. More...
Classes | |
class | GCellTopology |
Build the wiring for a Net inside a GCell (internal). More... | |
Enumerations | |
enum | LocalFunctionFlag { NoFlags = 0x00000000 , HAccess = 0x00000002, VSmall = 0x00000004, HSmall = 0x00000008, Punctual = 0x00000010 , DoSourceContact = 0x00000100, DoTargetContact = 0x00000200 } |
Functions | |
unsigned int | checkRoutingPadSize (Component *anchor) |
static void | doRp_AutoContacts (GCell *, Component *, AutoContact *&source, AutoContact *&target, unsigned int flags) |
static AutoContact * | doRp_Access (GCell *, Component *, unsigned int flags) |
static AutoContact * | doRp_AccessPad (RoutingPad *, unsigned int flags) |
static void | doRp_StairCaseH (GCell *, Component *rp1, Component *rp2) |
static void | doRp_StairCaseV (GCell *, Component *rp1, Component *rp2) |
void | _do_xG_1Pad () |
void | _do_xG () |
void | _do_1G_1M1 () |
void | _do_1G_xM1 () |
void | _do_xG_1M1_1M2 () |
void | _do_xG_xM1_xM3 () |
void | _do_xG_xM2 () |
void | _do_1G_1M3 () |
void | _do_xG_xM3 () |
void | singleGCell (KatabaticEngine *ktbt, Net *net) |
Translation rules to build detailed routing from global.
This module documents how the global routing built by Knik
is loaded into the Katabatic
data-base. It is intented for developpers only.
enum LocalFunctionFlag |
A set of flags for all functions of the LoadGrByNet module. They can be combined to form the flags argument of functions. the functions will ignore flags that are not intended to them.
For HSmall
, VSmall
& Punctual
see checkRoutingPadSize().
Enumerator | |
---|---|
NoFlags | A simple alias over zero to explicitly tell that no flag at all is passed to the function. |
HAccess | The constructed topology will be accessed through an horizontal segment. The absence of this flag tell that the access will be done trough a vertical. |
VSmall | The RoutingPad vertically covers a very small number of access points, so it is likely overconstrained for direct horizontal connexion. |
HSmall | The RoutingPad horizontally covers a very small number of access points, so it is likely overconstrained for direct vertical connexion. |
Punctual | The RoutingPad covers only an access point in either direction. |
DoSourceContact | When creating Katabatic::AutoContactTerminal on non-punctual RoutingPad, this flag request the creation of a contact on the source point. |
DoTargetContact | When creating Katabatic::AutoContactTerminal on non-punctual RoutingPad, this flag request the creation of a contact on the target point. |
unsigned int checkRoutingPadSize | ( | Component * | rp | ) |
Look at the geometrical size of the Component and assess if it's span is too narrow either horizontally or vertically. Return a combination of flags indicating it's state:
The component can be a RoutingPad, a Vertical or an Horizontal.
References Component::getLayer(), anonymous_namespace{LoadGrByNet.cpp}::HSmall, anonymous_namespace{LoadGrByNet.cpp}::Punctual, toLambda(), and anonymous_namespace{LoadGrByNet.cpp}::VSmall.
Referenced by GCellTopology::doRp_Access().
|
static |
gcell | The GCell into which create the AutoContact. |
rp | The Component we want to access. |
source | The AutoContact created on the source (returned). |
target | The AutoContact created on the target (returned). |
flags | Managed by this function:
|
Create the AutoContact directly anchored on the Component (terminal). Three cases are manageds:
METAL1
terminal: an AutoContactTerminal is anchored on the RoutingPad.METAL1
terminal, the access must never be blocked by other routing. To ensure it, we create a fixed AutoSegment (anchored on two AutoContactTerminal) to cover it. The normal AutoContactTerminal is also created.METAL1
terminal, as for the punctual METAL1
, a fixed protection is added over the RoutingPad. If we access horizontally a vertical RoutingPad or vertically an horizontal one, an extra AutoContactTerminal is added (to allow is displacement along the RoutingPad).To avoid creating a fixed protection over a RoutingPad multiple times, the RoutingPad and it's associated protection is stored in a static map
: __routingPadAutoSegments
.
Conversely, because an AutoContactTerminal can only be connected to one segment, each time this function is called a new terminal will be created (or maybe two in case of non-punctual terminals). If only one AutoContact is requested, it is created centered on the RoutingPad. The initial position of AutoContact do not prevent them to move afterwards, even those created on source/target on a non-punctual RoutingPad.
METAL
, but it is the RoutingGauge depth which is actually used.References Katabatic::CntFixed, AutoContactTerminal::create(), AutoSegment::create(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Session::getContactLayer(), Grid< GCellT >::getGCell(), KatabaticEngine::getGCellGrid(), Session::getKatabatic(), Component::getLayer(), Katabatic::KbHorizontal, Katabatic::SegFixed, and AutoSegment::setFlags().
Referenced by GCellTopology::_do_1G_1M3(), GCellTopology::_do_xG_1M1_1M2(), GCellTopology::_do_xG_xM1_xM3(), GCellTopology::_do_xG_xM2(), GCellTopology::_do_xG_xM3(), GCellTopology::doRp_Access(), GCellTopology::doRp_StairCaseH(), GCellTopology::doRp_StairCaseV(), and anonymous_namespace{LoadGrByNet.cpp}::singleGCell().
|
static |
gcell | The GCell into which create the AutoContact. |
rp | The Component onto which anchor the access contact. |
flags | Relevant flags are:
|
If HAccess
is set, the Component is to be accessed trough an horizontal segment. If unset, the access is done vertically.
Create an AutoContact to access a Component (terminal). If the Component is not to be accessed through an horizontal segment, and do not cover a large span in the horizontal direction (flag VSmall
), a local horizontal AutoSegment is added to slacken the vertical constraints.
References anonymous_namespace{LoadGrByNet.cpp}::checkRoutingPadSize(), AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), Session::getContactLayer(), Component::getNet(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, anonymous_namespace{LoadGrByNet.cpp}::HSmall, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::VSmall.
Referenced by GCellTopology::_do_1G_1M1(), GCellTopology::_do_1G_xM1(), GCellTopology::_do_xG_xM1_xM3(), GCellTopology::_do_xG_xM2(), and GCellTopology::_do_xG_xM3().
|
static |
rp | The Component onto which anchor the access contact. |
flags | Relevant flags are:
|
The Component rp
is a RoutingPad which belongs to a pad cell. This case occurs when we are routing a complete chip. This method build, from the rp
a stack of articulated punctual segments and contacts to reach the default H/V routing layers (usually METAL2
& METAL3
). This may be needed when the pad terminal is in METAL5
, for instance.
The returned AutoContactTerminal is anchored on the last punctual segment build.
The GCell into which the AutoContactTerminal is created may be under the pads area. However, it will be right on the border of the GCell. The global router vertexes of GCell under the pad area are marked as blocked so will never be used for routing.
References Contact::create(), Horizontal::create(), Vertical::create(), AutoContactTerminal::create(), Hook::detach(), Component::getBodyHook(), RoutingPad::getBoundingBox(), RoutingPad::getCenter(), Session::getContactLayer(), Grid< GCellT >::getGCell(), KatabaticEngine::getGCellGrid(), Box::getHeight(), Session::getKatabatic(), RoutingPad::getLayer(), Component::getNet(), RoutingPad::getOccurrence(), Transformation::getOrientation(), Occurrence::getPath(), Session::getRoutingLayer(), Path::getTransformation(), Box::getWidth(), Box::getXMax(), Box::getXMin(), Box::getYMax(), Box::getYMin(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, Katabatic::KbHorizontal, Point::setX(), and Point::setY().
Referenced by GCellTopology::_do_xG_1Pad().
Build the wiring to connect to horizontal Component. Two cases:
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Session::getContactLayer(), Component::getLayer(), Component::getNet(), Component::getX(), AutoContact::getY(), Katabatic::KbHorizontal, and Katabatic::KbVertical.
Referenced by GCellTopology::_do_xG_xM2().
Build the wiring to connect to vertical Components. Two cases:
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Session::getContactLayer(), Component::getLayer(), Component::getNet(), AutoContact::getX(), Component::getY(), Katabatic::KbHorizontal, and Katabatic::KbVertical.
Referenced by GCellTopology::_do_xG_xM3().
|
private |
Construct the topology, when there is only global wires and one local terminal, but coming from a Pad. As thoses connectors will always be on one border of the GCell they can be considered as a kind of global.
So this method mostly calls GCellTopology::doRp_AccessPad() to create the AutoContactTerminal, then calls GCellTopology::_do_xG(), except for straight lines which are managed directly.
References GCellTopology::_do_xG(), AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AccessPad(), AutoContact::getBodyHook(), Session::getContactLayer(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
|
private |
Construct the topology, when there is only global wires (no local terminals).
Some topology are not handled because they must not be managed by this function:
References AutoContactVTee::create(), AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), Session::getContactLayer(), Katabatic::KbHorizontal, and Katabatic::KbVertical.
Referenced by GCellTopology::_do_xG_1Pad().
|
private |
Construct a topology where there is one global and one RoutingPad in METAL1
. The METAL1
is assumed to be vertical.
References GCellTopology::doRp_Access(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, anonymous_namespace{LoadGrByNet.cpp}::NoFlags, and anonymous_namespace{LoadGrByNet.cpp}::VSmall.
|
private |
Construct a topology where there is one global and any number of RoutingPad in METAL1
. The METAL1
is assumed to be vertical.
The RoutingPads are linked together two by two. If the horizontal segments are not aligned by the router, part of the routage will be done through the RoutingPad itself. The global incoming segment will connected to the leftmost, rightmost or centermost RoutingPad according from wich side it comes from.
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_Access(), Component::getBoundingBox(), Session::getContactLayer(), Box::getHeight(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, Katabatic::KbHorizontal, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
|
private |
Construct a topology where there is at least one global (and up to 4), one METAL1
RoutingPad (assumed V) and one METAL2
RoutingPad (assumed H).
In this topology, we want to try to reuse the METAL2
RoutingPad as a feedtrough in the horizontal routage. Thus:
METAL1
and METAL2
RoutingPad are connected through a separate wiring.METAL2
.METAL2
.South/west and north/south can be build independantly. Depending on the number of globals, they can consist of:
References AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Session::getContactLayer(), Session::getRoutingLayer(), Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
|
private |
Construct a topology where there is at least one global (and up to 4), at least one METAL1
RoutingPad (assumed V) and at least one METAL3
RoutingPad (assumed V).
In this topology, we want to try to reuse the METAL3
RoutingPad as a feedtrough in the vertical routage. Thus:
METAL1
and METAL3
RoutingPad are connected through a separate wiring made of separate horizontals.METAL3
otherwise.METAL3
otherwise.South/west and north/south can be build independantly. Depending on the number of globals, they can consist of:
METAL3
(only south present).References AutoContactVTee::create(), AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), GCellTopology::doRp_Access(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Component::getBoundingBox(), Session::getContactLayer(), Box::getHeight(), Session::getRoutingLayer(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
|
private |
Construct a topology where there is at least one global (and up to 4), and any number of METAL2
RoutingPads (assumeds H).
In this topology, we want to try to reuse the METAL2
RoutingPad as a feedtrough in the horizontal routage. Thus:
References AutoContactVTee::create(), AutoSegment::create(), GCellTopology::doRp_Access(), GCellTopology::doRp_AutoContacts(), GCellTopology::doRp_StairCaseH(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, Component::getBoundingBox(), Session::getContactLayer(), Box::getWidth(), Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
|
private |
Construct a topology where there is one global and one METAL3
RoutingPad (assumeds V).
In this topology, we reuse the METAL3
RoutingPad as a feedtrough in the vertical routage. Thus:
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Session::getContactLayer(), AutoContact::getX(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
|
private |
Construct a topology where there at least one global and two METAL3
RoutingPad (assumed V).
In this topology, we reuse the METAL3
RoutingPad as a feedtrough in the vertical routage. We assume that the most likely relative position of the RoutingPads is to be aligned vertically. Thus:
South/west and north/south can be build independantly. Depending on the number of globals, they can consist of:
References AutoContactVTee::create(), AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_Access(), GCellTopology::doRp_AutoContacts(), GCellTopology::doRp_StairCaseV(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, anonymous_namespace{LoadGrByNet.cpp}::DoTargetContact, Session::getContactLayer(), DbU::getValueString(), AutoContact::getX(), anonymous_namespace{LoadGrByNet.cpp}::HAccess, Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
void singleGCell | ( | KatabaticEngine * | ktbt, |
Net * | net | ||
) |
All the RoutingPads of the net are concentrated under a single GCell. This function assumes that all the terminals are in METAL1
(vertical), and link them two by two by horizontal wires.
References AutoContactTurn::create(), AutoSegment::create(), GCellTopology::doRp_AutoContacts(), anonymous_namespace{LoadGrByNet.cpp}::DoSourceContact, Session::getContactLayer(), Grid< GCellT >::getGCell(), KatabaticEngine::getGCellGrid(), RoutingGauge::getLayerDepth(), Session::getRoutingGauge(), Net::getRoutingPads(), Katabatic::KbHorizontal, Katabatic::KbVertical, and anonymous_namespace{LoadGrByNet.cpp}::NoFlags.
Generated by doxygen 1.8.14 on Mon Feb 3 2020 | Return to top of page |
Katabatic - Routing Toolbox | Copyright © 2008-2016 UPMC. All rights reserved |