11 #include "threads-model.h"
14 #define REQUESTS_BEFORE_ALLOC 1024
16 size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
19 #if !USE_MPROTECT_SNAPSHOT
20 static mspace sStaticSpace = NULL;
23 /** Non-snapshotting calloc for our use. */
24 void *model_calloc(size_t count, size_t size)
26 #if USE_MPROTECT_SNAPSHOT
27 static void *(*callocp)(size_t count, size_t size) = NULL;
31 /* get address of libc malloc */
33 callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
34 if ((error = dlerror()) != NULL) {
39 ptr = callocp(count, size);
43 sStaticSpace = create_shared_mspace();
44 return mspace_calloc(sStaticSpace, count, size);
48 /** Non-snapshotting malloc for our use. */
49 void *model_malloc(size_t size)
51 #if USE_MPROTECT_SNAPSHOT
52 static void *(*mallocp)(size_t size) = NULL;
56 /* get address of libc malloc */
58 mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc");
59 if ((error = dlerror()) != NULL) {
68 sStaticSpace = create_shared_mspace();
69 return mspace_malloc(sStaticSpace, size);
73 /** @brief Snapshotting malloc, for use by model-checker (not user progs) */
74 void * snapshot_malloc(size_t size)
76 void *tmp = mspace_malloc(model_snapshot_space, size);
81 /** @brief Snapshotting calloc, for use by model-checker (not user progs) */
82 void * snapshot_calloc(size_t count, size_t size)
84 void *tmp = mspace_calloc(model_snapshot_space, count, size);
89 /** @brief Snapshotting realloc, for use by model-checker (not user progs) */
90 void *snapshot_realloc(void *ptr, size_t size)
92 void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
97 /** @brief Snapshotting free, for use by model-checker (not user progs) */
98 void snapshot_free(void *ptr)
100 mspace_free(model_snapshot_space, ptr);
103 /** Non-snapshotting free for our use. */
104 void model_free(void *ptr)
106 #if USE_MPROTECT_SNAPSHOT
107 static void (*freep)(void *);
110 /* get address of libc free */
112 freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
113 if ((error = dlerror()) != NULL) {
114 fputs(error, stderr);
120 mspace_free(sStaticSpace, ptr);
124 /** Bootstrap allocation. Problem is that the dynamic linker calls require
125 * calloc to work and calloc requires the dynamic linker to work. */
127 #define BOOTSTRAPBYTES 4096
128 char bootstrapmemory[BOOTSTRAPBYTES];
131 void * HandleEarlyAllocationRequest(size_t sz)
133 /* Align to 8 byte boundary */
136 if (sz > (BOOTSTRAPBYTES-offset)) {
137 model_print("OUT OF BOOTSTRAP MEMORY\n");
141 void *pointer = (void *)&bootstrapmemory[offset];
146 /** @brief Global mspace reference for the model-checker's snapshotting heap */
147 mspace model_snapshot_space = NULL;
149 #if USE_MPROTECT_SNAPSHOT
151 /** @brief Global mspace reference for the user's snapshotting heap */
152 mspace user_snapshot_space = NULL;
154 /** Check whether this is bootstrapped memory that we should not free */
155 static bool DontFree(void *ptr)
157 return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
161 * @brief The allocator function for "user" allocation
163 * Should only be used for allocations which will not disturb the allocation
164 * patterns of a user thread.
166 static void * user_malloc(size_t size)
168 void *tmp = mspace_malloc(user_snapshot_space, size);
174 * @brief Snapshotting malloc implementation for user programs
176 * Do NOT call this function from a model-checker context. Doing so may disrupt
177 * the allocation patterns of a user thread.
179 void *malloc(size_t size)
181 if (user_snapshot_space) {
182 /* Only perform user allocations from user context */
183 ASSERT(!model || thread_current());
184 return user_malloc(size);
186 return HandleEarlyAllocationRequest(size);
189 /** @brief Snapshotting free implementation for user programs */
190 void free(void * ptr)
193 mspace_free(user_snapshot_space, ptr);
196 /** @brief Snapshotting realloc implementation for user programs */
197 void *realloc(void *ptr, size_t size)
199 void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
204 /** @brief Snapshotting calloc implementation for user programs */
205 void * calloc(size_t num, size_t size)
207 if (user_snapshot_space) {
208 void *tmp = mspace_calloc(user_snapshot_space, num, size);
212 void *tmp = HandleEarlyAllocationRequest(size * num);
213 memset(tmp, 0, size * num);
218 /** @brief Snapshotting allocation function for use by the Thread class only */
219 void * Thread_malloc(size_t size)
221 return user_malloc(size);
224 /** @brief Snapshotting free function for use by the Thread class only */
225 void Thread_free(void *ptr)
230 /** @brief Snapshotting new operator for user programs */
231 void * operator new(size_t size) throw(std::bad_alloc)
236 /** @brief Snapshotting delete operator for user programs */
237 void operator delete(void *p) throw()
242 /** @brief Snapshotting new[] operator for user programs */
243 void * operator new[](size_t size) throw(std::bad_alloc)
248 /** @brief Snapshotting delete[] operator for user programs */
249 void operator delete[](void *p, size_t size)
253 #endif /* USE_MPROTECT_SNAPSHOT */