Investigation on Describing, Compiling and Analysing Scalable Dataflow Actor Networks in Streaming Applications

Dataflow is a computation model for describing applications as a network of communicating processes (in our work we refer to these processes as actors).

This project investigates the suitability of the CAL Actor Language and associated tool-chains for describing very large networks of actors. Previous benchmarks had a maximum of 40 actors meaning that the performance of these tools has not been well considered for larger networks of actors. In contrast, this project will consider networks with hundreds of actors. This investigation will span multiple research areas including:
1. Creating new scalable benchmarks in CAL.
2. Expanding the CAL language to handle parametric scalable actor networks.
3. Expanded the automaton models (known Actor Machines) compiled from CAL to handle larger actors.
4. Compiling these actors to a standard IR to enable them to be run easily on different hardware platforms.
5. Analyzing parametric actor networks to make formal guarantees on their behavior.

There are many different formal ways to describe an application that will run on a computing platform. The method used to describe an application affects how well it performs, what kind of guarantees can be made on the reliability of the application and how easy the application is to analyze.

In our work, we focus on streaming applications (applications where there is a continuous flow of information such as a stream of music). We describe these applications as networks of individual processing elements with inputs and outputs. These elements are known as actors and the network of connected actors makes the application. These networks can easily run on a diverse range of computing devices (mobile phones, computers, embedded devices, FPGAs, etc) while also being easy to analyze (we can reason about the worst case execution time of these programs for example).

Previous research into these actor networks has only focused on relatively small networks of actors (about 40 actors in the largest benchmark). In our work we explore how to describe much larger networks of actors. We focus on some key issues:
1. We examine the limitations in programming languages used to describe actor networks that prevent them from scaling.
2. We investigate how the tools used create these actor networks break when the network size grows too large.
3. We propose and implement new benchmarks of larger actor networks that can be used to test future tools.