我在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的实现:
fn main() {
use std::os;
use std::io::File;
use std::io::BufferedReader;
let args = os::args();
let fname = args[1].as_slice();
let path = Path::new(fname);
let mut file = BufferedReader::new(File::open(&path));
let input_length = read_int(&mut file) as uint;
for i in range(0u, input_length) {
let d = read_double_slow(&mut file);
if i == input_length - 1 {
println!("{}", d);
}
}
}
fn read_int<R : Reader>(input: &mut R) -> i32 {
match input.read_be_i32() {
Ok(x) => x,
Err(e) => fail!(e)
}
}
fn read_double_slow<R : Reader>(input: &mut R) -> f64 {
match input.read_be_f64() {
Ok(x) => x,
Err(e) => fail!(e)
}
}
我正在输出最后一个值,以确保实际读取所有输入 . 在我的机器上,当文件包含(相同)3000万个随机生成的双精度数时,Java版本运行0.8秒,而Rust版本运行40.8秒 .
怀疑Rust的字节解释本身效率低下,我用自定义浮点反序列化实现重试了它 . 内部是almost exactly the same as what's being done in Rust's 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在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秒 . )
1 回答
在没有优化的情况下构建时,它通常会比在Java中慢 . 但是使用优化(
rustc -O
或cargo --release
)构建它并且它应该非常快 . 如果它的标准版本仍然变得更慢,那么应该仔细检查以确定缓慢的位置 - 也许是内联不应该是,或者不应该是,或者可能是一些预期的优化没有发生 .