Question

对于人口稀疏的密钥列表，我需要一个64位到16位的完美哈希函数。

我在python中有一个字典，它有48326个长度为64位的密钥。我想为这个键列表创建一个最小完美哈希。（我不想等待几天来计算MPH，所以我也可以将它映射到16位哈希）

目标是最终将此字典移植到C作为包含dict值的数组，并且索引由最小完美散列函数计算，该函数将键作为输入。我不能在我正在构建的应用程序的C端口中使用外部散列库

问题：是否有任何python库将我的键作为输入，并为我提供散列参数和（基于用于散列的定义算法）作为输出。

我找到了一个库perfection 2.0.0，但由于我的密钥是64位格式，所以它只是挂起了。（即使我在2000个键的子集上测试它）

修改正如评论中所建议的，我查看了Steve Hanov's Algo并修改了哈希函数以获取64位整数（根据此wiki page更改FNV Prime和偏移的值）

当我得到结果时，遗憾的是地图返回-ve索引值，而我可以使它工作，这意味着我必须通过检查-ve index

为哈希计算添加另外4个周期

想避免这个

Answer 1

就个人而言，我只是使用gperf生成一个表格，或者使用CMPH生成一个包含大量密钥的表格，然后完成。

如果你必须在Python中这样做，那么我发现this blog post有一些Python 2代码，它非常有效地使用中间表将 string 键转换为最小完美哈希。

根据您的要求调整帖子中的代码，在0.35秒内为50k项目生成最小的完美哈希：

>>> import random
>>> testdata = {random.randrange(2**64): random.randrange(2**64)
...             for __ in range(50000)}  # 50k random 64-bit keys
>>> import timeit
>>> timeit.timeit('gen_minimal_perfect_hash(testdata)', 'from __main__ import  gen_minimal_perfect_hash, testdata', number=10)
3.461486832005903

我所做的改变：

我切换到Python 3，遵循Python样式指南，使代码更像Pythonic
我正在使用int.to_bytes()
我使用一个标志来区分中间表中的直接值和哈希输入值，而不是存储负数。

改编的代码：

# Easy Perfect Minimal Hashing
# By Steve Hanov. Released to the public domain.
# Adapted to Python 3 best practices and 64-bit integer keys by Martijn Pieters
#
# Based on:
# Edward A. Fox, Lenwood S. Heath, Qi Fan Chen and Amjad M. Daoud,
# "Practical minimal perfect hash functions for large databases", CACM, 35(1):105-121
# also a good reference:
# Compress, Hash, and Displace algorithm by Djamal Belazzougui,
# Fabiano C. Botelho, and Martin Dietzfelbinger
from itertools import count, groupby


def fnv_hash_int(value, size, d=0x811c9dc5):
    """Calculates a distinct hash function for a given 64-bit integer.

    Each value of the integer d results in a different hash value. The return
    value is the modulus of the hash and size.

    """
    # Use the FNV algorithm from http://isthe.com/chongo/tech/comp/fnv/
    # The unsigned integer is first converted to a 8-character byte string.
    for c in value.to_bytes(8, 'big'):
        d = ((d * 0x01000193) ^ c) & 0xffffffff

    return d % size


def gen_minimal_perfect_hash(dictionary, _hash_func=fnv_hash_int):
    """Computes a minimal perfect hash table using the given Python dictionary.

    It returns a tuple (intermediate, values). intermediate and values are both
    lists. intermediate contains the intermediate table of indices needed to
    compute the index of the value in values; a tuple of (flag, d) is stored, where
    d is either a direct index, or the input for another call to the hash function.
    values contains the values of the dictionary.

    """
    size = len(dictionary)

    # Step 1: Place all of the keys into buckets
    buckets = [[] for __ in dictionary]
    intermediate = [(False, 0)] * size
    values = [None] * size

    for key in dictionary:
        buckets[_hash_func(key, size)].append(key)

    # Step 2: Sort the buckets and process the ones with the most items first.
    buckets.sort(key=len, reverse=True)
    # Only look at buckets of length greater than 1 first; partitioned produces
    # groups of buckets of lengths > 1, then those of length 1, then the empty
    # buckets (we ignore the last group).
    partitioned = (g for k, g in groupby(buckets, key=lambda b: len(b) != 1))
    for bucket in next(partitioned, ()):
        # Try increasing values of d until we find a hash function
        # that places all items in this bucket into free slots
        for d in count(1):
            slots = {}
            for key in bucket:
                slot = _hash_func(key, size, d=d)
                if values[slot] is not None or slot in slots:
                    break
                slots[slot] = dictionary[key]
            else:
                # all slots filled, update the values table; False indicates
                # these values are inputs into the hash function
                intermediate[_hash_func(bucket[0], size)] = (False, d)
                for slot, value in slots.items():
                    values[slot] = value
                break

    # The next group is buckets with only 1 item. Process them more quickly by
    # directly placing them into a free slot.
    freelist = (i for i, value in enumerate(values) if value is None)

    for bucket, slot in zip(next(partitioned, ()), freelist):
        # These are 'direct' slot references
        intermediate[_hash_func(bucket[0], size)] = (True, slot)
        values[slot] = dictionary[bucket[0]]

    return (intermediate, values)


