ECE 3060 VLSI and Advanced Digital Design

Transcription

1 ECE 3060 VLSI and Advanced Digital Design Lecture 12 Computer-Aided Heuristic Two-level Logic Minimization

2 Computer-Aided Heuristic Twolevel Logic Minimization Heuristic logic minimization Principles Operators on logic covers Espresso Disclaimer: lecture notes based on originals by Giovanni De Micheli

3 Heuristic minimization Provide irredundant covers with reasonably small cardinality Fast and applicable to many functions Avoid bottlenecks of exact minimization Prime generation and storage Covering

4 Heuristic minimization principles Local minimum cover: given initial cover make it prime make it irredundant Iterative improvement: improve on cardinality by modifying the implicants

5 Heuristic minimization operators Expand: make implicants prime remove covered implicants Reduce: reduce size of each implicant while preserving cover Reshape modify implicant pairs: enlarge one implicant enabling the reduction of another Irredundant: make cover irredundant

6 Example on-set : prime implicants : α 0** β *0* γ 01** δ 10** ε 1* ζ *

7 α β γ ε ζ

8 Example Expansion Expand 0000 to α = 0**0 drop 0100, 0010, 0110 from the cover Expand 1000 to β = *0*0 drop 1010 from the cover Expand 0101 to γ = 01** drop 0111 from the cover Expand 1001 to δ = 10** drop 1011 from the cover Expand 1101 to ε = 1*01 Cover is {α,β,γ,δ,ε}

9

10 Example reduction Reduce 0**0 to nothing Reduce β = *0*0 to β = 00*0 Reduce ε = 1*01 to ε = 1101 Cover is {β,γ,δ,ε}

11

12 Example reshape Reshape {β,δ} to {β,δ} where δ = 10*1 Cover is {β,γ, δ,ε}

13

14 Example second expansion Expand δ = 10*1 to δ = 10** Expand ε = 1101 to ζ = *101

15

16 Summary of Example Expansion: Cover: {α,β,γ,δ,ε} prime, redundant, minimal w.r.to single cube containment Reduction: α eliminated β = *0*0 reduced to β = 00*0 ε = 1*01 reduced to ε = 1101 Cover: {β,γ,δ,ε} Reshape: {β,δ} reshaped to {β,δ} where δ = 10*1 Second expansion: Cover: {β,γ,δ,ζ} prime, irredundant (= minimal)

17 For each implicant Expand naive implementation for each non-* literal (care literal) 8raise it to * (don t care) if possible remove all covered implicants Problems: check validity of expansion: 2 ways 8non intersection of expanded implicant with OFF-set requires complementation of ON-set 8expanded implicant covered by union of ON-set and DC-set can be reduced to recursive tautology check order of expansions

18 Heuristics First expand cubes which are unlikely to be covered by other cubes Selection: choose implicants with least number of literals in common with other implicants Example: f = a b c d + ab cd + a b c d choose ab cd Choose expansions to cover the largest number of minterms possible (=> prime implicant)

19 Reduce Example Expanded cover: 8α **1 8β 00* Select α: cannot be reduced and still cover the ON-set Select β: reduced to 8β 001 Reduced cover: 8α **1 8β 001

20 Irredundant Cover Relatively essential set E r implicants covering some minterms of the function not covered by other implicants Totally redundant set R t implicants covered by the relatively essentials Partially redundant set R p remaining implicants

21 Irredundant cover goal and example Goal: find a subset of R p that, together with E r, covers the function Example: 8α 00* 8β *01 8γ 1*1 8δ 11* 8ε *10 E r = {α, ε} R t = {} R p = {β, γ, δ}

22 Example: continued Covering relations: β is covered by {α, γ} γ is covered by {β, δ} δ is covered by {γ, ε} Minimum cover: γ U E r

23 Espresso Algorithm Compute the complement Extract essentials Iterate: expand, irredundant, reduce Cost functions: cover cardinality Ø 1 weighed sum of cube and literal count Ø 2

24 Espresso(F,D) { R = complement(f U D); F = expand(f, R); F = irredundant(f, D); E = essentials(f, D); F = F - E; D = D U E; repeat { Ø 2 = cost(f); repeat { Ø 1 = F ; F = reduce(f, D); F = expand(f, R); F = irredundant(f, D); } until ( F z Ø 1 ); F = last_gasp(f, D, R); } until cost(f) z Ø 2 ; F = F U E; D = D - E; F = make_sparse(f, D, R); } Espresso algorithm

25 Summary heuristic minimization Heuristic minimization is iterative Few operators applied to covers Underlying mechanism cube operation recursive paradigm Efficient algorithms Preview: next lecture covers efficient boolean representations for computer manipulation