如何解决检查 Vec<u8> 以查看它是否全部为零?
我有很多 4KiB 缓冲区,它们有 50% 的机会只包含零值。非零缓冲区通常在缓冲区的早期有一个非零字节。
fn is_zero(buf: &Vec<u8>) -> bool {
for byte in buf.into_iter() {
if *byte != 0 {
return false;
}
}
return true;
}
这是使用 --release
检查 Rust 的一种高效方式吗? (我正在处理大量 GB 的数据。)
(在 C 版本中,我在检查之前将缓冲区强制转换为 unsigned long long
。考虑到 SSE 等,这可能不是我能做的最好的)
解决方法
您可以使用 align_to
将 u8
的切片转换为 u128
的切片,从而提高比较效率:
fn is_zero(buf: &[u8]) -> bool {
let (prefix,aligned,suffix) = unsafe { buf.align_to::<u128>() };
prefix.iter().all(|&x| x == 0)
&& suffix.iter().all(|&x| x == 0)
&& aligned.iter().all(|&x| x == 0)
}
在我的机器上运行一个简单的基准测试显示 16 倍的性能提升!
#![feature(test)]
extern crate test;
fn v() -> Vec<u8> {
std::iter::repeat(0).take(1000000).collect()
}
fn is_zero(buf: &[u8]) -> bool {
buf.into_iter().all(|&b| b == 0)
}
fn is_zero_aligned(buf: &[u8]) -> bool {
let (prefix,suffix) = unsafe { buf.align_to::<u128>() };
prefix.iter().all(|&x| x == 0)
&& suffix.iter().all(|&x| x == 0)
&& aligned.iter().all(|&x| x == 0)
}
#[bench]
fn bench_is_zero(b: &mut test::Bencher) {
let v = test::black_box(v());
b.iter(|| is_zero(&v[..]))
}
#[bench]
fn bench_is_zero_aligned(b: &mut test::Bencher) {
let v = test::black_box(v());
b.iter(|| is_zero_aligned(&v[..]))
}
running 2 tests
test tests::bench_is_zero ... bench: 455,975 ns/iter (+/- 414)
test tests::bench_is_zero_aligned ... bench: 28,615 ns/iter (+/- 116)
根据您的机器,不同的整数类型 (u64
) 可能会产生更好的性能。
感谢 Rust Discord 服务器上的 @Globi 提出这个想法
,在我的笔记本电脑上使用 byteorder
以本机字节序读取 u64
时发现速度提高了 4 倍。
lib.rs
extern crate byteorder;
use byteorder::{NativeEndian,ReadBytesExt};
use std::io::Cursor;
pub fn one(buf: &[u8]) -> bool {
buf.into_iter().all(|&byte| byte == 0)
}
pub fn two(buf: &[u8]) -> bool {
let mut cur = Cursor::new(buf);
while let Ok(val) = cur.read_u64::<NativeEndian>() {
if val != 0 {
return false;
}
}
while let Ok(val) = cur.read_u8() {
if val != 0 {
return false;
}
}
true
}
长凳/benches.rs
#![feature(test)]
extern crate test;
extern crate zero_slice_8;
use zero_slice_8::{one,two};
fn v() -> Vec<u8> {
let mut result = vec![];
for _ in 0..100000 {
result.push(0);
}
result
}
#[bench]
fn bench_one(b: &mut test::Bencher) {
let v = v();
b.iter(|| one(&v[..]))
}
#[bench]
fn bench_two(b: &mut test::Bencher) {
let v = v();
b.iter(|| two(&v[..]))
}
,
以下函数是纯保存Rust:
fn is_zero ( slice : &[u8] ) -> bool {
for i in (0..slice.len()).step_by(16) {
if slice.len() - i >= 16 {
let arr : [u8; 16] = slice[i..i+16].try_into().expect("this should always succeed");
if u128::from_be_bytes(arr) != 0 {
return false;
}
} else {
for i in i..slice.len() {
if slice[i] != 0 {
return false;
}
}
}
}
return true;
}
具体来说,它使用 u128::from_be_bytes
函数将 [u8; 16]
数组转换为 u128
作为非操作,并使用 TryInto
trait 将 {{ 1}} 适当长度到 [u8]
- 其余是相当简单的。可以手动展开内部循环以对其进行转换,但我怀疑这将是一个严重的性能瓶颈,因为 [u8; 16]
构成的列表尾部不是完全 16 字节的工作。>
根据处理器的不同,使用 u8
甚至 u64
可能会更快,您必须自己分析。
您可以使用 rayon,这是一个看起来很适合您的用例的数据并行库。使用起来非常简单:只需将 buf.iter()
更改为 buf.par_iter()
,剩下的由 Rayon 完成:
use rayon::prelude::*;
fn is_zero_par(buf: &[u8]) -> bool {
buf.par_iter().all(|&b| b == 0)
}
对于包含 2000 万个元素的向量,人造丝的性能提高了 7 倍:
#![feature(test)]
use rayon::prelude::*;
extern crate test;
fn v() -> Vec<u8> {
std::iter::repeat(0).take(20000000).collect()
}
fn is_zero(buf: &[u8]) -> bool {
buf.into_iter().all(|&b| b == 0)
}
fn is_zero_par(buf: &[u8]) -> bool {
buf.par_iter().all(|&b| b == 0)
}
#[bench]
fn bench_is_zero(b: &mut test::Bencher) {
let v = test::black_box(v());
b.iter(|| is_zero(&v[..]))
}
#[bench]
fn bench_is_zero_par(b: &mut test::Bencher) {
let v = test::black_box(v());
b.iter(|| is_zero_par(&v[..]))
}
running 2 tests
test tests::bench_is_zero ... bench: 7,217,686 ns/iter (+/- 478,845)
test tests::bench_is_zero_par ... bench: 1,080,959 ns/iter (+/- 111,692)
请注意,多线程对性能的影响取决于工作负载(元素数量),较小的工作负载可能会受到负面影响。
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。