我在 Rust 中尝试二进制序列化和反序列化,并注意到二进制反序列化比 Java 慢几个数量级。为了消除由于分配和开销等原因而产生开销的可能性,我只是从每个程序中读取二进制流。每个程序都从磁盘上的二进制文件中读取数据,该文件包含一个包含输入值数量的 4 字节整数,以及一个连续的 8 字节大端 IEEE 754 编码浮点数块。这是 Java 实现:
import java.io.*;
public class ReadBinary {
public static void main(String[] args) throws Exception {
DataInputStream input = new DataInputStream(new BufferedInputStream(new FileInputStream(args[0])));
int inputLength = input.readInt();
System.out.println("input length: " + inputLength);
try {
for (int i = 0; i < inputLength; i++) {
double d = input.readDouble();
if (i == inputLength - 1) {
System.out.println(d);
}
}
} finally {
input.close()
}
}
}
这是 Rust 实现:
use std::fs::File;
use std::io::{BufReader, Read};
use std::path::Path;
fn main() {
let args = std::env::args_os();
let fname = args.skip(1).next().unwrap();
let path = Path::new(&fname);
let mut file = BufReader::new(File::open(&path).unwrap());
let input_length: i32 = read_int(&mut file);
for i in 0..input_length {
let d = read_double_slow(&mut file);
if i == input_length - 1 {
println!("{}", d);
}
}
}
fn read_int<R: Read>(input: &mut R) -> i32 {
let mut bytes = [0; std::mem::size_of::<i32>()];
input.read_exact(&mut bytes).unwrap();
i32::from_be_bytes(bytes)
}
fn read_double_slow<R: Read>(input: &mut R) -> f64 {
let mut bytes = [0; std::mem::size_of::<f64>()];
input.read_exact(&mut bytes).unwrap();
f64::from_be_bytes(bytes)
}
我输出最后一个值以确保所有输入实际上都被读取。在我的机器上,当文件包含(相同的)3000万个随机生成的双精度数时,Java版本运行时间为0.8秒,而Rust版本运行时间为40.8秒。
怀疑 Rust 的字节解释本身效率低下,我使用自定义浮点反序列化实现重试了它。内部结构与 Rust 的 Reader 中所做的几乎完全相同,没有 IoResult
包装器:
fn read_double<R : Reader>(input: &mut R, buffer: &mut [u8]) -> f64 {
use std::mem::transmute;
match input.read_at_least(8, buffer) {
Ok(n) => if n > 8 { fail!("n > 8") },
Err(e) => fail!(e)
};
let mut val = 0u64;
let mut i = 8;
while i > 0 {
i -= 1;
val += buffer[7-i] as u64 << i * 8;
}
unsafe {
transmute::<u64, f64>(val);
}
}
为了完成这项工作,我对早期 Rust 代码所做的唯一更改是创建一个 8 字节切片,将其传入并(重新)用作
read_double
函数中的缓冲区。这显着提高了性能,平均运行时间约为 5.6 秒。不幸的是,这仍然比 Java 版本慢得多(而且更冗长!),因此很难扩展到更大的输入集。有什么办法可以让 Rust 运行得更快吗?更重要的是,是否可以通过将这些更改合并到默认的
Reader
实现本身来减少二进制 I/O 的痛苦?
作为参考,这是我用来生成输入文件的代码:import java.io.*;
import java.util.Random;
public class MakeBinary {
public static void main(String[] args) throws Exception {
DataOutputStream output = new DataOutputStream(new BufferedOutputStream(System.out));
int outputLength = Integer.parseInt(args[0]);
output.writeInt(outputLength);
Random rand = new Random();
for (int i = 0; i < outputLength; i++) {
output.writeDouble(rand.nextDouble() * 10 + 1);
}
output.flush();
}
}
(请注意,在我的测试机器上,生成随机数
并将它们写入磁盘只需要 3.8 秒。)
当您在没有优化的情况下进行构建时,它通常会比在 Java 中慢。但是用优化(rustc -O
或
cargo --release
)来构建它,它应该会快得多。如果它的标准版本最终仍然较慢,则应该仔细检查以找出缓慢的位置 - 也许正在内联某些不应该内联的内容,或者不应该内联的内容,或者可能是一些预期的优化没有发生。