Launches the execution of the dataflow graph with node function ```rootGraph```. ```args``` is a pointer to a packed struct, containing one field per argument of the RootGraph function, consecutively. For non-streaming DFGs with a non empty result type, ```args``` must contain an additional field of the type ```RootGraph.returnTy```, where the result of the graph will be returned. ```isStream``` chooses between a non streaming (0) or streaming (1) graph execution. Returns a handle to the executing graph.
```void __visc__wait(void* G)```
```void __hpvm__wait(void* G)```
Waits for completion of execution of the dataflow graph with handle ```G```.
```void __visc__push(void* G, void* args)```
```void __hpvm__push(void* G, void* args)```
Push set of input data items, ```args```, (same as type included in launch) to streaming DFG with handle ```G```.
```void* __visc__pop(void* G)```
```void* __hpvm__pop(void* G)```
Pop and return data produced from one execution of streaming DFG with handle ```G```.
Creates a static dataflow node replicated in ```dims``` dimensions (0 to 3), each executing node function ```F```. The arguments following ```F``` are the size of each dimension, respectively, passed in as a ```size_t```. Returns a handle to the created dataflow node.
Creates an edge from output ```sp``` of node ```src``` to input ```dp``` of node ```dst```. If ```replType``` is 0, the edge is a one-to-one edge, otherwise it is an all-to-all edge. ```isStream``` defines whether or not the edge is streaming. Returns a handle to the created edge.
```void __visc__bindIn(void* N, unsigned ip, unsigned ic, unsigned isStream)```
```void __hpvm__bindIn(void* N, unsigned ip, unsigned ic, unsigned isStream)```
Binds the input ```ip``` of the current node to input ```ic``` of child node function ```N```. ```isStream``` defines whether or not the input bind is streaming.
```void __visc__bindOut(void* N, unsigned op, unsigned oc, unsigned isStream)```
```void __hpvm__bindOut(void* N, unsigned op, unsigned oc, unsigned isStream)```
Binds the output ```op``` of the current node to output ```oc``` of child node function ```N```. ```isStream``` defines whether or not the output bind is streaming.
Must be called once in each node function. Indicates which hardware target the current function should run in
```void __visc__attributes(unsigned ni, …, unsigned no, …)```
```void __hpvm__attributes(unsigned ni, …, unsigned no, …)```
Must be called once at the beginning of each node function. Defines the properties of the pointer arguments to the current function. ```ni``` represents the number of input arguments, and ```no``` the number of output arguments. The arguments following ```ni``` are the input arguments, and the arguments following ```no``` are the output arguments. Arguments can be marked as both input and output. All pointer arguments must be included.
```void __visc__attributes(unsigned ni, …, unsigned no, …)```
```void __hpvm__attributes(unsigned ni, …, unsigned no, …)```
As described in internal node API.
```void __visc__return(unsigned n, ...)```
Returns ```n``` values from a leaf node function. The remaining arguments are the values to be returned. All ```__visc__return``` statements within the same function must return the same number of values.
```void __hpvm__return(unsigned n, ...)```
Returns ```n``` values from a leaf node function. The remaining arguments are the values to be returned. All ```__hpvm__return``` statements within the same function must return the same number of values.
```void* __visc__getNode()```
```void* __hpvm__getNode()```
Returns a handle to the current leaf node.
```void* __visc__getParentNode(void* N)```
```void* __hpvm__getParentNode(void* N)```
Returns a handle to the parent node of node ```N```.
Returns the dynamic ID of the current instance of node ```N``` in the x, y, or z dimension respectively. The dimension must be one of the dimensions in which the node is replicated.
Returns the number of dynamic instances of node ```N``` in the x, y, or z dimension respectively. The dimension must be one of the dimensions in which the node is replicated.
```void __visc__barrier()```
```void __hpvm__barrier()```
Local synchronization barrier across dynamic instances of current leaf node.
```void* __visc__malloc(long nBytes)```
```void* __hpvm__malloc(long nBytes)```
Allocate a block of memory of size ```nBytes``` and returns a pointer to it. The allocated object can be shared by all nodes, although the pointer returned must somehow be communicated explicitly for use by other nodes.
```int __visc__atomic_add(int* m, int v)```
```int __hpvm__atomic_add(int* m, int v)```
Atomically adds ```v``` to the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_sub(int* m, int v)```
```int __hpvm__atomic_sub(int* m, int v)```
Atomically subtracts ```v``` from the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_xchg(int* m, int v)```
```int __hpvm__atomic_xchg(int* m, int v)```
Atomically swaps ```v``` with the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_inc(int* m)```
```int __hpvm__atomic_inc(int* m)```
Atomically increments the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_dec(int* m)```
```int __hpvm__atomic_dec(int* m)```
Atomically decrements the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_min(int* m, int v)```
```int __hpvm__atomic_min(int* m, int v)```
Atomically computes the min of ```v``` and the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_max(int* m, int v)```
```int __hpvm__atomic_max(int* m, int v)```
Atomically computes the max of ```v``` and the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_and(int* m, int v)```
```int __hpvm__atomic_and(int* m, int v)```
Atomically computes the bitwise AND of ```v``` and the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_or(int* m, int v)```
```int __hpvm__atomic_or(int* m, int v)```
Atomically computes the bitwise OR of ```v``` and the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
```int __visc__atomic_xor(int* m, int v)```
```int __hpvm__atomic_xor(int* m, int v)```
Atomically computes the bitwise XOR of ```v``` and the value stored at memory location ```[m]```. Returns the value previously stored at ```[m]```.
