使用基于动态/状态的分配器的 STL 实现？

Question

有人知道 STL 实现允许在使用前将动态分配器传递到容器实例吗？

场景是，我们有一个通用内存分配器来管理多个内存池，对于 stl::vector 的每个实例，我们希望从不同的内存池中分配每个实例。

标准 STL 实现的问题是您只能在类型的基础上定义内存池，即所有 int 类型的向量将从同一个池中分配。

我已经将默认的 stl::allocator 换成了具有状态的分配器，即我们想要从中分配此实例的池，但这对于在默认构造函数中分配内容的 stl::list 来说效果不佳。

由于与我们的库相关的原因，我们在 ctor 中也没有针对所有对象的有效池，因此我们希望在用户使用 stl 容器之前调用“设置内存池”函数。

有人遇到过支持这种事情的实现吗？

Answer 1

好吧，STL 端口似乎确实支持这种功能，而 Microsoft（VS 2008）和 GNU 实现（stl 大约 gcc 3.4.1 的端口）则不支持这种功能，因为它们在 ctors/dtors 中分配/取消分配内容。

这是我的测试代码，展示了如何执行此操作。警告它无论如何都不是一个完整的实现！

#include <list>
#include <assert.h>

namespace my
{

class memory_pool
{
public:
    memory_pool() : m_top( 0 ){};
    ~memory_pool(){};

    void* alloc( int size, int align ) { void* p = (void*)&m_pool[m_top]; m_top += size; return p; }
    void free ( void* p ) { assert( (p >= m_pool) && (p < &m_pool[m_top] ) ); }
private:
    char m_pool[0xFFFF];
    int m_top;
};

template<class T>
class dynamic_allocator 
{
    template<typename U> friend class dynamic_allocator;
public:
    typedef T                   value_type;         
    typedef size_t              size_type;          
    typedef value_type*         pointer;            
    template <class _Tp1> struct rebind { typedef dynamic_allocator<_Tp1> other; };

    dynamic_allocator() : m_pPool( NULL ){}
    dynamic_allocator( memory_pool* pPool ){ m_pPool = pPool; }
    dynamic_allocator( const dynamic_allocator< T >& alloc ) : m_pPool( alloc.m_pPool ){}
    template< typename U >
    dynamic_allocator( const dynamic_allocator< U >& alloc ) : m_pPool( alloc.m_pPool ){}
    ~dynamic_allocator() {}

    pointer allocate( size_type count ){ return allocate( count, NULL ); }
    pointer allocate( size_type count, const void* ) { assert( m_pPool ); return ( pointer )m_pPool->alloc( count * sizeof( T ), __alignof( T ) ); }
    void deallocate( pointer p, size_type count )   { assert( m_pPool ); m_pPool->free( p ); }

    void set( memory_pool* pPool ) { m_pPool = pPool; }

private:
    memory_pool* m_pPool;
};

template< typename T, typename Al = dynamic_allocator<T>  >
class list : public std::list<T, Al>
{
public:
    typedef typename std::list<T, Al>::allocator_type allocator_type;

    list() : std::list<T, Al>(){};
    list( const allocator_type& a ) : std::list<T, Al>( a ){};
    ~list(){};

    void initialise( memory_pool& pool ){ std::list<T, Al>::_M_node.set( &pool ); } // or something like this
    void terminate( void ){ clear(); std::list<T, Al>::_M_node.set( NULL ); }                   // or something like this
};

}; // namespace my

class lemon
{
public:
    lemon(){}       // must be empty ctor as we don't want to have active mem pool in ctor for users to use
    ~lemon(){}

    void initialise( my::memory_pool& pool ){ m_list.initialise( pool ); }
    void terminate( void )                  { m_list.terminate(); }

    void add( float f ) { m_list.push_back( f ); }

private:
    my::list<float> m_list;
};

