Class template private_adaptive_pool . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Indexes and Reference

Class template private_adaptive_pool

boost::interprocess::private_adaptive_pool

Synopsis

// In header: <boost/interprocess/allocators/private_adaptive_pool.hpp>
template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
         std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
class private_adaptive_pool {
public:
  // types
  typedef implementation_defined::segment_manager segment_manager;
  typedef segment_manager::void_pointer           void_pointer;   
  typedef implementation_defined::pointer         pointer;        
  typedef implementation_defined::const_pointer   const_pointer;  
  typedef T                                       value_type;     
  typedef unspecified                             reference;      
  typedef unspecified                             const_reference;
  typedef segment_manager::size_type              size_type;      
  typedef segment_manager::difference_type        difference_type;
  // member classes/structs/unions
  template<typename T2> 
  struct rebind {
    // types
    typedef private_adaptive_pool< T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > other;
  };
  // construct/copy/destruct
  private_adaptive_pool(segment_manager *);
  private_adaptive_pool(const private_adaptive_pool &);
  template<typename T2> 
    private_adaptive_pool(const private_adaptive_pool< T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > &);
  template<typename T2, typename SegmentManager2, std::size_t N2, 
           std::size_t F2, unsigned char OP2> 
    private_adaptive_pool & 
    operator=(const private_adaptive_pool< T2, SegmentManager2, N2, F2 > &);
  private_adaptive_pool & operator=(const private_adaptive_pool &);
  ~private_adaptive_pool();
  // public member functions
  node_pool_t * get_node_pool() const;
  segment_manager * get_segment_manager() const;
  size_type max_size() const;
  pointer allocate(size_type, cvoid_pointer = 0);
  void deallocate(const pointer &, size_type);
  void deallocate_free_blocks();
  pointer address(reference) const;
  const_pointer address(const_reference) const;
  void construct(const pointer &, const_reference);
  void destroy(const pointer &);
  size_type size(const pointer &) const;
  pointer allocation_command(boost::interprocess::allocation_type, size_type, 
                             size_type &, pointer &);
  void allocate_many(size_type, size_type, multiallocation_chain &);
  void allocate_many(const size_type *, size_type, multiallocation_chain &);
  void deallocate_many(multiallocation_chain &);
  pointer allocate_one();
  void allocate_individual(size_type, multiallocation_chain &);
  void deallocate_one(const pointer &);
  void deallocate_individual(multiallocation_chain &);
  // friend functions
  friend void swap(self_t &, self_t &);
};

Description

Аллокатор узла STL, который использует менеджер сегментов в качестве источника памяти. Внутренний тип указателя будет того же типа (сырой, умный), что и тип «типовое имя SegmentManager::void_pointer». Это позволяет разместить распределитель в общей памяти, карт памяти-файлы и т.д. Этот распределитель имеет собственный узел пула.

NodesPerBlock - это минимальное количество узлов узлов, выделенных одновременно, когда у распределителя заканчиваются узлы. MaxFreeBlocks - это максимальное количество полностью свободных блоков, которые будет поддерживать бассейн адаптивных узлов. Остальные свободные блоки будут размещены у менеджера сегмента.

OverheadPercent - максимальный размер накладных расходов (1-20%) распределителя: (память, используемая для узлов / общая память, выделенная из менеджера сегмента)

`private_adaptive_pool` public construct/copy/destruct

<
```
private_adaptive_pool(segment_manager*segment_mngr);
```
>
Конструктор от менеджера сегмента. Если нет, то строится узел-пул. Увеличивает количество ссылок на соответствующий пул узлов. Можно ли ставить<boost::interprocess::bad_alloc>
<
```
private_adaptive_pool(constprivate_adaptive_pool&other);
```
>
Копирование конструктора из других<private_adaptive_pool>. Увеличивает количество ссылок на соответствующий пул узлов. Никогда не бросать
<
```
template<typenameT2>
 private_adaptive_pool(constprivate_adaptive_pool<T2,SegmentManager,NodesPerBlock,MaxFreeBlocks,OverheadPercent>&other);
```
>
Копировать конструктор из родственных<private_adaptive_pool>. Если его нет, то строится узел. Увеличивает количество ссылок на соответствующий пул узлов. Может ли он<boost::interprocess::bad_alloc>

template<typenameT2,typenameSegmentManager2,std::size_tN2,
        std::size_tF2,unsignedcharOP2>
 private_adaptive_pool&
 operator=(constprivate_adaptive_pool<T2,SegmentManager2,N2,F2>&);

Не присваивается из родственных<private_adaptive_pool>

