Question

我正在使用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秒。）

Answer 1

如果在没有优化的情况下构建，它通常会比在Java中慢。但是使用优化（rustc -O或cargo --release）构建并且它应该非常快。如果它的标准版本仍然变得更慢，那么应该仔细检查以确定缓慢的位置 - 也许是内联不应该是，或者不应该是，或者可能是一些预期的优化没有发生。

为什么我的Rust程序比同等的Java程序慢？

1 个答案: