如何使用boost :: pool库创建自定义内存分配器

Question

我是新手，我想知道boost :: pool库如何帮助我创建自定义内存分配器。 我有两个struct对象向量。 第一个向量是结构类型A，而第二个向量是结构类型B. 如何重用分配给第一个向量的内存到第二个向量。

Answer 1

Boost Pool是一个定义了一些分配器类型的库。

显然，图书馆的重点是提供Pool Allocators。

当您分配相同大小的对象时，池分配器会闪烁。

  

注意如果您的结构A和结构B不是相同/非常相似，那么您可能不喜欢这种设计假设。

框架提供的分配器使用单例池，它们区分容器value_type的大小。如果您想在不同的值类型之间重用甚至共享池，那么这有点不灵活。此外，单例池可能不灵活，并且意味着线程安全成本。

所以，我想知道是否可以制作最简单的分配器来缓解这些问题。

我使用源boost::pool_alloc和cppreference example作为灵感，然后进行了一些测试和内存分析。

更灵活的有状态分配器

这是我能想到的最简单的池分配器：

using Pool = boost::pool<boost::default_user_allocator_malloc_free>;

template <typename T> struct my_pool_alloc {
    using value_type = T;

    my_pool_alloc(Pool& pool) : _pool(pool) {
        assert(pool_size() >= sizeof(T));
    }

    template <typename U>
    my_pool_alloc(my_pool_alloc<U> const& other) : _pool(other._pool) {
        assert(pool_size() >= sizeof(T));
    }

    T *allocate(const size_t n) {
        T* ret = static_cast<T*>(_pool.ordered_malloc(n));
        if (!ret && n) throw std::bad_alloc();
        return ret;
    }

    void deallocate(T* ptr, const size_t n) {
        if (ptr && n) _pool.ordered_free(ptr, n);
    }

    // for comparing
    size_t pool_size() const { return _pool.get_requested_size(); }

  private:
    Pool& _pool;
};

template <class T, class U> bool operator==(const my_pool_alloc<T> &a, const my_pool_alloc<U> &b) { return a.pool_size()==b.pool_size(); }
template <class T, class U> bool operator!=(const my_pool_alloc<T> &a, const my_pool_alloc<U> &b) { return a.pool_size()!=b.pool_size(); }

注意：

• 此分配器是有状态的，因此需要允许它们的容器实现（例如Boost Container，Boost MultiIndex）。理论上，所有符合C ++ 11标准的库should also support them
• 比较应指导容器交换/复制分配器。这不是我所关注的领域，并且选择的方法来标记不同请求大小的所有池不同可能对某些人来说不够。

样本，测试

在我的编译器上，它适用于std::vector和Boost的vector：

• Live On Coliru - 使用GCC std :: vector
• Live On Coliru - 使用GCC boost :: container :: vector
• Live On Coliru - 与Clang std :: vector
• Live On Coliru - 使用Clang boost :: container :: vector

所有跑步都是无泄漏的，并且ubsan / asan clean。

  

请注意我们如何重复使用具有不同结构大小的不同容器的相同池，以及我们如何一次将它与多个活动容器一起使用，前提是元素类型符合请求大小（32）

struct A { char data[7];  };
struct B { char data[29]; };

int main() {
    //using boost::container::vector;
    using std::vector;

    Pool pool(32); // 32 should fit both sizeof(A) and sizeof(B)
    {
        vector<A, my_pool_alloc<A> > v(1024, pool);
        v.resize(20480);
    };

    // pool.release_memory();

    {
        vector<B, my_pool_alloc<B> > v(1024, pool);
        v.resize(20480);
    }

    // pool.release_memory();

    // sharing the pool between multiple live containers
    {
        vector<A, my_pool_alloc<A> > v(512, pool);
        vector<B, my_pool_alloc<B> > w(512, pool);
        v.resize(10240);
        w.resize(10240);
    };
}

仿形

使用Valgrind的内存分析器显示，release_memory行注释掉如下所示：

在release_memory()来电中评论：

我希望这看起来像你想要的东西。

进一步的想法：简单的隔离存储

此分配器使用现有的pool委托回malloc / free来按需分配内存。要将其与固定的＆＃34;领域＆＃34;一起使用，您可能更喜欢直接使用simple_segregated_storage。这篇文章看起来像一个好的启动器https://theboostcpplibraries.com/boost.pool