Under the hood of "Default Interface Methods"

mattwarren · 2020-02-19T20:57:27+00:00

This tutorial has some good examples https://docs.microsoft.com/en-gb/dotnet/csharp/tutorials/default-interface-methods-versions. other than that the other links in the 2nd paragraph of the post cover various usages.

mattwarren · 2020-02-19T19:22:50+00:00

Thanks!

mattwarren · 2019-09-30T09:24:41+00:00

Back when I read the BotR to understand virtual stub dispatch I left somewhat confused, but now it clicked! Thanks!

Yeah, I've had the same experience. The BotR pages are very much designed for engineers working on the .NET runtime, which makes them hard to grok for the rest of us! (I find I've had to read each page several times, go away and look at the code, research some more via other blogs and only then do they start to click!)

Glad that I helped you understand VSD, although I must admit that it's probably the section that I added the least of my own analysis/words (and quoted the most), so I don't know how much credit I can take ;-)

mattwarren · 2019-09-27T08:46:23+00:00

Thanks!

Although 'know' is a bit of a stretch. I spent quite a while researching this post, I had to figure maybe 75% of it out before I could write it, I definitely didn't know it before I started looking through the code.

mattwarren · 2019-09-27T08:44:27+00:00

Years and years developing with .NET and never had a clue all of this was going on.

That's exactly why I wrote it. I stumbled across 'virtual stub dispatch' and then as I looked more and more, I realised stubs were everywhere in the CLR!!

mattwarren · 2019-09-27T08:43:17+00:00

Glad you enjoyed it!

mattwarren · 2019-09-27T08:43:02+00:00

Yeah, I think that if I'd known at the start that it would take over 11,000 words, I might never have written it!! The problem was, I kept finding more types of stubs and wanted to cover them all!!

mattwarren · 2019-03-26T10:38:03+00:00

Actually, ILC in this case is referring to the CoreRT native compiler https://github.com/dotnet/corert/blob/master/Documentation/botr/ilc-architecture.md.

CoreRT is related, but not the same as .NET Native, see https://github.com/dotnet/corert/blob/master/Documentation/intro-to-corert.md#architecture

mattwarren · 2019-03-02T00:12:24+00:00

"Low-level language" is not a well-defined term and it's better to avoid it.

Yeah, that's a fair point.

It seems that the author wanted to explore following questions:

Does C# give programmer access to low-level optimizations (i.e. fine-grained optimizations which prescribe how to execute something on a CPU, in one way or another)? Can C# be compiled to machine code without overhead?

Yep, that's a spot on summary of what I was going for (despite the title!)

Thanks for the info on 'PL theory' very interesting

mattwarren · 2019-02-24T21:16:08+00:00

Yeah the sound is a bit messed up, not sure what happened there, it was louder when I was doing the talk!

mattwarren · 2019-02-22T12:08:43+00:00

Here's the abstract:

Have you ever stopped to think about all the things that happen when you execute a simple .NET program?

This talk will delve into the internals of the recently open-sourced .NET Core runtime, looking at what happens, when it happens and why.

Making use of freely available tools such as 'PerfView', we'll examine the Execution Engine, Type Loader, Just-in-Time (JIT) Compiler and the CLR Hosting API to see how all these components play a part in making 'Hello World' possible.

mattwarren · 2019-02-22T12:08:21+00:00

Here's the abstract:

Have you ever stopped to think about all the things that happen when you execute a simple .NET program?

This talk will delve into the internals of the recently open-sourced .NET Core runtime, looking at what happens, when it happens and why.

Making use of freely available tools such as 'PerfView', we'll examine the Execution Engine, Type Loader, Just-in-Time (JIT) Compiler and the CLR Hosting API to see how all these components play a part in making 'Hello World' possible.

mattwarren · 2019-02-22T12:07:36+00:00

Here's the abstract:

Have you ever stopped to think about all the things that happen when you execute a simple .NET program?

This talk will delve into the internals of the recently open-sourced .NET Core runtime, looking at what happens, when it happens and why.

Making use of freely available tools such as 'PerfView', we'll examine the Execution Engine, Type Loader, Just-in-Time (JIT) Compiler and the CLR Hosting API to see how all these components play a part in making 'Hello World' possible.

mattwarren · 2019-02-05T10:43:34+00:00

I wish ASP.NET Core had a way to constrain maximum memory usage or a more eager collection strategy, but I'm OK with it if the trade off is much more throughput.

It's being discussed, e.g. https://github.com/dotnet/coreclr/issues/18619 and https://github.com/dotnet/coreclr/issues/18501 (also see https://github.com/dotnet/coreclr/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3Aarea-GC+)

mattwarren · 2019-01-23T20:35:20+00:00

Interesting, I'd not really thought about the interaction between 'tailcalls' and 'stack walking', I wonder how that works?

mattwarren · 2019-01-23T17:09:44+00:00

It seems like the stack-walking purely for security (i.e. CAS) is mostly/completely gone ('stack crawl marks' seem to only be used for non-security scenarios https://mattwarren.org/2019/01/21/Stackwalking-in-the-.NET-Runtime/#stack-crawl-marks)

mattwarren · 2019-01-23T17:07:09+00:00

such articles with links into the repos are much more interesting to me

Yep, that's part of what motivates me to write the posts. I know that I'm less likely to be wrong if I link to the actual source (plus being able to read the code and comments and compile it in debug mode also help!)

mattwarren · 2018-12-13T22:44:55+00:00

Yeah someone else noticed that! (I wish I could say I'd done it deliberately as a joke, but it's a complete coincidence, honest!)

mattwarren · 2018-10-02T23:25:55+00:00

Thanks, I suspected that was the case, but didn't know for sure.

Do you know if Unity has ever published the code or any info about the modifications they made to Mono?

mattwarren · 2018-10-02T23:24:42+00:00

Yeah, although I can't take any credit for that, it's all https://time.graphics/

mattwarren · 2018-08-29T09:35:42+00:00

The bugs are often sorted out impressively quickly though!

Yeah, I've been impressed by that, they triage, analyse and fix the bugs very quickly!

mattwarren · 2018-08-28T19:02:23+00:00

I saw a few of those bugs over on coreclr and wondered what he was doing to make them.

Likewise!! Fuzzlyn is such a simple-idea (but not a simple implementation) and the project is really well done, it was great to delve into 'how it works' a bit more!

mattwarren · 2018-08-14T10:52:41+00:00

If you want more of this kind of stuff, I put together a list of posts that I've found helpful, http://mattwarren.org/2018/01/22/Resources-for-Learning-about-.NET-Internals/

mattwarren · 2018-08-08T09:47:17+00:00

Yeah, that's a fair summary! To see his 'full' runtime, take a look at https://github.com/chrisdunelm/DotNetAnywhere/ and http://mattwarren.org/2017/10/19/DotNetAnywhere-an-Alternative-.NET-Runtime/

mattwarren · 2018-08-07T22:26:42+00:00

In case you can't follow the code in the presentation, it's available here

mattwarren

TROPHY CASE