手工字典比.Net字典快多少？

Question

Reviewing one opensource project, I've come across one interesting Data structure:

// Represents a layer of "something" that covers the map
public class CellLayer<T> : IEnumerable<T>
{
    public readonly Size Size;
    public readonly TileShape Shape;
    public event Action<CPos> CellEntryChanged = null;

    readonly T[] entries;

    public CellLayer(Map map)
        : this(map.TileShape, new Size(map.MapSize.X, map.MapSize.Y)) { }

    public CellLayer(TileShape shape, Size size)
    {
        Size = size;
        Shape = shape;
        entries = new T[size.Width * size.Height];
    }

    public void CopyValuesFrom(CellLayer<T> anotherLayer)
    {
        if (Size != anotherLayer.Size || Shape != anotherLayer.Shape)
            throw new ArgumentException(
                "layers must have a matching size and shape.", "anotherLayer");
        if (CellEntryChanged != null)
            throw new InvalidOperationException(
                "Cannot copy values when there are listeners attached to the CellEntryChanged event.");
        Array.Copy(anotherLayer.entries, entries, entries.Length);
    }

    // Resolve an array index from cell coordinates
    int Index(CPos cell)
    {
        return Index(cell.ToMPos(Shape));
    }

    // Resolve an array index from map coordinates
    int Index(MPos uv)
    {
        return uv.V * Size.Width + uv.U;
    }

    /// <summary>Gets or sets the <see cref="OpenRA.CellLayer"/> using cell coordinates</summary>
    public T this[CPos cell]
    {
        get
        {
            return entries[Index(cell)];
        }

        set
        {
            entries[Index(cell)] = value;

            if (CellEntryChanged != null)
                CellEntryChanged(cell);
        }
    }

    /// <summary>Gets or sets the layer contents using raw map coordinates (not CPos!)</summary>
    public T this[MPos uv]
    {
        get
        {
            return entries[Index(uv)];
        }

        set
        {
            entries[Index(uv)] = value;

            if (CellEntryChanged != null)
                CellEntryChanged(uv.ToCPos(Shape));
        }
    }

    /// <summary>Clears the layer contents with a known value</summary>
    public void Clear(T clearValue)
    {
        for (var i = 0; i < entries.Length; i++)
            entries[i] = clearValue;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return (IEnumerator<T>)entries.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

This structure represents a matrix of type T in that, given a CPos (an X,Y) structure, it returns the T element at that position. Here's one sample usage:

var dic = new CellLayer<CellInfo>(TileShape.Rectangle, new Size(1280,1280));
cellLayer[new CPos(0, 1)] = new CellInfo(0, new CPos(0, 1), false);

Internally, the CellLayer class transforms the given CPos into a int which operates as the index for the internal array.

By the looks of how the class operates from a client-side perspective, it felt to me like a Dictionary, so I replaced the implementation. After several runtimes tests and microbenchmarking, it turned out that using the dictionary was dozens of times slower than using the handmade CellLayer class. That surprised me. Here are the tests I did:

    [Test]
    public void DictionaryTest()
    {
        var dic = new Dictionary<CPos, CellInfo>(1280 * 1280);

        var watch = Stopwatch.StartNew();

        for (int i = 0; i < 1280; i++)
            for (int u = 0; u < 1280; u++)
                dic[new CPos(i, u)] = new CellInfo(0, new CPos(i, u), false);

        Console.WriteLine(watch.ElapsedTicks);
    }

    [Test]
    public void CellLayerTest()
    {
        var dic = new CellLayer<CellInfo>(TileShape.Rectangle, new Size(1280,1280));

        var watch = Stopwatch.StartNew();

        for (int i = 0; i < 1280; i++)
            for (int u = 0; u < 1280; u++)
                dic[new CPos(i, u)] = new CellInfo(0, new CPos(i, u), false);

        Console.WriteLine(watch.ElapsedTicks);
    }

I thought that .NET Collections were as optimized as possible. Can anyone explain to me how is it that using Dictionary is slower that using a "custom Dictionary"?

Thanks

Answer 1

For the original version, you find the location of an entry by using this formula

uv.V * Size.Width + uv.U

To find the location in a dictionary

1. Calculate the hash code for CPos.
2. Find the bucket in the dictionary using a modulus operation hashcode % dictionarySize
3. If the bucket isn't empty, compare the CPos you have with the CPos in that bucket. If they don't match you have a secondary hash code collision. Move to the next bucket and retry step 3.

If you have a primary has code collision, which is to say lots of different CPos values have the same hash code, your dictionary is going to be ridiculously slow.

If you have unique hash codes, then it is probably the modulus operation that is killing performance. But you would need to attach a profiler (eg Redgate ANTS) to find out for sure.

Answer 2

A dictionary maintains an search/retrievable set of itmes (either through a hash-table, a binary tree or something similar). So each Add() and each [key] implies some search (which tends to be relatively "slow").

In your case, if there is a simple mapping from a CPos to an integer (aka array index) there is no search but a direct (and fast) access to a cell of an array.

Or, to put it simpler: Essentially you compare a hash table/binary tree against a flat array.

---

Edit

Of course both collections are rather fast and show O(1) compexity. A lookup in a hash table is more complex than an array index operation however.