1. Enumeration of Irredundant Circuit Structures Alan Mishchenko Department of EECS UC Berkeley UC Berkeley

2. 2 Overview Logic synthesis is important and challenging task Logic synthesis is important and challenging task Boolean decomposition is a way to do logic synthesis Boolean decomposition is a way to do logic synthesis Several algorithms - many heuristics Several algorithms - many heuristics Drawbacks Drawbacks Incomplete algorithms - suboptimal results Incomplete algorithms - suboptimal results Computationally expensive algorithms - high runtime Computationally expensive algorithms - high runtime Our goal is to overcome these drawbacks Our goal is to overcome these drawbacks Perform exhaustive enumeration offline Perform exhaustive enumeration offline Use pre-computed results online, to get good Q&R and low runtime Use pre-computed results online, to get good Q&R and low runtime Practical discoveries Practical discoveries The number of unique functions up to 16 inputs is not too high The number of unique functions up to 16 inputs is not too high The number of unique decompositions of a function is not too high The number of unique decompositions of a function is not too high

3. Small Practical Functions Classifications of Boolean functions Classifications of Boolean functions Random functions Random functions Special function classes Special function classes Symmetric Symmetric Unate Unate etc etc Logic synthesis and technology mapping deal with Logic synthesis and technology mapping deal with Functions appearing in the designs Functions appearing in the designs Functions with small support (up to 16 variables) Functions with small support (up to 16 variables) These functions are called small practical functions (SPFs) These functions are called small practical functions (SPFs) We will concentrate on SPFs and study their properties We will concentrate on SPFs and study their properties In particular, we will ask In particular, we will ask How many different SPFs exist? How many different SPFs exist? How many different irredundant logic structures they have? How many different irredundant logic structures they have?

4. DSD Structure DSD structure is a tree of nodes derived by applying DSD recursively until remaining nodes are not decomposable DSD structure is a tree of nodes derived by applying DSD recursively until remaining nodes are not decomposable DSD is full if the resulting tree consists of only simple gates (AND/XOR/MUX) DSD is full if the resulting tree consists of only simple gates (AND/XOR/MUX) DSD is partial if the resulting tree has non-decomposable nodes (called prime nodes) DSD is partial if the resulting tree has non-decomposable nodes (called prime nodes) DSD does not exist if the tree is composed of one node DSD does not exist if the tree is composed of one node a b cde f abcde f Full DSDPartial DSD abcdef No DSD

5. Computing DSD The input is a Boolean function The input is a Boolean function The output is a DSD structure The output is a DSD structure The structure is unique up to several normalizations: The structure is unique up to several normalizations: Selection of base functions (elementary gates) Selection of base functions (elementary gates) Placement of inverters Placement of inverters Factoring of multi-input AND/XOR gates Factoring of multi-input AND/XOR gates Ordering of fanins of AND/XOR gates Ordering of fanins of AND/XOR gates Ordering of data inputs of MUXes Ordering of data inputs of MUXes NPN representative of prime nodes NPN representative of prime nodes This computation is fast and reliable This computation is fast and reliable Originally implemented with BDDs (Bertacco et al) Originally implemented with BDDs (Bertacco et al) In a limited form, re-implemented with truth tables In a limited form, re-implemented with truth tables Detects about 95% of DSDs of cut functions Detects about 95% of DSDs of cut functions To put DSD computation in perspective To put DSD computation in perspective For 8-LUT mapping, it takes roughly the same time to For 8-LUT mapping, it takes roughly the same time to to compute structural cuts to compute structural cuts to derive their truth tables to derive their truth tables to compute DSDs of the truth tables to compute DSDs of the truth tables F(a,b,c,d) = ab + cd cda b F

6. Pre-computing Non-Disjoint-Support Decompositions Enumerate bound sets while increasing size Enumerate bound sets while increasing size Enumerate shared sets while increasing size Enumerate shared sets while increasing size If the bound+shared set is irredundant If the bound+shared set is irredundant Add it to the computed set Add it to the computed set Bound+shared set is redundant Bound+shared set is redundant If a variable can be removed and the resulting set is decomposable If a variable can be removed and the resulting set is decomposable Ex: (abCD) is redundant if (abcD) or (abD) is a valid set Ex: (abCD) is redundant if (abcD) or (abD) is a valid set abCDe abcD ab c D e e H HH G G G

