Should we use “workstation” garbage collection or “server” garbage collection?

by

It’s not explained very well, but as far as I can tell, the server mode is synchronous per core, while the workstation mode is asynchronous.

In other words, the workstation mode is intended for a small number of long running applications that need consistent performance. The garbage collection tries to “stay out of the way” but, as a result, is less efficient on average.

The server mode is intended for applications where each “job” is relatively short lived and handled by a single core (edit: think multi threaded web server). The idea is that each “job” gets all the cpu power, and gets done quickly, but that occasionally the core stops handling requests and cleans up memory. So in this case the hope is that GC is more efficient on average, but the core is unavailable while its running, so the application needs to be able to adapt to that.

In your case it sounds like, because you have a single application whose threads are relatively coupled, you’re fitting better into the model expected by the first mode rather than the second.

But that’s all just after-the-fact justification. Measure your system’s performance (as ammoQ said, not your GC performance, but how well you application behaves) and use what you measure to be best.

More Related Contents:

  1. Proper use of the IDisposable interface
  2. Understanding garbage collection in .NET
  3. Do event handlers stop garbage collection from occurring?
  4. When is it acceptable to call GC.Collect?
  5. Do you need to dispose of objects and set them to null?
  6. Best Practice for Forcing Garbage Collection in C#
  7. Implementing IDisposable correctly
  8. Memory Leak in C#
  9. Dispose, when is it called?
  10. .Net and Bitmap not automatically disposed by GC when there is no memory left
  11. Does garbage collector call Dispose()? [duplicate]
  12. GC.Collect()
  13. Monitoring Garbage Collector in C#
  14. How can I write a unit test to determine whether an object can be garbage collected?
  15. Is correct to use GC.Collect(); GC.WaitForPendingFinalizers();?
  16. GC.Collect() and Finalize
  17. Can .NET Task instances go out of scope during run?
  18. Timer, event and garbage collection : am I missing something?
  19. When should I use GC.SuppressFinalize()?
  20. MemoryStream.Close() or MemoryStream.Dispose()
  21. Guidelines For Dispose() and Ninject
  22. Why should we call SuppressFinalize when we don’t have a destructor
  23. Does WeakReference make a good cache?
  24. How does garbage collection and scoping work in C#? [duplicate]
  25. Garbage Collection should have removed object but WeakReference.IsAlive still returning true
  26. How do I get .NET to garbage collect aggressively?
  27. What’s the purpose of GC.SuppressFinalize(this) in Dispose() method?
  28. Garbage Collection not happening even when needed
  29. Is it possible to create a new operator in c#?
  30. Multi-threading with .Net HttpListener

Leave a Comment