mem0mem.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:10k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. The memory management
  3. (c) 1994, 1995 Innobase Oy
  4. Created 6/9/1994 Heikki Tuuri
  5. *************************************************************************/
  6. #include "mem0mem.h"
  7. #ifdef UNIV_NONINL
  8. #include "mem0mem.ic"
  9. #endif
  10. #include "mach0data.h"
  11. #include "buf0buf.h"
  12. #include "btr0sea.h"
  13. #include "srv0srv.h"
  14. #include "mem0dbg.c"
  15. /*
  16. THE MEMORY MANAGEMENT
  17. =====================
  18. The basic element of the memory management is called a memory
  19. heap. A memory heap is conceptually a
  20. stack from which memory can be allocated. The stack may grow infinitely.
  21. The top element of the stack may be freed, or
  22. the whole stack can be freed at one time. The advantage of the
  23. memory heap concept is that we can avoid using the malloc and free
  24. functions of C which are quite expensive, for example, on the Solaris + GCC
  25. system (50 MHz Sparc, 1993) the pair takes 3 microseconds,
  26. on Win NT + 100MHz Pentium, 2.5 microseconds.
  27. When we use a memory heap,
  28. we can allocate larger blocks of memory at a time and thus
  29. reduce overhead. Slightly more efficient the method is when we
  30. allocate the memory from the index page buffer pool, as we can
  31. claim a new page fast. This is called buffer allocation. 
  32. When we allocate the memory from the dynamic memory of the
  33. C environment, that is called dynamic allocation.
  34. The default way of operation of the memory heap is the following.
  35. First, when the heap is created, an initial block of memory is
  36. allocated. In dynamic allocation this may be about 50 bytes.
  37. If more space is needed, additional blocks are allocated
  38. and they are put into a linked list.
  39. After the initial block, each allocated block is twice the size of the 
  40. previous, until a threshold is attained, after which the sizes
  41. of the blocks stay the same. An exception is, of course, the case
  42. where the caller requests a memory buffer whose size is
  43. bigger than the threshold. In that case a block big enough must
  44. be allocated.
  45.  
  46. The heap is physically arranged so that if the current block
  47. becomes full, a new block is allocated and always inserted in the
  48. chain of blocks as the last block.
  49. In the debug version of the memory management, all the allocated
  50. heaps are kept in a list (which is implemented as a hash table).
  51. Thus we can notice if the caller tries to free an already freed
  52. heap. In addition, each buffer given to the caller contains
  53. start field at the start and a trailer field at the end of the buffer.
  54. The start field has the following content:
  55. A. sizeof(ulint) bytes of field length (in the standard byte order)
  56. B. sizeof(ulint) bytes of check field (a random number)
  57. The trailer field contains:
  58. A. sizeof(ulint) bytes of check field (the same random number as at the start)
  59. Thus we can notice if something has been copied over the
  60. borders of the buffer, which is illegal.
  61. The memory in the buffers is initialized to a random byte sequence.
  62. After freeing, all the blocks in the heap are set to random bytes
  63. to help us discover errors which result from the use of
  64. buffers in an already freed heap. */
  65. #ifdef MEM_PERIODIC_CHECK
  66. ibool mem_block_list_inited;
  67. /* List of all mem blocks allocated; protected by the mem_comm_pool mutex */
  68. UT_LIST_BASE_NODE_T(mem_block_t) mem_block_list;
  69. #endif
  70. /*******************************************************************
  71. NOTE: Use the corresponding macro instead of this function.
  72. Allocates a single buffer of memory from the dynamic memory of
  73. the C compiler. Is like malloc of C. The buffer must be freed 
  74. with mem_free. */
  75. void*
  76. mem_alloc_func_noninline(
  77. /*=====================*/
  78. /* out, own: free storage,
  79. NULL if did not succeed */
  80. ulint n, /* in: desired number of bytes */
  81. const char* file_name, /* in: file name where created */
  82. ulint line /* in: line where created */
  83. )
  84. {
  85. return(mem_alloc_func(n, file_name, line));
  86. }
  87. /**************************************************************************
  88. Duplicates a NUL-terminated string, allocated from a memory heap. */
  89. char*
  90. mem_heap_strdup(
  91. /*============*/
  92. /* out, own: a copy of the string */
  93. mem_heap_t* heap, /* in: memory heap where string is allocated */
  94. const char* str) /* in: string to be copied */
  95. {
  96. ulint len = strlen(str) + 1;
  97. return(memcpy(mem_heap_alloc(heap, len), str, len));
  98. }
  99. /*******************************************************************
  100. Creates a memory heap block where data can be allocated. */
  101. mem_block_t*
  102. mem_heap_create_block(
  103. /*==================*/
  104. /* out, own: memory heap block,
  105. NULL if did not succeed */
  106. mem_heap_t* heap, /* in: memory heap or NULL if first block
  107. should be created */
  108. ulint n, /* in: number of bytes needed for user data, or
  109. if init_block is not NULL, its size in bytes */
  110. void* init_block, /* in: init block in fast create,
  111. type must be MEM_HEAP_DYNAMIC */
  112. ulint type, /* in: type of heap: MEM_HEAP_DYNAMIC or
  113. MEM_HEAP_BUFFER */
  114. const char* file_name,/* in: file name where created */
  115. ulint line) /* in: line where created */
  116. {
  117. mem_block_t* block;
  118. ulint len;
  119. ut_ad((type == MEM_HEAP_DYNAMIC) || (type == MEM_HEAP_BUFFER)
  120. || (type == MEM_HEAP_BUFFER + MEM_HEAP_BTR_SEARCH));
  121. if (heap && heap->magic_n != MEM_BLOCK_MAGIC_N) {
  122. mem_analyze_corruption((byte*)heap);
  123. }
  124. /* In dynamic allocation, calculate the size: block header + data. */
  125. if (init_block != NULL) {
  126. ut_ad(type == MEM_HEAP_DYNAMIC);
  127. ut_ad(n > MEM_BLOCK_START_SIZE + MEM_BLOCK_HEADER_SIZE);
  128. len = n;
  129. block = init_block;
  130. } else if (type == MEM_HEAP_DYNAMIC) {
  131. len = MEM_BLOCK_HEADER_SIZE + MEM_SPACE_NEEDED(n);
  132. block = mem_area_alloc(len, mem_comm_pool);
  133. } else {
  134. ut_ad(n <= MEM_MAX_ALLOC_IN_BUF);
  135. len = MEM_BLOCK_HEADER_SIZE + MEM_SPACE_NEEDED(n);
  136. if (len < UNIV_PAGE_SIZE / 2) {
  137. block = mem_area_alloc(len, mem_comm_pool);
  138. } else {
  139. len = UNIV_PAGE_SIZE;
  140. if ((type & MEM_HEAP_BTR_SEARCH) && heap) {
  141. /* We cannot allocate the block from the
  142. buffer pool, but must get the free block from
  143. the heap header free block field */
  144. block = (mem_block_t*)heap->free_block;
  145. heap->free_block = NULL;
  146. } else {
  147. block = (mem_block_t*)buf_frame_alloc();
  148. }
  149. }
  150. }
  151. if (block == NULL) {
  152. return(NULL);
  153. }
  154. block->magic_n = MEM_BLOCK_MAGIC_N;
  155. ut_memcpy(&(block->file_name), file_name + ut_strlen(file_name) - 7,
  156. 7);
  157. block->file_name[7]='';
  158. block->line = line;
  159. #ifdef MEM_PERIODIC_CHECK
  160. mem_pool_mutex_enter();
  161. if (!mem_block_list_inited) {
  162. mem_block_list_inited = TRUE;
  163. UT_LIST_INIT(mem_block_list);
  164. }
  165. UT_LIST_ADD_LAST(mem_block_list, mem_block_list, block);
  166. mem_pool_mutex_exit();
  167. #endif
  168. mem_block_set_len(block, len);
  169. mem_block_set_type(block, type);
  170. mem_block_set_free(block, MEM_BLOCK_HEADER_SIZE);
  171. mem_block_set_start(block, MEM_BLOCK_HEADER_SIZE);
  172. block->free_block = NULL;
  173. block->init_block = (init_block != NULL);
  174. ut_ad((ulint)MEM_BLOCK_HEADER_SIZE < len);
  175. return(block);
  176. }
  177. /*******************************************************************
  178. Adds a new block to a memory heap. */
  179. mem_block_t*
  180. mem_heap_add_block(
  181. /*===============*/
  182. /* out: created block, NULL if did not
  183. succeed */
  184. mem_heap_t*  heap, /* in: memory heap */
  185. ulint n) /* in: number of bytes user needs */
  186. {
  187. mem_block_t* block; 
  188. mem_block_t* new_block; 
  189. ulint new_size;
  190. ut_ad(mem_heap_check(heap));
  191. block = UT_LIST_GET_LAST(heap->base);
  192. /* We have to allocate a new block. The size is always at least
  193. doubled until the standard size is reached. After that the size
  194. stays the same, except in cases where the caller needs more space. */
  195. new_size = 2 * mem_block_get_len(block);
  196. if (heap->type != MEM_HEAP_DYNAMIC) {
  197. /* From the buffer pool we allocate buffer frames */
  198. ut_a(n <= MEM_MAX_ALLOC_IN_BUF);
  199. if (new_size > MEM_MAX_ALLOC_IN_BUF) {
  200. new_size = MEM_MAX_ALLOC_IN_BUF;
  201. }
  202. } else if (new_size > MEM_BLOCK_STANDARD_SIZE) {
  203. new_size = MEM_BLOCK_STANDARD_SIZE;
  204. }
  205. if (new_size < n) {
  206. new_size = n;
  207. }
  208. new_block = mem_heap_create_block(heap, new_size, NULL, heap->type,
  209. heap->file_name, heap->line);
  210. if (new_block == NULL) {
  211. return(NULL);
  212. }
  213. /* Add the new block as the last block */
  214. UT_LIST_INSERT_AFTER(list, heap->base, block, new_block);
  215. return(new_block);
  216. }
  217. /**********************************************************************
  218. Frees a block from a memory heap. */
  219. void
  220. mem_heap_block_free(
  221. /*================*/
  222. mem_heap_t* heap, /* in: heap */
  223. mem_block_t* block) /* in: block to free */
  224. {
  225. ulint type;
  226. ulint len;
  227. ibool init_block;
  228. if (block->magic_n != MEM_BLOCK_MAGIC_N) {
  229. mem_analyze_corruption((byte*)block);
  230. }
  231. UT_LIST_REMOVE(list, heap->base, block);
  232. #ifdef MEM_PERIODIC_CHECK
  233. mem_pool_mutex_enter();
  234. UT_LIST_REMOVE(mem_block_list, mem_block_list, block);
  235. mem_pool_mutex_exit();
  236. #endif
  237. type = heap->type;
  238. len = block->len;
  239. init_block = block->init_block;
  240. block->magic_n = MEM_FREED_BLOCK_MAGIC_N;
  241. #ifdef UNIV_MEM_DEBUG
  242. /* In the debug version we set the memory to a random combination
  243. of hex 0xDE and 0xAD. */
  244. mem_erase_buf((byte*)block, len);
  245. #endif
  246. if (init_block) {
  247. /* Do not have to free: do nothing */
  248. } else if (type == MEM_HEAP_DYNAMIC) {
  249. mem_area_free(block, mem_comm_pool);
  250. } else {
  251. ut_ad(type & MEM_HEAP_BUFFER);
  252. if (len >= UNIV_PAGE_SIZE / 2) {
  253. buf_frame_free((byte*)block);
  254. } else {
  255. mem_area_free(block, mem_comm_pool);
  256. }
  257. }
  258. }
  259. /**********************************************************************
  260. Frees the free_block field from a memory heap. */
  261. void
  262. mem_heap_free_block_free(
  263. /*=====================*/
  264. mem_heap_t* heap) /* in: heap */
  265. {
  266. if (heap->free_block) {
  267. buf_frame_free(heap->free_block);
  268. heap->free_block = NULL;
  269. }
  270. }
  271. #ifdef MEM_PERIODIC_CHECK
  272. /**********************************************************************
  273. Goes through the list of all allocated mem blocks, checks their magic
  274. numbers, and reports possible corruption. */
  275. void
  276. mem_validate_all_blocks(void)
  277. /*=========================*/
  278. {
  279. mem_block_t* block;
  280. mem_pool_mutex_enter();
  281. block = UT_LIST_GET_FIRST(mem_block_list);
  282. while (block) {
  283. if (block->magic_n != MEM_BLOCK_MAGIC_N) {
  284. mem_analyze_corruption((byte*)block);
  285. }
  286. block = UT_LIST_GET_NEXT(mem_block_list, block);
  287. }
  288. mem_pool_mutex_exit();
  289. }
  290. #endif