12 #include "threads-model.h"
15 #define REQUESTS_BEFORE_ALLOC 1024
17 size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
20 #if !USE_MPROTECT_SNAPSHOT
21 static mspace sStaticSpace = NULL;
24 /** Non-snapshotting calloc for our use. */
25 void *model_calloc(size_t count, size_t size)
27 #if USE_MPROTECT_SNAPSHOT
28 static void *(*callocp)(size_t count, size_t size) = NULL;
32 /* get address of libc malloc */
34 callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
35 if ((error = dlerror()) != NULL) {
40 ptr = callocp(count, size);
44 sStaticSpace = create_shared_mspace();
45 return mspace_calloc(sStaticSpace, count, size);
49 /** Non-snapshotting malloc for our use. */
50 void *model_malloc(size_t size)
52 #if USE_MPROTECT_SNAPSHOT
53 static void *(*mallocp)(size_t size) = NULL;
57 /* get address of libc malloc */
59 mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc");
60 if ((error = dlerror()) != NULL) {
69 sStaticSpace = create_shared_mspace();
70 return mspace_malloc(sStaticSpace, size);
74 /** Non-snapshotting malloc for our use. */
75 void *model_realloc(void *ptr, size_t size)
77 #if USE_MPROTECT_SNAPSHOT
78 static void *(*reallocp)(void *ptr, size_t size) = NULL;
82 /* get address of libc malloc */
84 reallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "realloc");
85 if ((error = dlerror()) != NULL) {
90 newptr = reallocp(ptr, size);
94 sStaticSpace = create_shared_mspace();
95 return mspace_realloc(sStaticSpace, ptr, size);
99 /** @brief Snapshotting malloc, for use by model-checker (not user progs) */
100 void * snapshot_malloc(size_t size)
102 void *tmp = mspace_malloc(model_snapshot_space, size);
107 /** @brief Snapshotting calloc, for use by model-checker (not user progs) */
108 void * snapshot_calloc(size_t count, size_t size)
110 void *tmp = mspace_calloc(model_snapshot_space, count, size);
115 /** @brief Snapshotting realloc, for use by model-checker (not user progs) */
116 void *snapshot_realloc(void *ptr, size_t size)
118 void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
123 /** @brief Snapshotting free, for use by model-checker (not user progs) */
124 void snapshot_free(void *ptr)
126 mspace_free(model_snapshot_space, ptr);
129 /** Non-snapshotting free for our use. */
130 void model_free(void *ptr)
132 #if USE_MPROTECT_SNAPSHOT
133 static void (*freep)(void *);
136 /* get address of libc free */
138 freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
139 if ((error = dlerror()) != NULL) {
140 fputs(error, stderr);
146 mspace_free(sStaticSpace, ptr);
150 /** Bootstrap allocation. Problem is that the dynamic linker calls require
151 * calloc to work and calloc requires the dynamic linker to work. */
153 #define BOOTSTRAPBYTES 131072
154 char bootstrapmemory[BOOTSTRAPBYTES];
157 void * HandleEarlyAllocationRequest(size_t sz)
159 /* Align to 8 byte boundary */
162 if (sz > (BOOTSTRAPBYTES-offset)) {
163 model_print("OUT OF BOOTSTRAP MEMORY. Increase the size of BOOTSTRAPBYTES in mymemory.cc\n");
167 void *pointer = (void *)&bootstrapmemory[offset];
172 /** @brief Global mspace reference for the model-checker's snapshotting heap */
173 mspace model_snapshot_space = NULL;
175 #if USE_MPROTECT_SNAPSHOT
177 /** @brief Global mspace reference for the user's snapshotting heap */
178 mspace user_snapshot_space = NULL;
180 /** Check whether this is bootstrapped memory that we should not free */
181 static bool DontFree(void *ptr)
183 return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
187 * @brief The allocator function for "user" allocation
189 * Should only be used for allocations which will not disturb the allocation
190 * patterns of a user thread.
192 static void * user_malloc(size_t size)
194 void *tmp = mspace_malloc(user_snapshot_space, size);
200 * @brief Snapshotting malloc implementation for user programs
202 * Do NOT call this function from a model-checker context. Doing so may disrupt
203 * the allocation patterns of a user thread.
205 void *malloc(size_t size)
207 if (user_snapshot_space) {
208 /* Only perform user allocations from user context */
209 ASSERT(!model || thread_current());
210 return user_malloc(size);
212 return HandleEarlyAllocationRequest(size);
215 /** @brief Snapshotting free implementation for user programs */
216 void free(void * ptr)
218 if (!DontFree(ptr)) {
219 mspace_free(user_snapshot_space, ptr);
223 /** @brief Snapshotting realloc implementation for user programs */
224 void *realloc(void *ptr, size_t size)
226 void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
231 /** @brief Snapshotting calloc implementation for user programs */
232 void * calloc(size_t num, size_t size)
234 if (user_snapshot_space) {
235 void *tmp = mspace_calloc(user_snapshot_space, num, size);
239 void *tmp = HandleEarlyAllocationRequest(size * num);
240 memset(tmp, 0, size * num);
245 /** @brief Snapshotting allocation function for use by the Thread class only */
246 void * Thread_malloc(size_t size)
248 return user_malloc(size);
251 /** @brief Snapshotting free function for use by the Thread class only */
252 void Thread_free(void *ptr)
257 /** @brief Snapshotting new operator for user programs */
258 void * operator new(size_t size) throw(std::bad_alloc)
263 /** @brief Snapshotting delete operator for user programs */
264 void operator delete(void *p) throw()
269 /** @brief Snapshotting new[] operator for user programs */
270 void * operator new[](size_t size) throw(std::bad_alloc)
275 /** @brief Snapshotting delete[] operator for user programs */
276 void operator delete[](void *p, size_t size)
281 #else /* !USE_MPROTECT_SNAPSHOT */
283 /** @brief Snapshotting allocation function for use by the Thread class only */
284 void * Thread_malloc(size_t size)
286 return snapshot_malloc(size);
289 /** @brief Snapshotting free function for use by the Thread class only */
290 void Thread_free(void *ptr)
295 #endif /* !USE_MPROTECT_SNAPSHOT */