7

静的メモリ プロバイダーとしてブースト プールを使用していますが、

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_allocator実際には、オブジェクトのタイプを除いて、他に 4 つのテンプレート パラメータがあります。

  • UserAllocator: 基になるプールがシステムからメモリを割り当てるために使用する方法を定義します (デフォルト = boost::default_user_allocator_new_delete)。
  • Mutex: 基礎となる singleton_pool で使用される同期のタイプをユーザーが決定できるようにします (デフォルト = boost::details::pool::default_mutex)。
  • NextSize: このパラメーターの値は、基礎となるプールが作成されるときに渡され、最初の割り当て要求で割り当てるチャンクの数を指定します (デフォルト = 32)。
  • MaxSize: このパラメータの値は、基礎となる Pool の作成時に渡され、単一の割り当てリクエストで割り当てるチャンクの最大数を指定します (デフォルト = 0)。

MaxSizeまさにあなたが望むもの だと思うかもしれませんが、残念ながらそうではありません。に基づく基にboost::pool_allocatorなる を使用すると、は最終的に:のデータ メンバーに渡されます。見てみましょう：boost::singleton_poolboost::poolMaxSizeboost::pool<>max_sizemax_sizeboost::poolboost::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次回システムから要求するチャンクの数に関連しているだけなので、このパラメーターを介して増加速度を遅くすることしかできません。
ただし、基になるプールがシステムからメモリを割り当てるために使用する方法を定義できることに注意してください。システムから割り当てられるメモリのサイズを制限すると、プールのサイズは増え続けなくなります。このように、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 に答える