News for hackers. Stuff that matters.
Re:Why is .NET reflection slow? by kevingadd on Friday December 16, 2016 @11:08PM (#13199137)
FWIW, the pre-RyuJIT .NET runtime was definitely capable of inlining and devirtualization. I've seen it do the optimization for IDisposable.Dispose calls, off the top of my head. I would expect RyuJIT is capable of doing this in more places.

I don't know if they've ever implemented this for delegates, though.

Re:Why is .NET reflection slow? by int_19h on Saturday December 17, 2016 @03:28AM (#13199875)
It was actually capable of inlining to the point where it could do some tricks that you'd normally expect only from C++. For example, if you use generics and structs rather than delegates to implement higher-order functions, like so:

    class Program {
        interface IFunc<T1, T2, TResult> {
            TResult Invoke(T1 x1, T2 x2);
        }

        struct AddInt32 : IFunc<int, int, int> {
            public int Invoke(int x, int y) {
                return x + y;
            }
        }

        static T FoldLeft<T, F>(T[] xs, F f) where F : IFunc<T, T, T> {
            var res = xs[0];
            for (int i = 1; i < xs.Length; ++i) {
                res = f.Invoke(res, xs[i]);
            }
            return res;
        }

        static void Main() {
            Console.ReadKey();
            int[] xs = { 1, 2, 3, 5, 8 };
            int res = FoldLeft(xs, new AddInt32());
            Console.WriteLine(res);
        }
    }
I compiled and ran it with 3.5 SP1 x86 (the old 64-bit JIT wasn't good, and won't inline in this case). It didn't inline FoldLeft, but it did inline AddInt32 into the loop - this is from VS debugger disassembly:

            for (int i = 1; i < xs.Length; ++i) {
    017B0106  mov         edx,1  
    017B010B  mov         edi,dword ptr [ecx+4]  
    017B010E  cmp         edi,1  
    017B0111  jle         017B011E  
                res = f.Invoke(res, xs[i]);
    017B0113  mov         eax,dword ptr [ecx+edx*4+8]  
    017B0117  add         esi,eax  
            for (int i = 1; i < xs.Length; ++i) {
    017B0119  inc         edx  
    017B011A  cmp         edi,edx  
    017B011C  jg          017B0113  
            }
Re:Why is .NET reflection slow? by dfkf on Saturday December 17, 2016 @07:04AM (#13200385)
Generic code working with reference types can be shared, but passing structs for generic parameters forces JIT compiler to generate separate instances of generic methods or classes for each combination of structs. From there inlining becomes trivial. But yes, being able to pull stuff like this is one of the cooler parts of .NET.
Re:Why is .NET reflection slow? by taspeotis on Saturday December 17, 2016 @12:22AM (#13199376)
Yeah my wording is a bit loose. There's a lot of clever stuff that RyuJit etc. do for performance. I believe the JVM has even more clever stuff although I haven't dedicated much time to learning what it does better or differently.