## 3 Workflow and Preliminaries
### Model of Computation (MoC)  
We use synchronous data flow [24] (SDF) as model of computation. This model describes the application data flow between _Actors_ via communication _Channels_. The SDF graphs of our use-cases are shown in Figure 2b,c. A complete execution of the graph is called _Iteration_. Figure 2b shows one possible valid execution of the Sobel-Filter example. The Sobel-Filter consists of four actors and five channels. The SDF model offers a strict separation of a computation phase (_Compute_) and communication phases (_Read_ and _Write_).  
During the _Compute_ phase, only local memory of a tile is used. This guarantees that there will be no interference with other actors while an actor gets executed. During the _Read_ and _Write_ phase, data tokens get transferred between actors via channels.  
Channels are FIFO buffers that can be mapped to any memory that is accessible by the producer and the consumer actor. For communication with actors mapped on a different tile, the channels need to be mapped on shared memory. During the _Read_ phase of an actor, tokens get read from a channel buffer into a local memory buffer. During the _Write_ phase, tokens get written into a channel buffer. The amount of tokens that a producer writes or a consumer reads is called _token rate_. It is denoted by integer values on the SDF graphs edges (See Figure 2b,c). As FIFO access is blocked, an actor can only switch to its  
Figure 2: (**a**) Shows the architecture model of our evaluation platform (purple) and the measurement infrastructure (green) for characterization. (**b**) Shows details of the computation model on our Sobel-Filter Use-Case. (**c**) Shows our JPEG decoder Use-Case with and without considering data dependent behavior.  
computation phase after it reads all tokens from all incoming channels. In our SDF model, we assume that all tokens have the same size of exact one data word of the interconnect. The buffer sizes needed for communication are determined before deploying the software on the platform [25]. These buffer sizes are guaranteed to never overflow [25]. Channels can be initialized with tokens before executing the application to avoid deadlocks.  
In our Sobel-Filter example (Figure 2b), the first actor that needs to be executed is the _GetPixels_ actor. This actor has to read two tokens from an incoming channel. The dot on the channel visualizes that there are two initial tokens available. Our JPEG-Decoder example (Figure 2c) can be modeled in two different ways. All color channels can be decoded sequentially as shown on the top. Because the three color channels (\(Y\), \(Cr\), \(Cb\)) can be decoded independently, it is possible to decode them in parallel as shown on the bottom. This also allows to characterize the decoding actors (\(IQ\) and \(IDCT\)) for each set of data (\(Y\), \(Cr\), \(Cb\)). The characteristics of the data of those three sets are systematically different due to the JPEG compression algorithm. This knowledge about the algorithm can be used to improve the accuracy of model.  
In our work, all channels buffers are mapped onto shared memory, while the actors use the private memory of the tiles they get executed on. The execution order of the actors is predefined and static during run time [26]. This setup is fully composable such that the computation phases of any actor can be considered independent from communication phases.