Merge pull request #66 from kennethshackleton/feature/reduce-hash-table

Reduce hash table to less than 140kB.

Author: kennethshackleton

README.md

@@ -23,7 +23,7 @@ The implementation being immutable is already thread-safe and there is no initia
 
 ## How does it work?
 
-We exploit a key-scheme that gives us just enough uniqueness to correctly identify the integral rank of any 7-card hand, where the greater this rank is the better the hand we hold and two hands of the same rank always draw. We require a memory footprint of 230kB and typically six additions to rank a hand.
+We exploit a key-scheme that gives us just enough uniqueness to correctly identify the integral rank of any 7-card hand, where the greater this rank is the better the hand we hold and two hands of the same rank always draw. We require a memory footprint just shy of 140kB and typically six additions to rank a hand.
 
 To start with we computed by brute force the first thirteen non-negative integers such that the formal sum of exactly seven with each taken at most four times is unique among all such sums: 0, 1, 5, 22, 98, 453, 2031, 8698, 22854, 83661, 262349, 636345 and 1479181. A valid sum might be 0+0+1+1+1+1+5 = 9 or 0+98+98+453+98+98+1 = 846, but invalid sum expressions include 0+262349+0+0+0+1 (too few summands), 1+1+5+22+98+453+2031+8698 (too many summands), 0+1+5+22+98+453+2031+8698 (again too many summands, although 1+5+22+98+453+2031+8698 is a legitimate expression) and 1+1+1+1+1+98+98 (too many 1's). We assign these integers as the card face values and add these together to generate a key for any non-flush 7-card hand. The largest non-flush key we see is 7825759, corresponding to any of the four quad-of-aces-full-of-kings.
 

scripts/perfect_hash.py

@@ -23,8 +23,6 @@
 # A Czech-Havas-Majewski perfect hash implementation.
 # See "Fundamental Study Perfect Hashing" by Czech, Havas, Majewski,
 # Theoretical Computer Science 182 (1997) 1-143.
-#
-# Modified by sorting input so as to always write densest rows first.
 
 from rank import rank
 
@@ -50,54 +48,67 @@
 print "Key count is %i." % (len(keys),)
 print "Max key is %i." % (max_key,)
 
-side = 128 # Power of 2 to ultimately optimise hash key calculation.
-print "Square will be of side %i." % (side,)
+M = 31
+power = 9
+side = (1 << power)
+bits = 23
+print "Table will be of side %i." % (side,)
 
-square = [[-1]*(512*side) for i in xrange(side)]
+NOT_A_VALUE = -1
 
-offset = [0]*((max_key / side) + 1)
-ranks = [-1]*max_key
-length = 0
+square = [[NOT_A_VALUE]*(600*side) for i in xrange(side)]
+
+offset = [0]*(1 << (bits - power))
+ranks = [NOT_A_VALUE]*max_key
+
+diffused_keys = {}
 
-counts = [0]*len(offset)
+def diffuse(k):
+    k *= M
+    return k & ((1 << bits) - 1)
 
 for k in keys:
+    d = diffuse(k)
+    assert d not in diffused_keys
+    diffused_keys[diffuse(k)] = k
+
+for k, v in diffused_keys.iteritems():
     r = k / side
-    square[k % side][r] = rank(k)
-    counts[r] += 1
+    assert square[k % side][r] == NOT_A_VALUE
+    square[k % side][r] = rank(v)
 
-sorted_rows = sorted(
-    xrange(0, len(offset)),
-    key=lambda x: counts[x],
-    reverse=True)
+length = 0
 
 for i in xrange(0, len(offset)):
-    z = sorted_rows[i]
-    for j in xrange(0, len(ranks)-side):
+    for j in xrange(0, len(ranks)):
         collision = False
         for k in xrange(0, side):
-            s = square[k][z]
+            s = square[k][i]
             h = ranks[j+k]
-            collision = (s != -1 and h != -1 and s != h)
+            collision = (s != NOT_A_VALUE and h != NOT_A_VALUE and s != h)
             if collision: break
         if not collision:
-            offset[z] = j
+            offset[i] = j
             for k in xrange(0, side):
-                s = square[k][z]
-                if s != -1:
+                s = square[k][i]
+                if s != NOT_A_VALUE:
                     n = j+k
                     ranks[n] = s
                     length = max(length, n+1)
-            print "Offset of row %i is %i (length %i)." % (z, j, length)
+            print "Offset of row %i is %i (length %i)." % (i, j, length)
             break
 
+for k in keys:
+    d = diffuse(k)
+    assert rank(k) == ranks[offset[d / side] + (d % side)]
+
 for i in xrange(0, length):
-    if ranks[i] == -1: ranks[i] = 0
+    if ranks[i] == NOT_A_VALUE: ranks[i] = 0
 
-with open('./ranks_sort_%s' % (side,), 'w') as f:
+with open('./ranks_%i_%i' % (side, M,), 'w') as f:
     f.write("%s\n" % (ranks[0:length],))
 
-with open('./offset_sort_%s' % (side,), 'w') as f:
+with open('./offset_%i_%i' % (side, M,), 'w') as f:
     f.write("%s\n" % (offset,))
 
-print "Hash table has length %i." % (length,)
+print "Accepted hash table with length %i." % (length,)

scripts/rank.py

@@ -26,7 +26,7 @@
 FACE_BIT_MASK = ((1 << FLUSH_BIT_SHIFT) - 1)
 
 ranks = [
- 7220, 7243, 5860, 7297, 7309, 7229, 7242, 7298, 7153, 7310, 7206, 7298, 7142,
+  7220, 7243, 5860, 7297, 7309, 7229, 7242, 7298, 7153, 7310, 7206, 7298, 7142,
   7154, 7310, 7298, 7165, 7166, 7166, 7310, 7321, 7322, 7322, 7322, 7299, 7153,
   7311, 7194, 7299, 7141, 7153, 7311, 7299, 7142, 4161, 7154, 7311, 7165, 7165,
   7166, 7166, 7205, 7323, 7323, 7323, 7299, 7143, 7155, 7311, 7299, 7143, 4183,

src/Constants.h

@@ -86,8 +86,8 @@
 #define MAX_SEVEN_FLUSH_KEY_INT (ACE_FLUSH|KING_FLUSH|QUEEN_FLUSH|JACK_FLUSH|\
                                  TEN_FLUSH|NINE_FLUSH|EIGHT_FLUSH)
 
-#define RANK_OFFSET_SHIFT 7
-#define RANK_HASH_MOD 127
+#define RANK_OFFSET_SHIFT 9
+#define RANK_HASH_MOD ((1<<RANK_OFFSET_SHIFT) - 1)
 
 #define MAX_FLUSH_CHECK_SUM (7*CLUB)