分配最少的随机字符串生成器

Question

我想在给定参数的情况下生成一个包含伪随机 ASCII 字符的大文件：每行大小和行数。如果不为每一行分配新的Strings，我无法找到一种方法。这就是我所拥有的：https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=42f5b803910e3a15ff20561117bf9176

use rand::{Rng, SeedableRng};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    let mut data: Vec<u8> = Vec::new();
    write_random_lines(&mut data, 10, 10)?;
    println!("{}", std::str::from_utf8(&data)?);
    Ok(())
}

fn write_random_lines<W>(
    file: &mut W,
    line_size: usize,
    line_count: usize,
) -> Result<(), Box<dyn Error>>
where
    W: std::io::Write,
{
    for _ in 0..line_count {
        let mut s: String = rand::rngs::SmallRng::from_entropy()
            .sample_iter(rand::distributions::Alphanumeric)
            .take(line_size)
            .collect();
        s.push('\n');
        file.write(s.as_bytes())?;
    }
    Ok(())
}

我正在每行创建一个新的String，所以我认为这不是内存效率。有fn fill_bytes(&mut self, dest: &mut [u8])，但这是字节。

我最好不要为每一行创建一个新的SmallRng，但它是在循环中使用的，SmallRng 不能被复制。

如何以更节省内存和时间的方式生成随机文件？

Answer 1

您可以通过在循环外创建String 并在使用内容后clear 来轻松地在循环中重用它：

    // Use Kevin's suggestion not to make a new `SmallRng` each time:
    let mut rng_iter =
        rand::rngs::SmallRng::from_entropy().sample_iter(rand::distributions::Alphanumeric);
    let mut s = String::with_capacity(line_size + 1);  // allocate the buffer
    for _ in 0..line_count {
        s.extend(rng_iter.by_ref().take(line_size));   // fill the buffer
        s.push('\n');
        file.write(s.as_bytes())?;                     // use the contents
        s.clear();                                     // clear the buffer
    }

String::clear 会擦除 String 的内容（必要时删除），但不会释放其后备缓冲区，因此无需重新分配即可重复使用。

另见

• Weird behaviour when using read_line in a loop
• Why does Iterator::take_while take ownership of the iterator? 解释了为什么需要 by_ref

Answer 2

你的代码的这个修改不会分配任何Strings，也不会每次都构造一个新的SmallRng，但我没有对其进行基准测试：

fn write_random_lines<W>(
    file: &mut W,
    line_size: usize,
    line_count: usize,
) -> Result<(), Box<dyn Error>>
where
    W: std::io::Write,
{
    // One random data iterator.
    let mut rng_iter = rand::rngs::SmallRng::from_entropy()
        .sample_iter(rand::distributions::Alphanumeric);

    // Temporary storage for encoding of chars. If the characters used
    // are not all ASCII then its size should be increased to 4.
    let mut char_buffer = [0; 1];

    for _ in 0..line_count {
        for _ in 0..line_size {
            file.write(
                rng_iter.next()
                    .unwrap()  // iterator is infinite so this never fails
                    .encode_utf8(&mut char_buffer)
                    .as_bytes())?;
        }
        file.write("\n".as_bytes())?;
    }
    Ok(())
}

我是 Rust 的新手，所以它可能缺少一些整理方法。另外，请注意，这一次只写入一个字符；如果您的 W 每次操作比内存缓冲区更昂贵，您可能希望将其包装在 std::io::BufWriter 中，这将批量写入目标（使用需要分配的缓冲区，但只分配一次）。

Answer 3

我（MakotoE）对 Kevin Reid 的答案进行了基准测试，尽管内存分配似乎相同，但他们的方法似乎更快。

时间基准：

#[cfg(test)]
mod tests {
    extern crate test;
    use test::Bencher;
    use super::*;

    #[bench]
    fn bench_write_random_lines0(b: &mut Bencher) {
        let mut data: Vec<u8> = Vec::new();
        data.reserve(100 * 1000000);
        b.iter(|| {
            write_random_lines0(&mut data, 100, 1000000).unwrap();
            data.clear();
        });
    }

    #[bench]
    fn bench_write_random_lines1(b: &mut Bencher) {
        let mut data: Vec<u8> = Vec::new();
        data.reserve(100 * 1000000);
        b.iter(|| {
            // This is Kevin's implementation
            write_random_lines1(&mut data, 100, 1000000).unwrap();
            data.clear();
        });
    }
}

test tests::bench_write_random_lines0 ... bench: 764,953,658 ns/iter (+/- 7,597,989)
test tests::bench_write_random_lines1 ... bench: 360,662,595 ns/iter (+/- 886,456)

使用 valgrind 的 Massif 对内存使用情况进行基准测试表明两者大致相同。我的总共使用了 3.072 Gi，峰值为 101.0 MB。 Kevin 总共使用了 4.166 Gi，峰值 128.0 MB。