slab.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. /* -*- mode:c; c-file-style:"k&r"; c-basic-offset: 4; tab-width:4; indent-tabs-mode:nil; mode:auto-fill; fill-column:78; -*- */
  2. /* vim: set ts=4 sw=4 et tw=78 fo=cqt wm=0: */
  3. /* Copyright (C) 2014 Stony Brook University
  4. This file is part of Graphene Library OS.
  5. Graphene Library OS is free software: you can redistribute it and/or
  6. modify it under the terms of the GNU Lesser General Public License
  7. as published by the Free Software Foundation, either version 3 of the
  8. License, or (at your option) any later version.
  9. Graphene Library OS is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU Lesser General Public License for more details.
  13. You should have received a copy of the GNU Lesser General Public License
  14. along with this program. If not, see <http://www.gnu.org/licenses/>. */
  15. /*
  16. * slab.c
  17. *
  18. * This file contains implementation of PAL's internal memory allocator.
  19. */
  20. #include "pal_internal.h"
  21. #include "api.h"
  22. #ifndef NO_INTERNAL_ALLOC
  23. #include "pal_defs.h"
  24. #include "pal_error.h"
  25. #include "pal_debug.h"
  26. static int slab_alignment;
  27. static PAL_LOCK slab_mgr_lock = LOCK_INIT;
  28. #define system_lock() _DkInternalLock(&slab_mgr_lock)
  29. #define system_unlock() _DkInternalUnlock(&slab_mgr_lock)
  30. #if STATIC_SLAB == 1
  31. # define POOL_SIZE 64 * 1024 * 1024 /* 64MB by default */
  32. static char mem_pool[POOL_SIZE];
  33. static char *bump = mem_pool;
  34. static char *mem_pool_end = &mem_pool[POOL_SIZE];
  35. #else
  36. # define PAGE_SIZE (slab_alignment)
  37. #endif
  38. #define STARTUP_SIZE 2
  39. static inline void * __malloc (int size)
  40. {
  41. void * addr = NULL;
  42. #if STATIC_SLAB == 1
  43. if (bump + size <= mem_pool_end) {
  44. addr = bump;
  45. bump += size;
  46. return addr;
  47. }
  48. #endif
  49. _DkVirtualMemoryAlloc(&addr, size, PAL_ALLOC_INTERNAL,
  50. PAL_PROT_READ|PAL_PROT_WRITE);
  51. return addr;
  52. }
  53. #define system_malloc(size) __malloc(size)
  54. static inline void __free (void * addr, int size)
  55. {
  56. #if STATIC_SLAB == 1
  57. if ((char *) addr >= (char *) mem_pool && (char *) addr + size <= (char *) mem_pool_end)
  58. return;
  59. #endif
  60. _DkVirtualMemoryFree(addr, size);
  61. }
  62. #define system_free(addr, size) __free(addr, size)
  63. #include "slabmgr.h"
  64. static SLAB_MGR slab_mgr = NULL;
  65. void init_slab_mgr (int alignment)
  66. {
  67. if (slab_mgr)
  68. return;
  69. #if PROFILING == 1
  70. unsigned long before_slab = _DkSystemTimeQuery();
  71. #endif
  72. slab_alignment = alignment;
  73. slab_mgr = create_slab_mgr();
  74. if (!slab_mgr)
  75. init_fail(PAL_ERROR_NOMEM, "cannot initialize slab manager");
  76. #if PROFILING == 1
  77. pal_state.slab_time += _DkSystemTimeQuery() - before_slab;
  78. #endif
  79. }
  80. void * malloc (size_t size)
  81. {
  82. #if PROFILING == 1
  83. unsigned long before_slab = _DkSystemTimeQuery();
  84. #endif
  85. void * ptr = slab_alloc(slab_mgr, size);
  86. #ifdef DEBUG
  87. /* In debug builds, try to break code that uses uninitialized heap
  88. * memory by explicitly initializing to a non-zero value. */
  89. if (ptr)
  90. memset(ptr, 0xa5, size);
  91. #endif
  92. #if PROFILING == 1
  93. pal_state.slab_time += _DkSystemTimeQuery() - before_slab;
  94. #endif
  95. return ptr;
  96. }
  97. /* This function is not realloc(). remalloc() allocates a new buffer
  98. * with with a provided size and copies the contents of the old buffer
  99. * to the new buffer. The old buffer is not freed. The old buffer must
  100. * be at least size bytes long. This function should probably be renamed
  101. * to something less likely to be confused with realloc. */
  102. void * remalloc (const void * mem, size_t size)
  103. {
  104. void * nmem = malloc(size);
  105. if (nmem)
  106. memcpy(nmem, mem, size);
  107. return nmem;
  108. }
  109. char * strdup (const char *s)
  110. {
  111. size_t len = strlen(s) + 1;
  112. char *new = malloc(len);
  113. if (new)
  114. memcpy(new, s, len);
  115. return new;
  116. }
  117. void * calloc (size_t nmem, size_t size)
  118. {
  119. void * ptr = malloc(nmem * size);
  120. if (ptr)
  121. memset(ptr, 0, nmem * size);
  122. return ptr;
  123. }
  124. void free (void * ptr)
  125. {
  126. #if PROFILING == 1
  127. unsigned long before_slab = _DkSystemTimeQuery();
  128. #endif
  129. slab_free(slab_mgr, ptr);
  130. #if PROFILING == 1
  131. pal_state.slab_time += _DkSystemTimeQuery() - before_slab;
  132. #endif
  133. }
  134. #endif /* !NO_INTERNAL_ALLOC */