CMU Fall VLSI CAD

Transcription

1 CMU Fll VLSI CAD [120 pts] Homework 2. Out Thu Sep 13, Due Thu Sep BDD ordering [10 pts] We sw tht vrible order is highly significnt for something s simple s multiplexor. How bout something like comprtor? A simple comprtor tkes two 2-bit unsigned binry numbers 10 nd b1b0 nd compres their mgnitude, nd sets the output z=1 just if 10 is less thn or equl to b1b0. Do this: Is there prticulrly good vrible ordering for this function? Show it--show the BDD. Is there prticulrly bd vrible ordering for this function? Show it--show the BDD. Drw gte-level netlist using ny AND, OR, NOT, EXOR gtes you wnt, to implement the simple comprtor from the previous problem. Apply Minto s ordering heuristic (nd where you need to brek ties or mke ny rbitrry ordering decicion--just tell us wht you did nd show the work). Show wht vrible ordering it produces. 2. ITE for Gtes [10 pts] Wht is the fewest number of clls you need to mke to ITE to implement b? In other words, you don t wnt to use ITE severl times to build AND, OR, nd NOT, to do b + b tht s too esy. You cn do it much more simply if you think bout it Drw the multiplexor-hrdwre picture of the ITE nd lbel clerly wht s going in nd out of ech ITE. 3. ITE Decomposition [10 pts] Using wht you know of Boolen lgebr, the definition of ITE, nd the properties of cofctors, show tht the ITE decomposition below (from clss) ctully works: ITE( ITE,, ) = x ITE( I x, T x, E x ) + x ITE( I x, T x, E x ) (EQ 1) 4. ITE Recursion [10 pts] Let f(x, y) = x y nd g(x, y) = x y (this is exclusive-nor). Assume we hve multi-rooted DAG for the BDDs representing these two functions (you need to drw them.) We wnt to EXOR these functions, nd compute new function Q(x, y) = (f g)(x,y). Using the ITE opertor s discussed in the notes, show how you would implement this EXOR opertion. As in the slides, show how the recursive computtion proceeds s ITE clls itself. At ech node of the recursive cll tree, tell wht ITE is computing (lbel the nodes in your BDD in some sensible wy) nd show clerly when ech recursive cll termintes. Drw the finl recursive cll tree. CMU Fll VLSI CAD September 14,

2 Drw the finl result, i.e., show the finl form of the multi-rooted DAG tht now represents functions f, g, nd Q. 5. Derived Opertors [20 pts] Suppose we hve softwre pckge tht hs dt structures representing vribles nd Boolen functions s BDDs, nd tht the following opertions re vilble s subroutines in this softwre. (We will write these in simplified sort of C lnguge nottion): bdd vr2func(vr x) Generte the BDD corresponding to single vrible x. Input is single vrible (of type vr), nd the returned output is BDD. bdd ITE(bdd I, bdd T, bdd E ) Compute the if-then-else opertion. Inputs re 3 BDDs, clled I (if prt), T (then prt) E (else prt), nd the returned output is nother BDD. int iszero(bdd func ) Returns integer 1 just if func is the lwys-zero function. Input is BDD, output is integer 1 or 0 (it s not BDD) bdd cofctor(bdd func, vr x, int vl) Computes cofctor of func with respect to vr x, setting x = vl. func is BDD, vr is vrible, vl is integer 0 or 1 bdd AND(bdd f, bdd g) bdd OR(bdd f, bdd g) bdd EXOR(bdd f, bdd g) bdd NOT(bdd f) Compute the bsic logicl (gte type) opertions on BDDs. AND, OR nd EXOR crete new BDDs representing the logicl AND, OR nd exclusive-or of their inputs. NOT cretes the BDD for the complement of its input. bdd CONST1, CONST0 You cn ssume these two BDDs re lredy defined. These re just the constnt 1 function nd the constnt 0 function. Note tht iszero(const0) == (int) 1. No other opertions re implemented, nd there is no wy for you to exmine the BDD dt structure directly. Describe (in C-like pseudo-code nottion we don t need rel code here!) how you would implement the following opertions: CMU Fll VLSI CAD September 14,

