5 #ifndef BITCOIN_ALLOCATORS_H
6 #define BITCOIN_ALLOCATORS_H
10 #include <boost/thread/mutex.hpp>
12 #include <openssl/crypto.h>
18 #define _WIN32_WINNT 0x0501
19 #define WIN32_LEAN_AND_MEAN 1
52 assert(!(page_size & (page_size-1)));
59 boost::mutex::scoped_lock lock(
mutex);
61 const size_t base_addr =
reinterpret_cast<size_t>(p);
62 const size_t start_page = base_addr &
page_mask;
63 const size_t end_page = (base_addr + size - 1) & page_mask;
64 for(
size_t page = start_page; page <= end_page; page +=
page_size)
66 Histogram::iterator it =
histogram.find(page);
70 histogram.insert(std::make_pair(page, 1));
82 boost::mutex::scoped_lock lock(
mutex);
84 const size_t base_addr =
reinterpret_cast<size_t>(p);
85 const size_t start_page = base_addr &
page_mask;
86 const size_t end_page = (base_addr + size - 1) & page_mask;
87 for(
size_t page = start_page; page <= end_page; page +=
page_size)
89 Histogram::iterator it =
histogram.find(page);
105 boost::mutex::scoped_lock lock(
mutex);
119 static inline size_t GetSystemPageSize()
123 SYSTEM_INFO sSysInfo;
124 GetSystemInfo(&sSysInfo);
125 page_size = sSysInfo.dwPageSize;
126 #elif defined(PAGESIZE) // defined in limits.h
127 page_size = PAGESIZE;
128 #else // assume some POSIX OS
129 page_size = sysconf(_SC_PAGESIZE);
144 bool Lock(
const void *addr,
size_t len)
147 return VirtualLock(const_cast<void*>(addr), len);
149 return mlock(addr, len) == 0;
155 bool Unlock(
const void *addr,
size_t len)
158 return VirtualUnlock(const_cast<void*>(addr), len);
160 return munlock(addr, len) == 0;
188 OPENSSL_cleanse((
void*)(&t),
sizeof(T));
200 typedef std::allocator<T>
base;
210 template <
typename U>
219 p = std::allocator<T>::allocate(n, hint);
229 OPENSSL_cleanse(p,
sizeof(T) * n);
232 std::allocator<T>::deallocate(p, n);
244 typedef std::allocator<T>
base;
254 template <
typename U>
263 OPENSSL_cleanse(p,
sizeof(T) * n);
264 std::allocator<T>::deallocate(p, n);
void UnlockObject(const T &t)
base::const_reference const_reference
secure_allocator(const secure_allocator &a)
LockedPageManagerBase(size_t page_size)
static LockedPageManager instance
void LockRange(void *p, size_t size)
Thread-safe class to keep track of locked (ie, non-swappable) memory pages.
base::const_pointer const_pointer
base::size_type size_type
base::value_type value_type
base::value_type value_type
secure_allocator< _Other > other
~zero_after_free_allocator()
bool Unlock(const void *addr, size_t len)
Unlock memory pages.
void LockObject(const T &t)
std::map< size_t, int > Histogram
zero_after_free_allocator< _Other > other
base::const_reference const_reference
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
base::reference reference
Singleton class to keep track of locked (ie, non-swappable) memory pages, for use in std::allocator t...
secure_allocator(const secure_allocator< U > &a)
OS-dependent memory page locking/unlocking.
base::const_pointer const_pointer
zero_after_free_allocator(const zero_after_free_allocator &a)
base::size_type size_type
zero_after_free_allocator(const zero_after_free_allocator< U > &a)
void UnlockRange(void *p, size_t size)
T * allocate(std::size_t n, const void *hint=0)
base::difference_type difference_type
void deallocate(T *p, std::size_t n)
zero_after_free_allocator()
base::difference_type difference_type
void deallocate(T *p, std::size_t n)
base::reference reference
bool Lock(const void *addr, size_t len)
Lock memory pages.