Viewing file:  node_mem-inl.h (3.6 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#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_
|