QNX

QNX is designed to be used inside small hardware system

Small Foot print: has extremely low memory requirement
Portable: Is available for a large range of different architectures
Message based microkernel: Designed as a pure microkernel system with a small
kernel which contains only CPU scheduling, interprocess communication, interrupt
redirection and timers
Secure: One of the strongest and less vulnerable OS in the market
Standard complaint: QNX makes extensive use of standard and open source
technologies increasing its interoperability and reducing customer lock in:
POSIX: QNX is POSIX complaint
OpenNGL: QNX uses this portable open source graphics library
Eclipse: The QNX developer tool kit is built around the eclipse frame work and
platform
QNX has extreme microkernel architecture, the kernel also known as Neutrino
provides a small set of functionality
Microkernel architecture: Structures the operating system by removing all
nonessential components from the kernel and implementing them as system and
user level programs. The result is a small kernel
Microkernels provide minimal process and memory management, in addition to a
communication facility.
QNx satisfies the core principles of the real time operating system
Single purpose
Small size
Inexpensively mass produced
Specific timing requirements
All other common operating system functions are provided by satellite processes
running in user space
QNX OS directs extreme manufacturing such as flawless grinding of optical lenses

Process Management
Based on message sending. The kernel routes messages using a single system call
(Msgsend) which copies the message from one address space onto
another.Messages can be passed synchronously and asynchronously. In case of
synchronous transfers, the kernel passes the message and the control of CPU to the
receive process at the same time without calling the CPU scheduler kernel process.
This kind of inter process communication is unique to QNX and provides high
performance
QNX uses several scheduling algorithms: FIFO, Round Robin, Adaptive(which
reduces the priority of processes that already executed their time slice)
sporadic(threads are allowed to execute at periodic times) periodic and priority
based scheduling are typical of real time operating systems since their timing
requirements are far stricter than normal operating systems. This makes QNX a
choice for mission critical equipment
The QNX kernel also features preemptive multitasking

Nucleus RTOS Kernel

The Nucleus RTOS is based on a micro kernel architecture that can reside in as little 2 KB of Flash, yet
expand to cover all of the protocol, device, and connectivity support found in full featured operating
systems, including multi-core and applications requiring memory protection for greater system reliability.
Deployed in excess of 3 billion devices over the last 20 years, Nucleus has the long term stability and
reliability for the most demanding environments. Systems ranging throughout the medical, industrial,
hand-held, automotive, security, aerospace, and smart energy markets have all relied on Nucleus as their
platform of choice.
With the Nucleus RTOS embedded system designers can:

Rely on a proven and stable RTOS kernel with over 3 billion device deployment

Access well documented source code

Deliver hard real-time performance

Scale from a minimum memory footprint as little as 2 kb

Design systems with low power consumption

Implement responsive systems with fast boot time and sub microsecond latency for interrupt
service and context switching

Maximize performance on multicore systems

Features

Application interface

Familiar RTOS kernel APIs for multi-threaded application development

ANSI C

POSIX

C++

Core services

Integrated power management

Dynamic task creation and deletion

Application timers (One and multi-shot timers)

Static and dynamic memory allocation

Inter-task communications and synchronization

Counting Semaphores and Mutexes (Priority Inheritance support)

Event Flags

Fixed and variable queues and pipes

Mailboxes

UNIX-like signals

Real-time MMU services

Deterministic flat memory model supportGraceful handling of errors in the field

Nucleus MMU enables kernel-application, application-application memory protection

Enhanced services

Powerful build and configuration system

Granular control of system foot print, performance, and functionality

Device manager for standardized driver interface

Automatic initialization

Portable abstraction layer

Task stack-checking APIs for optimal run-time stack usage

Two-tier interrupt processing model for efficient interrupt service

No interrupt lock-out during kernel service calls - extremely responsive and low latency

Dynamic loading services

Enables field upgrades

Supports minimal RAM footprint

Integrated with MMU services

Multicore support

Inter-process communication through rpmsg over virtIO and MCAPI