You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
398 lines
13 KiB
398 lines
13 KiB
// Distributed under the Boost Software License, Version 1.0. (See |
|
// accompanying file LICENSE_1_0.txt or copy at |
|
// http://www.boost.org/LICENSE_1_0.txt) |
|
// (C) Copyright 2007 Anthony Williams |
|
#ifndef THREAD_HEAP_ALLOC_HPP |
|
#define THREAD_HEAP_ALLOC_HPP |
|
#include <new> |
|
#include "thread_primitives.hpp" |
|
#include <stdexcept> |
|
#include <boost/assert.hpp> |
|
#include <boost/throw_exception.hpp> |
|
|
|
#if defined( BOOST_USE_WINDOWS_H ) |
|
# include <windows.h> |
|
|
|
namespace boost |
|
{ |
|
namespace detail |
|
{ |
|
namespace win32 |
|
{ |
|
using ::GetProcessHeap; |
|
using ::HeapAlloc; |
|
using ::HeapFree; |
|
} |
|
} |
|
} |
|
|
|
#else |
|
|
|
# ifdef HeapAlloc |
|
# undef HeapAlloc |
|
# endif |
|
|
|
namespace boost |
|
{ |
|
namespace detail |
|
{ |
|
namespace win32 |
|
{ |
|
extern "C" |
|
{ |
|
__declspec(dllimport) handle __stdcall GetProcessHeap(); |
|
__declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr); |
|
__declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*); |
|
} |
|
} |
|
} |
|
} |
|
|
|
#endif |
|
|
|
#include <boost/config/abi_prefix.hpp> |
|
|
|
namespace boost |
|
{ |
|
namespace detail |
|
{ |
|
inline BOOST_THREAD_DECL void* allocate_raw_heap_memory(unsigned size) |
|
{ |
|
void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size); |
|
if(!heap_memory) |
|
{ |
|
boost::throw_exception(std::bad_alloc()); |
|
} |
|
return heap_memory; |
|
} |
|
|
|
inline BOOST_THREAD_DECL void free_raw_heap_memory(void* heap_memory) |
|
{ |
|
BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0); |
|
} |
|
|
|
template<typename T> |
|
inline T* heap_new() |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
|
|
#ifndef BOOST_NO_RVALUE_REFERENCES |
|
template<typename T,typename A1> |
|
inline T* heap_new(A1&& a1) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(static_cast<A1&&>(a1)); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
template<typename T,typename A1,typename A2> |
|
inline T* heap_new(A1&& a1,A2&& a2) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2)); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1&& a1,A2&& a2,A3&& a3) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2), |
|
static_cast<A3&&>(a3)); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2), |
|
static_cast<A3&&>(a3),static_cast<A4&&>(a4)); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
#else |
|
template<typename T,typename A1> |
|
inline T* heap_new_impl(A1 a1) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(a1); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
|
|
template<typename T,typename A1,typename A2> |
|
inline T* heap_new_impl(A1 a1,A2 a2) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(a1,a2); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new_impl(A1 a1,A2 a2,A3 a3) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(a1,a2,a3); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4) |
|
{ |
|
void* const heap_memory=allocate_raw_heap_memory(sizeof(T)); |
|
try |
|
{ |
|
T* const data=new (heap_memory) T(a1,a2,a3,a4); |
|
return data; |
|
} |
|
catch(...) |
|
{ |
|
free_raw_heap_memory(heap_memory); |
|
throw; |
|
} |
|
} |
|
|
|
|
|
template<typename T,typename A1> |
|
inline T* heap_new(A1 const& a1) |
|
{ |
|
return heap_new_impl<T,A1 const&>(a1); |
|
} |
|
template<typename T,typename A1> |
|
inline T* heap_new(A1& a1) |
|
{ |
|
return heap_new_impl<T,A1&>(a1); |
|
} |
|
|
|
template<typename T,typename A1,typename A2> |
|
inline T* heap_new(A1 const& a1,A2 const& a2) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&>(a1,a2); |
|
} |
|
template<typename T,typename A1,typename A2> |
|
inline T* heap_new(A1& a1,A2 const& a2) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&>(a1,a2); |
|
} |
|
template<typename T,typename A1,typename A2> |
|
inline T* heap_new(A1 const& a1,A2& a2) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&>(a1,a2); |
|
} |
|
template<typename T,typename A1,typename A2> |
|
inline T* heap_new(A1& a1,A2& a2) |
|
{ |
|
return heap_new_impl<T,A1&,A2&>(a1,a2); |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1& a1,A2& a2,A3 const& a3) |
|
{ |
|
return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3); |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1& a1,A2 const& a2,A3& a3) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1 const& a1,A2& a2,A3& a3) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3> |
|
inline T* heap_new(A1& a1,A2& a2,A3& a3) |
|
{ |
|
return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3); |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4); |
|
} |
|
|
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4); |
|
} |
|
template<typename T,typename A1,typename A2,typename A3,typename A4> |
|
inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4) |
|
{ |
|
return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4); |
|
} |
|
|
|
#endif |
|
template<typename T> |
|
inline void heap_delete(T* data) |
|
{ |
|
data->~T(); |
|
free_raw_heap_memory(data); |
|
} |
|
|
|
template<typename T> |
|
struct do_heap_delete |
|
{ |
|
void operator()(T* data) const |
|
{ |
|
detail::heap_delete(data); |
|
} |
|
}; |
|
} |
|
} |
|
|
|
#include <boost/config/abi_suffix.hpp> |
|
|
|
|
|
#endif
|
|
|