Handel-C

In order to facilitate a way to describe parallel behavior some of the CSP keywords are used, along with the general file structure of Occam.

For example:[1]

par {    
     ++c;
     a = d + e;
     b = d + e;
}

Channels provide a mechanism for message passing between parallel threads. Channels can be defined as asynchronous or synchronous (with or without an inferred storage element respectively). A thread writing to a synchronous channel will be immediately blocked until the corresponding listening thread is ready to receive the message. Likewise the receiving thread will block on a read statement until the sending thread executes the next send. Thus they may be used as a means of synchronizing threads.[1]

par {
    chan int a; // declare a synchronous channel
    int x;

    // begin sending thread
    seq (i = 0; i < 10; i++) {
        a ! i;  // send the values 0 to 9 sequentially into the channel
    }

    // begin receiving thread
    seq (j = 0; j < 10; j++) {
        a ? x;  // perform a sequence of 10 reads from the channel into variable x
        delay;  // introduce a delay of 1 clock cycle between successive reads
                // this has the effect of blocking the sending thread between writes
    }
}

Asynchronous channels provide a specified amount of storage for data passing through them in the form of a FIFO. Whilst this FIFO neither full nor empty, both sending and receiving threads may proceed without being blocked. However, when the FIFO is empty, the receiving thread will block at the next read. When it is full, the sending thread will block at the next send. A channel with actors in differing clock domains is automatically asynchronous due to the need for at least one element of storage to mitigate metastability.

A thread may simultaneously wait on multiple channels, synchronous or asynchronous, acting upon the first one available given a specified order of priority or optionally executing an alternate path if none is ready.

The scope of declarations are limited to the code blocks ({ ... }) in which they were declared, the scope is hierarchical in nature as declarations are in scope within sub blocks.[1]

For example:

int a;

void main(void)
{
   int b;
   /* "a" and "b" are within scope */
   {
     int c;
     /* "a", "b" and "c" are within scope */ 
   }
   {
     int d;
     /* "a", "b" and "d" are within scope */  
   }
}

In addition to the effects the standard semantics of C have on the timing of the program, the following keywords[1] are reserved for describing the practicalities of the FPGA environment or for the language elements sourced from Occam:

In Handel-C, assignment and the delay command take one cycle. All other operations are "free".[1] This allows programmers to manually schedule tasks and create effective pipelines. By arranging loops in parallel with the correct delays, pipelines can massively increase data throughput, at the expense of increased hardware resource use.