What optimizations can be done for soft real-time code in C#?

Question

I'm writing a soft real-time application in C#. Certain tasks, like responding to hardware requests coming in from a network, needs to be finished within a certain amount of milliseconds; however it is not 100% mission-critical to do so (i.e. we can tolerate it being on time most of the time, and the 1% is undesirable but not a failure), hence the "soft" part.

Now I realize that C# is a managed language, and managed languages aren't particularly suited for real-time applications. However, the speed in which we can get things done in C#, as well as the language features, like reflection and memory management, make the task of building this application much easier.

Are there any optimizations or design strategies one can take to reduce the amount of overhead and increase determinism? Ideally I would have the following goals

• Delay the garbage collection until it is "safe"
• Allow the garbage collector to work without interfering with real-time processes
• Thread/process priorities for different tasks

Are there any ways to do these in C#, and are there any other things to look out for with regards to real-time when using C#?

The platform target for the application is .NET 4.0 Client Profile on Windows 7 64-bit, with. I've set it currently to Client profile but this was just the default option and wasn't chosen for any particular reason.

Answer 1

The optimization that fulfills your first two bullets is called an Object Pool. It works by

1. creating a pool of objects when the program starts,
2. maintaining references to those objects in a list so that they don't get garbage collected,
3. handing objects to your program from the pool as needed, and
4. returning objects back to the pool when you're done using them.

You can find an example class that implements an Object Pool using a ConcurrentBag here.

Thread/process priority can easily be set at runtime. The Thread Class has methods and properties that allow you to set priority and processor affinity. The Process Class contains similar facilities.

Answer 2

Delay the garbage collection until it is "safe"

You can do that, by setting the GC latency mode to LowLatency. For some more info, see this answer on SO.

Answer 3

Take the same approach that games development does in a managed environment and try to minimise object creation / death down to the absolute minimum.

e.g. Try to create all the objects likely to be required at the start and pool obsessively, pass by ref whereever possible, avoid operations that create short term intermediate objects

Answer 4

Bear in mind that the target environment (Windows) is a pre-emptive multi-tasking O/S. In other words, your soft real time process will inevitably be pre-empted at some time or another, which will introduce other latencies besides the .NET garbage collection. You can mitigate it by reducing the time slice (quantum) value (default is something like 16ms) and elevating the priority of your process (but there are practical limits), but pre-emptions will/must still occur because other essential processes still need to do stuff. All this has nothing to do with programming language; it's fundamental to the O/S.

GC issues aside, your application running on an out-of-the-box Windows machine will probably be able to deliver latencies of a few milliseconds MOST OF THE TIME. It certainly can't be guaranteed 100% of the time, or anything close. Even with tuning (short quantum, high priority), you'll still get occasional high latencies. It's the nature of the beast.

Bottom line: if you need guaranteed response times, especially on the order of a few milliseconds, Windows is probably not the best choice for the delivery O/S.