Memory Optimization Proposal: Shared Collector for Multi-HashMap Structures

[anonymous5l]

When implementing structures containing multiple HashMap instances, the current separate Collector allocation pattern introduces significant memory overhead.

// Current implementation (high memory cost)
struct Heavy {
    state1: HashMap<i32, i32>,  // Each has its own Collector
    ...
    state10: HashMap<i32, i32>
}

// Proposed implementation (shared collector)
struct Heavy {
    collector: Arc<Collector>,  // Shared reference
    state1: HashMap<i32, i32>,
    ...
    state10: HashMap<i32, i32>
}

// Reclaim by who owned `Collector`
impl Drop for Heavy {
    fn drop(&mut self) {
        unsafe { self.collector.reclaim_all() }
    }
}

[ibraheemdev]

This would be nice to have, but unfortunately Arc<Collector> would not be sound. The HashMap relies on the fact that all memory is reclaimed when the HashMap is dropped, and doesn't linger in the collector to be reclaimed later. It also cannot expose the collector because of #41 (comment). It would be possible to have something like

struct HashMaps<K, V, const N: usize> {
    collector: Collector,
    maps: [HashMap<K, V>; N]
}

which feels a little ugly, but probably works fine in practice. The alternative would be allowing shared collectors with unsafe code, but I would prefer a safe API.

[4r33x]

This would be nice to have, but unfortunately Arc<Collector> would not be sound. The HashMap relies on the fact that all memory is reclaimed when the HashMap is dropped, and doesn't linger in the collector to be reclaimed later. It also cannot expose the collector because of #41 (comment). It would be possible to have something like

struct HashMaps<K, V, const N: usize> {
collector: Collector,
maps: [HashMap<K, V>; N]
}

which feels a little ugly, but probably works fine in practice. The alternative would be allowing shared collectors with unsafe code, but I would prefer a safe API.

Would it be possible to implement guard reuse across different HashMaps? This is just an example - my real use case involves nested map, and I'd like to avoid pinning them one by one by reusing the same guard:

let map_0 = papaya::HashMap::new();
let map_1 = papaya::HashMap::new();
let mut guard_0 = map_0.guard_many();
map_1.insert("key", "value", &mut guard_0);

[ibraheemdev]

That's not really possible, guards are scoped to a given collector instance. Creating a guard for collector A does nothing to protect objects retired using collector B.

I think we could expose an API that takes an Arc<Collector> as long as {K, V}: Send + 'static. That way it is sound to defer the reclamation of the entries arbitrarily, and it is sound for entries to be retired by other threads even if the HashMap itself isn't shared, which means the user can manage the Arc<Collector> however they want.