A general approach for identifying hierarchical symmetry constraints for analog circuit layout
Kishor Kunal, Jitesh Poojary, Tonmoy Dhar, Meghna Madhusudan, Ramesh Harjani, Sachin S. Sapatnekar
AA general approach for identifying hierarchical symmetryconstraints for analog circuit layout
Kishor Kunal
University of Minnesota
Jitesh Poojary
University of Minnesota
Tonmoy Dhar
University of Minnesota
Meghna Madhusudan
University of Minnesota
Ramesh Harjani
University of Minnesota
Sachin S. Sapatnekar
University of Minnesota
ABSTRACT
Analog layout synthesis requires some elements in the circuit netlistto be matched and placed symmetrically. However, the set of sym-metries is very circuit-specific and a versatile algorithm, applicableto a broad variety of circuits, has been elusive. This paper presentsa general methodology for the automated generation of symmetryconstraints, and applies these constraints to guide automated layoutsynthesis. While prior approaches were restricted to identifyingsimple symmetries, the proposed method operates hierarchicallyand uses graph-based algorithms to extract multiple axes of sym-metry within a circuit. An important ingredient of the algorithm isits ability to identify arrays of repeated structures. In some circuits,the repeated structures are not perfect replicas and can only befound through approximate graph matching. A fast graph neuralnetwork based methodology is developed for this purpose, basedon evaluating the graph edit distance. The utility of this algorithmis demonstrated on a variety of circuits, including operational am-plifiers, data converters, equalizers, and low-noise amplifiers.
CCS CONCEPTS • Hardware → Electronic design automation ; Physical de-sign (EDA) ; Analog and mixed-signal circuit optimization ; •
Computing methodologies → Machine learning ; Neural net-works . KEYWORDS
Analog layout automation, machine learning
ACM Reference Format:
Kishor Kunal, Jitesh Poojary, Tonmoy Dhar, Meghna Madhusudan, RameshHarjani, and Sachin S. Sapatnekar. 2020. A general approach for identifyinghierarchical symmetry constraints for analog circuit layout. In
IEEE/ACMInternational Conference on Computer-Aided Design (ICCAD ’20), November2–5, 2020, Virtual Event, USA.
ACM, New York, NY, USA, 8 pages. https://doi.org/10.1145/3400302.3415685
Permission to make digital or hard copies of all or part of this work for personal orclassroom use is granted without fee provided that copies are not made or distributedfor profit or commercial advantage and that copies bear this notice and the full citationon the first page. Copyrights for components of this work owned by others than theauthor(s) must be honored. Abstracting with credit is permitted. To copy otherwise, orrepublish, to post on servers or to redistribute to lists, requires prior specific permissionand/or a fee. Request permissions from [email protected].
ICCAD ’20, November 2–5, 2020, Virtual Event, USA © 2020 Copyright held by the owner/author(s). Publication rights licensed to ACM.ACM ISBN 978-1-4503-8026-3/20/11...$15.00https://doi.org/10.1145/3400302.3415685
Specialized layout techniques involving forms of symmetry, such assymmetry about an axis, common-centroid layout, and matching,have long been used by analog layout engineers to achieve highperformance and high yield in analog designs. Matching techniquesare important for both active and passive elements [1], which aresubject to perturbations due to random and systematic variationsas well as changing operating conditions. Analog circuits convertthe less controllable problem of reducing absolute variations intoone of bounding relative variations, or mismatch. One approach toreduce mismatch is to rely on fixed ratios between devices (e.g., in acurrent mirror), as the mismatch in ratios is more controllable whennearby devices experience similar variations (e.g., due to systematicor spatially correlated effects). A second approach involves theuse of differential structures (e.g., differential pairs) for mismatchreduction. In a typical CMOS process, the absolute value of deviceparameters for transistors, capacitors, and resistors can vary by 20%,while the requirements on ratio mismatch may be within 0.1% [2].Traditionally, these constraints are extracted manually by cir-cuit designers, relying on expert knowledge. Automated constraintextraction is one of the chief bottlenecks [3] to full automation,despite recent progress in analog automation [4]. Manual constraintextraction methods, which rely on “designer intent” and years ofexperience, are difficult to translate to an algorithmic methodology.One class of prior methods is based on sensitivity analysis:Malavasi et al. [5] identify matching requirements between nodeswith similar sensitivities. However, sensitivity analysis is compu-tationally intensive, especially for nonlinear circuits that requirelarge-change sensitivities. A second class of methods is topology-based: Eick et al. [6] uses a building block based approach usinga signal flow graph method to extract the symmetries. While thismethod is computationally tractable and is effective on simplersymmetries, it is noted in [6] that it does not handle more complexsymmetries such as those that are hierarchically nested. A thirdclass of recent methods is spectrally based: Kunal et al. [7] employgraph convolutional networks to identify structures within graphsand then identify symmetries only using traversal methods similarto [6]; Liu et al. [8] use spectral methods to solve a related problemof identifying symmetric circuits at the system level.No spectral method addresses the full problem of hierarchicalconstraint generation in analog circuits with multiple symmetrylines. Moreover, prior approaches have only been applied to designswith a small number of blocks, with relatively simpler symmetries.To illustrate the complexity that must be addressed to solve the fullproblem, we consider the schematic of the FIR equalizer shown inFig. 1, in which any mismatch between differential pair transistors a r X i v : . [ c s . L G ] S e p CCAD ’20, November 2–5, 2020, Virtual Event, USA K. Kunal, J. Poojary, T. Dhar, M. Madhusudan, R. Harjani, and S. S. Sapatnekar
DP1
INV[0] INV[1]
INV[9]
L L L OUTPUTINPUT Clk
Clkb Clkb Vb M1 M2
R1 R2
M3 M4 M19 M20
Tap 1
C0 C1 C9
Tap 2 Tap 9 o o DP1 DP1
Figure 1: Schematic of an FIR equalizer [9]. {M1-M2},{M3-M4}, · · · , {M19-M20} associated with the taps canresult in a gain error. Moreover, the V ds across current sources C0, · · · , C9 should be the same to maintain similar overdrive current.A set of symmetry constraints, along multiple axes of symmetry,must be detected between the transistors in the differential pairs;the current sources must be self symmetric; each tap and its outputsmust be symmetrically laid out with respect to resistors R1 and R2.The differential pairs also have symmetry requirements, and thecurrent driver (shown in the inset for C9) requires ratioed structureswith common-centroid layout for mismatch reduction.A complicating factor is that the variable current sources, C0, · · · , C9 may not be identical: in [9], the first 4 taps use 7-bit current-steering DACs, while the rest employ 5-bit DACs. The bias voltageis the same for all taps: thus, despite the small difference in topology,the placement and routing must be matched. To the best of ourknowledge, no existing technique addresses this problem of detect-ing symmetries between approximately identical analog blocks.The requirements for a methodology that identifies symmetriesin a netlist are: (1) Speed and scalability to large circuits; (2) Abilityto identify constraints hierarchically; (3) Generality and applicabil-ity to a wide range of circuits; (4) Capability of identifying multipleaxes of symmetry; (5) Capacity to identify symmetries betweenblocks that are approximately similar and need matching. Our workall requirements and has the following key features: • It hierarchically handles multiple symmetry levels using agraph-based framework, and identifies array structures. • It invokes a matching algorithm based on exact or approx-imate matching: the latter is based on finding graph editdistances, and employs a graph neural network (GNN) todetect matching in structures such as Fig. 1. • It demonstrates solutions on a range of design types, rangingfrom low-frequency analog to wireless designs.Open-source software for this algorithm is available at [10].
Inspired by [11], we represent a circuit netlist as an undirected bipar-tite graph G ( V , E ) . The set of vertices V can be partitioned into twosubsets, V e , corresponding to the elements (transistors/passives/hierarchical blocks) in the netlist, and V n , the set of nets. For eachelement e corresponding to vertex v e ∈ V e , if net n is incident on e , then the net vertex v n ∈ V n is connected to v e by an edge in E . There are no edges between two elements in V e , or two netsin V n , and therefore the graph is bipartite. Edges to multiterminal elements are labeled to indicate which terminal connects to a netvertex, e.g., each edge from a transistor node is assigned a three-bit label ( l д l s l d ) marking a gate, source, or drain connection. Wetraverse this graph to hierarchically identify structural symmetries.Initially, the graph is preprocessed using a traversal to identifythe lowest level of building blocks, similar to library building blocksin [6] or primitives in [7]. Primitives are composed from a few ele-ments that form the basic building blocks of an analog circuit, andare specified by the user in a library. These are typically simplestructures, e.g., passives or collections of a small number of transis-tors such as differential pairs, current mirrors, cascoded structures,or level shifters. For example, in the circuit in Fig. 2, four currentmirrors – a current mirror bank (CMB1) and three single currentmirrors (SCM2–SCM4), and a differential pair (DP) are mapped tolibrary primitives. The elements in a primitive are collapsed intosupernode vertices with labeled ports (net vertices) so that likeports of like vertices can be recognized for symmetry. For example,in a DP, the two transistor drain nodes are marked as symmetricand the source node is labeled so that it can be used in higher-levelsymmetry detection. Such primitive-level symmetry constraintsare passed to the next level of hierarchy. Figure 2: An OTA circuit used to illustrate our approach.
We propose a bottom-up approach that hierarchically detects sym-metry constraints. At each level of hierarchy, symmetrical net in-formation is passed to higher levels using ports whose informationis used to identify matching at those levels.After primitive blocks are identified using graph-based tech-niques [6, 7] and primitive-level symmetries are identified, a searchbegins from all potentially symmetric pairs of node vertices ( s , s ) ,e.g., transistor drain nodes in a DP, or corresponding nodes of anSCM and CMB. For primitives CMB1 and SCM2 in Fig. 2, out1could match with out2, and net4 could match with {net3, net7,net9}. Therefore, the candidate choices for ( s , s ) are: (out1, out2),(net3, net4), (net7, net4) and (net9, net4). Similarly, DP1 leads to thecandidate (out1,out2), also identified by CMB1/SCM2.The overall algorithm for graph-based symmetry detection op-erates recursively and is described in Algorithm 1. It is initiallyinvoked with set ( s , s ) corresponding to all potential symmetry general approach for identifying hierarchical symmetry constraints for analog circuit layout ICCAD ’20, November 2–5, 2020, Virtual Event, USA Algorithm 1
Hierarchical symmetry detection algorithm Function
FindSymmetricPairs ( G , ( s , s ), P )2: Input : simplified circuit graph ( G ), start points ( s , s )3: Output : list of match pairs ( P )4: N = Neighbors( s ) ; N = Neighbors( s )5: if N == N == NULL then // End of recursion Return end if
8: group_of_pairs = MatchPair( N , N )9: if length(group_of_pairs) == then // Single axis of symmetry
10: pairs = group_of_pairs[0]11: for ( p , p ) ∈ pairs do P . add ( p , p ) if p == p then // Self-symmetric nodes; New axis of symmetry
14: FindSymmetricPairs( G , ( p , p ) , P . copy () )15: else // Symmetric node pairs
16: FindSymmetricPairs( G , ( p , p ) , P )17: end if end for else if length(group_of_pairs) > then // Multiple possible axes of symmetry
20: valid_groups = NULL21: for pairs ∈ group_of_pairs do for ( p , p ) ∈ pairs do P new = ( p , p )
24: FindSymmetricPairs ( G , ( p , p ) , P new ) if P new then valid_groups.add ( P new ) end if end for end for if length(valid_groups) == then P . add (valid_groups[0])31: FindSymmetricPairs( G , valid_groups[0], P )32: else if length(valid_groups) > then // Multiple parallel symmetrical paths A = CreateArray( G , s )34: A = CreateArray( G , s )35: P . add ( A , A )
36: FindSymmetricPairs( G , ( A , A ) , P )37: else P = NULL39: end if else P = NULL42: end if points from the primitive set. All vertices in the graph are marked asunexplored, except for supply and ground; the algorithm continuestraversing the circuit graph and terminates when no unexplorednode can be reached. The algorithm proceeds as follows: Neighbor list
For each pair of candidate points ( s , s ) providedas an input to the algorithm, we invoke Neighbors( N ), which re-turns the unvisited neighbors of node N (line 4). For transistors,these neighbors correspond to source/drain-connected vertices. Forexample, in Fig. 2, starting from the ports of DP1 (and so DP1 ismarked as visited), for ( s , s ) = (out1, out2), the neighbor setsare N = {R1, C1, D1, D2, CMB1/out1} and N = {R2, C2, D3, D4,SCM2/out2}. (Note that for CMB1 and SCM2, we annotate the nodevertices with the matching port.) End case detection
A recursive search is then carried out fromthe above list of neighbors, with the end case occurring when s and s have no unexplored neighbors, (line 5). Finding groups of pairs
Next, MatchPair detects matches be-tween the vertices of N and N , returning “group_of_pairs,” a setof all matching vertex pairs. For example, in Fig. 2, starting fromDP1, for ( s , s ) = (out1, out2),group_of_pairs = {(D1, D3), (D1, D4), (D2, D3), (D2, D4),(R1, R2), (C1, C2), (CMB1/out1, SCM2/out2)}Thus, from the cross-product of N and N , this list eliminates pairs that do not match, e.g., (R1,C1). When FindSymmetricPairs is re-cursively called, it traverses unvisited neighbors of these elements,e.g., when ( s , s ) = (CMB1/out1, SCM2/out2), there are furtherrecursive calls to match (net3, net4), (net7, net4), and (net9, net4).The MatchPair function can detect two types of matches: • An exact match , e.g., a two-terminal element such as a resistor,represented by N A , matches a resistor of identical value, repre-sented by N B . For a multiterminal element such as transistors, edgelabels are also considered in pronouncing a match. • An approximate match , i.e., nonidentical structures to be matched.In Section 3, we show how a neural network is used to find thegraph edit distance (GED) to predict matches. If the GED is zero,the match is exact, and if it is small, the match is approximate. Processing matches
Lines 9 – 18 consider the case where a singlepair ( p , p ) is detected. This means there is a single axis of symme-try for the pair. If p and p are identical, there is a self-symmetrythat begins a new axis of symmetry. Otherwise we have a sym-metric node pair that continues the previous axis; any matchingconstraints propagated from inside the block are added to P .For example, starting from CMB1 and SCM2, searching from cor-responding ports ( s , s ) = (net3, net4), a unique pair (SCM3/out1,SCM3/out2) is found. Since these ports are symmetric, p = p , andthe new axis of symmetry lies at the center of SCM3. In the nextrecursive call, since the only unvisited neighbor of SCM3 is ground,the symmetric axis involving DP1, CMB1, SCM2, SCM3 is complete.Lines 19 – 39 consider cases where more than one pair is matched:this may lead to > P ; else, the multiplematches correspond to an array of matching elements, rooted at s and s . Each array is recognized as a hierarchical block, andthe matched arrays are added to P . Array generation is performedby CreateArray( G , s ) (lines 33–34) by collecting a set of repeatedstructures connected to a node s of a graph G . For the matches for ( s , s ) = (out1, out2) listed above, D1 and D2 each match with D3and D4; therefore, D1+D2 are grouped into array Dummy1, andD3+D4 into Dummy2. Matching constraints are created between(Dummy1, Dummy2), (R1, R2), (C1, C2)(CMB1/out1, SCM2/out2)A key contribution of this algorithm is its ability to build sym-metry hierarchies, as shown in the case with (Dummy1, Dummy2)above. It could be argued that this simple illustrative case could besolved by defining a group of two dummy transistors as a primitive;however, the algorithm is general enough to handle more complexscenarios that other existing approaches cannot process. As an ex-ample, consider the FIR equalizer in Fig. 1 with multiple symmetriesand array structures, as described in Section 1. If ( s , s ) = ( o , o ) ,the two nodes from the differential output, MatchPair would firstdetect the multiple matches corresponding to the DP. This wouldthen be extended to a larger structure in valid_groups by also in-cluding the current source and XOR, where the current source isconsidered a match based on the approximate matching scheme tobe described in Section 3. This combined structure, (DP + currentsource + XOR), is assembled into an array. CCAD ’20, November 2–5, 2020, Virtual Event, USA K. Kunal, J. Poojary, T. Dhar, M. Madhusudan, R. Harjani, and S. S. Sapatnekar
Finally, Line 41 discards P if no match is found, and the searchfrom ( s , s ) terminates. Fig. 1 had shown an example of the need for approximate matching,with a different numbers of bits being used in different taps of anequalizer: despite difference in the topology of the tap control bits,the circuit requires matching between taps for optimal performance.Fig. 3 illustrates another example that shows the matching require-ment between a common-gate low-noise amplifier (CG-LNA) anda common-source LNA (CS-LNA) in a noise cancellation LNA. Thetwo sides have a small difference in topology: the transistor sourceis connected to the capacitor terminal at left, but to ground at right.These examples show that matching requirements are morecomplex than the simpler test cases typically handled in academicpapers, and that matching is frequently required between partsthat are similar but not identical. In fact, production analog designsuse multiple techniques such as asymmetric dummy transistors inperformance-critical parts [12], noise cancellation circuits [13, 14],trim bits to handle noise and testing [15, 16], and different devicesizes for handling multiple bands in phased array systems [17].This implies that the MatchPair function that detects symme-tries must allow for minor changes in circuit topology. This is theinexact graph matching problem, and we map this to the GraphEdit Distance (GED) problem. The GED a measure of similaritybetween two graphs G and G : given a set of graph edit operations(insertion, deletion, vertex/edge relabeling), the GED is a metric ofthe number of edit operations required to translate G to G .Let graphs G and G represent, respectively, the CS-LNA andthe CG-LNA, as shown in Fig. 3, with element vertices at left andnet vertices at right. To transform G to G , four edits are needed(i.e., GED = 4): (1) Deletion of two edges in G : (capacitor element,ground net) and (transistor element (source label), V I N net), and(2) Addition of two edges in G : (capacitor element, V I N net) and(transistor element (source label), ground net).We calculate the similarity between two subblocks by comparinggraph embedding of the two graphs. If the similarity is within abound, the MatchPair function in Algorithm 1 returns a match.
The GED problem is NP-hard [18], implying that an exact solutionis computationally expensive. This work uses a neural network thattransforms the original NP-hard problem to a learning problem [19]for computing graph similarity.The method works in four steps: first, each node in the graphis converted to a node-level embedding vector; next, these em-bedding vectors are used to create a graph-level embedding ofdimension d . The lower half of Fig. 3 illustrates these two stepsfor the graphs for the CG-LNA and CS-LNA. For each subblock inthe circuit, these steps need to be carried out once, and the graphembeddings are stored for matching any two pairs of subblocksin later stages. The computational complexity of these two stepsis linear in the number of nodes in the graph. The last two stepsare shown in Fig. 4. In the third step, the graph-level embeddingsfrom the second step for two candidate graphs are fed to a trained Figure 3: Example showing graph embedding for commongate low noise amplifier (CG LNA) and common source LNA(CS LNA) in noise cancellation LNA.Figure 4: GED prediction based on graph embeddings [19]. neural tensor network that generates a similarity matrix betweenthe graphs. The fourth step then processes this matrix using a fullyconnected neural network to yield a single score. This matchingmethod for two subblocks uses the previously stored graph em-beddings instead of the full subblock graphs. The complexity ofthese two steps is quadratic in d , where d is bounded by a smallconstant in practice, the procedure is computationally inexpensiveas compared to an exact GED computational complexity which isexponential in the number of nodes of the graphs involved. Node embedding stage:
This stage transforms each node of agraph into a vector, encoding d node features and neighborhoodinformation in a manner that is representation-invariant. We useneighbor feature aggregation based on a three-layer graph convo-lutional network (GCN) [20] to obtain the node embedding. Theoutput X l + ∈ R N × d in layer l + l as: X l + = ReLU ( ˆ D − / ˆ A ˆ D − / X l W l ) (1)where ReLU ( x ) = max ( , x ) is the activation function, ˆ A = A + I N ∈ R N × N is the adjacency matrix of an undirected graph with addedconnections for each vertex to itself, ˆ D ∈ R N × N is the diagonalmatrix of ˆ A , and W l ∈ R d l × d l + are trainable weights for layer l .The GCN output, X , is the node embedding matrix, X . The n th row of X , X Tn ∈ R d , is the embedding of node n . Graph embedding stage:
For each graph to be compared, we nowproduce an embedding using the attention-based aggregation ofnode embeddings generated in the previous stage. general approach for identifying hierarchical symmetry constraints for analog circuit layout ICCAD ’20, November 2–5, 2020, Virtual Event, USA
We first compute a global context, c T ∈ R d , for the graph, com-puted as weighted sum of node mbedding vector averages, followedby a nonlinear transformation, using trainable weights W ∈ R d × d : c = tanh (cid:34) (cid:205) Nm = X m N W (cid:35) (2)Here, N is the number of nodes in the graph. Next, we use an atten-tion mechanism to allow the model weights to focus on importantparts of circuit, guided by the GED similarity metric. We empir-ically observe that nodes with high degree, and nodes formingspecial structures such as loops, get higher attention weights: thisis because high-degree nodes receive contributions from a largernumber of neighbors. The graph embedding h ∈ R d is given by: h = (cid:205) Nn = σ ( X n c T ) X n (3)where σ ( x ) = /( + exp (− x )) is the sigmoid function. Neural Tensor Network stage:
Next, the relationship betweentwo graph embeddings, h i , h j ∈ R d , is measured using NeuralTensor Networks (NTNs) [21] as: д ( h i , h j ) = ReLU ( h Ti W [ K ] h j + V [ h i h j ] T + b ) (4)where K is a hyperparameter related to number of slices in thetensor, which controls the number of similarity scores producedby the model, W [ K ] ∈ R d × d × K is a weight tensor, V ∈ R K × d is aweight vector, and b ∈ R K is a bias vector. Graph similarity score computation stage:
The final step re-duces the similarity scores in previous stage using a two-layerfully-connected neural network to provide a predicted similarityscore PS . To train this network, the final score is compared againstthe ground truth GED score GS using the mean square error loss: L = | S | (cid:205) ( i , j )∈ S ( PS ij − GS ij ) (5)where S is the set of training graph pairs. We have trained our network on 79 pairs of analog designs, whereeach pair has a small difference in topologies. Examples in ourtraining set include single-ended vs. differential OTAs, multiplecommon-gate vs. common-source LNAs, OTAs with dummies, andarrays of current mirrors of different sizes. For each pair, the groundtruth GED was computed using the algorithm in [22], and a simi-larity metric between graphs G and G was defined as:dist ( G , G ) = GED ( G , G )(| G v | + | G e | + | G v | + | G e |) (6)where | G iv | ( | G ie | ) is the number of vertices (edges) in G i . Thedenominator normalizes the GED to the size of the graph. Next,recognizing that the GED score is more qualitative than quantitative(i.e., accuracy of multiple decimal places does not matter), we dividethese distance scores into bins that define the level of similarity, asillustrated in Fig. 5. This score is used in Eq. (5) both for trainingand inference, to quantify the match between candidate pairs.For a train:test ration of 51:28 among the 79 pairs, Fig. 7 showsthe computation time for calculating correct GED: it can be seen toincrease exponentially with the graph size. Figure 5: Distribution of the results of training into bins toobtain the similarity score used in Eq. (5) .Figure 6: Results on training the network.Figure 7: Computational cost of the GED algorithm in [22].
We have experimented with several options in training withregard to the use of edge labels: recall that edge labels are used forvertices in the graph that represent multiterminal elements. Thesimplest version ignored the edge labels and performed matchingwithout labels, while a more complex version required us to mod-ify the graph embeddings at the GCN stage to enable the use ofedge labels. We verified during training our model that the use ofedge labels is important for improved accuracy as it provides moreinformation about the presence of a drain/gate/source connectionto a transistor.Fig. 7 illustrates the reduction of the loss metric in successiveepochs during training. For both training and test phases, a steadyreduction in loss is noted. Fig. 8 compares the GED predicted by ourapproach with the slower GED calculation from [22], and shows agood match. The relatively small, but noticeable, magnitude of thedifference is reflective of the fact that shows that many elements ofthe training set do not exercise a topology difference that involvesa multiterminal element with labels.
CCAD ’20, November 2–5, 2020, Virtual Event, USA K. Kunal, J. Poojary, T. Dhar, M. Madhusudan, R. Harjani, and S. S. Sapatnekar
Figure 8: Comparison of GED prediction using our approachand [22] on a set of pairs of circuit graphs.
Our optimized model is a three-layer GCN with 128 input chan-nels (the number of channels is halved in each layer), with 8 slicesin the NTN, and a fully connected network with one hidden layerafter the NTN. The trained net uses d = , d = , d = d = Figure 9: (top) Schematic of an R2R DAC with an R2R ladderrecognized using our algorithm. (bottom) R2R DAC layout.
We first present results on three designs that exercise hierarchicalsymmetries: the OTA of Fig. 2, an R-2R DAC shown in Fig. 9(top),and the FIR equalizer of Fig. 1. The characteristics of the graphsof these circuits are summarized in Table 1. These circuits containsufficient complexity to exercise our method and demonstrate itsvalidity and effectiveness. Our symmetry detection algorithm isintegrated into the public-domain open-source analog layout tool,ALIGN [4], to generate layouts for these circuits. For clarity andto demonstrate the ability of our approach to identify symmetries,only the placement is shown, without routing.
R-2R DAC (Fig. 9(top)) : The main source of nonlinearity is mis-match between the array resistors. The area of the resistors in thiscircuit is significant as compared to the CMOS devices, and the
Table 1: Statistics of the graphs for three test designs
Method b − b and ¯ b − ¯ b are part of a digi-tal block, and may be placed outside the resistor array. The resultof the ALIGN-generated layout using our constraint generationmethodology is shown in Fig. 9(bottom). Figure 10: Layout of the OTA in Fig. 2.OTA circuit (Fig. 2) : Our algorithm detects the symmetrical axisof the circuit, and the layout about the symmetric line is shownin Fig. 10. The dummy blocks, Dummy1 and Dummy2, that weredetected (as described in Section 2.2) must be placed symmetricallywith respect to the differential pair (DP1). Similarly, resistors R1 andR2 share the same symmetry axis with DP1, as do capacitors C1 andC2, the current mirrors SCM3 and SCM4. Transistors P1 and P2 aresymmetric, and the transistors in CMB1 are in common-centroid.
FIR Equalizer (Fig. 1) : This circuit has ten taps for equalization,each containing an differential pair, a current mirror DAC, and CMLXOR gate. All blocks in each tap share a common symmetry axisfor matching. The first four taps use a 7-bit current mirror DAC,and the remaining taps have 5-bit current mirror DAC. To achievebetter matching, the first four taps are placed in the center and theremaining taps are placed around these four, sharing a commonsymmetry axis. The layout of equalizer, shown in Fig. 11, meets allthese requirements. This design demonstrates the detection anduse of multiple lines of symmetry in a hierarchical way withinprimitives, within each tap, and globally at the block level. general approach for identifying hierarchical symmetry constraints for analog circuit layout ICCAD ’20, November 2–5, 2020, Virtual Event, USA
Figure 11: Layout of the FIR equalizer of Fig. 1.Figure 12: Prediction accuracy of our algorithm, compared with manual verification.
The algorithm presented in this paper has been tested on a widerange of over a variety of circuits, including OTAs, buffers compara-tors, VCOs, analog-to-digital and digital-to-analog converters, andfilters. The circuits are preprocessed to remove dummy transistorsfor which all terminals are connected to supply/ground lines.Beyond the three circuits discussed earlier, we were able to ver-ify the correctness of the constraints through manual inspectionon 36 circuits. The results of this verification, showing true/falsepositives and true/false negatives, are summarized in Fig. 12. Foreach hierarchical instance (e.g., device, passive, detected array) inthe circuit, a true positive implies that the instance has a symmetryconstraint that is correctly identified; a negative implies no sym-metry constraint. Symmetrical instances must be connected usingsymmetrical nets. For the circuit names highlighted on the x-axis,our algorithm created a new hierarchy for arrays in these designsby grouping like elements. For the smallest circuits, it can be seenthat no symmetries are identified. From C5 onwards, most circuitshave some symmetry constraints (with the exception of C28, a DC-DC converter, and C32, an inverter-based VCO); a few circuits (C13,a fully differential telescopic OTA, and C23, a switched-capacitorfilter) have symmetry constraints involving most/all devices. Mostof the constraints detected by our algorithm are true positives ortrue negatives. No false negatives were detected.Four circuits have false positives, related to (a) level-shifter struc-tures connected to the output stages of amplifiers, and (b) dummy structures. The former is not harmful because it is connected sym-metric current mirror units, and therefore it is logical to place thesesymmetrically even though matching is not required. The latter is anonintuitive use of a dummy structure: since dummies are used forcorrections subsequent to first silicon, it is recommended that anysymmetries involving them should be annotated by the designer.
This paper has proposed an approach to handle multiple levelsof symmetry hierarchies, including nested hierarchies, in analogcircuits. The core algorithm is based on graph traversal through thenetwork graph, and includes both exact graph-based matching anda novel machine learning based approximate matching techniqueusing a GCN and a neural tensor network based GNN. We validateour results on a variety of designs, demonstrating the detection ofmultiple lines of symmetry, hierarchical symmetries, and common-centroid structure detection. We show how these guidelines aretransferred for implementation to a layout generation tool thatprovides high layout quality.
ACKNOWLEDGMENTS
This work was supported in part by DARPA IDEA program underSPAWAR contract N660011824048.
CCAD ’20, November 2–5, 2020, Virtual Event, USA K. Kunal, J. Poojary, T. Dhar, M. Madhusudan, R. Harjani, and S. S. Sapatnekar
REFERENCES [1] M. J. M. Pelgrom, et al. , “Matching properties of MOS transistors,”
IEEE J. Solid-St.Circ. , vol. 24, no. 5, pp. 1433–1439, 1989.[2] R. Naiknaware and T. S. Fiez, “Automated hierarchical CMOS analog circuit stackgeneration with intramodule connectivity and matching considerations,”
IEEE J.Solid-St. Circ. , vol. 34, no. 3, pp. 304–317, 1999.[3] J. Scheible and J. Lienig, “Automation of analog IC layout: Challenges and solu-tions,” in
Proc. ISPD , pp. 33–40, 2015.[4] K. Kunal, et al. , “ALIGN: Open-source analog layout automation from the groundup,” in
Proc. DAC , pp. 1–4, 2019.[5] E. Malavasi, et al. , “Automation of IC layout with analog constraints,”
IEEE T.Comput. Aid D. , vol. 15, no. 8, pp. 923–942, 1996.[6] M. Eick, et al. , “Automatic generation of hierarchical placement rules for analogintegrated circuits,” in
Proc. ISPD , pp. 47–54, 2010.[7] K. Kunal, et al. , “GANA: Graph convolutional network based automated netlistannotation for analog circuits,”
Proc. DATE , 2020.[8] M. Liu, et al. , “S3DET: Detecting system symmetry constraints for analog circuitswith graph similarity,” in
Proc. ASP-DAC , pp. 193–198, 2020.[9] K.-L. J. Wong and C.-K. K. Yang, “A serial-link transceiver with transition equal-ization,” in
Proc. ISSCC , pp. 223–232, 2006.[10] “ALIGN: Automatic circuit annotation.” https://github.com/ALIGN-analoglayout/hierarchical-symmetry.[11] M. Ohlrich, et al. , “SubGemini: Identifying subcircuits using a fast subgraphalgorithm,” in
Proc. DAC , pp. 31–37, 1993. [12] C. Lin, et al. , “Mismatch-aware common-centroid placement for arbitrary-ratiocapacitor arrays considering dummy capacitors,”
IEEE T. Comput. Aid D. , vol. 31,no. 12, pp. 1789–1802, 2012.[13] S. Chehrazi, et al. , “A 6.5 GHz wideband CMOS low noise amplifier for multi-banduse,” in
Proc. CICC , pp. 801–804, 2005.[14] F. Bruccoleri, et al. , “Wide-band CMOS low-noise amplifier exploiting thermalnoise canceling,”
IEEE J. Solid-St. Circ. , vol. 39, no. 2, pp. 275–282, 2004.[15] C. Moreland, et al. , “A 14-bit 100-Msample/s subranging ADC,”
IEEE J. Solid-St.Circ. , vol. 35, no. 12, pp. 1791–1798, 2000.[16] L. R. Carley, “Trimming analog circuits using floating-gate analog MOS memory,”
IEEE J. Solid-St. Circ. , vol. 24, no. 6, pp. 1569–1575, 1989.[17] D. Ehyaie,
Novel Approaches to the Design of Phased Array Antennas . PhD thesis,University of Michigan, Ann Arbor, MI, 2011.[18] Z. Zeng, et al. , “Comparing stars: On approximating graph edit distance,”
Proc.VLDB Endow. , vol. 2, pp. 25–36, Aug. 2009.[19] Y. Bai, et al. , “SimGNN: A neural network approach to fast graph similaritycomputation,” in
Proc. WSDM , pp. 384–392, 2019.[20] T. Kipf, “Semi-supervised classification with graph convolutional networks,” in
Proc. ICLR , 2017.[21] R. Socher, et al. , “Reasoning with neural tensor networks for knowledge basecompletion,” in
Proc. NeurIPS , pp. 926–934, 2013.[22] Z. Abu-Aisheh, et al. , “An exact graph edit distance algorithm for solving patternrecognition problems,” in