#include <mem_pool.h>

Inheritance diagram for Botan::Pooling_Allocator:

Public Member Functions
void *	allocate (size_t)
void	deallocate (void *, size_t)
void	destroy ()
virtual void	init ()
	Pooling_Allocator (Mutex *mutex)
virtual std::string	type () const =0
	~Pooling_Allocator ()

Static Public Member Functions
static Allocator *	get (bool locking)

Detailed Description

Pooling Allocator

Definition at line 22 of file mem_pool.h.

Constructor & Destructor Documentation

◆ Pooling_Allocator()

Botan::Pooling_Allocator::Pooling_Allocator ( Mutex * mutex )

Parameters

mutex used for internal locking

Definition at line 99 of file mem_pool.cpp.

                                             : mutex(m)
   {
   last_used = blocks.begin();
   }

Referenced by Botan::Locking_Allocator::Locking_Allocator(), and Botan::MemoryMapping_Allocator::MemoryMapping_Allocator().

◆ ~Pooling_Allocator()

Botan::Pooling_Allocator::~Pooling_Allocator ( )

Definition at line 107 of file mem_pool.cpp.

   {
   delete mutex;
   #if 0
   if(blocks.size())
      throw Invalid_State("Pooling_Allocator: Never released memory");
   #endif
   }

References Botan::Invalid_State::Invalid_State().

Member Function Documentation

◆ allocate()

void * Botan::Pooling_Allocator::allocate ( size_t n )

virtual

Allocate a block of memory

Parameters

n	how many bytes to allocate

Returns: pointer to n bytes of memory

Implements Botan::Allocator.

Definition at line 133 of file mem_pool.cpp.

   {
   const size_t BITMAP_SIZE = Memory_Block::bitmap_size();
   const size_t BLOCK_SIZE = Memory_Block::block_size();
 
   Mutex_Holder lock(mutex);
 
   if(n <= BITMAP_SIZE * BLOCK_SIZE)
      {
      const size_t block_no = round_up(n, BLOCK_SIZE) / BLOCK_SIZE;
 
      byte* mem = allocate_blocks(block_no);
      if(mem)
         return mem;
 
      get_more_core(BOTAN_MEM_POOL_CHUNK_SIZE);
 
      mem = allocate_blocks(block_no);
      if(mem)
         return mem;
 
      throw Memory_Exhaustion();
      }
 
   void* new_buf = alloc_block(n);
   if(new_buf)
      return new_buf;
 
   throw Memory_Exhaustion();
   }

References Botan::round_up().

◆ deallocate()

void Botan::Pooling_Allocator::deallocate	(	void *	ptr,
		size_t	n )

virtual

Deallocate memory allocated with allocate()

Parameters

ptr	the pointer returned by allocate()
n	the size of the block pointed to by ptr

Implements Botan::Allocator.

Definition at line 167 of file mem_pool.cpp.

   {
   const size_t BITMAP_SIZE = Memory_Block::bitmap_size();
   const size_t BLOCK_SIZE = Memory_Block::block_size();
 
   if(ptr == 0 || n == 0)
      return;
 
   Mutex_Holder lock(mutex);
 
   if(n > BITMAP_SIZE * BLOCK_SIZE)
      dealloc_block(ptr, n);
   else
      {
      const size_t block_no = round_up(n, BLOCK_SIZE) / BLOCK_SIZE;
 
      std::vector<Memory_Block>::iterator i =
         std::lower_bound(blocks.begin(), blocks.end(), Memory_Block(ptr));
 
      if(i == blocks.end() || !i->contains(ptr, block_no))
         throw Invalid_State("Pointer released to the wrong allocator");
 
      i->free(ptr, block_no);
      }
   }

References Botan::Invalid_State::Invalid_State(), and Botan::round_up().

◆ destroy()

void Botan::Pooling_Allocator::destroy ( )

virtual

Shutdown the allocator

Reimplemented from Botan::Allocator.

Definition at line 119 of file mem_pool.cpp.

   {
   Mutex_Holder lock(mutex);
 
   blocks.clear();
 
   for(size_t j = 0; j != allocated.size(); ++j)
      dealloc_block(allocated[j].first, allocated[j].second);
   allocated.clear();
   }

◆ get()

Allocator * Botan::Allocator::get ( bool locking )

staticinherited

Acquire a pointer to an allocator

Parameters

locking is true if the allocator should attempt to secure the memory (eg for using to store keys)

Returns: pointer to an allocator; ownership remains with library, so do not delete

Definition at line 90 of file defalloc.cpp.

   {
   std::string type = "";
   if(!locking)
      type = "malloc";
 
   Allocator* alloc = global_state().get_allocator(type);
   if(alloc)
      return alloc;
 
   throw Internal_Error("Couldn't find an allocator to use in get_allocator");
   }