7. Example of Non-DS Decomposition: Mapping 4:1 MUX into two 4-LUTs The complete set of support-reducing bound-sets for Boolean function of 4:1 MUX: Set 0 : S = 1 D = 3 C = 5 x=Acd y=xAbef Set 1 : S = 1 D = 3 C = 5 x=Bce y=xaBdf Set 2 : S = 1 D = 3 C = 5 x=Ade y=xAbcf Set 3 : S = 1 D = 3 C = 5 x=Bde y=xaBcf Set 4 : S = 1 D = 3 C = 5 x=Acf y=xAbde Set 5 : S = 1 D = 3 C = 5 x=Bcf y=xaBde Set 6 : S = 1 D = 3 C = 5 x=Bdf y=xaBce Set 7 : S = 1 D = 3 C = 5 x=Aef y=xAbcd Set 8 : S = 1 D = 4 C = 4 x=aBcd y=xBef Set 9 : S = 1 D = 4 C = 4 x=Abce y=xAdf Set 10 : S = 1 D = 4 C = 4 x=Abdf y=xAce Set 11 : S = 1 D = 4 C = 4 x=aBef y=xBcd Set 12 : S = 2 D = 5 C = 4 x=ABcde y=xABf Set 13 : S = 2 D = 5 C = 4 x=ABcdf y=xABe Set 14 : S = 2 D = 5 C = 4 x=ABcef y=xABd Set 15 : S = 2 D = 5 C = 4 x=ABdef y=xABc

8. Application to LUT Structure Mapping: Matching 6-input function with LUT structure “44” abcDe H G f abcdef abcDe H G abcde f f abCde H G abcde f f abCde H’ G f Case 1 Case 2 Case 3

9. Application to Standard Cell Mapping Enumerate decomposable bound sets Enumerate decomposable bound sets For each bound set, enumerate NPN classes of G and H For each bound set, enumerate NPN classes of G and H Use them as choice nodes Use them as choice nodes Use choice nodes to improve quality of Boolean matching Use choice nodes to improve quality of Boolean matching Property: When non-disjoint-support decomposition is applied, there are exactly M = 2^((2^k)-1) pairs of different NPN classes of decomposition/composition functions, G and H, where k is the number of shared variables Property: When non-disjoint-support decomposition is applied, there are exactly M = 2^((2^k)-1) pairs of different NPN classes of decomposition/composition functions, G and H, where k is the number of shared variables H G F kM 01 12 28 3128 432768 52147483648

10. Example of a Typical SPF abc 01> rt 000A115F abc 02> print_dsd –d F = 0505003F(a,b,c,d,e) This 5-variable function has 10 decomposable variable sets: Set 0 : S = 1 D = 3 C = 4 x=abC y=xCde 0 : 011D{decf} 1 : 110D{decf} Set 1 : S = 1 D = 3 C = 4 x=bCd y=xaCe 0 : !(!d!(cb)) 1 : 1C{bdc} 3407{aecf} Set 2 : S = 1 D = 3 C = 4 x=abE y=xcdE 0 : 0153{cdef} 1 : 5103{cdef} Set 3 : S = 1 D = 3 C = 4 x=acE y=xbdE 0 : !(!c!(ea)) 01F3{bdef} 1 : 1C{ace} F103{bdef} Set 4 : S = 1 D = 3 C = 4 x=bcE y=xadE 0 : (c!(!e!b)) (!f ) 1 : 38{bce} 5003{adef} Set 5 : S = 1 D = 3 C = 4 x=bCe y=xaCd 0 : !(!e!(cb)) 1 : 1C{bec} 3503{adcf} Set 6 : S = 1 D = 3 C = 4 x=adE y=xbcE 0 : (!f!(c!(!e!b))) 1 : 3007{bcef} Set 7 : S = 1 D = 4 C = 3 x=abcE y=xdE 0 : FAC0{abce} (!f!(!ed)) 1 : 05C0{abce} C1{def} Set 8 : S = 1 D = 4 C = 3 x=aCde y=xbC 0 : (!f!(cb)) 1 : 03AC{adec} 43{bcf} Set 9 : S = 1 D = 4 C = 3 x=bcdE y=xaE 0 : CCF8{bcde} (!f!(ea)) 1 : 33F8{bcde} 43{aef} abc 01> rt 000A115F abc 02> pk Truth table: 000a115f d e \ a b c 0 0 0 0 1 1 1 1 0 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0 +---+---+---+---+---+---+---+---+ 00 | 1 | 1 | 1 | 1 | 1 | | | 1 | +---+---+---+---+---+---+---+---+ 01 | | | | | 1 | | | 1 | +---+---+---+---+---+---+---+---+ 11 | | | | | | | | | +---+---+---+---+---+---+---+---+ 10 | 1 | 1 | | | | | | | +---+---+---+---+---+---+---+---+ NOTATIONS: !a is complementation NOT(a) (ab) is AND(a,b) [ab] is XOR(a,b) is MUX(a, b, c) = ab + !ac {abc} is PRIME node

