Wydajność wywołania delegatów a metody

Od CLR v 2 koszt wywołania delegata jest bardzo zbliżony do kosztu wywołania metody wirtualnej, która jest używana dla metod interfejsu.

Zobacz Blog Joela Pobara .

Uważam za całkowicie nieprawdopodobne, że delegat jest znacznie szybszy lub wolniejszy niż metoda wirtualna. Jeśli już, delegat powinien być niedbale szybszy. Na niższym poziomie delegaty są zwykle implementowane w podobny sposób (używając notacji w stylu C, ale proszę wybaczyć drobne błędy składniowe, ponieważ jest to tylko ilustracja): {]}

struct Delegate {
    void* contextPointer;   // What class instance does this reference?
    void* functionPointer;  // What method does this reference?
}

Wywołanie delegata działa tak:

struct Delegate myDelegate = somethingThatReturnsDelegate();
// Call the delegate in de-sugared C-style notation.
ReturnType returnValue = 
    (*((FunctionType) *myDelegate.functionPointer))(myDelegate.contextPointer);

Klasa, przetłumaczona na C, byłaby czymś w stylu:

struct SomeClass {
    void** vtable;        // Array of pointers to functions.
    SomeType someMember;  // Member variables.
}

Aby wywołać funkcja vritual, wykonałbyś następujące czynności:

struct SomeClass *myClass = someFunctionThatReturnsMyClassPointer();
// Call the virtual function residing in the second slot of the vtable.
void* funcPtr = (myClass -> vtbl)[1];
ReturnType returnValue = (*((FunctionType) funcPtr))(myClass);

