- Compiler flow. This flow has a twofold objective:
- to guide the process to generate the binary that will execute on the many-core architecture and
- to generate the application Direct Acyclic Graph (DAG) used for the timing analysis and run-time components.
- Analysis flow. This flow is in charge of deriving timing guarantees of the parallel execution considering execution time traces of the application running on the many-core platform and incorporated in the DAG. Timing guarantees are derived by means of execution time bounds and static scheduler or dynamic scheduler supported with response time analysis.
- Execution stack. These two components are in charge of orchestrating the parallel execution of the application in a time predictable manner, based on the DAG.
The compiler must pave the way towards a reliable and predictable timing and schedulability analyses. The compiler flow of the UpScale SDK guides the process of generating the binary that will execute on the many-core architecture and creates the interface that glues the different SDK components. It:
- Transforms OpenMP directives to the corresponding set of run-time calls;
- Builds the OpenMP-DAG required to perform timing and schedulability analysis, and derive a static task-to-thread allocation if configured for higher predictability;
- Automatically generates the set of data structures needed to store the DAG into the application's memory address space; and
- Instruments the code to measure the execution time of the different parts of the application, i.e. task-parts and run-time overhead.
It is paramount that the OpenMP run-time and operating system components understand the target hardware design and incorporate all the features required to orchestrate an efficient and predictable parallel execution of the real-time tasks. UpScale provides:
- A lightweight OpenMP runtime that support the lightweight execution of the OpenMP accelerator (target directive) and tasking models on the Kalray MPPA 256 platform
- The ERIKA3 RTOS, designed to add proper support for multi-core architectures, by using one single kernel image across several cores.
Meeting both the timing and high-performance requirements for parallel real-time applications which aim at executing on the last generations of many-core processors requires a deep insight into the interactions between the tasks at run-time. To this end, the set of tools that allow the system designer to gather the tasks’ maximum execution times on the target processor as well as to conduct a sound timing and schedulability analyses in various hardware setups is critical. The UpScale SDK Analysis toolbox is composed of the Analyser and the Mapper. It provides the tools to:
- model, measure, analyse and optimize the system to reach the desired goals
- to rapidly identify the bottlenecks and create “what if” scenarios regarding how to perform the task-to-core mappings at run-time.