rust simd相关库使用

将给定的 C++ 代码转换为 Rust 代码是一个相当复杂的任务，因为 Rust 的 SIMD 支持和 C++ 的 SIMD 支持有所不同。Rust 提供了 std::arch::x86_64 模块用于访问 x86_64 指令集中的 SIMD 指令。我们需要使用这些指令来实现相同的功能。

下面是将您的 C++ 代码转换为 Rust 的示例代码：

Rust 代码

use std::arch::x86_64::*;
use std::f32;

pub fn compare_l1(a: &[u8], b: &[u8]) -> f64 {
    unsafe {
        let mut sum = _mm_setzero_ps();
        let pa = a.as_ptr();
        let pb = b.as_ptr();
        let last = pa.add(a.len());
        let lastgroup = last.sub(7);
        let zero = _mm_setzero_si128();

        let mut pa = pa;
        let mut pb = pb;

        while pa < lastgroup {
            let x1 = _mm_cvtepu8_epi16(_mm_loadu_si128(pa as *const __m128i));
            let x2 = _mm_cvtepu8_epi16(_mm_loadu_si128(pb as *const __m128i));
            let mut x1 = _mm_subs_epi16(x1, x2);
            x1 = _mm_sign_epi16(x1, x1);
            sum = _mm_add_ps(sum, _mm_cvtepi32_ps(_mm_unpacklo_epi16(x1, zero)));
            sum = _mm_add_ps(sum, _mm_cvtepi32_ps(_mm_unpackhi_epi16(x1, zero)));
            pa = pa.add(8);
            pb = pb.add(8);
        }

        let mut f = [0.0f32; 4];
        _mm_store_ps(f.as_mut_ptr(), sum);
        let mut s = f[0] as f64 + f[1] as f64 + f[2] as f64 + f[3] as f64;

        while pa < last {
            let d = f64::abs(*pa as f64 - *pb as f64);
            s += d;
            pa = pa.add(1);
            pb = pb.add(1);
        }

        s
    }
}

fn main() {
    let a: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let b: Vec<u8> = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
    let result = compare_l1(&a, &b);
    println!("L1 Distance: {}", result);
}

解释

1. SIMD 指令：使用 std::arch::x86_64 模块中的 SIMD 指令，例如 _mm_setzero_ps，_mm_loadu_si128，_mm_cvtepu8_epi16 等。
2. 指针操作：在 Rust 中，指针操作需要使用 unsafe 块，因为这些操作可能不安全。
3. 数据对齐：在 C++ 代码中，使用 __attribute__((aligned(32))) 来对齐数据。在 Rust 中，我们不需要显式对齐，因为 _mm_loadu_si128 能够处理未对齐的数据。
4. 类型转换：在进行 SIMD 运算时，使用类型转换函数将数据转换为适当的类型。

注意事项

• 安全性：由于使用了不安全的指针操作，必须确保输入数据的有效性和长度相同。
• 性能：Rust 的 SIMD 支持在不同平台上可能有所不同，因此在实际应用中需要进行性能测试。
• 依赖：确保你的编译器支持所需的 SIMD 指令集，可以通过 rustup target add x86_64-unknown-linux-gnu 来添加目标平台。

此代码片段展示了如何将 C++ 中的 SIMD 代码转换为 Rust，但在实际应用中，可能需要根据具体情况进行调整和优化。
在 Rust 中，除了直接使用 std::arch::x86_64 模块来访问特定的 SIMD 指令外，还有一些专门的库可以更方便地进行 SIMD 编程。这些库提供了更高级别的抽象，并且在不同的硬件架构上具有更好的跨平台支持。

以下是一些常用的 Rust SIMD 库：

1. packed_simd

packed_simd 是一个非常流行的 SIMD 库，它提供了对多种 SIMD 指令的支持，并且支持不同的硬件架构（如 x86 和 ARM）。

安装

在 Cargo.toml 中添加以下依赖项：

[dependencies]
packed_simd_2 = "0.3.5"  # 请检查最新版本

示例代码

use packed_simd_2::u8x16;

fn compare_l1(a: &[u8], b: &[u8]) -> f64 {
    let mut sum = 0.0;
    let chunks = a.chunks_exact(16);
    let remainder = chunks.remainder();
    let b_chunks = b.chunks_exact(16);

    for (chunk_a, chunk_b) in chunks.zip(b_chunks) {
        let va = u8x16::from_slice_unaligned(chunk_a);
        let vb = u8x16::from_slice_unaligned(chunk_b);
        let diff = (va - vb).abs();
        sum += diff.wrapping_sum() as f64;
    }

    for (x, y) in remainder.iter().zip(b.chunks_exact(16).remainder()) {
        sum += (*x as f64 - *y as f64).abs();
    }

    sum
}

fn main() {
    let a: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
    let b: Vec<u8> = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
    let result = compare_l1(&a, &b);
    println!("L1 Distance: {}", result);
}

2. simd

simd 库是 Rust 标准库中提供的实验性模块，用于 SIMD 编程。它在 std::simd 下提供了一些基本的 SIMD 类型和操作。

安装

该库是实验性的，可能需要启用特定的 Rust nightly 版本和特性：

[dependencies]
stdsimd = { version = "0.1.3", features = ["std"] }

示例代码

#![feature(portable_simd)]

use std::simd::{u8x16, Simd};

fn compare_l1(a: &[u8], b: &[u8]) -> f64 {
    let mut sum = 0.0;
    let chunks = a.chunks_exact(16);
    let remainder = chunks.remainder();
    let b_chunks = b.chunks_exact(16);

    for (chunk_a, chunk_b) in chunks.zip(b_chunks) {
        let va = u8x16::from_slice(chunk_a);
        let vb = u8x16::from_slice(chunk_b);
        let diff = (va - vb).abs();
        sum += diff.reduce_sum() as f64;
    }

    for (x, y) in remainder.iter().zip(b.chunks_exact(16).remainder()) {
        sum += (*x as f64 - *y as f64).abs();
    }

    sum
}

fn main() {
    let a: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
    let b: Vec<u8> = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
    let result = compare_l1(&a, &b);
    println!("L1 Distance: {}", result);
}

3. wide

wide 是另一个 Rust 库，它提供了对 SIMD 类型的支持，具有更高的抽象层次。

安装

在 Cargo.toml 中添加以下依赖项：

[dependencies]
wide = "0.6.5"  # 请检查最新版本

示例代码

use wide::{u8x16, Zeroable};

fn compare_l1(a: &[u8], b: &[u8]) -> f64 {
    let mut sum = 0.0;
    let chunks = a.chunks_exact(16);
    let remainder = chunks.remainder();
    let b_chunks = b.chunks_exact(16);

    for (chunk_a, chunk_b) in chunks.zip(b_chunks) {
        let va = u8x16::from_slice_unaligned(chunk_a);
        let vb = u8x16::from_slice_unaligned(chunk_b);
        let diff = (va - vb).abs();
        sum += diff.sum() as f64;
    }

    for (x, y) in remainder.iter().zip(b.chunks_exact(16).remainder()) {
        sum += (*x as f64 - *y as f64).abs();
    }

    sum
}

fn main() {
    let a: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
    let b: Vec<u8> = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
    let result = compare_l1(&a, &b);
    println!("L1 Distance: {}", result);
}

总结

• packed_simd 和 wide 提供了更高级别的抽象，使 SIMD 编程更容易。
• std::arch::x86_64 提供了对特定硬件指令的低级访问。
• std::simd 是 Rust 标准库中提供的实验性模块，用于统一 SIMD 编程接口。

不同的库有不同的优缺点，可以根据具体需求选择合适的库。