1 |
|
|
#ifndef SRC_NODE_MEM_INL_H_ |
2 |
|
|
#define SRC_NODE_MEM_INL_H_ |
3 |
|
|
|
4 |
|
|
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS |
5 |
|
|
|
6 |
|
|
#include "node_mem.h" |
7 |
|
|
#include "node_internals.h" |
8 |
|
|
|
9 |
|
|
namespace node { |
10 |
|
|
namespace mem { |
11 |
|
|
|
12 |
|
|
template <typename Class, typename AllocatorStruct> |
13 |
|
806 |
AllocatorStruct NgLibMemoryManager<Class, AllocatorStruct>::MakeAllocator() { |
14 |
|
|
return AllocatorStruct { |
15 |
|
|
static_cast<void*>(static_cast<Class*>(this)), |
16 |
|
|
MallocImpl, |
17 |
|
|
FreeImpl, |
18 |
|
|
CallocImpl, |
19 |
|
|
ReallocImpl |
20 |
|
806 |
}; |
21 |
|
|
} |
22 |
|
|
|
23 |
|
|
template <typename Class, typename T> |
24 |
|
211381 |
void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr, |
25 |
|
|
size_t size, |
26 |
|
|
void* user_data) { |
27 |
|
211381 |
Class* manager = static_cast<Class*>(user_data); |
28 |
|
|
|
29 |
|
211381 |
size_t previous_size = 0; |
30 |
|
211381 |
char* original_ptr = nullptr; |
31 |
|
|
|
32 |
|
|
// We prepend each allocated buffer with a size_t containing the full |
33 |
|
|
// size of the allocation. |
34 |
✓✓ |
211381 |
if (size > 0) size += sizeof(size_t); |
35 |
|
|
|
36 |
✓✓ |
211381 |
if (ptr != nullptr) { |
37 |
|
|
// We are free()ing or re-allocating. |
38 |
|
105712 |
original_ptr = static_cast<char*>(ptr) - sizeof(size_t); |
39 |
|
105712 |
previous_size = *reinterpret_cast<size_t*>(original_ptr); |
40 |
|
|
// This means we called StopTracking() on this pointer before. |
41 |
✓✓ |
105712 |
if (previous_size == 0) { |
42 |
|
|
// Fall back to the standard Realloc() function. |
43 |
|
1954 |
char* ret = UncheckedRealloc(original_ptr, size); |
44 |
✗✓ |
1954 |
if (ret != nullptr) |
45 |
|
|
ret += sizeof(size_t); |
46 |
|
1954 |
return ret; |
47 |
|
|
} |
48 |
|
|
} |
49 |
|
|
|
50 |
|
209427 |
manager->CheckAllocatedSize(previous_size); |
51 |
|
|
|
52 |
|
209427 |
char* mem = UncheckedRealloc(original_ptr, size); |
53 |
|
|
|
54 |
✓✓ |
209427 |
if (mem != nullptr) { |
55 |
|
|
// Adjust the memory info counter. |
56 |
|
|
// TODO(addaleax): Avoid the double bookkeeping we do with |
57 |
|
|
// current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory |
58 |
|
|
// and provide versions of our memory allocation utilities that take an |
59 |
|
|
// Environment*/Isolate* parameter and call the V8 method transparently. |
60 |
|
105723 |
const int64_t new_size = size - previous_size; |
61 |
|
105723 |
manager->IncreaseAllocatedSize(new_size); |
62 |
|
105723 |
manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory( |
63 |
|
|
new_size); |
64 |
|
105723 |
*reinterpret_cast<size_t*>(mem) = size; |
65 |
|
105723 |
mem += sizeof(size_t); |
66 |
✓✗ |
103704 |
} else if (size == 0) { |
67 |
|
103704 |
manager->DecreaseAllocatedSize(previous_size); |
68 |
|
103704 |
manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory( |
69 |
|
|
-static_cast<int64_t>(previous_size)); |
70 |
|
|
} |
71 |
|
209427 |
return mem; |
72 |
|
|
} |
73 |
|
|
|
74 |
|
|
template <typename Class, typename T> |
75 |
|
104610 |
void* NgLibMemoryManager<Class, T>::MallocImpl(size_t size, void* user_data) { |
76 |
|
104610 |
return ReallocImpl(nullptr, size, user_data); |
77 |
|
|
} |
78 |
|
|
|
79 |
|
|
template <typename Class, typename T> |
80 |
|
241083 |
void NgLibMemoryManager<Class, T>::FreeImpl(void* ptr, void* user_data) { |
81 |
✓✓ |
241083 |
if (ptr == nullptr) return; |
82 |
✗✓ |
105658 |
CHECK_NULL(ReallocImpl(ptr, 0, user_data)); |
83 |
|
|
} |
84 |
|
|
|
85 |
|
|
template <typename Class, typename T> |
86 |
|
1620 |
void* NgLibMemoryManager<Class, T>::CallocImpl(size_t nmemb, |
87 |
|
|
size_t size, |
88 |
|
|
void* user_data) { |
89 |
|
1620 |
size_t real_size = MultiplyWithOverflowCheck(nmemb, size); |
90 |
|
1620 |
void* mem = MallocImpl(real_size, user_data); |
91 |
✓✗ |
1620 |
if (mem != nullptr) |
92 |
|
1620 |
memset(mem, 0, real_size); |
93 |
|
1620 |
return mem; |
94 |
|
|
} |
95 |
|
|
|
96 |
|
|
template <typename Class, typename T> |
97 |
|
25274 |
void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) { |
98 |
|
25274 |
size_t* original_ptr = reinterpret_cast<size_t*>( |
99 |
|
|
static_cast<char*>(ptr) - sizeof(size_t)); |
100 |
|
25274 |
Class* manager = static_cast<Class*>(this); |
101 |
|
25274 |
manager->DecreaseAllocatedSize(*original_ptr); |
102 |
|
25274 |
manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory( |
103 |
|
|
-static_cast<int64_t>(*original_ptr)); |
104 |
|
25274 |
*original_ptr = 0; |
105 |
|
25274 |
} |
106 |
|
|
|
107 |
|
|
} // namespace mem |
108 |
|
|
} // namespace node |
109 |
|
|
|
110 |
|
|
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS |
111 |
|
|
|
112 |
|
|
#endif // SRC_NODE_MEM_INL_H_ |