View
233
Download
0
Category
Preview:
Citation preview
Logic Synthesis
• Minimization of Boolean logic– Technology-independent mapping
• Objective: minimize # of implicants, # of literals, etc.
• Not directly related to precise technology (# transistors), but correlated – consistent with objectives for any technology
– Technology-dependent mapping• Linked to precise technology/library
• Technology-independent mapping– Two-level minimization – sum of products (SOP)/product of sums (POS)
• Karnaugh maps – “visual” technique
• Quine-McCluskey method – algorithmic
• Heuristic minimization – fast and “pretty good,” but not exact
– Multi-level minimization
Basic Definitions
• Specification of a function f– On-set fon: set of input combinations for which f evaluates to 1
– Off-set foff: set of input combinations for which f evaluates to 0
– Don’t care set fdc: set of input combinations over which function is unspecified
• Cubes– Can represent a function of k variables over a k-dimensional space
– Example: f(x1,x2,x3) = m(0,3,5,6) + d(7)
fon = {0,3,5,6}; fdc = {7}; foff = {1,2,4}
– Graphically:
x1
x2
x3
000
110
100
001
101111
011
010
k-cubes
• k-cube: k-dim. subset of fon
– 0-cube = vertex in fon
– k-cube = a pair of (k-1) cubes with a Hamming distance of 1
• Examples– A 0-cube is a vertex
– A 1-cube is an edge
– A 2-cube is a face
– A 3-cube is a 3D cube
– A 4-cube is harder to visualize but can be shown as
More defintions
• Implicant– A k-cube whose vertices all lie in the fon fdc and contains at least one
element of fon
• Prime implicant– A k-cube implicant such that no k+1-cube containing this cube is an
implicant
• Cover– A set of implicants whose union contains all elements of fon and no
elements of foff (may contain some elements of fdc)
• Minimum cover– A cover of minimum cost (e.g., cardinality)– A min cardinality cover composed only of prime implicants exists (if not,
can combine some implicants into larger prime implicants)
Quine-McCluskey Method
• Illustration by example:f(x1,x2,x3,x4) = m(0,5,7,8,9,10,11,14,15)
0-cubes 1-cubes 2-cubes0 (0000) x 0,8 (-000) A 8,9,10,11 (10--) D5 (0101) x 5,7 (01-1) B 10,11,14,15 (1-1-) E7 (0111) x 7,15 (-111) C8 (1000) x 8,9 (100-) x9 (1001) x 8,10 (10-0) x10 (1010) x 9,11 (10-1) x11 (1011) x 10,11 (101-) x14 (1110) x 10,14 (1-10) x15 (1111) x 11,15 (1-11) x
14,15 (111-) x• “x” implies that the cube has been combined into a larger cube
Prime implicants
Prime implicant table
• Essential Prime Implicant (PIs): – The only PI that covers a minterm (encircled in the table)– Must be included in any cover– Here, essential PIs = A,B,D,E – form a cover!– WARNING: this was luck – in general, essential PIs will not form a cover!
PI’s A
(0,8)
B
(5,7)
C
(7,15)
D
(8,9,10,11)
E
(10,11,14,15)minterms
0 x
5 x
7 x x
8 x x
9 x
10 x x
11 x x
14 x
15 x x
Reducing the prime implicant table
• PI table reduction– In general, essential PIs will not form a cover
– Reduce table by removing essential PIs, corresponding minterms
• Further reduction: can removeDominating rows Dominated columns
Row m1 dominates row m2 Column J dominates column K
PI’s P Q R Sminterms
m1 x x x
m2 x x
m3 x x
m4 x x
PI’s J K L Mminterms
m1’ x x
m2’ x x
m3’ x x x
m4’ x x
Branch-and-bound algorithm
• May still not have a cover– Example: example from
previous slide after removing dominating row m1 and consequently empty column P
• Can enumerate possibilities using a search tree– Binary search tree: include or
exclude PI
PI’s Q R Sminterms
m2 x x
m3 x x
m4 x x
Q
R
excludeinclude
DoneCover = {R,S}
PI’s R Sminterms
m4 x x
include excludeReduced PI table
DoneCover = {Q,S}
DoneCover = {Q,R}
Branch-and-bound algorithm (contd.)
• ESPRESSO-EXACT– Implementation of branching algorithm from previous slide
– Traversal to a leaf node of the tree yields a cover (though possibly not a minimum cost cover)
– ESPRESSO-EXACT adds bounding at any node: • If Costnode + LBsubtree > Best_cost_so_far, do not search the subtree
– Costnode = cost (e.g., number of implicants) chosen so far
– LBsubtree = a lower bound on the cost of a subtree (can be determined by solving a maximal independent set problem)
– Best_cost_so_far = cost of best cover found so far through the traversal of the search tree; initialized to
Heuristic Logic Minimization
• Apply a sequence of logic transformations to reduce a cost function
• Transformations– Expand:
• Input expansion
– Enlarge cube by combining smaller cubes
– Reduces total number of cubes
• Output expansion
– Use cube for one output to cover another
– Reduce: break up cube into sub-cubes • Increases total number of cubes
• Hope to allow overall cost reduction in a later expand operation
– Irredundant• Remove redundant cubes from a cover
Example
• Expand: input expansion
Examples from G. Hachtel and F. Somenzi, “Logic Synthesis and Verification Algorithms,” Kluwer Academic Publishers, Boston, MA, 1996.
x
yz
Off-set memberOn-set member
xyz f000 101- 1-11 1
xyz f0-0 101- 1-11 1
xyz f0-0 1-11 1
Redundant!
Example
• Expand: output expansion– Two output functions of three variables each with initial covers
shown below
Examples from G. Hachtel and F. Somenzi, “Logic Synthesis and Verification Algorithms,” Kluwer Academic Publishers, Boston, MA, 1996.
x
yz
f1 f2
x
yz
f1 f2xyz F1F2
0-1 101-0 1000- 01-00 01-11 01
xyz F1F2
0-1 111-0 1000- 01-00 01-11 01
Other operators
• Reduce
• Irredundant
Reduce
FutureExpand
operation
Irredundant
Identified as redundant; removed
Example of an application of operators
Example from S. Devadas, A. Ghosh and K. Keutzer, “Logic Synthesis,” McGraw-Hill, New York, NY, 1994.
--11 11
1001 01
1101 10
-001 10
-1-0 01
1010 01
0110 10
-010 10
-100 10
1000 10
reduce -011 10
--11 11
1001 01
1101 10
-001 10
-1-0 01
1010 01
0110 10
0010 10
1010 10
-100 10
1000 10
reduce
--11 11
1001 01
1101 10
-0-1 10
-1-0 01
1010 01
0-10 10
-100 10
10-0 10
expand
expand
expand
(10 cubes)(12 cubes)
(9 cubes)
Example of a minimization loop
F = Expand(F, D)
F = Irredundant(F,D)
do {
Cost = |F|
F = Reduce(F,D)
F = Expand(F,D)
F = Irredundant(F,d)
} while (|F| < Cost)
F= Make_sparse(F,D)
• Make_sparse reduces output parts of a cube (e.g., from 11 to 10) to remove redundant connections)
• Example:
xyz F1F2
11- 10-01 101-1 110-0 01
xyz F1F2
11- 10-01 101-1 010-0 01
Implementation of operators
• Uses “unate recursive paradigm”• Definition: Shannon expansion
– F(x1,x2, …, xi, …, xn)
= xi F(x1,x2, …, xi, …, xn) + xi’ F(x1,x2, …, xi, …, xn)
= xi Fxi + xi’ Fxi’ (notationally)
• Unate function– Positive unate in variable xi: Fxi Fxi’ F = xi Fxi + Fxi’
– Negative unate in variable xi: Fxi Fxi’ F = Fxi + xi’ Fxi’
– Unate function: positive unate or negative unate in each variable
• Unate recursive paradigm– Recursively perform Shannon expansions about the variables until a unate
function is obtained– Why unate functions? Various operations (tautology checking,
complementation, etc. are “easy” for unate functions)
Unateness
• Example– Unate cover (not minimum)
• Every column has only 1’s and –’s, or only 0’s and –’s
– Nonunate cover: nonunate in y and z (both 1 and 0 appear in the columns)
w x y z
0 – 1 –
– – 1 –
0 – – 1
w x y z
1 – 1 –
– – 0 1
– 1 1 0
Note on notation:The table at leftrepresents the on set
Unate recursive paradigm
a b c d e
1 – 1 – 0
– – 0 1 –
– 1 1 0 1
1 – 1 0 1
Expand aboutbinate variable
Fc Fc’
a b c d e
– – – 1 –
a b c d e
1 – – – 0
– 1 – 0 1
1 – – 0 1 (Unate function)Fe Fe’
a b c d e
– 1 – 0 –
1 – – 0 –
a b c d e
1 – 1 – –
(Unate function)(Unate function)
Example: Unate complementation
• (Example to show that unate operations are “easy”)x y z
1 0 –
1 1 0
0 – 1
x y z
– – 1
x y z
– 0 –
– 1 0
x x’
x y z
– – 0
x y z
– – –
y’y
Complement x y z
– – 1
ComplementEmpty set!
ComplementComplement
Complement
x y z
– – 0x y z
– 1 1
x y z
1 1 1
0 – 0
Basic result:
If F = x Fx + x’ Fx’ then
F’ = x (Fx)’+ x’ (Fx’)’
Proof: Let G = x (Fx)’+ x’ (Fx’)’
Show that F+G = 1 and F.G = 0
Cofactors with respect to sets of cubes
• Can generalize the Shannon expansion to
F = c Fc + c’ Fc’
where c is an set of cubes• Result: c F Fc is a
tautology• Example of finding a cofactor
with respect to a cube:– Cofactor of F =
with respect to c = [1 1 – – ]
• Fc contains elements of Fon that agree with c at all non-don’t care positions (in this example, in variables p and q)
• If so: replace non-don’t cares by “–” and copy the rest of the cube
• Following this prescription, Fc is
p q r s
1 1 0 –
0 1 – 0
1 1 1 1
p q r s
– – 0 –
– – 1 1
Checking for Tautology
• Checking for tautology:1. F is a tautology Fxj is a tautology and Fxj’ is a tautology
2. Let C be a unate cover of F. Then “F is a tautology” “C has a row of all “-’s
• Example p q r s
– – 1 –
1 – – 1
– 0 – 0
– – 0 –
Binate variable
r r’p q r s
– – – –
1 – – 1
– 0 – 0
p q r s
1 – – 1
– 0 – 0
– – – – Tautology!
Tautology!
Since all leaf nodes are tautologies, the function is a tautology
The Expand Operator and Tautology
• Consider the function f with a cover G and fdc specified in the table– Objective: to expand 000 | 1 to 0 – 0 | 1
– Need to check if the expansion is valid, i.e., it does
not overlap with foff
– Define ci = 0 0 0 | 1
– di = difference between ci and 0 – 0 | 1 = 0 1 0 | 1 here
– Need to know if di Q = (G \ ci) fdc : if so, can expand
– In other words, check if Qdi is a tautology
– Qdi can easily be verified here to be – – –| 1 here, which is a tautology
x y z f
0 0 0 1
0 1 – 1
– 1 1 1
1 0 0 –
The Irredundant Operator and Tautology
• Objective: to check if a cube ci in a cover G of function F is redundant– In other words, check if ci Q = (G \ ci) Fdc
– In other words, check if Qci is a tautology
Multilevel logic optimization
• Motivation– Two-level optimization (SOP, POS) is too limiting
– Useful for structures like PLA’s, but most circuits are not designed in that way
– May require gates with a large number of inputs
– Restricts “sharing” of logic gates between outputs
– Multilevel optimization permits more than two levels of gates between the inputs and the outputs
– Necessarily heuristic
Reference for this part: G. De Micheli, “Synthesis and Optimization of Digital Circuits,” McGraw-Hill, New York, NY, 1994.
Basic Transformations
• Eliminationr = p + a’; s = r + b’ s = p + a’ + b’
• Decompositionv = a’d + bd + cd + a’e j = a’ + b + c; v = j d + a’e
• Extractionp = ce+de; t = ac+ad+bc+bd+e k = c+d; p = ke; t = ka+kb+e
• Simplificationu = q’c+qc’+qc u = q+c
• Substitutiont = ka+kb+e; q = a+b t = kq+e
• (Others exist; these are the most common)
Transformations
• Apply the transformations heuristically
• Two methods:– Algorithmic: algorithm for each transformation type
– Rule-based: according to a set of rules injected into the system by a human designer
A typical synthesis script
• script.rugged in the SIS synthesis system from Berkeleysweep; eliminate –1simplify –m nocompeliminate –1
sweep; eliminate 5simplify –m nocompresub –a
fxresub –a; sweep
eliminate –1; sweepfull_simplify –m nocomp
Explanationsweep: eliminates single-input vertices(w = x; y = w+z becomes y = x+z)eliminate k: eliminate defined earlier;Eliminates vertices so that area estimateincreases by no more than k simplify –m nocomp: simplify defined earlierInvokes ESPRESSO to minimize withoutcomputing full off-set (“nocomp”)full_simplify –m nocomp: as above, butuses a larger don’t care setresub –a: algebraic substitute for vertex pairsfx: extracts double cube and single cubeexpressions
Algebraic model
• Also known as weak division• Manipulation according to rules of polynomial algebra• Support of a function
– Sup(f) = set of all variables v that occur as v or v’ in a minimal representation of f
– Sup(ab+c) = {a,b,c}; Sup(ab+a’b) = {b}– f is orthogonal to g (or f g) if Sup(f) Sup(g) =
• g is an algebraic (or weak) divisor of f when– f = g h + r, provided h and g h– g divides f evenly if r = – Example
• If f = ab+ac+d; g = b+c, then f = ag + d (here h = a, r = d)
– The quotient, loosely referred to as f/g, is the largest cube h such that f = gh + r
Computing the quotient f/g
• Given f = {set of cubes ci}, g = {set of cubes ai}• Define hi = {bj | ai bj f} for all cubes ai g
(all multipliers of a cube ai that produce elements in f)• f/g = i=1 to |g| hi
• Example– f = abc + abde + abh + bcd, or f = {abc,abde,abh,bcd}– g = c + de + h, or g = {c,de,h}– h1 = f/c = ab + bd, or {ab,bd}; h2 = f/de = ab, or {ab}; h3 = f/h = ab, or {ab}
– f/g = h1 h2 h3 = {ab}– (Confirmation: f = ab(c+de+h) + bcd = (f/g) g + r)
• Complexity of this method = |f|.|g|
Doing this more efficiently
• Encode ai g with integer codes with a unique bit position for each literal in sup(g)
– g = {c,de,h}; sup(g) = {c,d,e,h}; encoding = {1000,0110,0001}
• Encode ci f with the same encoding
– f = {abc,abde,abh,bcd}; encoding = {1000,0110,0001,1100}
• Sort {ai, cj} by their encodings to get
– 1100: bcd
– 1000: c, abc h1 = ab
– 0110: de, abde h2 = ab
– 0001: h, abh h3 = ab
– (Not the same hi’s, but the intersection is the same)
– Complexity = O(n log n) where n = |f| + |g|
Finding good divisors
• Now that we know how to divide – how do we find good divisors?
• Primary divisors– P(f) = {f/c | f is a cube}
– Example: f = abc + abde• f/a = bc + bde is a primary divisor
• f/ab = c + de is a primary divisor
– g is cube free if the only cube dividing g evenly (i.e., with remainder zero) is 1. Example: c+de
• Kernels– K(f) = set of primary divisors that are cube-free
– f/ab belongs to the set of kernels; f/a does not.
– Kernels are good candidates for divisors
Kernels and co-kernels
• For f = abc + abde, f/ab = c + de– c+de is a kernel
– ab is a co-kernel
• Co-kernel of a kernel is not unique– f = acd + bcd + ae + be
– f/a = f/b = cd+e Kernel = cd+e Co-kernels = {a,b}
– f/cd = f/e = a+b Kernel = a+b Co-kernels = {cd,e}
Finding all kernels
Kernel (f)
Find cf so that f/cf is cube-free and cf has the largest number of
literals
K = Kernel1(0,f/cf)
if (f is cube-free)
return(f K)
return(K)
Kernel1(j,g)
R = {g}
for (i = j+1; i n; i++)
if ( ith literal li has 0 or 1 terms)
continue
ce = cube that evenly divides g/li and
has the max number of literals
/* kernel already identified */
if (lk is not in ce for all k i)
R = R Kernel1(i,(g/li)/ce)
return(R)
Example
F = abc(d+e)(k+l) + agh + m
F/a = bc(d+e)(k+l) + gh
a
b c
F/ab = c(d+e)(k+l)
[Leads to kernels (d+e) and (k+l)]
F/ac = b(d+e)(k+l)
Triggers “if” condition that finds that thiskernel was found earlier and prunes the search tree here
Example: extraction and resubstitution
F1 = ab(c(d+e)+f+g)+h
F2 = ai(c(d+e)+f+j)+k
1. Generate kernels for F1, F2
2. Select K1 K(F1) and K2 K(F2) such that K1 K2 is not a cube
3. Set the new variable v to K1 K2
4. Rewrite Fi = v (Fi/v) + ri
For the example:
v1 = d+e
F1 = ab(cv1+f+g)+h; F2 = ai(cv1+f+j)+k
v2 = cv1+f
F1 = ab(v2+g)+h; F2 = ai(v2+j)+k
Generic factorization algorithm
Factor(F)
If (F has no factor) return(F);
D = Divisor(F);
(Q,R) = Divide(F,D); /* F = QD + R*/
return(Factor(Q),Factor(D),Factor(R));
• “Divisor” function identifies divisors, for example, based on a kernel-based algorithm
• “Divide” function may be algebraic (weak) division
Don’t care based optimization: an outline
• Two types of don’t cares considered here– Satisfiability don’t cares
– Observability don’t cares
– Others: SPFD’s (sets of pairs of functions to be differentiated)
• Satisfiability don’t cares (SDC’s)– Example: Consider
• Y1 = a’b’ Y2 = c’d’ Y3 = Y1’Y2’
• Since Y1 = a’b’ is enforced by one equation, the minterms of “Y1 (a’b’)” can be considered to be don’t cares
• In other words, Y1a’b’ + Y1(a+b) corresponds to a don’t care
• Similarly, “Y2 (c’d’)” is also a don’t care
Don’t care based optimization (contd.)
• Observability don’t cares (ODC’s)– For r = p+q, if p = 1, then q is an observability don’t care
– Similarly, can define ODC’s for AND operations, etc.
• Example of don’t care based optimization– y1 = xw, y2 = x’+y, f = y1+y2
– Cost = 1 AND + 2 OR’s + 1 NOT
– Minimize function for y1
– SDC(y1) = y2 (x’+y) = y2xy’+y2’x’+y2’y
– ODC(y1) = y2
w x y y2 y1
1 1 – – 1
– – – 1 –
– 1 0 1 –
– 0 – 0 –
– – 1 0 –y1 = w
ODC
SDC’s
y1 = w, y2 = x’+y, f = y1 + y2 y2 = x’+y, f = w + y2(eliminate)
(Cost: 2 OR’s + 1 NOT)
Acknowledgements
• Hardly anything in these notes is original, and they borrow heavily from sources such as– G. De Micheli, “Synthesis and Optimization of Digital Circuits,”
McGraw-Hill, New York, NY, 1994.– S. Devadas, A. Ghosh and K. Keutzer, “Logic Synthesis,” McGraw-Hill,
New York, NY, 1994– G. Hachtel and F. Somenzi, “Logic Synthesis and Verification
Algorithms,” Kluwer Academic Publishers, Boston, MA, 1996.– Notes from Prof. Brayton's synthesis class at UC Berkeley (http://www-
cad.eecs.berkeley.edu/~brayton/courses/219b/219b.html)– Notes from Prof. Devadas's CAD class at MIT
(http://glenfiddich.lcs.mit.edu/~devadas/6.373/lectures)– Possibly other sources that I may have omitted to acknowledge (my
apologies)
Recommended