425 lines
23 KiB
Groff
425 lines
23 KiB
Groff
|
.TH "LoadGlobalRouting" 3 "Sun Nov 21 2021" "Version 1.0" "Katabatic - Routing Toolbox" \" -*- nroff -*-
|
||
|
|
.ad l
|
||
|
|
.nh
|
||
|
|
.SH NAME
|
||
|
|
LoadGlobalRouting \- Translation rules to build detailed routing from global\&.
|
||
|
|
|
||
|
|
.SH SYNOPSIS
|
||
|
|
.br
|
||
|
|
.PP
|
||
|
|
.SS "Classes"
|
||
|
|
|
||
|
|
.in +1c
|
||
|
|
.ti -1c
|
||
|
|
.RI "class \fBGCellTopology\fP"
|
||
|
|
.br
|
||
|
|
.RI "Build the wiring for a Net inside a GCell (\fBinternal\fP)\&. "
|
||
|
|
.in -1c
|
||
|
|
.SS "Enumerations"
|
||
|
|
|
||
|
|
.in +1c
|
||
|
|
.ti -1c
|
||
|
|
.RI "enum \fBLocalFunctionFlag\fP { \fBNoFlags\fP = 0x00000000, \fBHAccess\fP = 0x00000002, \fBVSmall\fP = 0x00000004, \fBHSmall\fP = 0x00000008, \fBPunctual\fP = 0x00000010, \fBDoSourceContact\fP = 0x00000100, \fBDoTargetContact\fP = 0x00000200 }"
|
||
|
|
.br
|
||
|
|
.in -1c
|
||
|
|
.SS "Functions"
|
||
|
|
|
||
|
|
.in +1c
|
||
|
|
.ti -1c
|
||
|
|
.RI "unsigned int \fBcheckRoutingPadSize\fP (\fBComponent\fP *anchor)"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "static void \fBdoRp_AutoContacts\fP (\fBGCell\fP *, \fBComponent\fP *, \fBAutoContact\fP *&source, \fBAutoContact\fP *&target, unsigned int flags)"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "static \fBAutoContact\fP * \fBdoRp_Access\fP (\fBGCell\fP *, \fBComponent\fP *, unsigned int flags)"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "static \fBAutoContact\fP * \fBdoRp_AccessPad\fP (\fBRoutingPad\fP *, unsigned int flags)"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "static void \fBdoRp_StairCaseH\fP (\fBGCell\fP *, \fBComponent\fP *rp1, \fBComponent\fP *rp2)"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "static void \fBdoRp_StairCaseV\fP (\fBGCell\fP *, \fBComponent\fP *rp1, \fBComponent\fP *rp2)"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_xG_1Pad\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_xG\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_1G_1M1\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_1G_xM1\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_xG_1M1_1M2\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_xG_xM1_xM3\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_xG_xM2\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_1G_1M3\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fB_do_xG_xM3\fP ()"
|
||
|
|
.br
|
||
|
|
.ti -1c
|
||
|
|
.RI "void \fBsingleGCell\fP (\fBKatabaticEngine\fP *ktbt, \fBNet\fP *net)"
|
||
|
|
.br
|
||
|
|
.in -1c
|
||
|
|
.SH "Detailed Description"
|
||
|
|
.PP
|
||
|
|
Translation rules to build detailed routing from global\&.
|
||
|
|
|
||
|
|
This module documents how the global routing built by \fCKnik\fP is loaded into the \fC\fBKatabatic\fP\fP data-base\&. It is intented for developpers only\&.
|
||
|
|
.SH "Enumeration Type Documentation"
|
||
|
|
.PP
|
||
|
|
.SS "enum \fBLocalFunctionFlag\fP"
|
||
|
|
A set of flags for all functions of the LoadGrByNet module\&. They can be combined to form the \fIflags\fP argument of functions\&. the functions will ignore flags that are not intended to them\&.
|
||
|
|
.PP
|
||
|
|
For \fCHSmall\fP, \fCVSmall\fP & \fCPunctual\fP see \fBcheckRoutingPadSize()\fP\&.
|
||
|
|
.PP
|
||
|
|
\fBEnumerator\fP
|
||
|
|
.in +1c
|
||
|
|
.TP
|
||
|
|
\fB\fINoFlags \fP\fP
|
||
|
|
A simple alias over zero to explicitly tell that no flag at all is passed to the function\&.
|
||
|
|
.TP
|
||
|
|
\fB\fIHAccess \fP\fP
|
||
|
|
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\&.
|
||
|
|
.TP
|
||
|
|
\fB\fIVSmall \fP\fP
|
||
|
|
The RoutingPad vertically covers a very small number of access points, so it is likely overconstrained for direct horizontal connexion\&.
|
||
|
|
.TP
|
||
|
|
\fB\fIHSmall \fP\fP
|
||
|
|
The RoutingPad horizontally covers a very small number of access points, so it is likely overconstrained for direct vertical connexion\&.
|
||
|
|
.TP
|
||
|
|
\fB\fIPunctual \fP\fP
|
||
|
|
The RoutingPad covers only an access point in either direction\&.
|
||
|
|
.TP
|
||
|
|
\fB\fIDoSourceContact \fP\fP
|
||
|
|
When creating \fBKatabatic::AutoContactTerminal\fP on non-punctual RoutingPad, this flag request the creation of a contact \fIon the source point\fP\&.
|
||
|
|
.TP
|
||
|
|
\fB\fIDoTargetContact \fP\fP
|
||
|
|
When creating \fBKatabatic::AutoContactTerminal\fP on non-punctual RoutingPad, this flag request the creation of a contact \fIon the target point\fP\&.
|
||
|
|
.SH "Function Documentation"
|
||
|
|
.PP
|
||
|
|
.SS "unsigned int checkRoutingPadSize (\fBComponent\fP * 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:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
HSmall : less than 3 pitches in horizontal direction\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
VSmall : less than 3 pitches in vertical direction\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
Punctual : one pitch in either directions\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
The component can be a RoutingPad, a Vertical or an Horizontal\&.
|
||
|
|
.PP
|
||
|
|
checkRoutingPadSize()
|
||
|
|
.PP
|
||
|
|
References Component::getLayer(), anonymous_namespace{LoadGrByNet\&.cpp}::HSmall, anonymous_namespace{LoadGrByNet\&.cpp}::Punctual, toLambda(), and anonymous_namespace{LoadGrByNet\&.cpp}::VSmall\&.
|
||
|
|
.PP
|
||
|
|
Referenced by GCellTopology::doRp_Access()\&.
|
||
|
|
.SS "void doRp_AutoContacts (\fBGCell\fP * gcell, \fBComponent\fP * rp, \fBAutoContact\fP *& source, \fBAutoContact\fP *& target, unsigned int flags)\fC [static]\fP"
|
||
|
|
|
||
|
|
.PP
|
||
|
|
\fBParameters:\fP
|
||
|
|
.RS 4
|
||
|
|
\fIgcell\fP The GCell into which create the AutoContact\&.
|
||
|
|
.br
|
||
|
|
\fIrp\fP The Component we want to access\&.
|
||
|
|
.br
|
||
|
|
\fIsource\fP The AutoContact created on the \fCsource\fP (\fIreturned\fP)\&.
|
||
|
|
.br
|
||
|
|
\fItarget\fP The AutoContact created on the \fCtarget\fP (\fIreturned\fP)\&.
|
||
|
|
.br
|
||
|
|
\fIflags\fP Managed by this function:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
LocalFunctionFlag::DoSourceContact
|
||
|
|
.IP "\(bu" 2
|
||
|
|
LocalFunctionFlag::DoTargetContact
|
||
|
|
.PP
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
Create the AutoContact directly anchored on the Component (terminal)\&. Three cases are manageds:
|
||
|
|
.IP "1." 4
|
||
|
|
\fBOrdinary (non-punctual) \fCMETAL1\fP terminal\fP: an AutoContactTerminal is anchored on the RoutingPad\&.
|
||
|
|
.IP "2." 4
|
||
|
|
\fBPunctual \fCMETAL1\fP terminal\fP, 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 \fInormal\fP AutoContactTerminal is also created\&.
|
||
|
|
.IP "3." 4
|
||
|
|
\fBnon \fCMETAL1\fP terminal\fP, as for the punctual \fCMETAL1\fP, 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)\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
To avoid creating a fixed protection over a RoutingPad multiple times, the RoutingPad and it's associated protection is stored in a static \fCmap\fP : \fC__routingPadAutoSegments\fP\&.
|
||
|
|
.PP
|
||
|
|
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 \fIdo not prevent them to move afterwards\fP, even those created on source/target on a non-punctual RoutingPad\&.
|
||
|
|
.PP
|
||
|
|
\fBRemark: For clarity we describe the layer management of this function in term\fP
|
||
|
|
.RS 4
|
||
|
|
of \fCMETAL\fP, but it is the RoutingGauge depth which is actually used\&.
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
doRp_AutoContacts()
|
||
|
|
.PP
|
||
|
|
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()\&.
|
||
|
|
.PP
|
||
|
|
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()\&.
|
||
|
|
.SS "\fBAutoContact\fP * doRp_Access (\fBGCell\fP * gcell, \fBComponent\fP * rp, unsigned int flags)\fC [static]\fP"
|
||
|
|
|
||
|
|
.PP
|
||
|
|
\fBParameters:\fP
|
||
|
|
.RS 4
|
||
|
|
\fIgcell\fP The GCell into which create the AutoContact\&.
|
||
|
|
.br
|
||
|
|
\fIrp\fP The Component onto which anchor the access contact\&.
|
||
|
|
.br
|
||
|
|
\fIflags\fP Relevant flags are:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
HAccess, the terminal is to be accessed through an horizontal segment\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
VSmall, force the terminal to be considered as small in the vertical direction\&.
|
||
|
|
.PP
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
If \fCHAccess\fP is set, the Component is to be accessed trough an horizontal segment\&. If unset, the access is done vertically\&.
|
||
|
|
.PP
|
||
|
|
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 \fCVSmall\fP), a local horizontal AutoSegment is added to slacken the vertical constraints\&.
|
||
|
|
.PP
|
||
|
|
doRp_Access()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.PP
|
||
|
|
Referenced by GCellTopology::_do_1G_1M1(), GCellTopology::_do_1G_xM1(), GCellTopology::_do_xG_xM1_xM3(), GCellTopology::_do_xG_xM2(), and GCellTopology::_do_xG_xM3()\&.
|
||
|
|
.SS "\fBAutoContact\fP * doRp_AccessPad (\fBRoutingPad\fP * rp, unsigned int flags)\fC [static]\fP"
|
||
|
|
|
||
|
|
.PP
|
||
|
|
\fBParameters:\fP
|
||
|
|
.RS 4
|
||
|
|
\fIrp\fP The Component onto which anchor the access contact\&.
|
||
|
|
.br
|
||
|
|
\fIflags\fP Relevant flags are:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
HAccess, the terminal is to be accessed through an horizontal segment\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
VSmall, force the terminal to be considered as small in the vertical direction\&.
|
||
|
|
.PP
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
\fBReturns:\fP
|
||
|
|
.RS 4
|
||
|
|
A \fBKatabatic::AutoContactTerminal\fP \&.
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
The Component \fCrp\fP is a RoutingPad which belongs to a pad cell\&. This case occurs when we are routing a complete chip\&. This method build, from the \fCrp\fP a stack of articulated punctual segments and contacts to reach the default H/V routing layers (usually \fCMETAL2\fP & \fCMETAL3\fP)\&. This may be needed when the pad terminal is in \fCMETAL5\fP, for instance\&.
|
||
|
|
.PP
|
||
|
|
The returned AutoContactTerminal is anchored on the last punctual segment build\&.
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.PP
|
||
|
|
\fBRemark: The segments and contacts added to ensure the layer connexity are not\fP
|
||
|
|
.RS 4
|
||
|
|
put into the \fBKatabatic\fP database\&. They are plain Hurricane objects, invisibles from it\&.
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
|
||
|
|
.PP
|
||
|
|
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()\&.
|
||
|
|
.PP
|
||
|
|
Referenced by GCellTopology::_do_xG_1Pad()\&.
|
||
|
|
.SS "void doRp_StairCaseH (\fBGCell\fP * gcell, \fBComponent\fP * rp1, \fBComponent\fP * rp2)\fC [static]\fP"
|
||
|
|
Build the wiring to connect to horizontal Component\&. Two cases:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The Component are aligneds, then only a straight wire is created\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
They are \fInot\fP aligned, then a complete dogleg is created\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
doRp_StairCaseH()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.PP
|
||
|
|
Referenced by GCellTopology::_do_xG_xM2()\&.
|
||
|
|
.SS "void doRp_StairCaseV (\fBGCell\fP * gcell, \fBComponent\fP * rp1, \fBComponent\fP * rp2)\fC [static]\fP"
|
||
|
|
Build the wiring to connect to vertical Components\&. Two cases:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The Components are aligneds, then only a straight wire is created\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
They are \fInot\fP aligned, then a complete dogleg is created\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
doRp_StairCaseV()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.PP
|
||
|
|
Referenced by GCellTopology::_do_xG_xM3()\&.
|
||
|
|
.SS "void _do_xG_1Pad ()\fC [private]\fP"
|
||
|
|
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\&.
|
||
|
|
.PP
|
||
|
|
So this method mostly calls \fBGCellTopology::doRp_AccessPad()\fP to create the AutoContactTerminal, then calls \fBGCellTopology::_do_xG()\fP, except for straight lines which are managed directly\&.
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void _do_xG ()\fC [private]\fP"
|
||
|
|
Construct the topology, when there is only global wires (no local terminals)\&.
|
||
|
|
.PP
|
||
|
|
Some topology are not handled because they must not be managed by this function:
|
||
|
|
.PD 0
|
||
|
|
|
||
|
|
.IP "\(bu" 2
|
||
|
|
One global: nonsensical because there also must be a terminal\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
Two aligned globals: in that case we do a straight wire without any AutoContact (handled by the source/target of the wire)\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
_do_xG()
|
||
|
|
.PP
|
||
|
|
References AutoContactVTee::create(), AutoContactTurn::create(), AutoContactHTee::create(), AutoSegment::create(), Session::getContactLayer(), Katabatic::KbHorizontal, and Katabatic::KbVertical\&.
|
||
|
|
.PP
|
||
|
|
Referenced by GCellTopology::_do_xG_1Pad()\&.
|
||
|
|
.SS "void _do_1G_1M1 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there is \fIone\fP global and one RoutingPad in \fCMETAL1\fP\&. The \fCMETAL1\fP is assumed to be vertical\&.
|
||
|
|
.PP
|
||
|
|
\fBRemark: When accessing the RoutingPad through an horizontal global segment\fP
|
||
|
|
.RS 4
|
||
|
|
and the vertical extension of the segment is small, the global is still directly attached to the terminal, inducing a high constraint on it\&. We left to job of slackening it to the router\&.
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
_do_1G_1M1()
|
||
|
|
.PP
|
||
|
|
References GCellTopology::doRp_Access(), anonymous_namespace{LoadGrByNet\&.cpp}::HAccess, anonymous_namespace{LoadGrByNet\&.cpp}::NoFlags, and anonymous_namespace{LoadGrByNet\&.cpp}::VSmall\&.
|
||
|
|
.SS "void _do_1G_xM1 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there is \fIone\fP global and any number of RoutingPad in \fCMETAL1\fP\&. The \fCMETAL1\fP is assumed to be vertical\&.
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.PP
|
||
|
|
_do_1G_xM1()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void _do_xG_1M1_1M2 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there is at least one global (and up to 4), one \fCMETAL1\fP RoutingPad (assumed V) and one \fCMETAL2\fP RoutingPad (assumed H)\&.
|
||
|
|
.PP
|
||
|
|
In this topology, we want to try to reuse the \fCMETAL2\fP RoutingPad as a feedtrough in the horizontal routage\&. Thus:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The \fCMETAL1\fP and \fCMETAL2\fP RoutingPad are connected through a separate wiring\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The south & west global wiring is attached to the leftmost contact of the \fCMETAL2\fP\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The north & east global wiring is attached to the rightmost contact of the \fCMETAL2\fP\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
South/west and north/south can be build independantly\&. Depending on the number of globals, they can consist of:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
Nothing (no south nor west)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An AutoContact (west present)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An horizontal plus a turn (south present)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An horizontal plus a HTee (south & west present)\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
\fBRemark: Not all configurations are represented below\&.\fP
|
||
|
|
.RS 4
|
||
|
|
|
||
|
|
.RE
|
||
|
|
.PP
|
||
|
|
_do_xG_1M1_1M2()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void _do_xG_xM1_xM3 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there is at least one global (and up to 4), at least one \fCMETAL1\fP RoutingPad (assumed V) and at least one \fCMETAL3\fP RoutingPad (assumed V)\&.
|
||
|
|
.PP
|
||
|
|
In this topology, we want to try to reuse the \fCMETAL3\fP RoutingPad as a feedtrough in the vertical routage\&. Thus:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The \fCMETAL1\fP and \fCMETAL3\fP RoutingPad are connected through a separate wiring made of separate horizontals\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The south-west global wiring is attached to the leftmost RoutingPad if there isn't south or to the first \fCMETAL3\fP otherwise\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The north-east global wiring is attached to the rightmost RoutingPad if there isn't north or to the first \fCMETAL3\fP otherwise\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
South/west and north/south can be build independantly\&. Depending on the number of globals, they can consist of:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
Nothing (no south nor west)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An AutoContact on the leftmost RoutingPad (west present)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An AutoContact on the first \fCMETAL3\fP (only south present)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An AutoContact plus a vertical plus a VTee (south & west present)\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
_do_xG_xM1_xM3()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void _do_xG_xM2 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there is at least one global (and up to 4), and any number of \fCMETAL2\fP RoutingPads (assumeds H)\&.
|
||
|
|
.PP
|
||
|
|
In this topology, we want to try to reuse the \fCMETAL2\fP RoutingPad as a feedtrough in the horizontal routage\&. Thus:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The RoutingPad are connecteds trough a separate staircase (or straight wire if aligneds)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The south-west global wiring is attached to the leftmost RoutingPad if there isn't south or to the biggest horizontal RoutingPad otherwise\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The north-east global wiring is attached to the rightmost RoutingPad if there isn't south or to the biggest horizontal RoutingPad otherwise\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
_do_xG_xM2()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void _do_1G_1M3 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there is one global and one \fCMETAL3\fP RoutingPad (assumeds V)\&.
|
||
|
|
.PP
|
||
|
|
In this topology, we reuse the \fCMETAL3\fP RoutingPad as a feedtrough in the vertical routage\&. Thus:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
If the global is either north or south, we directly connect to the north end or south end of the RoutingPad\&. The vertical global will have no slack at all we assume that METAL3 terminals are only from blocks and are aligneds vertically\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
If the global is east or west \fIand\fP the RoutingPad is sufficiently extended in the vertical direction, we connect an horizontal in the normal way\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
If the global is not sufficiently extended, we add a turn to give some slack to the global\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
_do_1G_1M3()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void _do_xG_xM3 ()\fC [private]\fP"
|
||
|
|
Construct a topology where there at least one global and two \fCMETAL3\fP RoutingPad (assumed V)\&.
|
||
|
|
.PP
|
||
|
|
In this topology, we reuse the \fCMETAL3\fP 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:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
All RoutingPads are linked two by two trough vertical staircases\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The south-west global wiring is attached to the bottommost RoutingPad (without vertical slack)\&. If a misalignment is detected, then a dogleg is added\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
The north-east global wiring is attached to the topmost RoutingPad (without vertical slack)\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
South/west and north/south can be build independantly\&. Depending on the number of globals, they can consist of:
|
||
|
|
.IP "\(bu" 2
|
||
|
|
Nothing (no south nor west)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An sliding AutoContact on the bottommost RoutingPad (west present)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An fixed AutoContact on the bottommost RoutingPad (only south present)\&.
|
||
|
|
.IP "\(bu" 2
|
||
|
|
An fixed AutoContact plus a vertical plus a VTee (south & west present)\&.
|
||
|
|
.PP
|
||
|
|
.PP
|
||
|
|
_do_xG_xM3()
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SS "void singleGCell (\fBKatabaticEngine\fP * ktbt, \fBNet\fP * net)"
|
||
|
|
All the RoutingPads of the net are concentrated under a single GCell\&. This function assumes that all the terminals are in \fCMETAL1\fP (vertical), and link them two by two by horizontal wires\&.
|
||
|
|
.PP
|
||
|
|
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\&.
|
||
|
|
.SH "Author"
|
||
|
|
.PP
|
||
|
|
Generated automatically by Doxygen for Katabatic - Routing Toolbox from the source code\&.
|