Partikle is a embedded real time operating system designed to be POSIX compliant. The native API is "C" POSIX threads. But it also provides support for C++, Ada and Java (tasking, synchronisation, protected objects, exception handling, etc.). Besides POSIX compatibility, Partikle also provides the RTLinux/GPL non-portable POSIX extensions; therefore, it should be possible to compile RTLinux/GPL applications on Partikle to get all its benefits.

Partikle has been designed to support applications with real-time requirements, providing features such as full preemptability, minimal interrupt latencies, and all the necessary synchronization primitives, scheduling policies, and interrupt handling mechanisms needed for this type of applications.

Partikle can be configurated for three different execution environments:

  • As a stand-alone system on a bare machine: The generated code (run-time plus application) can be executed directly on x86 boards.
  • As a Linux process: This environment is intented for testing purposes. The generated code is executed as a regular Linux process. There has been two reasons to port Partikle to Linux as a regular Linux process: easing the process of debugging the application, teaching POSIX (the current implementation of threads and other features in Linux are not completely POSIX-compliant, so PaRTiKle can be used instead to implement and execute full POSIX compliant applications in a comfortable Linux environment).
  • As a XtratuM domain: XtratuM is an hypervisor that provides hardware virtualisation and allows to execute several kernels (or run-times) concurrently. Partikle can be built to be XtratuM aware and then executed as a XtratuM domain. The advantages of this configuration consist in dividing complex real-time applications in different parts according to their timing criticality and executing each part on the most suitable operating system.

Partikle architecture

Contrarily to other small embedded RTOS, which are implemented as a library which is linked with the application, Partikle has been designed as a real kernel with a clean and well defined separation between kernel and application execution spaces. All kernel services are provided via a single entry point, which improves the robustness and also greatly simplifies the work to port Partikle to other architectures and environments. Partikle has eight functional blocks:

Kernel space

  • Core hardware drivers: Interrupt manager, and clock and timer drivers and virtual memory. These drivers are needed on all execution environments.
  • Peripheral drivers: Among others, keyboard and screen drivers.
  • Kernel C library: This is a small library (called klibc) of C functions used by kernel code.
  • POSIX functionality: Threads, mutexes, signals, timers, I/O, etc.
  • System call interface: Implements the system call mechanism.

User space

  • PSE 5.1 C library.
  • DWARF2 support: DWARF is a debugging mechanism which is also used to manage high level exception handling (e.i. try and catch blocks in C++).
  • Language support: Runtime library of the supported languages.

The Core hardware drivers jointly with the peripheral drivers form the hardware abstraction layer (HAL).

Partikle kernel implements a minimal C library. This minimal C library does not share any line of code with the libraries used by the application. The application space is composed by a C library, PSE51 Compliant, which relays on the services provided by the kernel via the system call interface.

Also, the support for Ada, C++ and Java applications are provided at user space level. Additionally, to support all these run-times, Partikle implements the Debugging Information Format DWARF2, which will be also linked with the application if required. The application is linked on the top of all these support libraries.