def perfect_hash_lookup(key, intermediate, values, _hash_func=fnv_hash_int):
    "Look up a value in the hash table defined by intermediate and values"
    direct, d = intermediate[_hash_func(key, len(intermediate))]
    return values[d if direct else _hash_func(key, len(values), d=d)]

以上产生两个列表，每个列表有50k个条目;第一个表中的值是(boolean, integer)个元组，其中整数的范围为[0, tablesize)（理论上，这些值的范围可以达到2 ^ 16但是如果它花费了65k +，我会非常惊讶试图找到您的数据的插槽安排。你的桌子大小是＆lt; 50k，因此上述安排可以将此列表中的条目以4个字节（bool和short生成3，但alignment rules添加一个字节填充）表示为C阵列。

快速测试以查看哈希表是否正确并再次生成正确的输出：

>>> tables = gen_minimal_perfect_hash(testdata)
>>> for key, value in testdata.items():
...     assert perfect_hash_lookup(key, *tables) == value
...

您只需要在C：

中实现查找功能

fnv_hash_int操作可以获取指向64位整数的指针，然后将该指针强制转换为8位值数组，并将索引递增8次以访问每个单独的字节;使用suitable function to ensure big-endian (network) order。
您不需要在C中使用0xffffffff进行掩码，因为无论如何都会自动丢弃C整数值上的溢出。
len(intermediate) == len(values) == len(dictionary)并且可以在常量中捕获。
假设C99，将中间表存储为结构类型的数组，其中flag为bool，d为无符号short;这只是3个字节，加上1个填充字节在4字节边界上对齐。 values数组中的数据类型取决于输入字典中的值。

如果你原谅我的C技能，这里有一个示例实现：

mph_table.h

#include "mph_generated_table.h"
#include <arpa/inet.h>
#include <stdint.h>

#ifndef htonll
// see https://stackoverflow.com/q/3022552
#define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
#endif

uint64_t mph_lookup(uint64_t key);

mph_table.c

#include "mph_table.h"
#include <stdbool.h>
#include <stdint.h>

#define FNV_OFFSET 0x811c9dc5
#define FNV_PRIME 0x01000193

uint32_t fnv_hash_modulo_table(uint32_t d, uint64_t key) {
    d = (d == 0) ? FNV_OFFSET : d;
    uint8_t* keybytes = (uint8_t*)&key;
    for (int i = 0; i < 8; ++i) {
        d = (d * FNV_PRIME) ^ keybytes[i];
    }
    return d % TABLE_SIZE;
}

uint64_t mph_lookup(uint64_t key) {
    _intermediate_entry entry = 
        mph_tables.intermediate[fnv_hash_modulo_table(0, htonll(key))];
    return mph_tables.values[
        entry.flag ?
            entry.d : 
            fnv_hash_modulo_table((uint32_t)entry.d, htonll(key))];
}

将依赖于生成的头文件，该文件来自：

from textwrap import indent

template = """\
#include <stdbool.h>
#include <stdint.h>

#define TABLE_SIZE %(size)s

typedef struct _intermediate_entry {
    bool flag;
    uint16_t d;
} _intermediate_entry;
typedef struct mph_tables_t {
    _intermediate_entry intermediate[TABLE_SIZE];
    uint64_t values[TABLE_SIZE];
} mph_tables_t;

static const mph_tables_t mph_tables = {
    {  // intermediate
%(intermediate)s
    },
    {  // values
%(values)s
    }
};
"""

tables = gen_minimal_perfect_hash(dictionary)
size = len(dictionary)
cbool = ['false, ', 'true,  ']
perline = lambda i: zip(*([i] * 10))
entries = (f'{{{cbool[e[0]]}{e[1]:#06x}}}' for e in tables[0])
intermediate = indent(',\n'.join([', '.join(group) for group in perline(entries)]), ' ' * 8)
entries = (format(v, '#018x') for v in tables[1])
values = indent(',\n'.join([', '.join(group) for group in perline(entries)]), ' ' * 8)

with open('mph_generated_table.h', 'w') as generated:
    generated.write(template % locals())

其中dictionary是您的输入表。

使用gcc -O3编译，内联哈希函数（循环展开），整个mph_lookup函数以300 CPU指令计时。我生成的所有50k随机密钥的快速基准测试表明，我的2.9 GHz英特尔酷睿i7笔记本电脑每秒可以查找5000万个这些按键值（每个按键0.02微秒）。

为稀疏的64位无符号整数创建最小完美哈希

1 个答案: