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

最佳答案

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

显然，库的重点是提供池分配器。

当您分配相同大小的对象时，池分配器会大放异彩。

Note If your structure A and structure B aren't identical/very similar size you may not like this design assumption.

框架提供的分配器与单例池一起使用，它们根据容器 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 干净。

Note how we re-use the same pool with different containers of different struct sizes, and how we can even use it with multiple live containers at a time, provided that the element types fit in the request size (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 委托(delegate)回 malloc/free 以按需分配内存。要将它与固定的“领域”一起使用，您可能更喜欢直接使用 simple_segregated_storage。这篇文章看起来像一个很好的入门https://theboostcpplibraries.com/boost.pool

关于c++ - 如何使用 boost::pool 库创建自定义内存分配器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48782450/