<
```
private_adaptive_pool&operator=(constprivate_adaptive_pool&);
```
>
Не присваивается от других<private_adaptive_pool>
<
```
~private_adaptive_pool();
```
>
Деструктор удаляет из памяти node_pool_t, если его опорное число достигает нуля. Никогда не бросайте

`private_adaptive_pool` public member functions

<
```
node_pool_t*get_node_pool()const;
```
>
Возвращает указатель в узел бассейна. Никогда не бросайте
<
```
segment_manager*get_segment_manager()const;
```
>
Возвращает менеджера сегмента. Никогда не бросайте
<
```
size_typemax_size()const;
```
>
Возвращает число элементов, которые можно было бы выделить. Никогда не бросайте
<
```
pointerallocate(size_typecount,cvoid_pointerhint=0);
```
>
Выделите память для массива счетных элементов. Бросает<boost::interprocess::bad_alloc>, если не хватает памяти
<
```
voiddeallocate(constpointer&ptr,size_typecount);
```
>
Выделить выделенную память. Никогда не бросайте
<
```
voiddeallocate_free_blocks();
```
>
Выделяет все свободные блоки бассейна
<
```
pointeraddress(referencevalue)const;
```
>
Возвращает адрес изменяемого объекта. Никогда не бросайте
<
```
const_pointeraddress(const_referencevalue)const;
```
>
Возвращает адрес неизменяемого объекта. Никогда не бросайте
<
```
voidconstruct(constpointer&ptr,const_referencev);
```
>
Копии строят объект. Бросает, если копирует конструктор Т
<
```
voiddestroy(constpointer&ptr);
```
>
Уничтожает объект. Бросает, если разрушитель объекта бросает
<
```
size_typesize(constpointer&p)const;
```
>
Возвращает максимальное количество объектов, которые может удерживать ранее выделенная память, указанная p. Этот размер работает только для памяти, выделенной с выделением, выделением_командой и выделением_многими.

pointerallocation_command(boost::interprocess::allocation_typecommand,
                          size_typelimit_size,
                          size_type&prefer_in_recvd_out_size,
                          pointer&reuse);

<
```
voidallocate_many(size_typeelem_size,size_typenum_elements,
                  multiallocation_chain&chain);
```
>
Выделяет множество элементов размера elem_size в смежный блок памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Элементы должны быть размещены с помощью соглашения (...)
<
```
voidallocate_many(constsize_type*elem_sizes,size_typen_elements,
                  multiallocation_chain&chain);
```
>
Выделяет элементы n_элементов, каждый из которых размером elem_sizes[i] в смежный блок памяти. Элементы должны быть размещены
<
```
voiddeallocate_many(multiallocation_chain&chain);
```
>
Выделяет множество элементов размера elem_size в смежный блок памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Элементы должны быть размещены с помощью соглашения (...)
<
```
pointerallocate_one();
```
>
Выделяют только один объект. Память, выделенная с этой функцией, должна быть размещена только с помощью deallocate_one(). Бросает<boost::interprocess::bad_alloc>, если не хватает памяти
<
```
voidallocate_individual(size_typenum_elements,
                        multiallocation_chain&chain);
```
>
Выделяет множество элементов размера == 1 в смежном блоке памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Память, выделенная с этой функцией, должна быть размещена только с помощью deallocate_one().
<
```
voiddeallocate_one(constpointer&p);
```
>
Выделяет память, ранее выделенную с выделением_one(). Вы никогда не должны использовать deallocate_one для обработки памяти, выделенной с другими функциями, отличными от allocate_one(). Никогда не бросайте
<
```
voiddeallocate_individual(multiallocation_chain&chain);
```
>
Выделяет множество элементов размера == 1 в смежном блоке памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Память, выделенная с этой функцией, должна быть размещена только с помощью deallocate_one().

`private_adaptive_pool` friend functions

<
```
friendvoidswap(self_t&alloc1,self_t&alloc2);
```
>
Распределители свопов. Не бросает. Если каждый распределитель помещается в отдельный сегмент памяти, результат не определен.

Статья Class template private_adaptive_pool раздела The Boost C++ Libraries BoostBook Documentation Subset Indexes and Reference может быть полезна для разработчиков на c++ и boost.

Class template private_adaptive_pool

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Indexes and Reference

Boost C++ Libraries

Class template private_adaptive_pool

Synopsis

Description

private_adaptive_pool public construct/copy/destruct

private_adaptive_pool public member functions

private_adaptive_pool friend functions

`private_adaptive_pool` public construct/copy/destruct

`private_adaptive_pool` public member functions

`private_adaptive_pool` friend functions