Production postmortemA null reference in our abstraction

time to read 4 min | 781 words

This little nugget has caused a database upgrade to fail. Consider the following code for a bit. We have CompoundKey, which has two versions, slow and fast. The idea is that we use this as keys into a cache, and there are two types because we can “query” the cache cheaply, but constructing the actual key for the cache is more expensive. Hence, the names.

public class CompoundKey
{
    public int HashKey;

}

public sealed class FastCompoundKey : CompoundKey
{
    public int Val;

}

public sealed class SlowCompoundKey : CompoundKey
{
    public int SlowVal;

}
public class CompoundKeyEqualityComparer : IEqualityComparer<CompoundKey>
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool Equals(CompoundKey x, CompoundKey y)
    {
        if (x == null || y == null)
            return false;

        SlowCompoundKey k;
        FastCompoundKey self;
        var key = x as FastCompoundKey;
        if (key != null)
        {
            self = key;
            k = y as SlowCompoundKey;
        }
        else
        {
            self = y as FastCompoundKey;
            k = x as SlowCompoundKey;
        }

        return self.Val == k.SlowVal;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int GetHashCode(CompoundKey obj)
    {
        return obj.HashKey;
    }
}

The problem was a null reference exception in the Equals method.  And I believe the term for how I felt was:

The problem is that it is obvious why a null reference exception can be thrown. If the values passed to this method are both SlowCompoundKey or both FastCompoundKey. But the reason the Equals method looks the way it does is that this is actually in a very performance sensitive portion of our code, and we have worked to make sure that it runs as speedily as possible. We considered the case where we would have both of them, but the code had a measured performance impact, and after checking the source of the dictionary class, we were certain that such comparisons were not possible.

We were wrong.

Boiling it all down, here is how we can reproduce this issue:

 var dic = new Dictionary<CompoundKey, object>(new CompoundKeyEqualityComparer());
 dic[new SlowCompoundKey { HashKey = 1 }] = null;
 dic[new SlowCompoundKey { HashKey = 1 }] = null;

What is going on here?

Well, it is simple. We add another value with the same hash code. That mean that the dictionary need to check if they are the same value, or just a hash collision. It does so by passing both the first key (slow) and the second key (slow) into the Equals method, and then hilarity enthused.

In retrospect, this is pretty much how it has to behave, and we should have considered that, but we were focused on looking at just the read side of the operation, and utterly forgot about how insert must work.

Luckily, this was an easy fix, although we still need to do regressive perf testing.

More posts in "Production postmortem" series:

  1. (07 Aug 2017) 30% boost with a single line change
  2. (04 Aug 2017) The case of 99.99% percentile
  3. (02 Aug 2017) The lightly loaded trashing server
  4. (23 Aug 2016) The insidious cost of managed memory
  5. (05 Feb 2016) A null reference in our abstraction
  6. (27 Jan 2016) The Razor Suicide
  7. (13 Nov 2015) The case of the “it is slow on that machine (only)”
  8. (21 Oct 2015) The case of the slow index rebuild
  9. (22 Sep 2015) The case of the Unicode Poo
  10. (03 Sep 2015) The industry at large
  11. (01 Sep 2015) The case of the lying configuration file
  12. (31 Aug 2015) The case of the memory eater and high load
  13. (14 Aug 2015) The case of the man in the middle
  14. (05 Aug 2015) Reading the errors
  15. (29 Jul 2015) The evil licensing code
  16. (23 Jul 2015) The case of the native memory leak
  17. (16 Jul 2015) The case of the intransigent new database
  18. (13 Jul 2015) The case of the hung over server
  19. (09 Jul 2015) The case of the infected cluster