12 #include "threads-model.h"
16 #define REQUESTS_BEFORE_ALLOC 1024
18 size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
21 #if !USE_MPROTECT_SNAPSHOT
22 static mspace sStaticSpace = NULL;
25 /** Non-snapshotting calloc for our use. */
26 void *model_calloc(size_t count, size_t size)
28 #if USE_MPROTECT_SNAPSHOT
29 static void *(*callocp)(size_t count, size_t size) = NULL;
33 /* get address of libc malloc */
35 callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
36 if ((error = dlerror()) != NULL) {
41 ptr = callocp(count, size);
45 sStaticSpace = create_shared_mspace();
46 return mspace_calloc(sStaticSpace, count, size);
50 /** Non-snapshotting malloc for our use. */
51 void *model_malloc(size_t size)
53 #if USE_MPROTECT_SNAPSHOT
54 static void *(*mallocp)(size_t size) = NULL;
58 /* get address of libc malloc */
60 mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc");
61 if ((error = dlerror()) != NULL) {
70 sStaticSpace = create_shared_mspace();
71 return mspace_malloc(sStaticSpace, size);
75 /** Non-snapshotting malloc for our use. */
76 void *model_realloc(void *ptr, size_t size)
78 #if USE_MPROTECT_SNAPSHOT
79 static void *(*reallocp)(void *ptr, size_t size) = NULL;
83 /* get address of libc malloc */
85 reallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "realloc");
86 if ((error = dlerror()) != NULL) {
91 newptr = reallocp(ptr, size);
95 sStaticSpace = create_shared_mspace();
96 return mspace_realloc(sStaticSpace, ptr, size);
100 /** @brief Snapshotting malloc, for use by model-checker (not user progs) */
101 void * snapshot_malloc(size_t size)
103 void *tmp = mspace_malloc(model_snapshot_space, size);
108 /** @brief Snapshotting calloc, for use by model-checker (not user progs) */
109 void * snapshot_calloc(size_t count, size_t size)
111 void *tmp = mspace_calloc(model_snapshot_space, count, size);
116 /** @brief Snapshotting realloc, for use by model-checker (not user progs) */
117 void *snapshot_realloc(void *ptr, size_t size)
119 void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
124 /** @brief Snapshotting free, for use by model-checker (not user progs) */
125 void snapshot_free(void *ptr)
127 mspace_free(model_snapshot_space, ptr);
130 /** Non-snapshotting free for our use. */
131 void model_free(void *ptr)
133 #if USE_MPROTECT_SNAPSHOT
134 static void (*freep)(void *);
137 /* get address of libc free */
139 freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
140 if ((error = dlerror()) != NULL) {
141 fputs(error, stderr);
147 mspace_free(sStaticSpace, ptr);
151 /** Bootstrap allocation. Problem is that the dynamic linker calls require
152 * calloc to work and calloc requires the dynamic linker to work. */
154 #define BOOTSTRAPBYTES 131072
155 char bootstrapmemory[BOOTSTRAPBYTES];
158 void * HandleEarlyAllocationRequest(size_t sz)
160 /* Align to 8 byte boundary */
163 if (sz > (BOOTSTRAPBYTES-offset)) {
164 model_print("OUT OF BOOTSTRAP MEMORY. Increase the size of BOOTSTRAPBYTES in mymemory.cc\n");
168 void *pointer = (void *)&bootstrapmemory[offset];
173 /** @brief Global mspace reference for the model-checker's snapshotting heap */
174 mspace model_snapshot_space = NULL;
176 #if USE_MPROTECT_SNAPSHOT
178 /** @brief Global mspace reference for the user's snapshotting heap */
179 mspace user_snapshot_space = NULL;
181 /** Check whether this is bootstrapped memory that we should not free */
182 static bool DontFree(void *ptr)
184 return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
188 * @brief The allocator function for "user" allocation
190 * Should only be used for allocations which will not disturb the allocation
191 * patterns of a user thread.
193 static void * user_malloc(size_t size)
195 void *tmp = mspace_malloc(user_snapshot_space, size);
201 * @brief Snapshotting malloc implementation for user programs
203 * Do NOT call this function from a model-checker context. Doing so may disrupt
204 * the allocation patterns of a user thread.
206 void *malloc(size_t size)
208 if (user_snapshot_space) {
209 /* Only perform user allocations from user context */
210 ASSERT(!model || thread_current());
211 return user_malloc(size);
213 return HandleEarlyAllocationRequest(size);
216 /** @brief Snapshotting free implementation for user programs */
217 void free(void * ptr)
219 if (!DontFree(ptr)) {
220 mspace_free(user_snapshot_space, ptr);
224 /** @brief Snapshotting realloc implementation for user programs */
225 void *realloc(void *ptr, size_t size)
227 void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
232 /** @brief Snapshotting calloc implementation for user programs */
233 void * calloc(size_t num, size_t size)
235 if (user_snapshot_space) {
236 void *tmp = mspace_calloc(user_snapshot_space, num, size);
238 recordCalloc(tmp, num*size);
241 void *tmp = HandleEarlyAllocationRequest(size * num);
242 memset(tmp, 0, size * num);
243 recordCalloc(tmp, num*size);
248 /** @brief Snapshotting allocation function for use by the Thread class only */
249 void * Thread_malloc(size_t size)
251 return user_malloc(size);
254 /** @brief Snapshotting free function for use by the Thread class only */
255 void Thread_free(void *ptr)
260 /** @brief Snapshotting new operator for user programs */
261 void * operator new(size_t size) throw(std::bad_alloc)
266 /** @brief Snapshotting delete operator for user programs */
267 void operator delete(void *p) throw()
272 /** @brief Snapshotting new[] operator for user programs */
273 void * operator new[](size_t size) throw(std::bad_alloc)
278 /** @brief Snapshotting delete[] operator for user programs */
279 void operator delete[](void *p, size_t size)
284 #else /* !USE_MPROTECT_SNAPSHOT */
286 /** @brief Snapshotting allocation function for use by the Thread class only */
287 void * Thread_malloc(size_t size)
289 return snapshot_malloc(size);
292 /** @brief Snapshotting free function for use by the Thread class only */
293 void Thread_free(void *ptr)
298 #endif /* !USE_MPROTECT_SNAPSHOT */