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
