diff options
Diffstat (limited to 'src/node_mem-inl.h')
-rw-r--r-- | src/node_mem-inl.h | 112 |
1 files changed, 112 insertions, 0 deletions
diff --git a/src/node_mem-inl.h b/src/node_mem-inl.h new file mode 100644 index 00000000000..ad6fc45b369 --- /dev/null +++ b/src/node_mem-inl.h @@ -0,0 +1,112 @@ +#ifndef SRC_NODE_MEM_INL_H_ +#define SRC_NODE_MEM_INL_H_ + +#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS + +#include "node_mem.h" +#include "node_internals.h" + +namespace node { +namespace mem { + +template <typename Class, typename AllocatorStruct> +AllocatorStruct NgLibMemoryManager<Class, AllocatorStruct>::MakeAllocator() { + return AllocatorStruct { + static_cast<void*>(static_cast<Class*>(this)), + MallocImpl, + FreeImpl, + CallocImpl, + ReallocImpl + }; +} + +template <typename Class, typename T> +void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr, + size_t size, + void* user_data) { + Class* manager = static_cast<Class*>(user_data); + + size_t previous_size = 0; + char* original_ptr = nullptr; + + // We prepend each allocated buffer with a size_t containing the full + // size of the allocation. + if (size > 0) size += sizeof(size_t); + + if (ptr != nullptr) { + // We are free()ing or re-allocating. + original_ptr = static_cast<char*>(ptr) - sizeof(size_t); + previous_size = *reinterpret_cast<size_t*>(original_ptr); + // This means we called StopTracking() on this pointer before. + if (previous_size == 0) { + // Fall back to the standard Realloc() function. + char* ret = UncheckedRealloc(original_ptr, size); + if (ret != nullptr) + ret += sizeof(size_t); + return ret; + } + } + + manager->CheckAllocatedSize(previous_size); + + char* mem = UncheckedRealloc(original_ptr, size); + + if (mem != nullptr) { + // Adjust the memory info counter. + // TODO(addaleax): Avoid the double bookkeeping we do with + // current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory + // and provide versions of our memory allocation utilities that take an + // Environment*/Isolate* parameter and call the V8 method transparently. + const int64_t new_size = size - previous_size; + manager->IncreaseAllocatedSize(new_size); + manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory( + new_size); + *reinterpret_cast<size_t*>(mem) = size; + mem += sizeof(size_t); + } else if (size == 0) { + manager->DecreaseAllocatedSize(previous_size); + manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory( + -static_cast<int64_t>(previous_size)); + } + return mem; +} + +template <typename Class, typename T> +void* NgLibMemoryManager<Class, T>::MallocImpl(size_t size, void* user_data) { + return ReallocImpl(nullptr, size, user_data); +} + +template <typename Class, typename T> +void NgLibMemoryManager<Class, T>::FreeImpl(void* ptr, void* user_data) { + if (ptr == nullptr) return; + CHECK_NULL(ReallocImpl(ptr, 0, user_data)); +} + +template <typename Class, typename T> +void* NgLibMemoryManager<Class, T>::CallocImpl(size_t nmemb, + size_t size, + void* user_data) { + size_t real_size = MultiplyWithOverflowCheck(nmemb, size); + void* mem = MallocImpl(real_size, user_data); + if (mem != nullptr) + memset(mem, 0, real_size); + return mem; +} + +template <typename Class, typename T> +void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) { + size_t* original_ptr = reinterpret_cast<size_t*>( + static_cast<char*>(ptr) - sizeof(size_t)); + Class* manager = static_cast<Class*>(this); + manager->DecreaseAllocatedSize(*original_ptr); + manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory( + -static_cast<int64_t>(*original_ptr)); + *original_ptr = 0; +} + +} // namespace mem +} // namespace node + +#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS + +#endif // SRC_NODE_MEM_INL_H_ |