Monday, September 10, 2012

GC - The Garbage Collector in managed .Net world

If you in the managed program execution world, you cannot avoid the word GC even though everybody says its managed automatically and there is no need to worry about memory management during coding. Ideally the garbage collection ie memory management should be done intelligently by the managed runtime environment otherwise there is no need to adopt that run-time. But the truth is opposite. Earlier when we had managed the memory ourselves, it was easy as we were deleting the objects .But now we need to depend and learn the working of another software piece written by somebody else to effectively manage memory of our application and that is called GC ie the GarbageCollector.Not a joke. If you don't know the working of GC you cannot survive in the managed world .At least it will be a bottle neck in your job interview.

This post is not intended to explain about the GC in paragraphs. This helps to refresh the concepts about GC by just pointing to already written articles. This means you need to have prior knowledge about GC.

What .Net GC does?

  • Collects unused objects and frees memory
  • Compacts / Defragment the memory of Gen 0,1,2 after clearing the speace used by the objects.
  • There is LOH (Large Object Heap) which contains large objects .Normally size > 85KB. This space is not defragmented by GC. Why there is a LOH is because the object moving process is heavy and may impact the performance.
  • LOH objects are marked as deleted by GC and GC keeps track of free space in LOH to perform allocation for the next time.

How GC works

  • Use generational algorithm.
  • Start by assuming that all the objects are garbage except the application roots.
  • Application root
    • Any static variable is application root
    • Any local variable or method params of function which is executing when the GC starts.
    • Any object in heap which is pointed by any CPU register.
    • Any object whose pointer is present in freachable queue or passed to COM+ via interop.
  • It creates memory map by traversing the objects starting from application roots.
  • If the object is in use it promotes the object from its current generation to higher generation.
  • Generation is simply an area in the memory heap. There are 3 Generations
  • Gen 0
    • Contains all the newly created objects.
  • Gen 1 
    • Contains objects which are promoted by GC from gen 0 .ie the objects which are still in use.
  • Gen 2
    • Contains objects which are promoted from Gen 2 .Mainly old objects.
  • Once the collection completes GC performs a compaction in the generation.
  • After compaction it moves the next object pointer to the end of allocated objects so that next time the new keyword can execute faster.
  • Collecting unwanted objects from these 3 generations is time consuming.So it can perform partial collections say collect only Gen 0.
  • Once the object seems Garbage to GC it moves the object pointer from Finalization queue to the freachable queue in case the object pointer is present in the finalization queue.
    • The entry to the finalization queue is put at the time of object allocation (new keyword) if the Finalize method is overriden
  • When any object pointer is available in the f-reachable queue the finalization thread starts and calls the Finalize method on each object. At this time the object becomes non-garbage.
  • Next time when GC finds the finalized objects as garbage it simply removed the objects.

Finalize method 

  • This is a mechanism to object to cleanup themselvs
  • Similar to destructor and now C# allows us to write the Finalize in the destructor syntax only.
  • This destructor method will be converted to Finalize method during compilation which means there is no real destructor in C# .Net.
  • GC calls this Finalize method after marking the object as garbage.

When GC starts collecting garbage?

  • It is NOT based on time interval.
  • When somebody calls the GC.Collect
  • When there is not enough physical memory
  • When a generation (heap) is full so that it cannot allocate new objects or move survived objects to next generation.

Monitoring GC

External links

Monday, September 3, 2012

Learn programming interactively in online

Below are some sites which will help you to learn coding interactively by trying out as you learn!!! ie Its not just another video based which we need to watch for long.Rather these sites provide interactive console which allows you to write code and execute in the browser itself. Some of them also provides tracking capability so that you will be confident on what you learnt.

Javascript - (Really good for non-programmers)
Javascript - (Fun learning for non-programmers)
Ruby -
Python -
Lua - (Gives web based interactive console not step by step instructions)
.Net - (This needs Visual Studio)

I really found these interesting as these do't need the long time environment setup to begin with or we will never get into sleep like video tutorials ;-) .Video tutorials are good when we just need to get awareness of the technology .But not good as interactive sites when it comes to becoming experts in the area.

Update 23OCT2012

Another page which lists more sites offers online learning materials both interactive and via videos

Update 22NOV2012

Update 7Feb2015