3 int depends(bdd f, vr x) Determine whether function f depends on the specified vrible x. This mens if you chnge x, t lest sometime the output of f will lso chnge. f is BDD, x is vrible, depends returns integer 0 or 1. bdd univqunt(bdd f, vr x) Compute universl quntifiction of function f with respect to vrible x. f is BDD, x is vrible, univqunt returns BDD. int opposite(bdd f, bdd g) Determine whether two functions re complementry, i.e., if one of them is the complement of the other. f nd g re BDDs, opposite returns integer 0 or 1. bdd exchnge(bdd f, vr, vr b ) Exchnge roles of specified vribles in function f. For exmple, exchnge( b + d,, d ) > d b +. f is BDD, nd b re vribles, exchnge returns BDD. bdd compose(bdd f, bdd g, vr x) Cretes new function (composition function) with vrible x in f set to the output of g. The picture below clrifies wht we re computing. f nd g re BDDs, x is vrible, nd compose returns BDD. b c d b c d f g f(,b,c,d) g(,b,c,d) b c d g b d f compose(f,g,c) HINTS: lots of things tht look difficult re esier when you cofctor them nd look t the cofctors. Ply round with ITE of vrious combintions of the cofctors. The first 3 opertors re pretty strightforwrd, the lst 2 re rther tricky. None of these things requires some sophisticted recursive lgorithm, just few lines of clls to the right opertors with the right inputs. To emphsize this, here is the nswer for the first prt, for depends(bdd f, vr x): int depends(bdd f, vr x) { return(1 - iszero( EXOR( cofctor(f, x, 0), cofctor(f, x, 1) ) ); } CMU Fll VLSI CAD September 14,

4 Notice how this works. If function f( ) depends on vrible x, then if I chnge x from x=0 to x=1, there ought to be t lest some pttern for the remining inputs tht mkes the output of the function chnge. But this is exctly wht the Boolen Difference tries to compute. So, we compute the BDD for new function f(... x=0...) f(... x=1...) using clls to cofctor nd to EXOR. Wht does this new function tell us? If the new function is zero lwys, for ll inputs, then you cnnot ffect the output of function f by chnging vrible x. In other words, f does not depend on vrible x. So if the iszero( ) function returns integer 1, it mens the originl f function does not depend on x. To get the true/ flse return for depends() correct, we hve to invert this, which is wht the (1 -...) does. 6. Combintionl Verifiction in KBDD [30 pts] kbdd is BDD clcultor done by Prof. Rndy Brynt s reserch group tht hs ll the opertors you d wnt to use to mnipulte Boolen functions, nd simple commnd line interfce to type in functions, etc. You will use this to try to verify the correctness of logic gte network whose BDDs re much too big to do by hnd. kbdd lives in /fs/ece/clss/ee760/bin/kbdd, nd it works on IBM AIX boxes nd on SUN Solris boxes. As strting point, the following pge shows complete trce of session with kbdd, using it to do the network repir problem on the lst homework ssignment. Inputs re in norml font, outputs itlics, kbdd s prompts for input shown in bold s KBDD: CMU Fll VLSI CAD September 14,

5 % /fs/ece/clss/ee760/bin/kbdd input vribles KBDD: boolen b cin d0 d1 d2 d3 define the correct eqution for the dder s crry out KBDD: evl cout &b + (+b)&cin cout: &b + (+b)&cin define the incorrect version of this eqution (just for fun) KBDD: evl wrong &b + (!(&b))&cin wrong: &b + (!(&b))&cin define the to-be-repired version with the MUX KBDD: evl repir &b + (d0&!&!b + d1&!&b + d2&&!b + d3&&b)&cin repir: &b + (d0&!&!b + d1&!&b + d2&&!b + d3&&b)&cin mke the Z function tht compres the right version of the network nd the version with the MUX replcing the suspect gte (this is EXNOR of cout nd repir functions) KBDD: evl Z repir&cout +!repir&!cout Z: repir&cout +!repir&!cout universlly quntify wy the non-mux vrs: b cin KBDD: quntify u ForllZ Z b cin let s sk kbdd to show n eqution for this quntified function KBDD: sop ForllZ!d0 & d1 & d2 wht vlues of the d s mke this function == 1? KBDD: stisfy ForllZ Vribles: d0 d1 d2 011 tht s it! KBDD: quit % CMU Fll VLSI CAD September 14,

6 KBDD Quick Reference boolen vr Declre vribles nd vrible ordering Extended nming vr[m.. n ] Numeric rnge (scending or descending) {s1,s2, } Enumertion evlute dest expr dest := bdd for boolen expression expr Opertions (decresing precedence)! Complement ^ Exclusive-Or & And + Or bdd funct Print BDD DAG s lisp-like representtion sop funct Print sum-of-products representtion of funct stisfy funct Print ll stisfying vrible ssignments of funct verify f1 f2 Verify tht two functions f1 f2 re equivlent size funct Compute totl BDD nodes for set of functions replce dest funct vr replce Functionl composition: dest := funct with vrible vr replced by replce function output quntify [u e] dest funct vr dest := Quntifiction of function funct over vribles vr... e Existentil quntifiction is done u Universl quntifiction is done dder n Cout Sums As Bs Cin Compute functions for n -bit dder n Word size Cout Crry output Sums Destintions for sum outputs: Sum.n Sum.0 As A inputs: A.n-1 A.2 A.1 A.0 Bs B inputs: B.n-1 B.2 B.1 B.0 Cin Crry input lu181 Cout Fs M Ss Cin As Bs Compute functions for 181 TTL ALU Cout Destintion for crry output Fs Destintions for function outputs: F.3 F.2 F.1 F.0 M Mode input Ss Opertion inputs: S.3 S.2 S.1 S.0 Cin Crry input function As A inputs: A.3 A.2 A.1 A.0 Bs B inputs: B.3 B.2 B.1 B.0 mux n Out Sels Ins Compute functions for 2n-bit multiplexor n Word size Out Destintion for output function Sels Control inputs: Sel.n-1 Sel.1 Sel.0 Ins Dt inputs: In.2n 1 In.1 In.0 quit Exit KBDD CMU Fll VLSI CAD September 14,

7 So, wht shll we use kbdd to verify? It turns out tht dders re very good choice here, becuse they come in so mny different styles, nd we know tht the BDD for bsic dder is very simple nd smll. Let us look t not-so-strightforwrd design for 4-bit binry dder block. To strt, here is reminder of how n ordinry crry lookhed dder works i-1 b i-1 i-2 b i-2 i-3 b i-3 i-4 b i-4 Crryout c i Ordinry 4-bit Lookhed Adder c i-4 Crryin s i-1 s i-2 s i-3 s i-4 sum bits In conventionl crry lookhed dder, we would do this: g i = i b i p i = i p i s i = p i g i per bit crry generte signl per bit crry propgte signl output sum bit Lookhed-style output crry: c i = g i-1 + g i-2 p i-1 + g i-3 p i-2 p i-1 + g i-4 p i-3 p i-2 p i-1 + c i-4 p i-4 p i-3 p i-2 p i-1 You could mke n 8-bit lookhed dder here by connected 2 of these 4-bit blocks, nd connecting the lower-block s crry out to the crry in of the higher block. It turns out tht there re mny other wys of doing lookhed ides. The dder on the next pge is one of the more fmous ones: the Ling Adder. Question: Does this thing relly work? (One does hope so, it s pretty fmous dder design, from Ling of IBM in But, we did copy these equtions from the lit, who knows, mybe we got them wrong...?) To test this, crete the equtions for n 8-bit Ling dder. This just mens tke 2 of the 4-bit blocks on the previous pge, nd connect them with the h 4 signl rippling between them. You cn ssume tht h 0 = Cin for crry in vrible. This mens, we wnt you to build the BDDs for ll 8 of the sum bits s 7, s 6,... s 0 for the Ling dder, nd compre them to n ordinry dder. Are they identiclly the sme Boolen functions? Ignore the crry out of the high bit -- the Ling dder doesn t generte this explicitly so we will ignore it. Use kbdd to formlly verify this 8-bit design. Include listing of your session with kbdd showing how you did this. Note especilly tht kbdd hs bsic n-bit dders built in, so to crete the bseline sum-bit equtions is simple opertion. For exmple, to do bsic 4-bit dder, this will suffice: kbdd: boolen [3..0] b[3..0] s[3..0] cout cin kbdd: dder 4 cout s[3..0] [3..0] b[3..0] cin CMU Fll VLSI CAD September 14,

8 i-1 b i-1 i-2 b i-2 i-3 b i-3 i-4 b i-4 rtificil h i out 4-bit Ling Adder h i-4 in s i-1 s i-2 s i-3 s i-4 sum bits In Ling Adder, insted of propgting the crry c i from stge to stge, we propgte n rtificil signl h i =c i +c i-1 The motivtion is tht it s fster to compute h i We do it like this: g i = i b i t i = i + p i per bit crry generte signl Ling-style propgte signl Ling-style lookhed output : h i = g i-1 + g i-2 + g i-3 t i-2 + g i-4 t i-3 t i-2 + h i-4 t i-4 t i-3 t i-2 Intermedite h signls use the sme pttern, but just hve fewer terms. For exmple, since i=4 bove, then: h 3 = g 2 + g 1 + g 0 t 1 t 2 t 3 + h 0 t 1 t 2 t 3 generted crry from 2 prev bits propgte g 0 in bit 0 thru bits 1 2 nd 3 propgte h 0 crry in thru bits nd 3 This sort-of--crry propgtion is nicer less levels of logic. However, the sum clcultion becomes more complicted: s i = ( t i h i+1 ) + h i g i t i-i All the work is in creting the Ling dder in kbdd, nd then compring it ppropritely. Note: It s probbly esiest to edit script file tht you then run through kbdd using the source kbdd commnd. In UNIX, if you type the following itlics stuff: % script % /fs/ece/clss/ee760/bin/kbdd kbdd: source myfilenme kbdd: quit <you hit control-d> then it will (1) strt sving everything in file clled typescript, (2) run kbdd, (3) tell kbdd to run your commnds in your file myfilenme. You type control-d to stop the script sving. You cn then print this typescript file nd hnd it in, nd include some comments so when we red it, we understnd wht you did. CMU Fll VLSI CAD September 14,

9 7. Multi-Terminl BDDs [10 pts] BDDs come in number of specilized vrints, one of which is the Multi-Terminl BDD, or MTBDD. MTBDDs re generliztion of BDDs tht llow n rbitrry number of rel-vlued terminls insted of just the bsic binry terminls, 0 nd 1. While BDD represents function tht returns Boolen vlue for ny ssignment to its vribles, n MTBDD returns rel number. More formlly: BDDs F : B n -> B MTBDDs F : B n -> R Suppose you wnted to represent the following function: F(,b) = 1.2 for =1, b=0 F(,b) = 2.5 for =0 F(,b) = 4.7 for =1, b=1 These numbers could hve ny number of menings. One exmple would be the power in mw consumed by prticulr circuit when it s input chnges from to b. Or it could be the dely in ns, or the rise time of the output. The MTBDD for this function would be the following: F b Furthermore, MTBDDs cn be used to represent rel-vlued mtrices firly efficiently. To do so, we introduce log(# rows) + log(# columns) vribles to encode the row position, nd column position. For simple 2 by 2 mtrix, we get the following: col row row CMU Fll VLSI CAD September 14,

10 For very lrge mtrices with lots of repeted numbers, the MTBDD representtion cn be considerbly smller thn simple listing of the vlues, nd opertions like mtrix-ddition or mtrix-multipliction re correspondingly fster. It turns out tht working with MTBDDs is just s esy s with BDDs. To pply n rbitrry binry opertor (function with two opernds, like +b ), we cn use the sme expnsion nd cofctoring rules s with BDDs. The cofctor of function F with respect to vrible x, or F x, is obtined by redrwing the MTBDD without ll of the x nodes, nd redirecting their incoming edges to the hi son. For exmple: b cofctor w.r.t. b Using cofctors, we cn decompose opertions on MTBDDs in exctly the sme mnner s for BDDs: F = x F x + x F x F+G = x ( F x + G x ) + x (F x + G x ) F*G = x ( F x * G x ) + x (F x * G x ) This results in nice recursive lgorithm for performing rbitrry opertions on two input MTBDDs tht looks remrkbly similr to lgorithms for BDDs. Do this: 1.) Drw the MTBDDs for the two following functions: F(,b) = 3 for =0 0 for =1,b=0 4 for =1,b=1 G(,b) = 0 for b=1 4 for b=0 2.) Compute nd drw the resulting MTBDDs for H=F+G nd M=F*G (Hint: This will be esier if you think bout wht the results should be for ech of the ssignments to nd b first, nd then try drwing the MTBDD. ) CMU Fll VLSI CAD September 14,

