Binary Decision Diagrams

Theory, Implementation, Usage

Barukh Ziv Intel

B.Z.

Boolean Functions And Their Representations

B.Z.

Boolean Functions
Definition
A map that associates a Boolean value to each possible assignment of input variables

Widely Used in CAD Applications

Hardware synthesis Test generation Validation

Uniform Description in Model Checking

Describing the model (Transition Relation) Representing the Set of States

B.Z.

Representing Boolean Functions

Truth Table
Functions value for each assignment of inputs Formulas using basic Boolean operations Network of logical gates Each path in a graph represents one assignment of input variables

Boolean Expressions Boolean Circuits

Binary Decision Trees

B.Z.

Representing Boolean Functions: Examples

Truth Table
X 0 0 0 0 1 1 1 1 Y 0 0 1 1 0 0 1 1 Z 0 1 0 1 0 1 0 1 F 0 0 1 0 1 1 0 0

Binary Decision Tree

X Y Z 0 0 Z 1 0 1 Z 1 0 Y Z 0

Boolean Circuit
X Y Z
B.Z.

Boolean Expression F = XYZ |X Y

Good Representation: Requirements

Compactness
Grow not too fast with number of inputs

Efficient Logic Manipulation

Computing Boolean functions Performing equivalence check Finding Out the satisfying assignment

What are the values of input variables that evaluate the Boolean function to TRUE

B.Z.

Good Representation: Is It Possible?

Theoretical Fact
No good representation exists for all Boolean functions

The concern is with practically interesting cases

Human designed models are regular

B.Z.

Binary Decision Diagrams

B.Z.

Toward BDD: Key Ideas

Use Binary Decision Diagrams
Two edges of a node of function F point to functions F(x=0) and F(x=1) Basis for recursive manipulation On each path in Decision Diagram the order of variables is the same A step to canonical form Efficient comparison

Fix the Order of Input Variables Share All Equal Functions

B.Z.

Towards BDD: Key Ideas

Represent Only Essential Variables A-Ha! Shannon Expansion
Dont put variables on paths where they cannot change the value of a function Theoretical fact: F = xF(x=0) | xF(x = 1) If F(x=0) and F(x=1) are equal, value of F does not depend on variable x Delete a node whose both edges point to the same function

Reduction Rule

B.Z.

Reduced Ordered BDD

Binary Decision Diagram F
X
0-edge
F(X=0)

Fixed Variables Order

X
For every node: X < Y, X < Z

1-edge

F(X=1)

Sharing Equivalent Functions

F=G X Y
B.Z.

Reduction Rule
X Y
F F

X Z Y

X Z

BDD Features
Canonicity
If two functions are equal than their BDD graphs are isomorphic

Compactness
Constant Boolean functions are one-node BDD Some important functions grow linearly with number of input variables (e.g. Parity)

Equivalence Check
Equivalence check is done in constant time

B.Z.

BDD Features
Basic Boolean Operations
The size of result of operation like FG is bounded by a product of sizes of F and G Using Dynamic Programming techniques, the time is almost linear with the size The size of F is equal to size of F The time is linear with the size Advanced techniques (attributed edges) reduce the time to constant

Complement

B.Z.

BDD Features
Find Satisfying Assignment Shared BDD
The time is linear with the size of a BDD All features remain true for multiple boolean functions represented by BDD set

B.Z.

Compare The Representations

Size Boolean Operator Equality Satisfy Canonicity

Truth Expression Table Exponenial Linear Linear Linear Linear Yes Constant

Circuit Linear Constant

Decision Tree Exponential Linear Linear Linear Yes

BDD Linear to Exponential Linear to Polinomial Constant Linear Yes

Exponential Exponential Exponential Exponential No No

B.Z.

Building a BDD
Models Are Boolean Expressions/Circuits Nave Approach
Build a decision tree and then apply reduction rules Wont work: decision trees are too big

Build BDD From Expressions

Use bottom-up strategy Always start from atomic functions F = x

B.Z.

Logic Manipulation Algorithm

BinOp(F, G)
If (TerminalCase) Return Result If COMPUTED(F,G) Return Result x = MIN(F-variable,G-variable) F0 = F(x=0), F1 = F(x=1) G0 = G(x=0), G1 = G(x=1) R0 = BinOp(F0, G0) R1 = BinOp(F1, G1) Result = BDDnode(x, R0, R1) Insert COMPUTED(F,G,Result) Return Result
B.Z.

Terminal Case Examples:

F 1 = F, F F = 0

Underlined are dynamic programming usage BDDnode function applies reduction rules The scheme of algorithm may be applied to other logic manipulations

Variables Ordering
Good Order Is Crucial
Different variable orders may change the size of BDD from exponential to linear

Theoretical Fact
Finding an optimal order is really hard Best known algorithms have complexity O(3N)

B.Z.

Variables Ordering: Examples

MUX
Y1 F Y2N
X1 XN

COMPARATOR
X1 XN Y1 YN q If F

If Y-variables are put first, the BDD size is exponential

q
q If

X-variables are put before Y-variables, the size is exponential

q If

X-variables are put first, the BDD size is linear

B.Z.

order is interlaced (X1,Y1, ,XN,YN) the size is linear

Variables Ordering: Examples

MULTIPLIER
X1 XN Y1 YN F1 FN F2N

q For

function FN, every order creates a BDD with size exponential

