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 277 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 301 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 310 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, Botan::lock(), and Botan::OS::page_allow_access().

deallocate()

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

noexcept

Definition at line 354 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;
}

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

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