Free-ebooks-library - Bahar Ali Khan

eal-time work, you must also elevate the process priority using the Process class in
System.Diagnostics (we didn’t tell you how to do this):
using (Process p = Process.GetCurrentProcess())
p.PriorityClass = ProcessPriorityClass.High;
ProcessPriorityClass.High is actually one notch short of the highest priority:
Realtime. Setting a process priority to Realtime instructs the OS that you never want
the process to yield CPU time to another process. If your program enters an accidental
infinite loop, you might find even the operating system locked out, with
nothing short of the power button left to rescue you! For this reason, High is usually
the best choice for real-time applications.
If your real-time application has a user interface, elevating the
process priority gives screen updates excessive CPU time, slowing
down the entire computer (particularly if the UI is complex).
Lowering the main thread’s priority in conjunction with raising
the process’s priority ensures that the real-time thread doesn’t
get preempted by screen redraws, but doesn’t solve the problem
of starving other applications of CPU time, because the operating
system will still allocate disproportionate resources to the
process as a whole. An ideal solution is to have the real-time
worker and user interface run as separate applications with different
process priorities, communicating via Remoting or
memory-mapped files. Memory-mapped files are ideally suited
to this task; we explain how they work in Chapters 14 and 25.
Even with an elevated process priority, there’s a limit to the suitability of the managed
environment in handling hard real-time requirements. In Chapter 12, we described
the issues of garbage collection and the workarounds. Further, the operating
system may present additional challenges—even for unmanaged applications—that
are best solved with dedicated hardware or a specialized real-time platform.
Exception Handling
Any try/catch/finally blocks in scope when a thread is created are of no relevance
to the thread when it starts executing. Consider the following program:
public static void Main()
{
try
{
new Thread (Go).Start();
}
catch (Exception ex)
{
// We'll never get here!
Console.WriteLine ("Exception!");
}
}
static void Go() { throw null; } // Throws a NullReferenceException
798 | Chapter 21: Threading