NodeTable

java.lang.Object
- jdd.bdd.NodeTable

Direct Known Subclasses:

BDD, ZDD
```
public class NodeTable
extends Object
```
implementation of a node table of elements (var,low,high,ref-count) that supports garbage collections.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`dead_nodes`
`protected long`	`ht_chain`
`protected int[]`	`mark_stack`
`static int`	`NODE_MARK` used to mark/unmark BDD nodes
`static int`	`NODE_UNMARK` used to mark/unmark BDD nodes
`protected int`	`nodesminfree`
`protected int`	`stat_gc_count` if true, we will use the faster version of mark_tree()
`protected long`	`stat_gc_freed`
`protected long`	`stat_gc_time`
`protected long`	`stat_grow_time`
`protected int`	`stat_lookup_count` if true, we will use the faster version of mark_tree()
`protected long`	`stat_notify_time`
`protected int`	`stat_nt_grow`
`protected int`	`table_size`
`protected int[]`	`work_stack`
`protected int`	`work_stack_tos`

Constructor Summary

Constructors
Constructor and Description

NodeTable(int nodesize)

Constructors
Constructor and Description
`NodeTable(int nodesize)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`add(int v, int l, int h)`
`Collection`	`addDebugger(BDDDebuger d)` for debugging: install a debugger.
`void`	`check_all_nodes()` check if all nodes are ok.
`void`	`check_node(int node, String str)` check if some node is ok.
`void`	`cleanup()`
`int`	`countRootNodes()` count the number of ROOT bdd nodes.
`int`	`deref(int bdd)` decrease the reference-count of this BDD once.
`void`	`enableStackMarking()` call this functio to enable the fast variant of the mark_node() function.
`int`	`gc()` do a garbage collection.
`int`	`getHigh(int bdd)`
`int`	`getLow(int bdd)`
`long`	`getMemoryUsage()`
`short`	`getRef(int bdd)` get the number of references to this BDD.
`int`	`getVar(int bdd)`
`protected int`	`getVarUnmasked(int bdd)` return the associated variable.
`protected void`	`grow()` grow is called when we need more nodes in the table.
`static void`	`internal_test()` testbench.
`protected void`	`invalidate(int bdd)` make the node invalid
`boolean`	`isNodeMarked(int bdd)`
`boolean`	`isValid(int bdd)` returns true if this bdd is a valid bdd
`void`	`mark_node(int bdd)`
`void`	`mark_tree(int bdd)` recursively mark nodes, used by some internal functions.
`protected boolean`	`match_table(int bdd, int var, int low, int high)` returns true of the bdd `bdd` is the same as (var,low,high)
`protected void`	`post_removal_callbak()` this function is called when something in the node table is changed (GC or grow).
`int`	`ref(int bdd)` increase the reference-count of this BDD once
`void`	`saturate(int bdd)` set the reference-count of this BDD to max.
`protected void`	`setAll(int bdd, int v, int l, int h)`
`protected void`	`setAll(int bdd, int v, int l, int h, short r)`
`protected void`	`show_table_all()`
`protected void`	`show_table()`
`protected void`	`show_tuple(int i)`
`void`	`showStats()` show some statistics ...
`protected void`	`signal_removed()`
`protected void`	`tree_depth_changed(int n)` this function MUST be called when a paramater that may change the tree dpeth (such as the number of variables in a BDD) has changed!
`void`	`unmark_node(int bdd)`
`void`	`unmark_tree(int bdd)` recursively unmark nodes, used by some internal functions
`protected void`	`update_grow_parameters()` this is called when the table ha grown and we might need to update some internal parameters

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NODE_MARK
```
public static final int NODE_MARK
```
    used to mark/unmark BDD nodes
    
    See Also:
    
    Constant Field Values
  - NODE_UNMARK
```
public static final int NODE_UNMARK
```
    used to mark/unmark BDD nodes
    
    See Also:
    
    Constant Field Values
  - table_size
```
protected int table_size
```
  - stat_nt_grow
```
protected int stat_nt_grow
```
  - dead_nodes
```
protected int dead_nodes
```
  - nodesminfree
```
protected int nodesminfree
```
  - stat_gc_count
```
protected int stat_gc_count
```
    if true, we will use the faster version of mark_tree()
  - stat_lookup_count
```
protected int stat_lookup_count
```
    if true, we will use the faster version of mark_tree()
  - stat_gc_freed
```
protected long stat_gc_freed
```
  - stat_gc_time
```
protected long stat_gc_time
```
  - stat_grow_time
```
protected long stat_grow_time
```
  - stat_notify_time
```
protected long stat_notify_time
```
  - work_stack
```
protected int[] work_stack
```
  - mark_stack
```
protected int[] mark_stack
```
  - work_stack_tos
```
protected int work_stack_tos
```
  - ht_chain
```
protected long ht_chain
```
- Constructor Detail
  - NodeTable
```
public NodeTable(int nodesize)
```
- Method Detail
  - cleanup
```
public void cleanup()
```
  - tree_depth_changed
```
protected void tree_depth_changed(int n)
```
    this function MUST be called when a paramater that may change the tree dpeth (such as the number of variables in a BDD) has changed!
  - post_removal_callbak
```
protected void post_removal_callbak()
```
    this function is called when something in the node table is changed (GC or grow).
    sub-classes must "implement" this function for, for example, flushing caches since it signals that something important has been changed and old data might have become invalid.
  - signal_removed
```
protected final void signal_removed()
```
  - gc
```
public int gc()
```
    do a garbage collection.
    
    Returns:
    
    number of freed nodes
  - grow
```
protected void grow()
```
    grow is called when we need more nodes in the table. it first will try to make more room by a garbage collection. if that fails, the node table is resized
  - add
```
public int add(int v,
               int l,
               int h)
