如何在结构中使用可重用的 Vec<RwLockReadGuard> 以避免分配？

Question

我的算法使用Vec<RwLockReadGuard<..>> 来处理数据。该算法被重复调用，我不想每次调用它时都分配Vec，如果我可以在处理结束时只使用clear()，我会很高兴，并在下一次重用它将其存储在与数据处理相关的同一结构中。但是，RwLockReadGuard 的生命周期比持有结构的可能生命周期短。由于我只在数据处理函数内部使用Vec，而在它外部它总是空的，我还能以某种方式将它存储在结构中吗？是否有一个板条箱或成语可以帮助我解决这个问题？

显示问题的最小可重现示例位于问题的底部。

如果我每次都分配Vec，这就是它的样子：

#[derive(Clone)]
pub struct T;

pub fn process_ts(ts: &[T]) {
    unimplemented!();
}

struct Process {
    locked_ts: Vec<RwLock<Vec<T>>>,
}

impl Process {
    pub fn process(&self) {
        let mut ts: Vec<T> = Vec::with_capacity(self.locked_ts.len());

        let guards: Vec<RwLockReadGuard<Vec<T>>> = self
            .locked_ts
            .iter()
            .map(|locked_t| locked_t.read().unwrap())
            .collect();

        let n = guards.iter().map(|guard| guard.len()).min().unwrap();

        for i in 0..n {
            ts.clear();
            for t in &guards {
                ts.push(t[i].clone());
                process_ts(&ts);
            }
        }
    }
}

我不喜欢这个解决方案的是，每次调用Process::process 时，都会分配ts: Vec<T> 和guards: Vec<RwLockReadGuard<Vec<T>>>。我可以摆脱ts：

struct ProcessReuseTs {
    locked_ts: Vec<RwLock<Vec<T>>>,
    reusable_ts: Vec<T>,
}

impl ProcessReuseTs {
    pub fn process(&mut self) {
        let guards: Vec<RwLockReadGuard<Vec<T>>> = self
            .locked_ts
            .iter()
            .map(|locked_t| locked_t.read().unwrap())
            .collect();

        let n = guards.iter().map(|guard| guard.len()).min().unwrap();

        for i in 0..n {
            self.reusable_ts.clear();
            for t in &guards {
                self.reusable_ts.push(t[i].clone());
                process_ts(&self.reusable_ts);
            }
        }
    }
}

但是如何提取guards？

use std::sync::{RwLock, RwLockReadGuard};

#[derive(Clone)]
pub struct T;

pub fn process_ts(ts: &[T]) {
    unimplemented!();
}

struct ProcessReuseBoth {
    locked_ts: Vec<RwLock<Vec<T>>>,
    reusable_ts: Vec<T>,
    reusable_guards: Vec<RwLockReadGuard<Vec<T>>>,
}

impl ProcessReuseBoth {
    pub fn process(&mut self) {
        self.reusable_guards.clear();
        self.reusable_guards.extend(
            self.locked_ts
                .iter()
                .map(|locked_t| locked_t.read().unwrap()),
        );

        let n = self
            .reusable_guards
            .iter()
            .map(|guard| guard.len())
            .min()
            .unwrap();

        for i in 0..n {
            self.reusable_ts.clear();
            for t in &self.reusable_guards {
                self.reusable_ts.push(t[i].clone());
                process_ts(&self.reusable_ts);
            }
        }

        self.reusable_guards.clear();
    }
}

pub fn main() {
    unimplemented!()
}

不能用

编译

error[E0106]: missing lifetime specifier
  --> src/main.rs:13:26
   |
13 |     reusable_guards: Vec<RwLockReadGuard<Vec<T>>>,
   |        

Playground

Answer 1

归结为，您似乎要做的是分配一个Vec。使用它来存储RwLockReadGuard<'a, Vec<T>> 类型的元素一段时间'a，然后清除向量并将其放入RwLockReadGuard<'b, Vec<T>> 类型的元素，其中生命周期'b 是与'a 不同的生命周期（实际上没有与它重叠），依此类推。这是行不通的，因为RwLockReadGuard<'a, Vec<T>> 与RwLockReadGuard<'b, Vec<T>> 是不同的类型，我们无法更改Vec 所持有的元素类型。

但也许真正的目标不是用相同的Vec 保存这些不同类型的元素（这是不可能的），而是避免需要重新分配每个新的Vec。我们可能会问，是否有可能从旧的Vec 回收分配的内存以跳过必须分配下一个Vec？好吧，对于一些非常丑陋、不安全的代码，可能只分配一个Vec<u8>，然后在每次调用process 时进行一些指针争论，将其就地转换为所需类型的Vec（大小为零但容量非零）；这可能很难正确完成，并且需要取决于std 中Vec 实现的内部细节。

也许值得退后一步，并认识到每次我们在堆上分配某些东西时都会问同样的问题——也就是说，有没有办法重用我们刚刚释放的空间以避免不得不做新的配置？在某些情况下，答案可能是肯定的，但是我们不得不问，为了进行优化而弄乱我们的代码是否值得？

这就引出了一个问题——我们是否有任何证据表明这里的分配实际上是一个重要的性能瓶颈？如果没有，也许没有必要担心。如果您确实需要提高分配的性能，可以尝试使用jemalloc 或某种竞技场。