Some questions about RT-preempt

A realtime preemption overview：http://lwn.net/Articles/146861/

 

How does the CONFIG_PREEMPT_RT patch work?

The RT-Preempt patch converts Linux into a fully preemptible kernel. The magic is done with:

Making in-kernel locking-primitives (using spinlocks)
preemptible though reimplementation with rtmutexes.
Critical sections protected by i.e. spinlock_t and rwlock_t are now preemptible. The creation of non-preemptible sections (in kernel) is still possible with raw_spinlock_t (same APIs like spinlock_t).
Implementing priority
inheritance for in-kernel spinlocks and semaphores. For more information on priority
inversion and priority inheritance please consult Introduction to Priority Inversion.
Converting interrupt handlers into preemptible kernel threads: The RT-Preempt patch treats soft interrupt handlers in kernel thread context, which is represented by a task_struct like a common user
space process. However it is also possible to register an IRQ in kernel context.
Converting the old Linux timer API into separate infrastructures for high resolution kernel timers plus one for timeouts, leading to user space POSIX timers with high resolution.
 

Which architectures does the CONFIG_PREEMPT_RT patch support?

There are systems representing the x86, x86_64, ARM, MIPS, and Power architectures using the CONFIG_PREEMPT_RT patch. However, in many ways this is the wrong question. Support for real-time is not just about the instruction set
architecture, but also about supporting the high resolution timer provided by the CPU and/or CPU support chipset, the device drivers for the system being well behaved, etc. So just because an ARM system from company A may work quite well with the -rt patchset,
it does not guarantee that another ARM system from Company B will work as well; it might have some longer latency problems or it might not work at all. It is true that overall design and architecture of the -rt patch tends to avoid the need for device-driver
specific changes, but there are always software bugs as well as hardware design bugs.

 

What are important things to keep in mind while writing realtime applications?

Taking care of the following during the initial startup phase:

Call mlockall() as soon as possible from main().
Create all threads at startup time of the application, and touch each page of the entire stack of each thread. Never start threads dynamically during RT show time, this will ruin RT behavior.
Never use system calls that are known to generate page faults, such as fopen(). (Opening of files does the mmap() system call, which generates a page-fault).
If you use 'compile time global variables' and/or 'compile time global arrays', then use mlockall() to prevent page faults when accessing them.
more information: HOWTO:
Build an RT-application