Class template segment_manager

Class template segment_manager_base

boost::interprocess::segment_manager_base

Synopsis

// In header: <boost/interprocess/segment_manager.hpp>

template<typename MemoryAlgorithm> 
class segment_manager_base : private MemoryAlgorithm {
public:
  // types
  typedef segment_manager_base< MemoryAlgorithm > segment_manager_base_type;
  typedef MemoryAlgorithm::void_pointer           void_pointer;             
  typedef MemoryAlgorithm::mutex_family           mutex_family;             
  typedef MemoryAlgorithm                         memory_algorithm;         
  typedef MemoryAlgorithm::multiallocation_chain  multiallocation_chain;    
  typedef MemoryAlgorithm::difference_type        difference_type;          
  typedef MemoryAlgorithm::size_type              size_type;                

  // construct/copy/destruct
  segment_manager_base(size_type, size_type);

  // public member functions
  size_type get_size() const;
  size_type get_free_memory() const;
  void * allocate(size_type, const std::nothrow_t &);
  void allocate_many(size_type, size_type, multiallocation_chain &);
  void allocate_many(const size_type *, size_type, size_type, 
                     multiallocation_chain &);
  void allocate_many(const std::nothrow_t &, size_type, size_type, 
                     multiallocation_chain &);
  void allocate_many(const std::nothrow_t &, const size_type *, size_type, 
                     size_type, multiallocation_chain &);
  void deallocate_many(multiallocation_chain &);
  void * allocate(size_type);
  void * allocate_aligned(size_type, size_type, const std::nothrow_t &);
  void * allocate_aligned(size_type, size_type);
  template<typename T> 
    T * allocation_command(boost::interprocess::allocation_type, size_type, 
                           size_type &, T *&);
  void * raw_allocation_command(boost::interprocess::allocation_type, 
                                size_type, size_type &, void *&, 
                                size_type = 1);
  void deallocate(void *);
  void grow(size_type);
  void shrink_to_fit();
  bool all_memory_deallocated();
  bool check_sanity();
  void zero_free_memory();
  size_type size(const void *) const;

  // public static functions
  static size_type get_min_size(size_type);

  // protected member functions
  void * prot_anonymous_construct(size_type, bool, unspecified);
  void prot_anonymous_destroy(const void *, unspecified);

  // public data members
  static const size_type PayloadPerAllocation;
};

Description

This object is the public base class of segment manager. This class only depends on the memory allocation algorithm and implements all the allocation features not related to named or unique objects.

Storing a reference to segment_manager forces the holder class to be dependent on index types and character types. When such dependence is not desirable and only anonymous and raw allocations are needed, segment_manager_base is the correct answer.

`segment_manager_base` public construct/copy/destruct

```
segment_manager_base(size_type sz, size_type reserved_bytes);
```
Constructor of the segment_manager_base

"size" is the size of the memory segment where the basic segment manager is being constructed.

"reserved_bytes" is the number of bytes after the end of the memory algorithm object itself that the memory algorithm will exclude from dynamic allocation

Can throw

`segment_manager_base` public member functions

```
size_type get_size() const;
```
Returns the size of the memory segment
```
size_type get_free_memory() const;
```
Returns the number of free bytes of the memory segment
```
void * allocate(size_type nbytes, const std::nothrow_t &);
```
Allocates nbytes bytes. This function is only used in single-segment management. Never throws

void allocate_many(size_type elem_bytes, size_type n_elements, 
                   multiallocation_chain & chain);

Allocates n_elements of elem_bytes bytes. Throws bad_alloc on failure. chain.size() is not increased on failure.

void allocate_many(const size_type * element_lengths, size_type n_elements, 
                   size_type sizeof_element, multiallocation_chain & chain);

Allocates n_elements, each one of element_lengths[i]*sizeof_element bytes. Throws bad_alloc on failure. chain.size() is not increased on failure.

void allocate_many(const std::nothrow_t &, size_type elem_bytes, 
                   size_type n_elements, multiallocation_chain & chain);

Allocates n_elements of elem_bytes bytes. Non-throwing version. chain.size() is not increased on failure.

void allocate_many(const std::nothrow_t &, const size_type * elem_sizes, 
                   size_type n_elements, size_type sizeof_element, 
                   multiallocation_chain & chain);

Allocates n_elements, each one of element_lengths[i]*sizeof_element bytes. Non-throwing version. chain.size() is not increased on failure.

```
void deallocate_many(multiallocation_chain & chain);
```
Deallocates all elements contained in chain. Never throws.
```
void * allocate(size_type nbytes);
```
Allocates nbytes bytes. Throws boost::interprocess::bad_alloc on failure

void * allocate_aligned(size_type nbytes, size_type alignment, 
                        const std::nothrow_t &);

Allocates nbytes bytes. This function is only used in single-segment management. Never throws

```
void * allocate_aligned(size_type nbytes, size_type alignment);
```
Allocates nbytes bytes. This function is only used in single-segment management. Throws bad_alloc when fails

template<typename T> 
  T * allocation_command(boost::interprocess::allocation_type command, 
                         size_type limit_size, 
                         size_type & prefer_in_recvd_out_size, T *& reuse);

void * raw_allocation_command(boost::interprocess::allocation_type command, 
                              size_type limit_objects, 
                              size_type & prefer_in_recvd_out_size, 
                              void *& reuse, size_type sizeof_object = 1);

```
void deallocate(void * addr);
```
Deallocates the bytes allocated with allocate/allocate_many() pointed by addr
```
void grow(size_type extra_size);
```
Increases managed memory in extra_size bytes more. This only works with single-segment management.
```
void shrink_to_fit();
```
Decreases managed memory to the minimum. This only works with single-segment management.
```
bool all_memory_deallocated();
```
Returns the result of "all_memory_deallocated()" function of the used memory algorithm
```
bool check_sanity();
```
Returns the result of "check_sanity()" function of the used memory algorithm
```
void zero_free_memory();
```
Writes to zero free memory (memory not yet allocated) of the memory algorithm
```
size_type size(const void * ptr) const;
```
Returns the size of the buffer previously allocated pointed by ptr.

`segment_manager_base` public static functions

```
static size_type get_min_size(size_type size);
```
Obtains the minimum size needed by the segment manager

`segment_manager_base` protected member functions

void * prot_anonymous_construct(size_type num, bool dothrow, 
                                unspecified table);

void prot_anonymous_destroy(const void * object, unspecified table);

Calls the destructor and makes an anonymous deallocate.

`segment_manager_base` public public data members

```
static const size_type PayloadPerAllocation;
```
This constant indicates the payload size associated with each allocation of the memory algorithm