When CLR Do Automatic Memory Management and GC?

Question

5.00/5 (1 vote)

See more:

I am trying to understand how .net CLR work, I listed how it work as far as I know(Maybe there are some mistake, please feel free to point out), and have some questions below.

1, When .Net Compiler compile .net application source code, it will select whatever language compiler.Than creates dll or exe assembly, which includes CIL, Metadata and Manifest.

2, In Manifest, it tells which outside library I need to use. So the library(or other dll) loaded.

3, JIT translate CIL to machine language which the computer can run the application. JIL also check the code safety.

My questions are:
1, Is the CLR run as I mentioned above?

2, I know that the CLR also responsible for Automatic memory management and Garbage Collection. When CLR do those thing?

Posted 2-Jan-13 11:45am

Chelseajcole

Add a Solution

Comments

Sergey Alexandrovich Kryukov 2-Jan-13 18:13pm

This is very rare case when I vote 5 for the question.

I can only repeat that the question are accurately formulated and probably show your intent to get the essence of things. Unfortunately, these days this is quite rare. I answered all your questions so far, and in all three cases I up-voted it with pleasure.

—SA

2 solutions

Solution 1

Memory management happens when it feels like it. This is not good enough if you use large objects in memory, like videos. It's fine for most applications.

It has nothing to do with the compilation process that you listed. It's something else entirely.

Posted 2-Jan-13 12:05pm

Christian Graus

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2013-01-02T12:10:00

Let's see:

Pretty much so, but not quite exactly when you write about the JIT operation. Usually, the code is JIT-compiled on per-method basis. When some method is about to be called for the very first time in the lifetime of its assembly, it is JIT-compiled.

It can be pre-compiled if you use NGEN.EXE, which can be done for some performance benefits, for example: http://msdn.microsoft.com/en-us/library/6t9t5wcf%28v=vs.110%29.aspx[^].

This is a very interesting in-depth CodeProject article on JIT optimization: JIT Optimizations[^].
Memory management is and garbage collection work pretty much all the time; their operation is independent from the application process and transparent to it. The general rule is: you can never rely on any particular order of operation.

You can prevent memory management operations when you pin some memory. This is done by using fixed statement. Please see:
http://msdn.microsoft.com/en-us/library/f58wzh21.aspx[^].

There are a number of cases when you really need pinning. Normally, you do it only if you directly use pointers in an assembly compiled with unsafe option in the code under unsafe statement: http://msdn.microsoft.com/en-us/library/chfa2zb8%28v=vs.110%29.aspx[^].

Again, this is an interesting in-depth CodeProject article on pinning: Pinned Object[^].

And now, about GC. The operation of GC is driven by the reachability of objects. The actual call of the object destructors and the act of reclaiming memory cannot be predicted bu the application (by the way, this is the reason why destructores are rarely written in the typical .NET applications, usually this is not needed and can created some problems of race conditions type), but it happens when some object becomes unreachable.

By the way, this is not so trivial criterion as you might think. For example, if object A references object B, object B references object C, and C reference A, this cyclic dependency does not prevent GC from figuring out that all objects should be garbage-collected if there are no other referenced to them. This is easy to check up by a simple experiment.

You can find the detail of reachability and garbage collection here: http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29[^].

Good luck,

—SA