为什么我的 Rust 程序比等效的 Java 程序慢？答案

【问题标题】：Why is my Rust program slower than the equivalent Java program?为什么我的 Rust 程序比等效的 Java 程序慢？
【发布时间】：2014-10-05 00:24:21
【问题描述】：

我在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 的字节解释本身效率低下，我用自定义浮点反序列化实现重试了它。内部是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 运行得更快吗？更重要的是，是否可以通过将这些更改合并到默认的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 秒。）

【问题讨论】：

您是否在进行优化构建？（rustc -O 或 cargo --release）我会尝试比较一下，但我没有安装 Java。
天啊！我什至没有想过启用优化。使用rustc -O，慢版运行时间为1.5s，快速版本运行时间为0.4s。天真的 Rust 版本是如何比 Java 版本运行得慢的仍然有点好奇，但我想这可以归结为 IoResult 包装器。我不知道我是否应该结束这个问题，或者您是否想将其添加为答案。

标签： performance file-io rust

【解决方案1】：

当您在没有优化的情况下构建时，它通常会比在 Java 中慢。但是使用优化（rustc -O 或cargo --release）构建它，它应该会快得多。如果它的标准版本最终仍然变慢，则应仔细检查以找出慢的地方——可能内联了不应该内联的内容，或者不应该内联的内容，或者可能是一些预期的优化没有发生。

【讨论】：