Botan::Memory_Pool Class Reference

#include <mem_pool.h>

Public Member Functions
void *	allocate (size_t size)
bool	deallocate (void *p, size_t size) noexcept
	Memory_Pool (const Memory_Pool &)=delete
	Memory_Pool (const std::vector< void * > &pages, size_t page_size)
	Memory_Pool (Memory_Pool &&)=delete
Memory_Pool &	operator= (const Memory_Pool &)=delete
Memory_Pool &	operator= (Memory_Pool &&)=delete
	~Memory_Pool ()

Detailed Description

Definition at line 20 of file mem_pool.h.

Constructor & Destructor Documentation

Memory_Pool() [1/3]

Botan::Memory_Pool::Memory_Pool	(	const std::vector< void * > &	pages,
		size_t	page_size
	)

Initialize a memory pool. The memory is not owned by *this, it must be freed by the caller.

Parameters

pages	a list of pages to allocate from
page_size	the system page size, each page should point to exactly this much memory.

Definition at line 293 of file mem_pool.cpp.

                                                                        :
   m_page_size(page_size)
   {
   m_min_page_ptr = ~static_cast<uintptr_t>(0);
   m_max_page_ptr = 0;
 
   for(auto page : pages)
      {
      const uintptr_t p = reinterpret_cast<uintptr_t>(page);
 
      m_min_page_ptr = std::min(p, m_min_page_ptr);
      m_max_page_ptr = std::max(p, m_max_page_ptr);
 
      clear_bytes(page, m_page_size);
#if defined(BOTAN_MEM_POOL_USE_MMU_PROTECTIONS)
      OS::page_prohibit_access(page);
#endif
      m_free_pages.push_back(static_cast<uint8_t*>(page));
      }
 
   /*
   Right now this points to the start of the last page, adjust it to instead
   point to the first byte of the following page
   */
   m_max_page_ptr += page_size;
   }

References Botan::clear_bytes(), and Botan::OS::page_prohibit_access().

~Memory_Pool()

Botan::Memory_Pool::~Memory_Pool

(

)

Definition at line 320 of file mem_pool.cpp.

   {
#if defined(BOTAN_MEM_POOL_USE_MMU_PROTECTIONS)
   for(size_t i = 0; i != m_free_pages.size(); ++i)
      {
      OS::page_allow_access(m_free_pages[i]);
      }
#endif
   }

References Botan::OS::page_allow_access().

Memory_Pool() [2/3]

Botan::Memory_Pool::Memory_Pool ( const Memory_Pool &  )

delete

Memory_Pool() [3/3]

Botan::Memory_Pool::Memory_Pool ( Memory_Pool &&  )

delete

Member Function Documentation

allocate()

void * Botan::Memory_Pool::allocate

(

size_t

size

)

Definition at line 330 of file mem_pool.cpp.

   {
   if(n > m_page_size)
      return nullptr;
 
   const size_t n_bucket = choose_bucket(n);
 
   if(n_bucket > 0)
      {
      lock_guard_type<mutex_type> lock(m_mutex);
 
      std::deque<Bucket>& buckets = m_buckets_for[n_bucket];
 
      /*
      It would be optimal to pick the bucket with the most usage,
      since a bucket with say 1 item allocated out of it has a high
      chance of becoming later freed and then the whole page can be
      recycled.
      */
      for(auto& bucket : buckets)
         {
         if(uint8_t* p = bucket.alloc())
            return p;
 
         // If the bucket is full, maybe move it to the end of the list?
         // Otoh bucket search should be very fast
         }
 
      if(!m_free_pages.empty())
         {
         uint8_t* ptr = m_free_pages[0];
         m_free_pages.pop_front();
#if defined(BOTAN_MEM_POOL_USE_MMU_PROTECTIONS)
         OS::page_allow_access(ptr);
#endif
         buckets.push_front(Bucket(ptr, m_page_size, n_bucket));
         void* p = buckets[0].alloc();
         BOTAN_ASSERT_NOMSG(p != nullptr);
         return p;
         }
      }
 
   // out of room
   return nullptr;
   }

References BOTAN_ASSERT_NOMSG, and Botan::OS::page_allow_access().

deallocate()

bool Botan::Memory_Pool::deallocate ( void *  p, size_t  size  )

noexcept

Definition at line 376 of file mem_pool.cpp.

   {
   // Do a fast range check first, before taking the lock
   const uintptr_t p_val = reinterpret_cast<uintptr_t>(p);
   if(p_val < m_min_page_ptr || p_val > m_max_page_ptr)
      return false;
 
   const size_t n_bucket = choose_bucket(len);
 
   if(n_bucket != 0)
      {
      try
         {
         lock_guard_type<mutex_type> lock(m_mutex);
 
         std::deque<Bucket>& buckets = m_buckets_for[n_bucket];
 
         for(size_t i = 0; i != buckets.size(); ++i)
            {
            Bucket& bucket = buckets[i];
            if(bucket.free(p))
               {
               if(bucket.empty())
                  {
#if defined(BOTAN_MEM_POOL_USE_MMU_PROTECTIONS)
                  OS::page_prohibit_access(bucket.ptr());
#endif
                  m_free_pages.push_back(bucket.ptr());
 
                  if(i != buckets.size() - 1)
                     std::swap(buckets.back(), buckets[i]);
                  buckets.pop_back();
                  }
               return true;
               }
            }
         }
      catch(...)
         {
         /*
         * The only exception throws that can occur in the above code are from
         * either the STL or BOTAN_ASSERT failures. In either case, such an
         * error indicates a logic error or data corruption in the memory
         * allocator such that it is no longer safe to continue executing.
         *
         * Since this function is noexcept, simply letting the exception escape
         * is sufficient for terminate to be called. However in this scenario
         * it is implementation defined if any stack unwinding is performed.
         * Since stack unwinding could cause further memory deallocations this
         * could result in further corruption in this allocator state. To prevent
         * this, call terminate directly.
         */
         std::terminate();
         }
      }
 
   return false;
   }

operator=() [1/2]

Memory_Pool & Botan::Memory_Pool::operator= ( const Memory_Pool &  )

delete

operator=() [2/2]

Memory_Pool & Botan::Memory_Pool::operator= ( Memory_Pool &&  )

delete

---

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

• src/lib/utils/mem_pool/mem_pool.h
• src/lib/utils/mem_pool/mem_pool.cpp