Botan::Locking_Allocator Class Reference

#include <defalloc.h>

Inheritance diagram for Botan::Locking_Allocator:

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

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

Detailed Description

Allocator using malloc plus locking

Definition at line 30 of file defalloc.h.

Constructor & Destructor Documentation

Locking_Allocator()

Botan::Locking_Allocator::Locking_Allocator ( Mutex * mutex )

inline

Parameters

mutex

used for internal locking

Definition at line 36 of file defalloc.h.

: Pooling_Allocator(mutex) {}

References Botan::Pooling_Allocator::Pooling_Allocator().

Referenced by Botan::Library_State::initialize().

Member Function Documentation

allocate()

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

virtualinherited

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 )

virtualinherited

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 ( )

virtualinherited

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");
   }

References Botan::Library_State::get_allocator(), Botan::global_state(), Botan::Internal_Error::Internal_Error(), and type().

Referenced by Botan::GMP_Engine::GMP_Engine(), and Botan::MemoryRegion< T >::init().

init()

virtual void Botan::Allocator::init ( )

inlinevirtualinherited

Initialize the allocator

Definition at line 53 of file allocate.h.

{}

Referenced by Botan::Library_State::add_allocator().

type()

std::string Botan::Locking_Allocator::type ( ) const

inlinevirtual

Returns

name of this allocator type

Implements Botan::Allocator.

Definition at line 38 of file defalloc.h.

{ return "locking"; }

---

The documentation for this class was generated from the following files:

• src/alloc/system_alloc/defalloc.h
• src/alloc/system_alloc/defalloc.cpp