与 C 相比，Rust 文件 I/O 非常慢.有什么问题吗? [英] Rust file I/O is very slow compared with C. Is something wrong?

问题描述

为了比较 C 和 Rust 之间的文件 I/O 性能，我将测试"写入文件 100,000,000 次，并从文件中读取 4 个字节 100,000,000 次.

To compare file I/O performance between C and Rust, I write "test" to a file 100,000,000 times and read 4 bytes from a file 100,000,000 times.

与 C 相比，Rust 代码花费了超过 450 倍的 sys 时间用于写入，140 倍用于读取.

Compared to C, the Rust code spent over 450 times of the sys time for writing, and 140 times for reading.

我怀疑有更好的方法来实现快速 I/O；如何在 Rust 中提高文件 I/O 的性能?

I suspect there are better ways to achieve fast I/O; how do I improve the performance of file I/O in Rust?

$ rustc --version
rustc 1.16.0
$ rustc rswrite.rs -C opt-level=3  # Rust for writing
$ time ./rswrite
real    1m8.411s
user    0m3.817s
sys     1m4.533s
$ rustc rsread.rs -C opt-level=3  # Rust for reading
$ time ./rsread
real    0m18.077s
user    0m2.130s
sys     0m15.910s
$ gcc -O3 cwrite.c -ocwrite  # C for writing
$ time ./cwrite
real    0m1.564s
user    0m1.397s
sys     0m0.143s
$ gcc -O3 cread.c -ocread  # C for reading
$ time ./cread
real    0m1.353s
user    0m1.240s
sys     0m0.113s

用于编写的 Rust 代码:

Rust code for writing:

use std::fs;
use std::io::Write;
fn main() {
    let b = b"test";
    let mut f = fs::File::create("rs.dump").unwrap();
    for _ in 0 .. 100_000_000 {
        f.write(b).unwrap();
    }
}

用于阅读的 Rust 代码:

Rust code for Reading:

use std::{fs, mem};
use std::io::Read;
fn main() {
    let mut f = fs::File::open("rs.dump").unwrap();
    let mut b: [u8; 4] = unsafe { mem::uninitialized() };
    for _ in 0 .. 100_000_000 {
        f.read_exact(&mut b).unwrap();
    }
}

用于编写的 C 代码:

C code for Writing:

#include <stdio.h>
#define N 100000000
int main()
{
    const char *teststr = "test";
    FILE *fp = fopen("c.dump", "wb");
    unsigned long long i;
    for (i=0; i<N; i++) fwrite(teststr, 4, 1, fp);
    fclose(fp);
    return 0;
}

用于阅读的C代码:

#include <stdio.h>
#define N 100000000

int main() {
    FILE *fp = fopen("c.dump", "rb");
    long long i;
    char buf[4];
    for (i=0; i<N; i++) fread(buf, 4, 1, fp);
    fclose(fp);
    return 0;
}

推荐答案

我的 Rust 程序没有使用缓冲 IO.感谢 BurntSushi5 和 Andrew Henle 的评论，问题解决了.

My Rust program was not using buffered IO. Thanks to BurntSushi5 and Andrew Henle's comments, the problem is solved.

$ strace ./rswrite
write(3, "test", 4)                     = 4
write(3, "test", 4)                     = 4
...
$ strace ./rswrite
read(3, "test", 4)                      = 4
read(3, "test", 4)                      = 4
...

我修改了代码:

use std::fs;
use std::io::{BufWriter, Write};
fn main() {
    let b = b"test";
    /**** Use std::io::BufWriter ****/
    let mut f = BufWriter::new(fs::File::create("rs.dump").unwrap());
    for _ in 0 .. 100_000_000 {
        f.write(b).unwrap();
    }
}

和

use std::{fs, mem};
use std::io::{BufReader, Read};
fn main() {
    /**** Use std::io::BufReader ****/
    let mut f = BufReader::new(fs::File::open("rs.dump").unwrap());
    let mut b: [u8; 4] = unsafe { mem::uninitialized() };
    for _ in 0 .. 100_000_000 {
        f.read_exact(&mut b).unwrap();
    }
}

现在，I/O 被缓冲了.

Now, I/O is buffered.

write(3, "testtesttesttesttesttesttesttest"..., 8192) = 8192
write(3, "testtesttesttesttesttesttesttest"..., 8192) = 8192
...

性能和 C 一样快.

$ time ./rswrite
real    0m1.341s
user    0m0.213s
sys     0m0.200s
$ time ./rsread_buf
real    0m0.596s
user    0m0.540s
sys     0m0.050s

这篇关于与 C 相比，Rust 文件 I/O 非常慢.有什么问题吗?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！