```
  - addDebugger
```
public Collection addDebugger(BDDDebuger d)
```
    for debugging: install a debugger. returns the set of caches.
  - update_grow_parameters
```
protected void update_grow_parameters()
```
    this is called when the table ha grown and we might need to update some internal parameters
  - ref
```
public final int ref(int bdd)
```
    increase the reference-count of this BDD once
    
    Returns:
    
    bdd
  - deref
```
public final int deref(int bdd)
```
    decrease the reference-count of this BDD once.
    
    Returns:
    
    bdd
  - saturate
```
public final void saturate(int bdd)
```
    set the reference-count of this BDD to max. after that, the ref-count cant be changed and the node cannot be garbage collected anymore.
    DO NOT USE, unless you know what you are doing (note: you probably don't).
  - getRef
```
public final short getRef(int bdd)
```
    get the number of references to this BDD.
  - getVar
```
public final int getVar(int bdd)
```
  - getLow
```
public final int getLow(int bdd)
```
  - getHigh
```
public final int getHigh(int bdd)
```
  - getVarUnmasked
```
protected final int getVarUnmasked(int bdd)
```
    return the associated variable. works even when the table is marked
  - isValid
```
public final boolean isValid(int bdd)
```
    returns true if this bdd is a valid bdd
  - invalidate
```
protected final void invalidate(int bdd)
```
    make the node invalid
  - setAll
```
protected final void setAll(int bdd,
                            int v,
                            int l,
                            int h,
                            short r)
```
  - setAll
```
protected final void setAll(int bdd,
                            int v,
                            int l,
                            int h)
```
  - match_table
```
protected final boolean match_table(int bdd,
                                    int var,
                                    int low,
                                    int high)
```
    returns true of the bdd bdd is the same as (var,low,high)
  - enableStackMarking
```
public void enableStackMarking()
```
    call this functio to enable the fast variant of the mark_node() function. if you do that, you mustlet JDD know the maximum depth of all trees by calling tree_depth_changed() from your sub-class
    
    See Also:
    
    tree_depth_changed(int)
  - mark_tree
```
public final void mark_tree(int bdd)
```
    recursively mark nodes, used by some internal functions.
    
    See Also:
    
    mark_node(int)
  - unmark_tree
```
public final void unmark_tree(int bdd)
```
    recursively unmark nodes, used by some internal functions
  - mark_node
```
public final void mark_node(int bdd)
```
  - unmark_node
```
public final void unmark_node(int bdd)
```
  - isNodeMarked
```
public final boolean isNodeMarked(int bdd)
```
  - getMemoryUsage
```
public long getMemoryUsage()
```
  - countRootNodes
```
public int countRootNodes()
```
    count the number of ROOT bdd nodes.
  - show_tuple
```
protected void show_tuple(int i)
```
  - show_table
```
protected void show_table()
```
  - show_table_all
```
protected void show_table_all()
```
  - showStats
```
public void showStats()
```
    show some statistics ...
  - check_all_nodes
```
public void check_all_nodes()
```
    check if all nodes are ok. it will test validaty and ref-count of nodes in the table
  - check_node
```
public void check_node(int node,
                       String str)
```
    check if some node is ok. it actuallt check the whole tree below the node
  - internal_test
```
public static void internal_test()
```
    testbench. do not call

Class NodeTable

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NODE_MARK

NODE_UNMARK

table_size

stat_nt_grow

dead_nodes

nodesminfree

stat_gc_count

stat_lookup_count

stat_gc_freed

stat_gc_time

stat_grow_time

stat_notify_time

work_stack

mark_stack

work_stack_tos

ht_chain

Constructor Detail

NodeTable

Method Detail

cleanup

tree_depth_changed

post_removal_callbak

signal_removed

gc

grow

add

addDebugger

update_grow_parameters

ref

deref

saturate

getRef

getVar

getLow

getHigh

getVarUnmasked

isValid

invalidate

setAll

setAll

match_table

enableStackMarking

mark_tree

unmark_tree

mark_node

unmark_node

isNodeMarked

getMemoryUsage

countRootNodes

show_tuple

show_table

show_table_all

showStats

check_all_nodes

check_node

internal_test