7

我正在使用 boost pool 作为静态内存提供程序，

void func()
{
  std::vector<int, boost::pool_allocator<int> > v;
  for (int i = 0; i < 10000; ++i)
    v.push_back(13);
}

在上面的代码中，我们如何修复池的大小，我的意思是我们知道 boost::pool 作为静态内存分配器提供，但我无法修复这个池的大小，它一直在增长，应该有办法来限制它的大小。例如，我只想要一个包含 200 个块的池，所以我可以在这之后取 200 个块，尽管 NULL 请让我现在如何执行此操作

4

1 回答 1

10

我不认为 boost pool 能提供你想要的。实际上，除了对象类型之外，还有其他 4 个模板参数boost::pool_allocator：

  • UserAllocator：定义底层池将用于从系统分配内存的方法（默认 = boost::default_user_allocator_new_delete）。
  • Mutex：允许用户确定要在底层 singleton_pool（默认 = boost::details::pool::default_mutex）上使用的同步类型。
  • NextSize：该参数的值在创建时传递给底层池，并指定在第一个分配请求中分配的块数（默认 = 32）。
  • MaxSize：此参数的值在创建时传递给底层池，并指定在任何单个分配请求中分配的最大块数（默认 = 0）。

您可能认为MaxSize这正是您想要的，但不幸的是，事实并非如此。 boost::pool_allocator使用boost::singleton_pool基于 an 的底层，boost::pool最终MaxSize将传递给boost::pool<>:的数据成员max_size，那么在其中max_size扮演什么角色boost::pool呢？让我们看看boost::pool::malloc()：

void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
{ //! Allocates a chunk of memory. Searches in the list of memory blocks
  //! for a block that has a free chunk, and returns that free chunk if found.
  //! Otherwise, creates a new memory block, adds its free list to pool's free list,
  //! \returns a free chunk from that block.
  //! If a new memory block cannot be allocated, returns 0. Amortized O(1).
  // Look for a non-empty storage
  if (!store().empty())
    return (store().malloc)();
  return malloc_need_resize();
}

显然，boost::pool如果内存块中没有可用的空闲块，则立即分配一个新的内存块。让我们继续深入研究malloc_need_resize()：

template <typename UserAllocator>
void * pool<UserAllocator>::malloc_need_resize()
{ //! No memory in any of our storages; make a new storage,
  //!  Allocates chunk in newly malloc aftert resize.
  //! \returns pointer to chunk.
  size_type partition_size = alloc_size();
  size_type POD_size = static_cast<size_type>(next_size * partition_size +
      math::static_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type));
  char * ptr = (UserAllocator::malloc)(POD_size);
  if (ptr == 0)
  {
     if(next_size > 4)
     {
        next_size >>= 1;
        partition_size = alloc_size();
        POD_size = static_cast<size_type>(next_size * partition_size +
            math::static_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type));
        ptr = (UserAllocator::malloc)(POD_size);
     }
     if(ptr == 0)
        return 0;
  }
  const details::PODptr<size_type> node(ptr, POD_size);

  BOOST_USING_STD_MIN();
  if(!max_size)
    next_size <<= 1;
  else if( next_size*partition_size/requested_size < max_size)
    next_size = min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size*requested_size/ partition_size);

  //  initialize it,
  store().add_block(node.begin(), node.element_size(), partition_size);

  //  insert it into the list,
  node.next(list);
  list = node;

  //  and return a chunk from it.
  return (store().malloc)();
}

从源码中我们可以看出，max_size只和下次向系统请求的chunk数量有关，我们只能通过这个参数来减缓增加的速度。
但请注意，我们可以定义底层池用于从系统分配内存的方法，如果我们限制从系统分配的内存大小，则池的大小不会继续增长。这样boost::pool看来是多余的，可以直接将自定义分配器传递给STL容器。这是自定义分配器的示例（基于此链接），它从堆栈分配内存到给定大小：

#include <cassert>
#include <iostream>
#include <vector>
#include <new>

template <std::size_t N>
class arena
{
    static const std::size_t alignment = 8;
    alignas(alignment) char buf_[N];
    char* ptr_;

    bool
        pointer_in_buffer(char* p) noexcept
    { return buf_ <= p && p <= buf_ + N; }

public:
    arena() noexcept : ptr_(buf_) {}
    ~arena() { ptr_ = nullptr; }
    arena(const arena&) = delete;
    arena& operator=(const arena&) = delete;

    char* allocate(std::size_t n);
    void deallocate(char* p, std::size_t n) noexcept;

    static constexpr std::size_t size() { return N; }
    std::size_t used() const { return static_cast<std::size_t>(ptr_ - buf_); }
    void reset() { ptr_ = buf_; }
};

template <std::size_t N>
char*
arena<N>::allocate(std::size_t n)
{
    assert(pointer_in_buffer(ptr_) && "short_alloc has outlived arena");
    if (buf_ + N - ptr_ >= n)
    {
        char* r = ptr_;
        ptr_ += n;
        return r;
    }
    std::cout << "no memory available!\n";
    return NULL;
}

template <std::size_t N>
void
arena<N>::deallocate(char* p, std::size_t n) noexcept
{
    assert(pointer_in_buffer(ptr_) && "short_alloc has outlived arena");
    if (pointer_in_buffer(p))
    {
        if (p + n == ptr_)
            ptr_ = p;
    }
}

template <class T, std::size_t N>
class short_alloc
{
    arena<N>& a_;
public:
    typedef T value_type;

public:
    template <class _Up> struct rebind { typedef short_alloc<_Up, N> other; };

    short_alloc(arena<N>& a) noexcept : a_(a) {}
    template <class U>
    short_alloc(const short_alloc<U, N>& a) noexcept
        : a_(a.a_) {}
    short_alloc(const short_alloc&) = default;
    short_alloc& operator=(const short_alloc&) = delete;

    T* allocate(std::size_t n)
    {
        return reinterpret_cast<T*>(a_.allocate(n*sizeof(T)));
    }
    void deallocate(T* p, std::size_t n) noexcept
    {
        a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
    }

    template <class T1, std::size_t N1, class U, std::size_t M>
    friend
        bool
        operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) noexcept;

    template <class U, std::size_t M> friend class short_alloc;
};

template <class T, std::size_t N, class U, std::size_t M>
inline
bool
operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
{
    return N == M && &x.a_ == &y.a_;
}

template <class T, std::size_t N, class U, std::size_t M>
inline
bool
operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
{
    return !(x == y);
}


int main()
{
    const unsigned N = 1024;
    typedef short_alloc<int, N> Alloc;
    typedef std::vector<int, Alloc> SmallVector;
    arena<N> a;
    SmallVector v{ Alloc(a) };
    for (int i = 0; i < 400; ++i)
    {
        v.push_back(10);
    }

}
于 2014-04-09T05:29:54.513 回答