Skip to main content

A glance at the insides of the CoreCLR

So these past days I was kind of bored and also I wanted to prove to myself that I can take a serious software project and the understand it. I heard so many things about the CLR like it was some kind of alien technology that no one could understand. I saw that it as a challenge and decided to see if it's really like that.

And the rumors were true in a way. The CLR is a marvel of software engineering. It is actually made out of multiple systems with one central system that glues them together. That central system is called the "Execution Engine". I think it's what controls and manages the execution of the program. It is for example responsible for stopping the execution of the program when the garbage collector starts to do it's job.

Actually the garbage collector sends a command to the execution engine to stop the execution of the program. Yes, the garbage collector is another system just like the execution engine. It is actually pretty interesting to see how the garbage collector actually works. The thing is that the code is compiled to native code when the program is executed. And the garbage collector has to somehow make sense of that compiled code in x86 assembly. I think it accesses the variables and objects through a high level interface that takes that compiled x86 code and translates it into something that the garbage collector can use. For example, local references stored on the stack need to be somehow accessed by the GC but it's all compiled code and you somehow need to know where inside the original IL code the execution stopped so you can see what references are available. Those references are used as roots to keep objects alive.

Not only that but I think the execution engine is also responsible for probing variables which is used by the debugger. I saw that there are some structures, C++ structures that tells the location of some variables. I think these are used to show in the locals window in Visual Studio the variables visible in the current scope.

I also think that the execution engine is responsible for debugging too. It can stop the execution of the program or let the program run until a certain point in the code is reached.

Another system inside the CLR is the jit compiler. I think all the IL instructions inside a method are added inside a tree, actually a GenTree that is then modified for specific optimizations. One of these optimizations that I noticed is "folding". I think this means that if we add some constant values inside the code, then before compiling those IL instructions to native code, the constant values are added together and replaced with that result. For example if you have inside the code an expression like "x+4+5" it will get transformed into "x+9".

After all the optimizations are done, I think that tree is traversed by the compiler and x86 code is generated.
Labels:

Comments

Post a Comment

Popular posts from this blog

Some software development common sense ideas

 I haven't really written here in a long time so it's time to write some new things. These are just some random common sense things that seemed to short to write about individually but seem really interesting and useful to me or other people 1. There is nothing fixed in software development, all things vary by circumstances and time Remember the documentation that didn't seem that important when you started the project, well after a couple of years one the application has grown and become really complicated, no one actually knows everything about the application anymore. So now you really need that documentation. What happens if you suddenly need much more people to develop the application because of some explosive growth? Without documentation, new developers will just look at the application like they look at a painting. This actually happened to me. Maybe in the beginning of a project, a technology really helped you a lot but as the project grew, it started making things...
3 comments
Read more

Protected variations in software engineering explained and extended beyond the common usages

While digging through some standard programming principles like low coupling and high cohesion I stumbled upon the fact that they are part of a larger series of principles called "GRASP" principles. After reading a bit about them, they seem just as important if not more important than the "SOLID" principles And one particular principle from that series stuck with me: protected variations. According to this principle, variations and changes in parts of the application should be contained only in them and not trigger further changes in the application. In general terms points of inflection should be established between the parts that change and the rest of the application which act like a boundary and stop additional changes from propagating to the rest of the application. For example, one of the most common parts that might change in an application, is the data access and storage methods. For example instead of using direct sql to read and write to a database, an...
1 comment
Read more

Some things which are often blindly applied and followed by developers which are not always good

This is probably one of the most controversial things that I have written so far but I am just tired of hearing about these things and discussing these things. Other developers that I know share part of my feelings. I would rather hear more about how people built things, overcame challenges or what new interesting ideas and concepts they implemented. Those things are really interesting and innovative, not hearing about the same theoretical things over and over again. I can just read and learn those things from 100 sources on the internet. Firstly, one of the most discussed and promoted things is agile/scrum development. I think I have been through 5-8 workshops about agile development methodology. And each time, some things differed. There is no 100% standard approach to this. Everyone uses their own version of this development methodology and seem to argue a lot that their approach is right and everyone else is doing it wrong. You go to an interview, this will be one of the first 10 t...
1 comment
Read more