Maestro Specifications

The next-generation OS for high performance embedded systems

Maestro releases the processing power of the hardware for applications that require high performance and low latencies.

Maestro provides real-time capabilities and predictable response times for automotive, robotics and machine vision applications.

Maestro is built around an asymmetric microkernel designed from the ground up for high performance, low-latency applications on multi-core processors. The fully event-based kernel is tickless to avoid jitter and optimise response times to always respond in a timely manner.

Maestro is designed to exploit the full performance of modern MPSoC hardware. Use the integrated FPGA support to design and load hardware accelerators for your application.

Maestro comes with a container-based development kit. You will be able to start developing your application in minutes.

Multi-core by design

Maestro is the first embedded OS to be designed specifically for multi- and many-core processors. Its kernel reduces latencies and jitter by using a near lock-free design.

Maestro implements traditional real-time schedulers such as Fixed-Task-Priority or Deadline-Driven Scheduling. Furthermore, it also supports cutting-edge scheduling techniques such as elastic mixed-criticality and the optimal U-EDF multi-core scheduling algorithm.

Maestro provides both partitioned and global versions of these scheduling algorithms, for predictability and efficiency (respectively).

Maestro provides all the building blocks to parallelize your application. Use the custom OpenMP integration to split your heavy computations on several cores.

Configurable memory safety

The microkernel in Maestro provides configurable levels of isolation between user applications. Maestro makes full use of the hardware memory management unit (if available). It provides full memory virtualization by default. Using this scheme, the system prevents unauthorized interactions between applications and protects the system from error propagation.

When performance becomes critical, safety features can get in the way of exploiting the hardware to its full potential. Full memory virtualization can be disabled, keeping only memory protection. Memory protection prevents applications from taking down the microkernel but does not prevent harmful interaction between applications. Nonetheless, it is a great compromise for non-critical applications.

Modern development environment

Maestro comes pre-packaged in a container-based development environment so that you will never have to worry about the configuration of your system. Maestro provides a one-stop-shop configuration file for your whole application. Use the XML task set specification file to define the parameters of your application. Build your application and integrate it to the IDE of your choice with our custom CMake integration. Deploy and debug your code on target using the automated deployment tools.

Maestro provides full support for the C and C++ languages. Maestro supports GCC, LLVM and the Xilinx SDSoC toolchains.

Heterogeneous platform support and reconfiguration

Modern multi-core hardware platforms are heterogeneous in nature. MPSoC platforms for embedded systems integrate several types of components, such as processing cores from different instruction set architectures, reconfigurable hardware in the form of FPGA and various ASIC accelerators. Maestro provides support for FPGA designs. Use the integration with the Xilinx SDSoC toolchain to design accelerators for your application. Load your bitstreams statically or dynamically using the DPR service on target.

Active power management

Maestro implements drivers and governors for power management, including Dynamic Voltage Frequency Scaling (DVFS) and sleep states management. The power management governors take decisions in accordance with the thread scheduler and enables efficient power management strategies.

Standard API

When developing the Maestro API, we focused on maximizing portability, especially from Linux. The Maestro API is POSIX-compliant for most features: 

  • Process management
  • Multithreading
  • Scheduling
  • Synchronisation primitives
  • File System
  • ...

Maestro only requires developers to learn a handful of proprietary calls for custom concepts, such as the task release model.

Detailed Specifications

Main Features
  • Multi-core asymmetric microkernel architecture
  • Global and partitioned scheduling
  • Timing control features
  • Full virtual memory isolation
  • Dynamic memory allocation
  • Deployment & debugging tools
  • Optional mixed criticality scheduling
Development Environment
  • Familiar C/C++ environment
  • GNU GCC toolchain support
  • LLVM (clang) toolchain support
  • SDx/SDSoC toolchain support (Xilinx compiler)
  • XML taskset specification file
  • Easy scripting between host and embedded target (python)
  • Automated compile/load/deploy development loop
  • FPGA bitstream upload
  • Fully independent container SDK
  • CMake integration
Supported Architectures
  • ARMv7-A
  • ARMv8-A
  • PowerPC64
  • x86

Maestro supports 32 and 64 bit architectures with and without MMU. Different memory virtualisation/protection schemes can be used depending on the needs of the application.

Libraries and Frameworks
  • CAN Stack
  • FAT File System
  • Full-featured IP stack
  • OpenMP Framework
  • OpenCV Framework
  • Ethernet
  • FPGA
  • SDIO
  • CAN
  • GPIO
  • I2C
  • SPI
  • Timers
  • UART