Altreonic is new releasing v.1.4 of its breakthrough formally developed network-centric OpenComRTOS suite. While the visual development environment was enhanced to make multi-processor developments even easier, v. 1.4 now has the Safe Virtual Machine (SVM) for C fully integrated and the RTOS itself has now fully distributed support for priority inheritance for easier resource management. The latter is a pre-condition for lower power consumption and better predictable real-time behaviour at the application level.
Altreonic’s SVM is made available to the developer as an OpenComRTOS task that has the capability to execute binary C code in a platform independent way. Any processing node in an OpenComRTOS application can have multiple SVM tasks. Each of them can access the underlying hardware and interact with other natively running tasks using the available OpenComRTOS services. Yet the latest version of the SVM only requires 2838 bytes for program and 476 bytes for data. (measured on ARM Cortex M3).
While the SVM itself is written in C, the code itself was automatically generated from a higher level description. A first model expresses the instructions and their actions of the Virtual Machine; a next level refines this into lower levels commands while the lowest level represents the finite state machine of the VM. The VM itself is generated as optimized C code. This approach guarantees that the VM is correct by design, is close to optimal and allows using more elaborate VM instructions set a redefinition of the models. It also allows adding safety support (e.g. acting like a software MMU on bare bones processors.
SVM apps competition
What Altreonic’s SVM does is bringing the power of “apps” to the embedded world. Users can create an SVM task and download it to a running embedded application, on any properly set up node in the system. The SVM task can use any service of the natively running OpenComRTOS system, yet it requires only Kbytes of memory.
A new application domain for the SVM-C is the capability to run old binary C-code. While it requires to generate a new Virtual Machine and has some restrictions like hardware dependencies, it allows to save previously developed software.
Distributed Priority Inheritance
The OpenComRTOS suite now also supports distributed priority inheritance. Priority inheritance is an algorithm that reduces blocking times in the context of resource locking by temporarily adjusting the priority of the application tasks. OpenComRTOS implements priority inheritance with a ceiling, preventing that high priority tasks can become blocked by less essential tasks. Priority inheritance is essential for hard real-time applications and was made famous by the Mars Rover reset issue some 20 years ago. Once it was re-enabled from earth, the Mars over resumed normal operation.
In a distributed system this algorithm is almost impossible to implement with traditional single processor RTOS solutions, but thanks to the distributed semantics and communication in OpenComRTOS, it is now totally transparent for the application developer. Support for priority inheritance across processor boundaries is also essential for allowing dynamic resource management. This is increasingly becoming a mandatory requirement for e.g. portable devices featuring multi- or manycore devices and safety critical applications that need to continue to operate even when some resources are failing.
While OpenComRTOS is already notoriously small in code size (typically less than 5 Kbytes per node), distributed priority inheritance only adds a 728 bytes to the memory requirements. This figure was measured on an ARM Cortex M3 with a total code size of 4156 bytes for a minimal application.
For more information, contact:
Eric.Verhulst (at) altreonic.com