Language
The developer specifies the behavior of the application by building an executable model. Particularly the developer must specify:

1. which computations to perform
2. input data requirements and output data production
1. data independent values – that is, those that can be fixed at compile time
2. data dependent values – that is, those that can change at run time
3. parameter values
4. point in the stream of processing changes
1. switching to a new algorithm
2. processing is to stop and be restarted

Each of these components to the functional behavior of the application are identified in figure 1.

Compiler
The developer specifies mapping of computational components to the available processors. The compiler takes in the application and the mapping specified by the developer and produces an executable that runs on the multiprocessor target. It does this in phases illustrated in figure 2.

1. The compiler starts out by analyzing the application to identify the execution threads that are inherent in the functional behavior and then further decomposes them based on the developer specified mapping to compute elements. The execution threads are bounded by data dependent (that is runtime) input data requirements and output data produces.
2. The compilers next task is to insert boxes that complete the implementation. The most common of these are send and receive boxes that move data among the processing elements. These transfers may impose deadlock avoidance requirements on the thread execution schedule. These may be augmented by synchronization functions depending on the interprocessor communication mechanism provided by the hardware. There are various other boxes that must be inserted to insure the functional behavior of the application is unchanged.
3. The compiler’s next task is to plan the execution sequence and memory use within the threads. Each functional element advertises its input data requirements and data production. Further, arcs that connect data outputs of one box to data inputs of another define the necessary sequencing of execution. Using this information the compiler sequences the execution and plans the memory use. It reuses memory when ever possible while protecting memory that has valid data that will be used in a later execution.
4. The compiler then analyzes the application for opportunities to share memory among threads. This is limited by a number of things – including but not limited to identifying if the will can be active concurrently.
5. The compiler also makes note of the thread interdependencies and records that information in data structures that will be loaded into the thread schedule that runs on the target hardware. The thread schedule will use this information to minimize the thread scheduling overhead.

Finally, the compiler builds the executable that will be loaded into EPROM. Once again the executable structure is dependent on the hardware architecture and the needs of the developer. In some cases a single executable is loaded into the EPROM of a control processor that contains all the executables. In other cases a separate executable is made for each processor in the system and each processor boots its executable from its eprom.