Są zasadniczo takie same, z tym wyjątkiem, że podczas korzystania z funkcji wirtualnych przechodzisz przez dodatkową warstwę indrection, aby uzyskać wskaźnik funkcji. Jednak ta dodatkowa warstwa indrection jest często Darmowa, ponieważ nowoczesne predyktory gałęzi procesora odgadną adres wskaźnika funkcji i spekulacyjnie wykonają jego cel równolegle z wyszukaniem adresu funkcji. Znalazłem (choć w D, A Nie w C#) tę wirtualną funkcję wywołania w ciasnej pętli nie są wolniejsze niż wywołania bezpośrednie nieinlinowane, pod warunkiem, że dla dowolnego przebiegu pętli są zawsze rozdzielane do tej samej rzeczywistej funkcji.

Zrobiłem kilka testów (w. Net 3.5... później sprawdzę w domu za pomocą. Net 4). Faktem jest: Uzyskanie obiektu jako interfejsu, a następnie wykonanie metody jest szybsze niż uzyskanie delegata z metody, a następnie wywołanie delegata.

Biorąc pod uwagę, że zmienna jest już we właściwym typie (interfejs lub delegat) i proste wywołanie powoduje, że delegat wygrywa.

Z jakiegoś powodu uzyskanie delegata nad metodą interfejsu (może nad dowolną metodą wirtualną) jest dużo wolniej.

I biorąc pod uwagę przypadki, w których po prostu nie możemy wstępnie zapisać delegata (jak na przykład w Dyspozytorach), może to uzasadniać, dlaczego interfejsy są szybsze.

Oto wyniki:

Aby uzyskać prawdziwe wyniki, skompiluj to w trybie Release i uruchom poza Visual Studio.

Sprawdzanie połączeń bezpośrednich dwa razy
00:00:00.5834988
00:00:00.5997071

Sprawdzanie połączeń interfejsu, pobieranie interfejsu przy każdym połączeniu
00:00:05.8998212

Sprawdzanie połączeń interfejsu, uzyskanie interfejsu raz
00:00:05.3163224

Sprawdzanie wywołań akcji (delegata), pobieranie akcji przy każdym wywołaniu
00:00:17.1807980

Sprawdzanie wywołań akcji (delegata), uzyskanie akcji raz
00:00:05.3163224

Sprawdzanie akcji (delegata) nad metodą interfejsu, uzyskanie obu w każde wywołanie
00:03:50.7326056

Sprawdzanie akcji (delegata) przez interfejs metoda, uzyskanie interfejs raz, delegat przy każdym wywołaniu
00:03:48.9141438

Sprawdzanie akcji (delegata) przez metodę interfejsu, uzyskanie obu raz
00:00:04.0036530

Jak widzisz, bezpośrednie połączenia są naprawdę szybkie. Przechowywanie interfejsu lub delegata przed, a następnie tylko wywołanie go jest naprawdę szybkie. Ale posiadanie delegata jest wolniejsze niż posiadanie interfejsu. Konieczności uzyskania delegata nad metodą interfejsu (lub metodą wirtualną, nie oczywiście) jest bardzo powolny (Porównaj 5 sekund uzyskania obiektu jako interfejsu do prawie 4 minut robienia tego samego, aby uzyskać akcję).

Kod, który wygenerował te wyniki jest tutaj:

using System;

namespace ActionVersusInterface
{
    public interface IRunnable
    {
        void Run();
    }
    public sealed class Runnable:
        IRunnable
    {
        public void Run()
        {
        }
    }

    class Program
    {
        private const int COUNT = 1700000000;
        static void Main(string[] args)
        {
            var r = new Runnable();

            Console.WriteLine("To get real results, compile this in Release mode and");
            Console.WriteLine("run it outside Visual Studio.");

            Console.WriteLine();
            Console.WriteLine("Checking direct calls twice");
            {
                DateTime begin = DateTime.Now;
                for (int i = 0; i < COUNT; i++)
                {
                    r.Run();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }
            {
                DateTime begin = DateTime.Now;
                for (int i = 0; i < COUNT; i++)
                {
                    r.Run();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }

            Console.WriteLine();
            Console.WriteLine("Checking interface calls, getting the interface at every call");
            {
                DateTime begin = DateTime.Now;
                for (int i = 0; i < COUNT; i++)
                {
                    IRunnable interf = r;
                    interf.Run();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }

            Console.WriteLine();
            Console.WriteLine("Checking interface calls, getting the interface once");
            {
                DateTime begin = DateTime.Now;
                IRunnable interf = r;
                for (int i = 0; i < COUNT; i++)
                {
                    interf.Run();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }

            Console.WriteLine();
            Console.WriteLine("Checking Action (delegate) calls, getting the action at every call");
            {
                DateTime begin = DateTime.Now;
                for (int i = 0; i < COUNT; i++)
                {
                    Action a = r.Run;
                    a();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }

            Console.WriteLine();
            Console.WriteLine("Checking Action (delegate) calls, getting the Action once");
            {
                DateTime begin = DateTime.Now;
                Action a = r.Run;
                for (int i = 0; i < COUNT; i++)
                {
                    a();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }


            Console.WriteLine();
            Console.WriteLine("Checking Action (delegate) over an interface method, getting both at every call");
            {
                DateTime begin = DateTime.Now;
                for (int i = 0; i < COUNT; i++)
                {
                    IRunnable interf = r;
                    Action a = interf.Run;
                    a();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }

            Console.WriteLine();
            Console.WriteLine("Checking Action (delegate) over an interface method, getting the interface once, the delegate at every call");
            {
                DateTime begin = DateTime.Now;
                IRunnable interf = r;
                for (int i = 0; i < COUNT; i++)
                {
                    Action a = interf.Run;
                    a();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }

            Console.WriteLine();
            Console.WriteLine("Checking Action (delegate) over an interface method, getting both once");
            {
                DateTime begin = DateTime.Now;
                IRunnable interf = r;
                Action a = interf.Run;
                for (int i = 0; i < COUNT; i++)
                {
                    a();
                }
                DateTime end = DateTime.Now;
                Console.WriteLine(end - begin);
            }
            Console.ReadLine();
        }
    }

}

A co z tym, że delegaci są kontenerami? Czy możliwość multicastu nie zwiększa kosztów? Skoro już jesteśmy w temacie, co zrobić, jeśli przesuniemy ten aspekt kontenera nieco dalej? Nic nie zabrania nam, Jeśli D Jest delegatem, wykonywania d + = d; lub budowania arbitralnie złożonego ukierunkowanego grafu par (wskaźnik kontekstowy, wskaźnik metody). Gdzie mogę znaleźć dokumentację opisującą jak ten wykres jest przesuwany po wywołaniu delegata?