11 8. Metproducts [20 pts] A wonderful property of BDDs is tht they only represent the bstrct Boolen function, not the wy you chose to implement it with logic gtes. This is why BDDs re so useful for verifiction: you cn implement x + x, or x + y + x y, or just plin 1, nd in ll these cses, you get the identicl BDD. Of course, sometimes we ctully wnt to represent the wy we hve implemented something s logic gtes. Suppose we relly wnt to represent--for whtever odd reson--the SOP expression = x + x. Is there ny wy we cn represent this directly, without immeditely resolving it to the 1 function? In other words, cn we preserve the SOP product structure of this expression? The nswer is yes -- sort of. We need new representtion of the function tht records the SOP structure, but which lso behves s much like BDD s possible. It turns out there is very elegnt trick for recsting the originl function in new set of vribles, nd then just representing this new function s BDD, tht does much of wht we wnt it to do. This new SOP preserving structure is clled metproduct nottion. (The ide is due to Olivier Coudert, originlly of Bull Reserch Center in Frnce.) Here s the trick: For ech vrible x in your SOP form, the metproduct formul hs 2 different vribles: r x nd s x. r x is the occurence vrible for x; s x is the sign vrible for x. Suppose your function is f(x,y,z,w). For ech product term in your SOP form, for exmple xy z, you get corresponding metproduct term. If your literl is in positive form, like x, you get (r x s x ) in the metproduct. If your literl is in negtive form, like x, you get (r x s x ) in the metproduct. If vrible is missing from the product, like w, you get (r w ) in the metproduct. (It turns out the s w vrible doesn t mtter in this cse, since w is not present, sign doesn t mtter) So, xy z would get trnsformed into ( r x s x r y s y r z s z r w ) in metproduct form. Red r x =1 s mening the vrible x occurs in the product. Red r x =0 s mening the vrible x does not occur in the product. Similrly, red s x =0 s the polrity of x is positive nd s x =1 s the polrity of x is negtive. For exmple: xy z w is bsent in this product term r x s x r y s y r z s z r w So, for exmple, if we ctully tried to represent f(x)=(x + x ) we would get ( r x s x + r x s x ) for the metproduct form. To mnipulte this, we represent it s BDD. we get one more rule here: CMU Fll VLSI CAD September 14,

12 Interpret the pths from the BDD root to the 1 lef s specifying the individul product terms in the metproduct form. If vrible is omitted on pth, you need to include it in both polrities in the finl metproduct. This sounds more complicted thn it relly is. Let s try it. Do this: Drw the BDD for the metproduct for the single-vrible function f(x)=x+x. Show how wlking the pths from root to 1 lef genertes the correct metproduct for this SOP form. Using wht you know bout BDDs, complement this BDD for this metproduct. Agin, wlk the pths from root to 1 nd generte the new metproduct for f (x). Interpret the result -- does this mkes sense? Why? Drw the BDD for the metproduct of the 4 vrible function: f(x,y,z,w) = yw + xzw + xy zw Agin, show how the pths from root to lef in this BDD generte the correct metproduct. (It s OK to use kbdd for this one, s long s you cn figure out the BDD structure yourself.) Agin, complement this BDD, nd show tht the result mkes sense s metproduct. (For this one, you might wnt to use kbdd -- if it s too messy to do by hnd.) CMU Fll VLSI CAD September 14,