CODEWITHSUNDEEP
.netperformancegenericshashtablemicro-optimization
mcintyre321
mcintyre321

Reputation: 13306

performance of IDictionary<Type, object> vs generic Type property

edit: I based this question on a false assumption - that the generic type instance lookups I was doing would be the doinf same work as when done on generic types created at runtime. The ones in my harness are accessible to the compiler so it can compile them into address lookups. I'm still pretty interested in what .MakeGenericType does behind the scenes.

I've just done a quick comparison between getting a value from a IDictionary and getting a value from generic type with a static property.

Results for 100000000 lookups:

Dictionary: 14.5246952 Generic type: 00.2513280

What kind of magic is .NET using in the background to map to the instance of the Generic so quickly? I would have thought something similar to a hashtable would have to be used to lookup. Maybe it gets JITTED... I don't know! Do you?

Here's my test harness - I'm sure it's full of mistakes so let me know what needs fixing!

void Main()
{
    var sw = new Stopwatch();
    var d = new Dictionary<Type, object>() 
    { 
     { typeof(string), new object() },
     { typeof(int), new object() } 

    };
    var stringType = typeof(string);
    var intType = typeof(int);
    sw.Start();
    for (var i = 0; i < 100000000; i++)
    {
        Debug.Assert(d[stringType] != d[intType]);
    }
    sw.Stop();
    sw.Elapsed.Dump();
    sw.Reset();

    Lookup<string>.o = new object();
    Lookup<int>.o = new object();
    sw.Start();
    for (var i = 0; i < 100000000; i++)
    {
        Debug.Assert(Lookup<string>.o != Lookup<int>.o);
    }
    sw.Stop();
    sw.Elapsed.Dump();
}

class Lookup<T>
{
    public static object o;
}

Upvotes: 3

Views: 452

Answers (2)

Hans Passant
Hans Passant

Reputation: 941635

The JIT compiler knows the address of the static o variable. It allocated it in the loader heap. That it is a member of a generic class is not relevant. In other words, resolving the address of a static variable does not require a runtime lookup, it is done at compile time. The generated machine code is trivial:

000000f8  mov         eax,dword ptr ds:[02785D0Ch] 
000000fd  cmp         eax,dword ptr ds:[02785D10h]

Note the hard-coded addresses.

Upvotes: 4

alpha-mouse
alpha-mouse

Reputation: 5003

I think that mappings to your generics are made at compile time, whereas dictionary performs lookup in runtime.

Upvotes: 2

Related Questions