16 #ifndef INCLUDE_NN_NLIB_HEAP_NMALLOC_H_ 17 #define INCLUDE_NN_NLIB_HEAP_NMALLOC_H_ 30 #if defined(_MSC_VER) && defined(nx_heap_EXPORTS) 31 #undef NLIB_VIS_PUBLIC 32 #define NLIB_VIS_PUBLIC NLIB_WINEXPORT 35 #ifndef INCLUDE_NN_NLIB_PLATFORM_H_ 56 #define NMALLOC_HEAPOPTION_ENABLE_ENV (0x00000001) 57 #define NMALLOC_HEAPOPTION_CACHE_DISABLE (0x00000004) 63 #pragma comment(linker, "/alternatename:_nmalloc_get_settings=_nmalloc_get_settings_default") 65 #pragma comment(linker, "/alternatename:nmalloc_get_settings=nmalloc_get_settings_default") 85 kNmallocQueryDump = 0,
86 kNmallocQueryPageSize,
87 kNmallocQueryAllocatedSize,
88 kNmallocQueryFreeSize,
89 kNmallocQuerySystemSize,
90 kNmallocQueryMaxAllocatableSize,
92 kNmallocQueryHeapHash,
93 kNmallocQueryUnifyFreelist,
94 kNmallocQuerySetColor,
95 kNmallocQueryGetColor,
98 kNmallocQueryCacheMin_,
99 kNmallocQueryCheckCache,
100 kNmallocQueryClearCache,
101 kNmallocQueryFinalizeCache,
102 NMALLOC_QUERY_DUMP = kNmallocQueryDump,
103 NMALLOC_QUERY_PAGE_SIZE = kNmallocQueryPageSize,
104 NMALLOC_QUERY_ALLOCATED_SIZE = kNmallocQueryAllocatedSize,
105 NMALLOC_QUERY_FREE_SIZE = kNmallocQueryFreeSize,
106 NMALLOC_QUERY_SYSTEM_SIZE = kNmallocQuerySystemSize,
107 NMALLOC_QUERY_MAX_ALLOCATABLE_SIZE = kNmallocQueryMaxAllocatableSize,
108 NMALLOC_QUERY_IS_CLEAN = kNmallocQueryIsClean,
109 NMALLOC_QUERY_HEAP_HASH = kNmallocQueryHeapHash,
110 NMALLOC_QUERY_UNIFY_FREELIST = kNmallocQueryUnifyFreelist,
111 NMALLOC_QUERY_SET_COLOR = kNmallocQuerySetColor,
112 NMALLOC_QUERY_GET_COLOR = kNmallocQueryGetColor,
113 NMALLOC_QUERY_SET_NAME = kNmallocQuerySetName,
114 NMALLOC_QUERY_GET_NAME = kNmallocQueryGetName,
115 NMALLOC_QUERY_CACHE_MIN_ = kNmallocQueryCacheMin_,
116 NMALLOC_QUERY_CHECK_CACHE = kNmallocQueryCheckCache,
117 NMALLOC_QUERY_CLEAR_CACHE = kNmallocQueryClearCache,
118 NMALLOC_QUERY_FINALIZE_CACHE = kNmallocQueryFinalizeCache
132 NLIB_ATTRIBUTE_ASSUME_ALIGNED(8);
158 template <
typename T>
159 struct NMallocStlAllocator {
160 typedef size_t size_type;
161 typedef T value_type;
163 typedef const T* const_pointer;
164 typedef T& reference;
165 typedef const T& const_reference;
166 typedef ptrdiff_t difference_type;
167 template <
typename U>
169 typedef NMallocStlAllocator<U> other;
171 NMallocStlAllocator() {}
172 explicit NMallocStlAllocator(
const NMallocStlAllocator<T>&) {}
173 template <
class _Other>
174 NMallocStlAllocator(
const NMallocStlAllocator<_Other>&) {}
175 pointer allocate(size_type n,
const void* p = 0);
176 void deallocate(pointer p, size_type n) {
184 void construct(pointer p,
const T& t) {
new ((
void*)p) T(t); }
185 void construct(pointer p) {
new ((
void*)p) T(); }
186 #if defined(NLIB_CXX11_RVALUE_REFERENCES) && defined(NLIB_CXX11_VARIADIC_TEMPLATES) 187 template<
class X,
class... ARGS>
188 void construct(X* p, ARGS&&... args) {
189 new ((
void*)p) X(std::forward<ARGS>(args)...);
192 void destroy(pointer ptr) {
201 size_t max_size()
const {
202 size_t cnt = (size_t)-1 /
sizeof(T);
203 return 0 < cnt ? cnt : 1;
205 pointer address(reference value)
const {
return &value; }
206 const_pointer address(const_reference value)
const {
return &value; }
209 template <
typename T>
210 typename NMallocStlAllocator<T>::pointer NMallocStlAllocator<T>::allocate(size_type n,
213 void* pp =
nmalloc(n *
sizeof(T));
214 return reinterpret_cast<T*
>(pp);
217 template <
class T1,
class T2>
218 inline bool operator==(
const NMallocStlAllocator<T1>&,
const NMallocStlAllocator<T2>&) {
222 template <
class T1,
class T2>
223 inline bool operator!=(
const NMallocStlAllocator<T1>&,
const NMallocStlAllocator<T2>&) {
233 #define NLIB_REPLACE_MALLOC \ 235 void* nlib_malloc(size_t n) { \ 238 void nlib_free(void* p) { \ 241 void* nlib_calloc(size_t nmemb, size_t size) { \ 242 return ncalloc(nmemb, size); \ 244 void* nlib_realloc(void* ptr, size_t size) { \ 245 return nrealloc(ptr, size); \ 247 void* nlib_memalign(size_t alignment, size_t size) { \ 248 return nmalloc_aligned(size, alignment); \ 250 void nlib_free_size(void* ptr, size_t size) { \ 251 nfree_size(ptr, size); \ 255 #ifndef NN_PLATFORM_CTR 256 #define NLIB_REPLACE_MALLOC_NEW \ 257 NLIB_REPLACE_MALLOC \ 258 void* operator new(size_t size) { \ 259 return nlib_malloc(size); \ 261 void operator delete(void* ptr) NLIB_NOEXCEPT { \ 264 void* operator new(size_t size, const std::nothrow_t&) NLIB_NOEXCEPT { \ 265 return nlib_malloc(size); \ 267 void operator delete(void* ptr, const std::nothrow_t&) NLIB_NOEXCEPT { \ 270 void* operator new[](size_t size) { return nlib_malloc(size); } \ 271 void operator delete[](void* ptr) NLIB_NOEXCEPT { nlib_free(ptr); } \ 272 void* operator new[](size_t size, const std::nothrow_t&) NLIB_NOEXCEPT \ 273 { return nlib_malloc(size); } \ 274 void operator delete [](void* ptr, const std::nothrow_t&) NLIB_NOEXCEPT { nlib_free(ptr); } \ 275 void operator delete(void* ptr, size_t size) NLIB_NOEXCEPT { \ 276 nlib_free_size(ptr, size); \ 278 void operator delete(void* ptr, size_t size, const std::nothrow_t&) NLIB_NOEXCEPT { \ 279 nlib_free_size(ptr, size); \ 281 void operator delete[](void* ptr, size_t size)NLIB_NOEXCEPT { nlib_free_size(ptr, size); } \ 282 void operator delete[](void* ptr, size_t size, const std::nothrow_t&) NLIB_NOEXCEPT { \ 283 nlib_free_size(ptr, size); \ 286 #define NLIB_REPLACE_MALLOC_NEW \ 287 NLIB_REPLACE_MALLOC \ 288 void* operator new(size_t size) throw(std::bad_alloc) { \ 289 return nlib_malloc(size); \ 291 void operator delete(void* ptr) throw() { \ 294 void* operator new(size_t size, const std::nothrow_t&) throw() { \ 295 return nlib_malloc(size); \ 297 void* operator new[](size_t size) throw(std::bad_alloc) { \ 298 return nlib_malloc(size); \ 300 void operator delete[](void* ptr) throw() { \ 303 void* operator new[](size_t size, const std::nothrow_t&) throw() { \ 304 return nlib_malloc(size); \ 308 #define NLIB_REPLACE_MALLOC \ 309 void* nlib_malloc(size_t n) { \ 312 void nlib_free(void* p) { \ 315 void* nlib_calloc(size_t nmemb, size_t size) { \ 316 return ncalloc(nmemb, size); \ 318 void* nlib_realloc(void* ptr, size_t size) { \ 319 return nrealloc(ptr, size); \ 321 void* nlib_memalign(size_t alignment, size_t size) { \ 322 return nmalloc_aligned(size, alignment); \ 324 void nlib_free_size(void* ptr, size_t size) { \ 325 nfree_size(ptr, size); \ 327 #define NLIB_REPLACE_MALLOC_NEW NLIB_REPLACE_MALLOC 330 #if defined(_MSC_VER) && defined(nx_heap_EXPORTS) 331 #undef NLIB_VIS_PUBLIC 332 #define NLIB_VIS_PUBLIC NLIB_WINIMPORT 335 #endif // INCLUDE_NN_NLIB_HEAP_NMALLOC_H_ void nfree_size(void *p, size_t size)
Frees a memory region. Using information about memory sizes makes it possible to free memory quickly...
int(* nmalloc_heapwalk_callback)(void *allocated_ptr, size_t size, void *user_ptr)
User-defined callback function that is called from nmalloc_walk_allocated_ptrs.
Only displays basic information.
NLIB_CHECK_RESULT void * nrealloc(void *ptr, size_t size)
Changes the memory allocation. Corresponds to the standard C function realloc.
Displays all information.
size_t nmalloc_size(const void *ptr)
Returns the amount of memory actually allocated at the ptr parameter.
size_t alloc_size
Total size of the regions allocated by the user application within the heap.
Displays the addresses and sizes of all memory allocated by the user application. ...
bool operator==(const HeapHash &rhs, const HeapHash &lhs)
Returns true if the two compared summaries are equal.
bool operator!=(const HeapHash &rhs, const HeapHash &lhs)
Returns true if the two compared summaries are not equal.
errno_t nmalloc_query(int query,...)
Gets and operates detailed data on the heap.
NLIB_CHECK_RESULT void * ncalloc(size_t nmemb, size_t size)
Allocates an array of memory and elements initialized to 0.
void nfree(void *p)
Frees a memory region. Corresponds to the standard C function free.
unsigned int heap_option
Specifies the heap options. The default is 0.
size_t alloc_count
Number of regions allocated by the user application within the heap.
size_t size
Specifies the maximum amount of memory that can be used by nmalloc. You must specify a multiple of 40...
Declares parameters that are initialized by nmalloc. Set by defining nmalloc_get_settings.
size_t hash
Hash value of the status of memory allocated by the user application within the heap.
NLIB_CHECK_RESULT void * nmalloc(size_t size)
Allocates a memory region of the specified size (in bytes). This corresponds to the standard C functi...
Displays the usage status for each page.
A file that contains the configuration information for each development environment.
Visually displays the overview of the page allocation density in the entire heap. An area of 1 MB is ...
void * addr
Specifies a pointer to the beginning of the region used by nmalloc.
void nmalloc_get_settings(NMallocSettings *settings)
User applications can define this function to control the initialization settings of nmalloc...
errno_t nmalloc_walk_allocated_ptrs(nmalloc_heapwalk_callback func, void *user_ptr)
The callback function func is called for each region allocated in the heap.
NMallocDumpMode
The type of the value that you specify for the second argument when specifying kNmallocQueryDump in t...
Structure that contains a summary of the memory usage status of the heap used by the user application...
NLIB_CHECK_RESULT void * nmalloc_aligned(size_t size, size_t algn)
Allocates memory with a specific alignment.