B.Z.

Obtaining A Good Order

Static Ordering
Basic idea: analyze the models structure

Dynamic Reordering
One basic idea: perform local order changes
Swap adjacent variables Try a single variable at a time

B.Z.

Basic Reorder Operation: Swap

Before:
F X Y Y Potentially reduce
Local Change

X and Y are adjacent in the order

Shannon expansion on both X and Y variables Each atomic swap removes at most 2 nodes Swapping X- and Y-level nodes may reduce as much nodes as on Y-level

Correctness Proof

BDD Size Reduction

F00 F01 F10 F11

After:
Y X

F Potentially new X

F00 F10 F01 F11

B.Z.

Reordering Algorithm: Sifting

SiftVariable (X) WHILE OnTop(X) Swap(Prev(X),X); SAVE Optimal WHILE OnBottom(X) Swap(X,Succ(X)); SAVE Optimal MoveTo(X, Optimal) Sifting(Variables) Prioritize(Variables) FOREACH X in Variables SiftVariable(X) ConvergenceSifting(Variables) DO SiftingReorder(Variables) WHILE ReductionSize > Thresh
B.Z.

Performance

Complexity of SiftVariable is linear with the size of BDD Complexity of Sifting is linear with N times the size of BDD ConvergenceSifting is basically more powerful, but may be very expensive

Reordering Variables: Advanced

Selective Reordering
Reorder only variables which are important Reduces the reordering time

Grouping Variables
Choose variables upon certain criterion (symmetry, dependency) and stick them together in groups Reorder on the group level only Better BDD size reduction in some cases

B.Z.

BDD Package Implementation

B.Z.

Main Components
Unique Table
Imposes a uniqueness of each BDD node

Computed Table
Stores the results of previous computations (dynamic programming technique)

Garbage Collection
Remove no-more-in-use BDD nodes

B.Z.

Unique Table
Unique Table
x Finds BDD node (x, F0, F1) Each variable has a separate Hash Table
Allows more efficient manipulation

Hash Table

The hash table entry Key is function of (F0, F1, size[hash]) Advanced Techniques
Resize Hash Table for efficiency Different Collision Chain policies
Last Recently Used - first Ring chain

..

...

key

Collision Chain x
x x

B.Z.

Computed Table
Cache Table
Stores result of Op(Arg1,Arg2) Implementation: Hash-Based Cache Table
Collisions are not resolved - last result stored

..

key

..

Cache entry Key is function of (Op, Arg1, Arg2, size[cache]) Advanced Techniques
Resize Cache table for efficiency Split Cache table to avoid collisions of frequently used Ops

Cache Table Entry

Op Arg1 Arg2 Result

B.Z.

Garbage Collection
Remove Dead BDD Nodes
`Dead node is one which is no longer in use Reference Counts Explicit Marks Number of references to each BDD node is kept All nodes with RC equal to zero are removed More expensive but more flexible A standard approach in many commercial BDD packages

Identification Of Dead Nodes Approaches

Reference Counts (RC)

B.Z.

Garbage Collection
Explicit Marks
Functions that are in use are marked Only BDD nodes representing functions in-use are left Less expensive but less flexible
Garbage Collection can not be triggered until a function is not built

Garbage Collection And Reordering

Reordering is usually done after Garbage Collection Garbage Collection is sometimes needed during Reordering Use Reference Counts only when Reordering

B.Z.

Using BDD In Model Checking

B.Z.

Finite State Machines

Mathematical Model For Model Checking Concepts

Memory elements, Inputs Allowed initial assignments FSM State, Set Of States Transition Relation

Set of allowed transitions between states

B.Z.

Finite State Machines

More Concepts

Image Of Set Of States S

Set of states reachable in one transition from S

Pre-Image Of Set Of States S

Set of states from which S is reachable in one transition

B.Z.

BDD Representation Of FSM

Memory Element Or Input
Set of BDD variables V, V (current, next value)

FSM State
Assignment of Boolean values B to V

A Set Of States
BDD of Characteristic Function S(V) B belongs to set S(B) = 1

B.Z.

BDD Representation Of FSM

Operations On Sets
BDD Boolean operations Example: A B S(A) S(B)

Transition Relation
BDD of Characteristic Function N(V, V) <A, B> is legal N(A,B) = 1

B.Z.

BDD Representation Of FSM

Image/Pre-Image
BDD Boolean operator Relational Product Computes V [S(V) N(V,V)] The algorithm computes the result in one pass Complexity: square of product of operand sizes

B.Z.

BDD Based Model Checking

Hardware Model
Represented as an FSM

Initial states
Set of atomic init functions x0 = Ix(V)

Transition relation
Set of atomic next-state functions x = Nx(V,V)

Assumptions

B.Z.

BDD Operations Flow

assumptions

Initial States Comp

Ix [Build/Conjunct]

Exclude Dead-Ends
[Pre-Image]

-inc

TransRelation Bld
Nx [Build/Conjunct]

Reach States Comp

[Image]

spec
B.Z.

Spec Evaluation
[Pre-Image]

CountExmap Gen
[Image/Pre-Image]

Model Checking And Reordering

Stage/Action Specific Reordering Change Criteria Of Good Order Advanced Algorithms
Different algorithms for different stages Consider active variables small overall BDD size small size of BDD representing Transition Relation Convergence Sifting Automatic Variables Grouping

B.Z.