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

Class template adaptive_pool

boost::interprocess::adaptive_pool

Synopsis

// In header: <boost/interprocess/allocators/adaptive_pool.hpp>
template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
         std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
class 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 adaptive_pool< T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > other;
  };
  // construct/copy/destruct
  adaptive_pool(segment_manager *);
  adaptive_pool(const adaptive_pool &);
  template<typename T2> 
    adaptive_pool(const adaptive_pool< T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > &);
  template<typename T2, typename SegmentManager2, std::size_t N2, 
           std::size_t F2, unsigned char OP2> 
    adaptive_pool & 
    operator=(const adaptive_pool< T2, SegmentManager2, N2, F2, OP2 > &);
  ~adaptive_pool();
  // public member functions
  void * 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;
  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». Это позволяет разместить распределитель в общей памяти, карт памяти-файлы и т.д.

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

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

`adaptive_pool` public construct/copy/destruct

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

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

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

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

`adaptive_pool` public member functions

<
```
void*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;
```
>
Возвращает адрес неизменяемого объекта. Никогда не бросайте
<
```
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().

`adaptive_pool` friend functions

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

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

Class template adaptive_pool

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

Boost C++ Libraries

Class template adaptive_pool

Synopsis

Description

adaptive_pool public construct/copy/destruct

adaptive_pool public member functions

adaptive_pool friend functions

`adaptive_pool` public construct/copy/destruct

`adaptive_pool` public member functions

`adaptive_pool` friend functions