Rust高性能哈希算法库fastmurmur3的使用，fastmurmur3提供快速MurmurHash3实现用于数据校验和哈希计算

Rust高性能哈希算法库fastmurmur3的使用

fastmurmur3是一个快速的MurmurHash3实现库，用于数据校验和哈希计算。根据测试，它是目前最快的Murmur3实现。

安装

在Cargo.toml中添加依赖：

fastmurmur3 = "0.2.0"

或者运行命令安装：

cargo add fastmurmur3

基本用法

内容中提供的示例代码：

let bytes: &[u8] = b"hello world";
let x: u128 = fastmurmur3::hash(bytes);

完整示例

use fastmurmur3;

fn main() {
    // 计算字符串的哈希
    let data = b"hello world";
    let hash_value: u128 = fastmurmur3::hash(data);
    
    println!("Hash of 'hello world': {}", hash_value);
    
    // 计算字节数组的哈希
    let bytes = vec![1, 2, 3, 4, 5];
    let bytes_hash: u128 = fastmurmur3::hash(&bytes);
    
    println!("Hash of [1,2,3,4,5]: {}", bytes_hash);
}

性能对比

根据基准测试：

  • fastmurmur3是最快的实现
  • xxh3_64慢1.66倍且只有64位值
  • xxh3_128慢2.50倍
  • fasthash中的Murmur3实现比fastmurmur3慢4.47倍

具体测试数据：

fastmurmur3             time:   [3.0878 ns 3.1215 ns 3.1619 ns]
xxhash_rust::xxh3_64    time:   [5.1473 ns 5.1872 ns 5.2456 ns]
xxhash_rust::xxh3_128   time:   [7.8066 ns 7.8271 ns 7.8499 ns]
fasthash                time:   [13.909 ns 13.960 ns 14.018 ns]
murmur3c                time:   [14.529 ns 14.604 ns 14.684 ns]
murmur3                 time:   [26.084 ns 26.163 ns 26.249 ns]

正确性

fastmurmur3的测试通过与C实现的对比进行了模糊测试，确保其正确性。

许可证

该项目使用MIT许可证。


1 回复

Rust高性能哈希算法库fastmurmurm3的使用指南

简介

fastmurmur3是一个Rust实现的MurmurHash3算法库，专注于提供高性能的哈希计算功能。MurmurHash3是一种非加密型哈希函数，适用于一般的哈希检索操作，具有很好的随机分布性和较快的计算速度。

安装

在Cargo.toml中添加依赖：

[dependencies]
fastmurmur3 = "0.2"

基本使用方法

计算32位哈希值

use fastmurmur3::murmur3_x86_32;

fn main() {
    let data = b"hello world";
    let seed = 0; // 可选的种子值
    let hash = murmur3_x86_32(data, seed);
    println!("32-bit hash: {:x}", hash);
}

计算128位哈希值

use fastmurmur3::murmur3_x64_128;

fn main() {
    let data = b"hello world";
    let seed = 0;
    let hash = murmur3_x64_128(data, seed);
    println!("128-bit hash: {:x?}", hash);
}

高级用法

处理大文件或流数据

use fastmurmur3::murmur3_x86_32;
use std::io::Read;

fn hash_file(path: &str) -> std::io::Result<u32> {
    let mut file = std::fs::File::open(path)?;
    let mut hasher = murmur3_x86_32::Hasher::with_seed(0);
    let mut buffer = [0; 4096];
    
    loop {
        let count = file.read(&mut buffer)?;
        if count == 0 {
            break;
        }
        hasher.write(&buffer[..count]);
    }
    
    Ok(hasher.finish())
}

自定义种子值

use fastmurmur3::murmur3_x86_32;

fn main() {
    let data = b"hello world";
    for seed in 0..5 {
        let hash = murmur3_x86_32(data, seed);
        println!("Seed {}: {:x}", seed, hash);
    }
}

完整示例

下面是一个完整的使用示例，包含了上述所有功能：

use fastmurmur3::{murmur3_x86_32, murmur3_x64_128};
use std::io::Read;

fn main() {
    // 示例1: 计算32位哈希
    let data = b"hello world";
    let hash32 = murmur3_x86_32(data, 0);
    println!("32-bit hash of 'hello world': {:x}", hash32);

    // 示例2: 计算128位哈希
    let hash128 = murmur3_x64_128(data, 0);
    println!("128-bit hash of 'hello world': {:x?}", hash128);

    // 示例3: 文件哈希计算
    if let Ok(hash) = hash_file("example.txt") {
        println!("File hash: {:x}", hash);
    } else {
        eprintln!("Failed to read file");
    }

    // 示例4: 不同种子值测试
    println!("\nTesting different seeds:");
    for seed in 0..3 {
        let hash = murmur3_x86_32(data, seed);
        println!("Seed {}: {:x}", seed, hash);
    }
}

fn hash_file(path: &str) -> std::io::Result<u32> {
    let mut file = std::fs::File::open(path)?;
    let mut hasher = murmur3_x86_32::Hasher::with_seed(0);
    let mut buffer = [0; 4096];
    
    loop {
        let count = file.read(&mut buffer)?;
        if count == 0 {
            break;
        }
        hasher.write(&buffer[..count]);
    }
    
    Ok(hasher.finish())
}

性能提示

  1. 对于小数据块(几十字节)，32位版本通常更快
  2. 对于大数据块(几百字节以上)，128位版本可能更高效
  3. 在x86架构上，32位版本通常比64位版本快
  4. 在x64架构上，128位版本可能比32位版本更快

使用场景

  • 数据校验
  • 哈希表实现
  • 布隆过滤器
  • 缓存键生成
  • 数据分片

注意事项

  1. MurmurHash3不是加密安全的哈希函数
  2. 不同架构上的哈希结果可能不同
  3. 对于相同输入，使用相同种子会得到相同输出
回到顶部