12 #define REQUESTS_BEFORE_ALLOC 1024
14 size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
17 #if !USE_MPROTECT_SNAPSHOT
18 static mspace sStaticSpace = NULL;
21 /** Non-snapshotting calloc for our use. */
22 void *model_calloc(size_t count, size_t size)
24 #if USE_MPROTECT_SNAPSHOT
25 static void *(*callocp)(size_t count, size_t size) = NULL;
29 /* get address of libc malloc */
31 callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
32 if ((error = dlerror()) != NULL) {
37 ptr = callocp(count, size);
41 sStaticSpace = create_shared_mspace();
42 return mspace_calloc(sStaticSpace, count, size);
46 /** Non-snapshotting malloc for our use. */
47 void *model_malloc(size_t size)
49 #if USE_MPROTECT_SNAPSHOT
50 static void *(*mallocp)(size_t size) = NULL;
54 /* get address of libc malloc */
56 mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc");
57 if ((error = dlerror()) != NULL) {
66 sStaticSpace = create_shared_mspace();
67 return mspace_malloc(sStaticSpace, size);
71 /** @brief Snapshotting malloc, for use by model-checker (not user progs) */
72 void * snapshot_malloc(size_t size)
74 void *tmp = mspace_malloc(model_snapshot_space, size);
79 /** @brief Snapshotting calloc, for use by model-checker (not user progs) */
80 void * snapshot_calloc(size_t count, size_t size)
82 void *tmp = mspace_calloc(model_snapshot_space, count, size);
87 /** @brief Snapshotting realloc, for use by model-checker (not user progs) */
88 void *snapshot_realloc(void *ptr, size_t size)
90 void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
95 /** @brief Snapshotting free, for use by model-checker (not user progs) */
96 void snapshot_free(void *ptr)
98 mspace_free(model_snapshot_space, ptr);
101 /** Non-snapshotting free for our use. */
102 void model_free(void *ptr)
104 #if USE_MPROTECT_SNAPSHOT
105 static void (*freep)(void *);
108 /* get address of libc free */
110 freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
111 if ((error = dlerror()) != NULL) {
112 fputs(error, stderr);
118 mspace_free(sStaticSpace, ptr);
122 /** Bootstrap allocation. Problem is that the dynamic linker calls require
123 * calloc to work and calloc requires the dynamic linker to work. */
125 #define BOOTSTRAPBYTES 4096
126 char bootstrapmemory[BOOTSTRAPBYTES];
129 void * HandleEarlyAllocationRequest(size_t sz)
131 /* Align to 8 byte boundary */
134 if (sz > (BOOTSTRAPBYTES-offset)) {
135 model_print("OUT OF BOOTSTRAP MEMORY\n");
139 void *pointer = (void *)&bootstrapmemory[offset];
144 /** @brief Global mspace reference for the model-checker's snapshotting heap */
145 mspace model_snapshot_space = NULL;
147 #if USE_MPROTECT_SNAPSHOT
149 /** @brief Global mspace reference for the user's snapshotting heap */
150 mspace user_snapshot_space = NULL;
152 /** Check whether this is bootstrapped memory that we should not free */
153 static bool DontFree(void *ptr)
155 return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
159 * @brief The allocator function for "user" allocation
161 * Should only be used for allocations which will not disturb the allocation
162 * patterns of a user thread.
164 static void * user_malloc(size_t size)
166 void *tmp = mspace_malloc(user_snapshot_space, size);
172 * @brief Snapshotting malloc implementation for user programs
174 * Do NOT call this function from a model-checker context. Doing so may disrupt
175 * the allocation patterns of a user thread.
177 void *malloc(size_t size)
179 if (user_snapshot_space)
180 return user_malloc(size);
182 return HandleEarlyAllocationRequest(size);
185 /** @brief Snapshotting free implementation for user programs */
186 void free(void * ptr)
189 mspace_free(user_snapshot_space, ptr);
192 /** @brief Snapshotting realloc implementation for user programs */
193 void *realloc(void *ptr, size_t size)
195 void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
200 /** @brief Snapshotting calloc implementation for user programs */
201 void * calloc(size_t num, size_t size)
203 if (user_snapshot_space) {
204 void *tmp = mspace_calloc(user_snapshot_space, num, size);
208 void *tmp = HandleEarlyAllocationRequest(size * num);
209 memset(tmp, 0, size * num);
214 /** @brief Snapshotting allocation function for use by the Thread class only */
215 void * Thread_malloc(size_t size)
217 return user_malloc(size);
220 /** @brief Snapshotting free function for use by the Thread class only */
221 void Thread_free(void *ptr)
226 /** @brief Snapshotting new operator for user programs */
227 void * operator new(size_t size) throw(std::bad_alloc)
232 /** @brief Snapshotting delete operator for user programs */
233 void operator delete(void *p) throw()
238 /** @brief Snapshotting new[] operator for user programs */
239 void * operator new[](size_t size) throw(std::bad_alloc)
244 /** @brief Snapshotting delete[] operator for user programs */
245 void operator delete[](void *p, size_t size)
249 #endif /* USE_MPROTECT_SNAPSHOT */