int main( void )
{
    my::memory_pool poolA;
    my::memory_pool poolB;

    my::dynamic_allocator<float> aa( &poolA );
    my::list<float> a( aa );
    my::list<float> fail;

    std::list<float>::allocator_type bb;
    std::list<float> b( bb );

    a.push_back( 0.2f );
    b.push_back( 50.0f );
    //fail.push_back( 19.0f );

    a.clear();
    b.clear();

    lemon lemons[2];

    lemons[0].initialise( poolA );
    lemons[1].initialise( poolB );

    lemons[0].add( 10.0f );
    lemons[1].add( 20.0f );
    lemons[1].add( 18.0f );

    lemons[0].terminate();
    lemons[1].terminate();

    scanf("press any key\n");

    return 0;
}

Answer 2

我不太确定你的问题。因此，我将介绍全状态分配器的情况。

在 C++03 中，任何分配器都应该能够释放由相同类型的另一个分配器分配的资源。

C++0x 标准实际上消除了这个限制，并允许将全状态分配器传递给 STL 容器，只要它们是分配器感知容器（我认为它涵盖了使用 STL 打包的所有容器，因为他们对序列建模）。

例如：[allocator.adaptor] $20.10 Classscoped_allocator 现在是 C++0x STL 的一部分。

Answer 3

类型化分配器可以使用下面的通用分配器来执行分配。

Allocator需要支持这些功能：

  pointer address ( reference x ) const;
  const_pointer address ( const_reference x ) const;
  pointer allocate (size_type n, allocator<void>::const_pointer hint=0);
  void deallocate (pointer p, size_type n);
  size_type max_size() const throw();
  void construct ( pointer p, const_reference val );

假设你有一个只分配内存和释放内存的机制，你可以用它来实现上面的一些功能。

键入分配器的优点是，您知道您将创建许多大小完全相同的项目，因此可以创建适合您的“页面”。最大的问题可能是你被迫通过 allocate() 返回连续的缓冲区（实际上向量需要它们）。

http://www.cplusplus.com/reference/std/memory/allocator/

你的问题仍然有点不清楚为什么这还不够。您可以使用“一次”逻辑初始化内存池。 （如果是多线程，您可以使用 boost::once 来实现这一点）。

Answer 4

标准STL的问题
实现是你只能
根据类型定义内存池
即所有 int 类型的向量都会
从同一个池中分配。

这并不完全正确。您可以使用不同的向量来保存 int 元素，每个向量具有不同的分配器类型。

不过，对于这个问题——

有人知道STL吗
实现允许动态
分配器被传递到
使用前的容器实例。

-- C++ 标准库 (STL) 根本不支持它，因此，虽然可能存在每个对象分配器可以工作的实现，但它不可移植。

有关为什么以及如何使用自定义分配器的详细分析，请参阅 Scott Meyers 的 书 Effective STL，特别是第 11 项：了解合法使用自定义分配器。

Answer 5

一种选择是使用线程局部变量来保存指向要使用的内存池的指针，并在分配器实现中捕获它。例如（使用 boost::thread_specific_ptr） ：

// Global variable
boost::thread_specific_ptr<allocator_impl> real_allocator;

struct set_allocator : boost::noncopyable {
private:
    allocator_impl *old;
public:
    set_allocator(allocator_impl *newAllocator) {
        old = real_allocator.get();
        real_allocator.reset(newAllocator);
    }
    ~set_allocator() {
        real_allocator.reset(old);
    }
};

template<typename T>
struct myallocator {
private:
    real_allocator *delegate;
public:
    myallocator() {
        delegate = real_allocator.get();
    }
    T *allocate(size_t n,  allocator<void>::const_pointer hint=0)
    {
        return delegate->allocate(sizeof(T), n, hint);
    }
    // Other mandatory STL Allocator functions and typedefs follow
};

// later:
allocator_impl *allocator = new allocator_impl();
set_allocator sa(allocator); // Set current allocator using RAII
std::list<int, myallocator> mylist; // using *allocator as the backing allocator

此处描述了 myallocator 必须实现的 API。

不幸的是，由于 STL API 的限制，这已经是您在不重新实现 STL 的情况下所能得到的最好结果了。但是，可能有第三方库允许您将分配器传递给某个地方的对象构造函数。