The small, proprietary kernels are often used for small embedded systems when very fast and highly predictable execution must be guaranteed. The kernels are often stripped down and optimized to reduce the run-time overhead caused by the kernel. The usual characteristics of these kernels are :
Ø fast context switching.
Ø small size and stripped-down functionality.
Ø quick response to external interrupts.
Ø minimized intervals, when interrupts are disabled.
Ø fixed or variable sized partitions for memory management.
Ø ability to lock code and data into memory.
Ø special sequential files for data accessing.
To deal with timing requirements, the kernel should provide a priority scheduling mechanism and a bounded execution time for most primitives. For timing purposes, the kernel should maintain a real-time clock and provide special alarm and timeout services, as well as primitives for delay by a fixed amount of time. In general, the kernel also performs multitasking and intertask communication and synchronization via standard well-known constructs such as mailboxes, events, signals, and semaphores. Additionally, the kernel should support real-time queuing methods such as delivering messages by a priority order. These kernels are suitable for small applications, such as instrumentation, communication front ends, intelligent peripherals, and process control. Since the application are simple, it is relatively easy to determine, that all timing constraints are met. As complexity of the system increases, it becomes more and more difficult to map all timing, computation time, resource, and value requirements to a single priority for each task. In these situations demonstrating predictability becomes very difficult. Because of these reasons, some researchers believe, that more sophisticated kernels are needed to address timing and fault tolerance constraints. Recently there are efforts to produce scalable kernels. The smallest level of support is a microkernel, and the support can be broaden by demands of the application. An example of this type of kernel is the Chorus microkernel , which can be scaled from a simple embedded microkernel to a full POSIX/UNIX support.