Node

Node is also part of Hybrid Design Flow (HDF). the node is atomic component which represent the state and its transition of the hardware model.
This session will introduce you how Kathryn's node system represent the state and type of node provided in this framework

Group of nodes called graph ( $G$ )
- $G = \{n_1, n_2, n_3, ..., n_k\}$
- ( $G$ ) is a set of nodes ( $n$ ) in Kathryn model.
Node is the representation of state and its transition of hardware flow
- $n_i = (C_i, D_i(C_i, t))$
- ( $n_i$ ) is the ordered pair of node number $i$ . First element is the set of input trigger conditions. and second element is determine function
Conditional trigger is input meta-data for a node
- $C_i = \{ (c, n_j) | n_j\ \epsilon\ G \}$
- ( $C_i$ ) is set of the ordered pair of $n_i$ where $c$ is logic value that can be interpreted as a boolean value and $n_j$ is a node that belongs to $G$ .
Determine function and logic interpretation
- $D_i(C_i, t)\ \epsilon\ \{true, false\}$
- $B(c, t)\ \epsilon\ \{true, false\}$
- ( $D_i$ ) is the function to determine that node $n_i$ is activated and ready for next state transition at cycle number ( $t$ ). In fact, $D_i$ will be modified for each specific type of the node (state) such as parallel block synchronization node, wait block node, and conditional node in conditional block.
- ( $B$ ) is the function to determine the value of condition ( $c$ ) at cycle number ( $t$ ).

src/model/flowBlock/abstract/nodes/stateNode.h
the node that will activate its status when for some dependent nodes is activate and its coresponding condition is true.
$d_st(C, t) = \exists\{(c,n)\ \epsilon\ C|\ n[2](n[1], t-1)\ \wedge\ B(c, t-1)\ =\ true \}$

src/model/flowBlock/abstract/nodes/stateNode.h
the node that will active its status when all dependent nodes is activate in any cycle in each iteration.
In case synNode mode: $DYNAMIC$ (means flow block cannot determine some sub-block cycle usage at model formation time)
$d_{dsync}(C, t) = \forall(c,n)\ \epsilon\ C\ ->\exists t_2 < t ,\ \forall t_3 < t, t_3 >= t_2\{ n[2](n[1], t_2)\ \wedge\ \forall d_{dsync}(C, t_3)\}$

In case synNode mode: $STATIC$ (means flowblock can determine all sub-block cycle usage at model formation time)
let the logest execution node is node $(S)$
$d_{ssync}(C, t) = \exists\{(c,n)\ = S|\ n[2](n[1], t-1)\ \lor \ n[2](n[1], t) \}$

src/model/flowBlock/abstract/nodes/waitNode.h
In case, designers specify amount of wait cycle Cywait
the node that will activate its status when some dependent nodes is activate and wait for meet the specified cycle A.
$d_cyt(C, t) = \exists\{(c,n)\ \epsilon\ C|\ n[2](n[1], t-A-1)\ \wedge\ B(c, t-A-1)\ =\ true \}$

In case, designers specify condition for waiting CondWait
the node that will activate its status when some dependent nodes is activate and wait for meet the specified condition E.
$d_{cdt}(C, t) = \exists\{(c,n)\ \epsilon\ C,\ t_2 < t|\ n[2](n[1], t_2)\ \wedge\ B(c, t_2)\ \wedge\ B(E, t)\ \wedge\ \forall t_3 > t_2 t_3 < t \ (!d_{cdt}(C, t3)) \}$

src/model/flowBlock/abstract/nodes/logicNode.h
Pseudo node does not represent state like previous node but it play an important role while Kathryn is formating model.
For instance, some flow graph that have cycling state flow (node1 -> node2 -> node3 -> node1), some time node3 require logic pre-process first; therefore node1 cannot build logic related to node3 directly. The Pseudo node aim to be the proxy node that prevent dead lock in this situation.
Futhermore, Pseudo Node can act as node aggregator. Sometime when controll require single node to represent several flow blocks, Pseudo then can handle this by aggreate source inputs to single output
let Op(C, t) be the operating function that operates source node condition and node values at cycle t.
$d_{psd}(C, t)\ =\ Op(C, t)$

src/model/flowBlock/abstract/nodes/logicNode.h
Dummy node does not represent state, it is used to represent reset or interrupt signal
let S be some operand to reset or interrupt
$d_{opr}(C, t) = B(S != 0, t)$