11. Statistics of DSD Manager abc 01> pub12_16.dsd; dsd_ps Total number of objects = 3567880 Externally used objects = 3060774 Non-DSD objects (max =12) = 479945 Non-DSD structures = 3220044 Prime objects = 1405170 Memory used for objects = 100.04 MB. Memory used for functions = 238.01 MB. Memory used for hash table = 40.83 MB. Memory used for bound sets = 79.98 MB. Memory used for array = 27.22 MB. 0 : All = 1 0 : All = 1 1 : All = 1 1 : All = 1 2 : All = 2 2 : All = 2 3 : All = 10 3 : All = 10 4 : All = 229 4 : All = 229 5 : All = 3823 5 : All = 3823 6 : All = 22273 6 : All = 22273 7 : All = 77959 7 : All = 77959 8 : All = 200088 8 : All = 200088 9 : All = 396307 9 : All = 396307 10 : All = 661620 10 : All = 661620 11 : All = 972333 11 : All = 972333 12 : All = 1233234 12 : All = 1233234 All : All = 3567880 abc 01> time elapse: 3.00 seconds, total: 3.00 seconds This DSD manager was created using cut enumeration applied to *all* MCNC, ISCAS, and ITC benchmarks circuits (the total of about 835K AIG nodes). This involved computing 16 priority 12-input cuts at each node. Binary file “pub12_16.dsd” has size 177 MB. Gzipped archive has size 42 MB. Reading it into ABC takes 3 sec. Harvesting functions contained in this DSD manager took 1 hour.

12. Typical DSD Structures NOTATIONS: !a is complementation NOT(a) (ab) is AND(a,b) [ab] is XOR(a,b) is MUX(a, b, c) = ab + !ac {abc} is a PRIME node with hexadecimal

13. Support-Reducing Decompositions For each support size (S) of NPN classes of non-DSD-decomposable functions - the columns are ranges of counts of irredundant decompositions - the entries are percentages of functions in each range - the last two columns are the maximum and average decomposition counts

14. LUT Structure Mapping LUT: LUT count Level: LUT level count Time, s: Runtime, in seconds The last two columns: - with online DSD computations - with offline DSD computations (based on pre-computed data)

15. LUT Level Minimization 6-LUT mapping: Standard mapping into 6-LUTs with structural choices LUTB: DSD-based LUT balancing proposed in this work SOPB+LUTB: SOP balancing followed by LUT balancing (ICCAD’11) LMS+LUTB: Lazy Man’s Logic Synthesis followed by LUT balancing (ICCAD’12)

16. Conclusions Introduced Boolean decomposition Introduced Boolean decomposition Proposed exhaustive enumeration of decomposable sets Proposed exhaustive enumeration of decomposable sets Discussed applications to Boolean matching Discussed applications to Boolean matching Experimented with benchmarks to find a 3x speedup in LUT structure mapping Experimented with benchmarks to find a 3x speedup in LUT structure mapping Future work will focus on Improving implementation Extending to standard cells Use in technology-independent synthesis

17. Abstract A new approach to Boolean decomposition and matching is proposed. It uses enumeration of all support-reducing decompositions of Boolean functions up to 16 inputs. The approach is implemented in a new framework that compactly stores multiple circuit structures. The method makes use of pre-computations performed offline, before the framework is started by the calling application. As a result, the runtime of the online computations is substantially reduced. For example, matching Boolean functions against an interconnected LUT structure during technology mapping is reduced to the extent that it no longer dominates the runtime of the mapper. Experimental results indicate that this work has promising applications in CAD tools for both FPGAs and standard cells. A new approach to Boolean decomposition and matching is proposed. It uses enumeration of all support-reducing decompositions of Boolean functions up to 16 inputs. The approach is implemented in a new framework that compactly stores multiple circuit structures. The method makes use of pre-computations performed offline, before the framework is started by the calling application. As a result, the runtime of the online computations is substantially reduced. For example, matching Boolean functions against an interconnected LUT structure during technology mapping is reduced to the extent that it no longer dominates the runtime of the mapper. Experimental results indicate that this work has promising applications in CAD tools for both FPGAs and standard cells.