-
Notifications
You must be signed in to change notification settings - Fork 1
/
CompiledValue.cpp
143 lines (98 loc) · 3.26 KB
/
CompiledValue.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/*=====================================================================
CompiledValue.cpp
-----------------
Copyright Glare Technologies Limited 2018 -
=====================================================================*/
#include "CompiledValue.h"
#include "wnt_ASTNode.h"
#include "wnt_FunctionDefinition.h"
#include "utils/StringUtils.h"
#include "maths/mathstypes.h"
using std::vector;
namespace Winter
{
//=====================================================================================
static int64 max_heap_mem_usage = 0;
static int64 cur_heap_mem_usage = 0;
static void* heapAlloc(size_t size)
{
cur_heap_mem_usage += size;
max_heap_mem_usage = myMax(max_heap_mem_usage, cur_heap_mem_usage);
// Allocate an extra 8 bytes to store allocation size (for now), so that we can use it in heapFree().
uint64* p = (uint64*)::malloc(size + sizeof(uint64));
*p = size;
return p + 1;
}
static void heapFree(void* ptr)
{
uint64* original_ptr = (uint64*)ptr - 1;
const uint64 allocation_size = *((uint64*)ptr - 1);
cur_heap_mem_usage -= allocation_size;
::free(original_ptr);
}
void resetMemUsageStats()
{
max_heap_mem_usage = 0;
cur_heap_mem_usage = 0;
}
uint64 getMaxHeapMemUsage()
{
return max_heap_mem_usage;
}
uint64 getCurrentHeapMemUsage()
{
return cur_heap_mem_usage;
}
//=====================================================================================
static void* getVoidPtrArg(const vector<ValueRef>& arg_values, int i)
{
assert(arg_values[i]->valueType() == Value::ValueType_VoidPtr);
return static_cast<const VoidPtrValue*>(arg_values[i].getPointer())->value;
}
VArrayRep* allocateVArray(uint64 elem_size_B, uint64 num_elems)
{
// Allocate space for the reference count, length, flags, and data.
VArrayRep* varray = (VArrayRep*)heapAlloc(sizeof(VArrayRep) + elem_size_B * num_elems);
return varray;
}
ValueRef allocateVArrayInterpreted(const vector<ValueRef>& args)
{
assert(0);
return NULL;
}
// NOTE: just return an int here as all external funcs need to return something (non-void).
int free(VArrayRep* varray)
{
assert(varray->refcount == 1);
heapFree(varray);
return 0;
}
//=====================================================================================
StringRep* allocateStringWithLen(size_t len)
{
StringRep* string_val = (StringRep*)heapAlloc(sizeof(StringRep) + len);
string_val->refcount = 0;
string_val->len = len;
string_val->flags = 1; // heap allocated
return string_val;
}
StringRep* allocateString(const char* initial_string_val)
{
const size_t string_len = strlen(initial_string_val);
StringRep* string_val = allocateStringWithLen(string_len);
std::memcpy((char*)string_val + sizeof(StringRep), initial_string_val, string_len);
return string_val;
}
ValueRef allocateStringInterpreted(const vector<ValueRef>& args)
{
return new StringValue((const char*)(getVoidPtrArg(args, 0)));
}
// NOTE: just return an int here as all external funcs need to return something (non-void).
int free(StringRep* str)
{
//assert(str->refcount == 1);
heapFree(str);
return 0;
}
//=====================================================================================
} // end namespace Winter