]> git.cworth.org Git - vogl/blob - src/voglcore/vogl_mem.cpp
Drop vogl_applaunchr.cpp and vogl_applauncher.h
[vogl] / src / voglcore / vogl_mem.cpp
1 /**************************************************************************
2  *
3  * Copyright 2013-2014 RAD Game Tools and Valve Software
4  * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
5  * All Rights Reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23  * THE SOFTWARE.
24  *
25  **************************************************************************/
26
27 // File: vogl_mem.cpp
28 #include "vogl_core.h"
29 #include "vogl_console.h"
30 #include "vogl.h"
31 #include "vogl_threading.h"
32 #include "vogl_strutils.h"
33 #include <malloc.h>
34
35 // Set to 1 to enable stb_malloc, otherwise voglcore uses plain malloc/free/realloc
36 #ifndef VOGL_USE_STB_MALLOC
37 #define VOGL_USE_STB_MALLOC 1
38 #endif
39
40 #ifndef VOGL_RAND_FILL_ALLLOCATED_MEMORY
41 #define VOGL_RAND_FILL_ALLLOCATED_MEMORY 0
42 #endif
43
44 #ifndef VOGL_SCRUB_FREED_MEMORY
45 #define VOGL_SCRUB_FREED_MEMORY 0
46 #endif
47
48 #if VOGL_RAND_FILL_ALLLOCATED_MEMORY || VOGL_SCRUB_FREED_MEMORY
49 #warning VOGL_RAND_FILL_ALLLOCATED_MEMORY and/or VOGL_SCRUB_FREED_MEMORY is enabled
50 #endif
51
52 #ifdef VOGL_USE_WIN32_API
53 #include "vogl_winhdr.h"
54 #endif
55
56 #if defined(__GNUC__)
57 #include "mcheck.h"
58 #endif
59
60 #if VOGL_USE_STB_MALLOC
61 #include "vogl_stb_heap.h"
62 #endif
63
64 #if VOGL_MALLOC_DEBUGGING
65 #define MALLOC_DEBUG
66 #include "rmalloc.h"
67 #endif
68
69 #undef vogl_malloc
70 #undef vogl_realloc
71 #undef vogl_calloc
72 #undef vogl_free
73 #undef vogl_check_heap
74 #undef vogl_print_heap_stats
75 #undef vogl_new
76 #undef vogl_new_array
77 #undef vogl_delete
78 #undef vogl_delete_array
79
80 #if VOGL_MALLOC_DEBUGGING
81 #warning vogl_mem.cpp: Malloc debugging enabled
82 #endif
83
84 #if VOGL_USE_STB_MALLOC
85
86 #define STB_ALLOC_INITIAL_HEAP_SIZE 32U * 1024U * 1024U
87 // Purposely written C-style so we can safely do heap allocs BEFORE C++ global construction time.
88
89 static uint64_t g_initial_heap_storage[(STBM_HEAP_SIZEOF + STB_ALLOC_INITIAL_HEAP_SIZE + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
90 static stbm_heap *g_pHeap;
91 static pthread_mutex_t g_mutex;
92 static size_t g_page_size;
93
94 // This flag helps us detect calls to malloc, etc. from within asynchronous signal handlers.
95 static bool g_allocating_flag;
96
97 static void *sys_alloc(void *user_context, size_t size_requested, size_t *size_provided)
98 {
99     VOGL_NOTE_UNUSED(user_context);
100
101     if (!g_page_size)
102     {
103         g_page_size = sysconf(_SC_PAGE_SIZE);
104         if (!g_page_size)
105             g_page_size = 65536;
106     }
107
108     size_requested = (size_requested + g_page_size - 1) & (~(g_page_size - 1));
109
110     void *p = mmap(NULL, size_requested, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
111
112     if ((!p) || (p == MAP_FAILED))
113     {
114         uint e = errno;
115
116         // Not using strerror_r because it fails when we're completely out of memory.
117         char *pError_desc = strerror(e);
118
119         char buf[256];
120         sprintf(buf, "%s: mmap() of %zu bytes failed! Reason: %s (errno 0x%x)\n", VOGL_FUNCTION_NAME, size_requested, pError_desc, e);
121
122         write(STDERR_FILENO, buf, strlen(buf));
123         abort();
124     }
125
126     *size_provided = size_requested;
127
128     return p;
129 }
130
131 static void sys_free(void *user_context, void *ptr, size_t size)
132 {
133     VOGL_NOTE_UNUSED(user_context);
134
135     int res = munmap(ptr, size);
136     if (res != 0)
137     {
138         uint e = errno;
139
140         // Not using strerror_r because it fails when we're completely out of memory.
141         char *pError_desc = strerror(e);
142
143         char buf[256];
144         sprintf(buf, "%s: munmap() ptr 0x%" PRIxPTR " size 0x%" PRIxPTR " failed! Reason: %s (errno 0x%x)\n", VOGL_FUNCTION_NAME, (uintptr_t)ptr, size, pError_desc, e);
145
146         write(STDERR_FILENO, buf, strlen(buf));
147         abort();
148     }
149 }
150
151 #if VOGL_MALLOC_DEBUGGING
152 static void *rmalloc_malloc_callback(size_t size, void *pUser)
153 {
154     VOGL_NOTE_UNUSED(pUser);
155     return stbm_alloc(NULL, g_pHeap, size, 0);
156 }
157
158 static void rmalloc_free_callback(void *ptr, void *pUser)
159 {
160     VOGL_NOTE_UNUSED(pUser);
161     stbm_free(NULL, g_pHeap, ptr);
162 }
163
164 static void *rmalloc_realloc_callback(void *ptr, size_t size, void *pUser)
165 {
166     VOGL_NOTE_UNUSED(pUser);
167     return stbm_realloc(NULL, g_pHeap, ptr, size, 0);
168 }
169 #endif
170
171 static void init_heap()
172 {
173     if (g_pHeap)
174         return;
175
176     pthread_mutex_init(&g_mutex, NULL);
177
178     stbm_heap_config config;
179     memset(&config, 0, sizeof(config));
180     config.system_alloc = sys_alloc;
181     config.system_free = sys_free;
182
183     g_pHeap = stbm_heap_init(g_initial_heap_storage, sizeof(g_initial_heap_storage), &config);
184
185 #if VOGL_MALLOC_DEBUGGING
186     Rmalloc_set_callbacks(rmalloc_malloc_callback, rmalloc_free_callback, rmalloc_realloc_callback, NULL);
187 #endif
188 }
189
190 static void lock_heap()
191 {
192     VOGL_ASSERT(g_pHeap);
193
194     pthread_mutex_lock(&g_mutex);
195
196     VOGL_ASSERT(!g_allocating_flag);
197     g_allocating_flag = true;
198 }
199
200 static void unlock_heap()
201 {
202     g_allocating_flag = false;
203
204     VOGL_ASSERT(g_pHeap);
205     pthread_mutex_unlock(&g_mutex);
206 }
207
208 static void *malloc_block(size_t size, const char *pFile_line)
209 {
210     VOGL_ASSERT(g_pHeap);
211
212     lock_heap();
213
214 #if VOGL_MALLOC_DEBUGGING
215     void *p = Rmalloc(size, pFile_line);
216 #else
217     VOGL_NOTE_UNUSED(pFile_line);
218     void *p = stbm_alloc(NULL, g_pHeap, size, 0);
219 #endif
220
221     unlock_heap();
222
223     return p;
224 }
225
226 static void *realloc_block(void *p, size_t size, const char *pFile_line)
227 {
228     VOGL_ASSERT(g_pHeap);
229
230     lock_heap();
231
232 #if VOGL_MALLOC_DEBUGGING
233     void *q = Rrealloc(p, size, pFile_line);
234 #else
235     VOGL_NOTE_UNUSED(pFile_line);
236     void *q = stbm_realloc(NULL, g_pHeap, p, size, 0);
237 #endif
238
239     unlock_heap();
240
241     return q;
242 }
243
244 static void free_block(void *p, const char *pFile_line)
245 {
246     VOGL_ASSERT(g_pHeap);
247
248     lock_heap();
249
250 #if VOGL_MALLOC_DEBUGGING
251     Rfree(p, pFile_line);
252 #else
253     VOGL_NOTE_UNUSED(pFile_line);
254     stbm_free(NULL, g_pHeap, p);
255 #endif
256
257     unlock_heap();
258 }
259
260 static size_t msize_block(void *p, const char *pFile_line)
261 {
262     VOGL_ASSERT(g_pHeap);
263
264     lock_heap();
265
266 #if VOGL_MALLOC_DEBUGGING
267     size_t n = Rmalloc_usable_size(p, pFile_line);
268 #else
269     VOGL_NOTE_UNUSED(pFile_line);
270     size_t n = stbm_get_allocation_size(p);
271 #endif
272
273     unlock_heap();
274
275     return n;
276 }
277
278 static void print_stats(const char *pFile_line)
279 {
280     VOGL_ASSERT(g_pHeap);
281
282 #if VOGL_MALLOC_DEBUGGING
283     lock_heap();
284
285     Rmalloc_stat(pFile_line);
286
287     unlock_heap();
288 #else
289     VOGL_NOTE_UNUSED(pFile_line);
290 #endif
291 }
292
293 static void check(const char *pFile_line)
294 {
295     VOGL_ASSERT(g_pHeap);
296
297 #if VOGL_MALLOC_DEBUGGING
298     lock_heap();
299
300     Rmalloc_test(pFile_line);
301
302     unlock_heap();
303 #else
304     VOGL_NOTE_UNUSED(pFile_line);
305 #endif
306 }
307
308 #else // !VOGL_USE_STB_MALLOC
309
310 static bool g_heap_initialized;
311 static pthread_mutex_t g_mutex;
312
313 static void init_heap()
314 {
315     if (g_heap_initialized)
316         return;
317
318     pthread_mutex_init(&g_mutex, NULL);
319     g_heap_initialized = true;
320 }
321
322 #if VOGL_USE_STB_MALLOC
323 static void lock_heap()
324 {
325     VOGL_ASSERT(g_heap_initialized);
326     pthread_mutex_lock(&g_mutex);
327 }
328
329 static void unlock_heap()
330 {
331     VOGL_ASSERT(g_heap_initialized);
332     pthread_mutex_unlock(&g_mutex);
333 }
334 #endif
335
336 static void *malloc_block(size_t size, const char *pFile_line)
337 {
338     VOGL_ASSERT(g_heap_initialized);
339     VOGL_NOTE_UNUSED(pFile_line);
340
341 #if VOGL_MALLOC_DEBUGGING
342     lock_heap();
343     void *p = Rmalloc(size, pFile_line);
344     unlock_heap();
345 #else
346     void *p = malloc(size);
347 #endif
348
349     return p;
350 }
351
352 static void *realloc_block(void *p, size_t size, const char *pFile_line)
353 {
354     VOGL_ASSERT(g_heap_initialized);
355     VOGL_NOTE_UNUSED(pFile_line);
356
357 #if VOGL_MALLOC_DEBUGGING
358     lock_heap();
359     void *q = Rrealloc(p, size, pFile_line);
360     unlock_heap();
361 #else
362     void *q = realloc(p, size);
363 #endif
364
365     return q;
366 }
367
368 static void free_block(void *p, const char *pFile_line)
369 {
370     VOGL_ASSERT(g_heap_initialized);
371     VOGL_NOTE_UNUSED(pFile_line);
372
373 #if VOGL_MALLOC_DEBUGGING
374     lock_heap();
375     Rfree(p, pFile_line);
376     unlock_heap();
377 #else
378     free(p);
379 #endif
380 }
381
382 static size_t msize_block(void *p, const char *pFile_line)
383 {
384     VOGL_ASSERT(g_heap_initialized);
385     VOGL_NOTE_UNUSED(pFile_line);
386
387 #if VOGL_MALLOC_DEBUGGING
388     lock_heap();
389     size_t n = Rmalloc_usable_size(p, pFile_line);
390     unlock_heap();
391 #else
392     size_t n = malloc_usable_size(p);
393 #endif
394
395     return n;
396 }
397
398 static void print_stats(const char *pFile_line)
399 {
400     VOGL_ASSERT(g_heap_initialized);
401     VOGL_NOTE_UNUSED(pFile_line);
402
403 #if VOGL_MALLOC_DEBUGGING
404     lock_heap();
405     Rmalloc_stat(pFile_line);
406     unlock_heap();
407 #endif
408 }
409
410 static void check(const char *pFile_line)
411 {
412     VOGL_ASSERT(g_heap_initialized);
413     VOGL_NOTE_UNUSED(pFile_line);
414
415 #if VOGL_MALLOC_DEBUGGING
416     lock_heap();
417     Rmalloc_test(pFile_line);
418     unlock_heap();
419 #endif
420 }
421
422 #endif // #ifdef VOGL_USE_STB_MALLOC
423
424 class global_heap_constructor
425 {
426 public:
427     global_heap_constructor()
428     {
429         //printf("global_heap_constructor\n");
430
431         init_heap();
432     }
433 };
434
435 global_heap_constructor g_global_heap_constructor __attribute__((init_priority(102)));
436
437 VOGL_NAMESPACE_BEGIN(vogl)
438
439 void vogl_init_heap()
440 {
441     init_heap();
442 }
443
444 // TODO: vararg this
445 void vogl_mem_error(const char *pMsg, const char *pFile_line)
446 {
447     char buf[512];
448     vogl::vogl_sprintf_s(buf, sizeof(buf), "%s: Fatal error: %s. Originally called from %s.\n", VOGL_FUNCTION_NAME, pMsg, pFile_line ? pFile_line : "?");
449     vogl_fail(buf, __FILE__, __LINE__);
450     abort();
451 }
452
453 #if VOGL_RAND_FILL_ALLLOCATED_MEMORY || VOGL_SCRUB_FREED_MEMORY
454 static uint32 g_cur_rand = 0xDEADBEEF;
455
456 static void random_fill(void *p, size_t size)
457 {
458 #define JSR (jsr ^= (jsr << 17), jsr ^= (jsr >> 13), jsr ^= (jsr << 5));
459     uint32 jsr = g_cur_rand;
460
461     while (size >= sizeof(uint32) * 4)
462     {
463         static_cast<uint32 *>(p)[0] = jsr;
464         JSR;
465         static_cast<uint32 *>(p)[1] = jsr;
466         JSR;
467         static_cast<uint32 *>(p)[2] = jsr;
468         JSR;
469         static_cast<uint32 *>(p)[3] = jsr;
470         JSR;
471
472         size -= sizeof(uint32) * 4;
473         p = static_cast<uint32 *>(p) + 4;
474     }
475
476     while (size >= sizeof(uint32))
477     {
478         static_cast<uint32 *>(p)[0] = jsr;
479         JSR;
480
481         size -= sizeof(uint32);
482         p = static_cast<uint32 *>(p);
483     }
484
485     while (size)
486     {
487         static_cast<uint8 *>(p)[0] = static_cast<uint8>(jsr);
488         JSR;
489
490         size--;
491         p = static_cast<uint8 *>(p) + 1;
492     }
493
494     g_cur_rand = jsr;
495 #undef JSR
496 }
497 #endif // VOGL_RAND_FILL_ALLLOCATED_MEMORY || VOGL_SCRUB_FREED_MEMORY
498
499 void *vogl_tracked_malloc(const char *pFile_line, size_t size, size_t *pActual_size)
500 {
501     size = (size + sizeof(uint32) - 1U) & ~(sizeof(uint32) - 1U);
502     if (!size)
503         size = sizeof(uint32);
504
505     if (size > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE)
506     {
507         vogl_mem_error("vogl_malloc: size too big", pFile_line);
508         return NULL;
509     }
510
511     uint8 *p_new = (uint8 *)malloc_block(size, pFile_line);
512
513     VOGL_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (VOGL_MIN_ALLOC_ALIGNMENT - 1)) == 0);
514
515     if (!p_new)
516     {
517         vogl_mem_error("vogl_malloc: out of memory", pFile_line);
518         return NULL;
519     }
520
521     if (pActual_size)
522     {
523         *pActual_size = msize_block(p_new, pFile_line);
524
525         if ((size) && (*pActual_size >= static_cast<uint64_t>(size) * 16U))
526         {
527             // I've seen this happen with glibc's absolutely terrible debug heap crap, best to let the caller know that shit is going to die
528             fprintf(stderr, "%s: malloc_usable_size may be misbehaving! Requested %zu bytes, but the usable size is reported as %zu bytes.\n", __FUNCTION__, size, *pActual_size);
529         }
530     }
531
532 #if VOGL_RAND_FILL_ALLLOCATED_MEMORY
533     random_fill(p_new, size);
534 #endif
535
536     return p_new;
537 }
538
539 void *vogl_tracked_realloc(const char *pFile_line, void *p, size_t size, size_t *pActual_size)
540 {
541     if ((ptr_bits_t)p & (VOGL_MIN_ALLOC_ALIGNMENT - 1))
542     {
543         vogl_mem_error("vogl_realloc: bad ptr", pFile_line);
544         return NULL;
545     }
546
547     if (size > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE)
548     {
549         vogl_mem_error("vogl_realloc: size too big!", pFile_line);
550         return NULL;
551     }
552
553     if ((size) && (size < sizeof(uint32)))
554         size = sizeof(uint32);
555
556 #if VOGL_RAND_FILL_ALLLOCATED_MEMORY || VOGL_SCRUB_FREED_MEMORY
557     size_t orig_size = p ? msize_block(p, pFile_line) : 0;
558
559 #if VOGL_SCRUB_FREED_MEMORY
560     if ((orig_size) && (!size))
561         random_fill(p, orig_size);
562 #endif
563 #endif
564
565     void *p_new = realloc_block(p, size, pFile_line);
566
567     VOGL_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (VOGL_MIN_ALLOC_ALIGNMENT - 1)) == 0);
568
569     if (pActual_size)
570     {
571         *pActual_size = 0;
572
573         if (size)
574         {
575             if (p_new)
576                 *pActual_size = msize_block(p_new, pFile_line);
577             else if (p)
578                 *pActual_size = msize_block(p, pFile_line);
579
580             if (*pActual_size >= static_cast<uint64_t>(size) * 16U)
581             {
582                 // I've seen this happen with glibc's absolutely terrible debug heap crap, best to let the caller know that shit is going to die
583                 fprintf(stderr, "%s: malloc_usable_size may be misbehaving! Requested %zu bytes, but the usable size is reported as %zu bytes.\n", __FUNCTION__, size, *pActual_size);
584             }
585         }
586     }
587
588 #if VOGL_RAND_FILL_ALLLOCATED_MEMORY
589     if ((size) && (p_new))
590     {
591         size_t new_size = msize_block(p_new, pFile_line);
592
593         if (new_size > orig_size)
594             random_fill(static_cast<uint8 *>(p_new) + orig_size, new_size - orig_size);
595     }
596 #endif
597
598     return p_new;
599 }
600
601 void *vogl_tracked_calloc(const char *pFile_line, size_t count, size_t size, size_t *pActual_size)
602 {
603     size_t total = count * size;
604     void *p = vogl_tracked_malloc(pFile_line, total, pActual_size);
605     if (p)
606         memset(p, 0, total);
607     return p;
608 }
609
610 void vogl_tracked_free(const char *pFile_line, void *p)
611 {
612     if (!p)
613         return;
614
615     if (reinterpret_cast<ptr_bits_t>(p) & (VOGL_MIN_ALLOC_ALIGNMENT - 1))
616     {
617         vogl_mem_error("vogl_free: bad ptr", pFile_line);
618         return;
619     }
620
621 #if VOGL_SCRUB_FREED_MEMORY
622     random_fill(p, msize_block(p, pFile_line));
623 #endif
624
625     free_block(p, pFile_line);
626 }
627
628 size_t vogl_msize(void *p)
629 {
630     if (!p)
631         return 0;
632
633     if (reinterpret_cast<ptr_bits_t>(p) & (VOGL_MIN_ALLOC_ALIGNMENT - 1))
634     {
635         vogl_mem_error("vogl_msize: bad ptr", VOGL_FILE_POS_STRING);
636         return 0;
637     }
638
639     return msize_block(p, VOGL_FILE_POS_STRING);
640 }
641
642 void vogl_tracked_print_stats(const char *pFile_line)
643 {
644     print_stats(pFile_line);
645 }
646
647 void vogl_tracked_check_heap(const char *pFile_line)
648 {
649     check(pFile_line);
650
651 #ifdef WIN32
652     // Also see_CrtSetDbgFlag ()
653     int status = _CrtCheckMemory();
654     VOGL_VERIFY(status == TRUE);
655 #elif defined(__GNUC__)
656     // App MUST have been linked with -mlcheck! Unfortunately -mlcheck() causes the CRT's heap API's to be unusable on some dev boxes, no idea why.
657     mcheck_check_all();
658 #else
659     fprintf(stderr, "%s: Need implementation\n", __FUNCTION__);
660 #endif
661 }
662
663 VOGL_NAMESPACE_END(vogl)
664
665 extern "C" void *vogl_realloc(const char *pFile_line, void *p, size_t new_size)
666 {
667     return vogl::vogl_tracked_realloc(pFile_line, p, new_size, NULL);
668 }