我有一个存储四叉树条目的哈希表 哈希函数如下所示：
四叉树哈希
#define node_hash(a,b,c,d) \
(((int)(d))+3*(((int)(c))+3*(((int)(b))+3*((int)(a))+3)))
请注意，此操作的结果始终使用模数素数进行分块，如下所示：
h = node_hash(p->nw, p->ne, p->sw, p->se) ;
h %= hashprime ;
...
与最佳哈希的比较
一些统计分析表明，这种哈希在减少碰撞方面是最佳的
给定具有b桶和n条目的哈希表。使用完美哈希的碰撞风险是：
(n - b * (1 - power((b-1)/b,n)))) * 100 / n
当n = b时，这意味着碰撞风险为37％。
一些测试表明，上面的哈希与标准非常吻合（对于哈希表的所有填充级别）。
运行时间
运行时很大程度上取决于hashprime
计时（最好的1000次运行）是：
hashprime CPU-cycles per run
--------------------------------
4049 56
16217 68
64871 127 <-- whoooh
有没有办法改善这一点，同时仍保持最佳碰撞风险？
通过优化模数运算（在循环外使用'魔术'数字计算机替换它） 用其他哈希函数替换哈希函数。
背景
生成以下程序集：
//--------h = node_hash(p->nw, p->ne, p->sw, p->se) ;
mov eax,[rcx+node.nw] <<+
lea eax,[eax+eax*2+3] |
add eax,[rcx+node.ne] |
lea eax,[eax+eax*2] +- takes +/- 12 cycles
add eax,[rcx+node.sw] |
lea eax,[eax+eax*2] |
add eax,[rcx+node.se] <<+
//--------h %= hashprime ;
mov esi,[hashprime]
xor edx,edx
div esi
mov rax,rdx <<--- takes all the rest
[编辑]
我可以做以下事实：
C = A % B相当于C = A – B * (A / B)
使用整数除法与乘以其倒数相同的事实
因此将公式转换为C = A - B * (A * rB)
请注意，对于整数除法，倒数是幻数，请参阅：http://www.hackersdelight.org/magic.htm
C代码在这里：http://web.archive.org/web/20070713211039/http://hackersdelight.org/HDcode/magic.c
[FNV哈希]
请参阅：http://www.isthe.com/chongo/tech/comp/fnv/#FNV-1a
hash = offset_basis
for each byte to be hashed
hash = hash xor octet_of_data
hash = hash * FNV_prime (for 32 bits = 16777619)
return hash
对于截断为32位= 16字节的4个指针，FNV哈希采用 27个周期（手工制作的程序集）
不幸的是，这导致了81％的哈希冲突，其应该是37％
运行完整的15次乘法需要179个周期。
答案 0 :(得分：3)
通过倒数乘法取代模数
此哈希函数中的主循环食者是模数运算符。
如果用乘以倒数替换此除法，则计算速度要快得多 请注意，计算倒数涉及3个除法，因此只有当倒数可以重复使用足够次数时才应该这样做。
好的，这是使用的代码：http://www.agner.org/optimize/asmlib.zip
来自：http://www.agner.org/optimize/
// ;************************* divfixedi64.asm *********************************
// ; Author: Agner Fog
//extern "C" void setdivisoru32(uint Buffer[2], uint d)
asm
mov r8d, edx // x
mov r9, rcx // Buffer
dec r8d // r8d = r8d or esi
mov ecx, -1 // value for bsr if r8d = 0
bsr ecx, r8d // floor(log2(d-1))
inc r8d
inc ecx // L = ceil(log2(d))
mov edx, 1
shl rdx, cl // 2^L (64 bit shift because cl may be 32)
sub edx, r8d
xor eax, eax
div r8d
inc eax
mov [r9], eax // multiplier
sub ecx, 1
setae dl
movzx edx, dl // shift1
seta al
neg al
and al,cl
movzx eax, al // shift 2
shl eax, 8
or eax, edx
mov [r9+4], eax // shift 1 and shift 2
ret
end;
和模数运算的代码：
//extern "C" uint modFixedU32(uint Buffer[2], uint d)
asm
mov eax, edx
mov r10d, edx // x
mov r11d, edx // save x
mul dword [rcx] // Buffer (i.e.: m')
sub r10d, edx // x-t
mov ecx, [rcx+4] // shift 1 and shift 2
shr r10d, cl
lea eax, [r10+rdx]
mov cl, ch
shr eax, cl
// Result:= x - m * fastDiv32.dividefixedu32(Buffer, x);
mul r8d // m * ...
sub r11d, eax // x - (m * ...)
mov eax,r11d
ret
end;
时间差异如下：
hashprime classic hash (mod) new hash new old
(# of runs) cycles/run per run (no cache) (no cache)
--------------------------------------------------------------------
4049 56 21 16.6 51
16217 68 not measured
64871 127 89 16.5 50
缓存问题
循环时间的增加是由数据溢出缓存引起的，导致访问主存储器
当我通过一遍又一遍地散列相同的值来移除缓存效果时，可以清楚地看到这一点。
答案 1 :(得分：1)
这样的事情可能有用：
static inline unsigned int hash4(unsigned int a, unsigned int b,
unsigned int c, unsigned int d) {
unsigned long long foo = 123456789*(long long)a ^ 243956871*(long long)b
^ 918273645*(long long)c ^ 347562981*(long long)d;
return (unsigned int)(foo >> 32);
}
用随机生成的64位奇数替换我输入的四个奇数;上面的那些不会那么好用。 （64位使得高32位在某种程度上是低位的随机混合。）这与您给出的代码一样快，但它允许您使用两个表的大小而不是主表大小而不使用恐惧。
每个人用于类似工作负载的事情是FNV hash。我不确定FNV是否实际上具有比上述类型的哈希更好的属性，但它同样快，而且它的使用相当广泛。
答案 2 :(得分：0)
假设hashprime是常量，您可以将模运算实现为按位掩码。我不确定细节，但也许this answer可以帮助你朝着正确的方向前进。