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

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. The memory management
  3. (c) 1994, 1995 Innobase Oy
  4. Created 6/8/1994 Heikki Tuuri
  5. *************************************************************************/
  6. #include "mem0dbg.ic"
  7. #include "mem0pool.h"
  8. /*******************************************************************
  9. Creates a memory heap block where data can be allocated. */
  10. mem_block_t*
  11. mem_heap_create_block(
  12. /*==================*/
  13. /* out, own: memory heap block,
  14. NULL if did not succeed */
  15. mem_heap_t* heap, /* in: memory heap or NULL if first block
  16. should be created */
  17. ulint n, /* in: number of bytes needed for user data, or
  18. if init_block is not NULL, its size in bytes */
  19. void* init_block, /* in: init block in fast create,
  20. type must be MEM_HEAP_DYNAMIC */
  21. ulint type, /* in: type of heap: MEM_HEAP_DYNAMIC or
  22. MEM_HEAP_BUFFER */
  23. const char* file_name,/* in: file name where created */
  24. ulint line); /* in: line where created */
  25. /**********************************************************************
  26. Frees a block from a memory heap. */
  27. void
  28. mem_heap_block_free(
  29. /*================*/
  30. mem_heap_t* heap, /* in: heap */
  31. mem_block_t* block); /* in: block to free */
  32. /**********************************************************************
  33. Frees the free_block field from a memory heap. */
  34. void
  35. mem_heap_free_block_free(
  36. /*=====================*/
  37. mem_heap_t* heap); /* in: heap */
  38. /*******************************************************************
  39. Adds a new block to a memory heap. */
  40. mem_block_t*
  41. mem_heap_add_block(
  42. /*===============*/
  43. /* out: created block, NULL if did not
  44. succeed */
  45. mem_heap_t*  heap, /* in: memory heap */
  46. ulint n); /* in: number of bytes user needs */
  47. UNIV_INLINE
  48. void
  49. mem_block_set_len(mem_block_t* block, ulint len)
  50. {
  51. ut_ad(len > 0);
  52. block->len = len;
  53. }
  54. UNIV_INLINE
  55. ulint
  56. mem_block_get_len(mem_block_t* block)
  57. {
  58. return(block->len);
  59. }
  60. UNIV_INLINE
  61. void
  62. mem_block_set_type(mem_block_t* block, ulint type)
  63. {
  64. ut_ad((type == MEM_HEAP_DYNAMIC) || (type == MEM_HEAP_BUFFER)
  65. || (type == MEM_HEAP_BUFFER + MEM_HEAP_BTR_SEARCH));
  66. block->type = type;
  67. }
  68. UNIV_INLINE
  69. ulint
  70. mem_block_get_type(mem_block_t* block)
  71. {
  72. return(block->type);
  73. }
  74. UNIV_INLINE
  75. void
  76. mem_block_set_free(mem_block_t* block, ulint free)
  77. {
  78. ut_ad(free > 0);
  79. ut_ad(free <= mem_block_get_len(block));
  80. block->free = free;
  81. }
  82. UNIV_INLINE
  83. ulint
  84. mem_block_get_free(mem_block_t* block)
  85. {
  86. return(block->free);
  87. }
  88. UNIV_INLINE
  89. void
  90. mem_block_set_start(mem_block_t* block, ulint start)
  91. {
  92. ut_ad(start > 0);
  93. block->start = start;
  94. }
  95. UNIV_INLINE
  96. ulint
  97. mem_block_get_start(mem_block_t* block)
  98. {
  99. return(block->start);
  100. }
  101. /*******************************************************************
  102. Allocates n bytes of memory from a memory heap. */
  103. UNIV_INLINE
  104. void*
  105. mem_heap_alloc(
  106. /*===========*/
  107. /* out: allocated storage */
  108. mem_heap_t* heap,  /* in: memory heap */
  109. ulint           n)      /* in: number of bytes; if the heap is allowed
  110. to grow into the buffer pool, this must be
  111. <= MEM_MAX_ALLOC_IN_BUF */
  112. {
  113. mem_block_t* block;
  114. void* buf;
  115. ulint free;
  116. ut_ad(mem_heap_check(heap));
  117. block = UT_LIST_GET_LAST(heap->base);
  118. ut_ad(!(block->type & MEM_HEAP_BUFFER) || (n <= MEM_MAX_ALLOC_IN_BUF));
  119. /* Check if there is enough space in block. If not, create a new
  120. block to the heap */
  121. if (mem_block_get_len(block) 
  122. < mem_block_get_free(block) + MEM_SPACE_NEEDED(n)) {
  123. block = mem_heap_add_block(heap, n);
  124. if (block == NULL) {
  125. return(NULL);
  126. }
  127. }
  128. free = mem_block_get_free(block);
  129. buf = (byte*)block + free;
  130. mem_block_set_free(block, free + MEM_SPACE_NEEDED(n));
  131. #ifdef UNIV_MEM_DEBUG
  132. /* In the debug version write debugging info to the field */
  133. mem_field_init((byte*)buf, n);
  134. /* Advance buf to point at the storage which will be given to the
  135. caller */
  136. buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
  137. #endif
  138. #ifdef UNIV_SET_MEM_TO_ZERO
  139. memset(buf, '', n);
  140. #endif
  141. return(buf);
  142. }
  143. /*********************************************************************
  144. Returns a pointer to the heap top. */
  145. UNIV_INLINE
  146. byte*
  147. mem_heap_get_heap_top(
  148. /*==================*/     
  149. /* out: pointer to the heap top */
  150. mem_heap_t*    heap)  /* in: memory heap */
  151. {
  152. mem_block_t* block;
  153. byte* buf;
  154. ut_ad(mem_heap_check(heap));
  155. block = UT_LIST_GET_LAST(heap->base);
  156. buf = (byte*)block + mem_block_get_free(block);
  157. return(buf);
  158. /*********************************************************************
  159. Frees the space in a memory heap exceeding the pointer given. The
  160. pointer must have been acquired from mem_heap_get_heap_top. The first
  161. memory block of the heap is not freed. */
  162. UNIV_INLINE
  163. void
  164. mem_heap_free_heap_top(
  165. /*===================*/
  166. mem_heap_t*    heap, /* in: heap from which to free */
  167. byte* old_top)/* in: pointer to old top of heap */
  168. {
  169. mem_block_t* block;
  170. mem_block_t* prev_block;
  171. #ifdef UNIV_MEM_DEBUG
  172. ibool error;
  173. ulint total_size;
  174. ulint size;
  175. #endif
  176. ut_ad(mem_heap_check(heap));
  177. #ifdef UNIV_MEM_DEBUG
  178. /* Validate the heap and get its total allocated size */
  179. mem_heap_validate_or_print(heap, NULL, FALSE, &error, &total_size,
  180. NULL, NULL);
  181. ut_a(!error);
  182. /* Get the size below top pointer */
  183. mem_heap_validate_or_print(heap, old_top, FALSE, &error, &size, NULL,
  184. NULL);
  185. ut_a(!error);
  186. #endif
  187. block = UT_LIST_GET_LAST(heap->base);
  188. while (block != NULL) {
  189. if (((byte*)block + mem_block_get_free(block) >= old_top)
  190. && ((byte*)block <= old_top)) {
  191. /* Found the right block */
  192. break;
  193. }
  194.  
  195. /* Store prev_block value before freeing the current block
  196. (the current block will be erased in freeing) */
  197. prev_block = UT_LIST_GET_PREV(list, block);
  198. mem_heap_block_free(heap, block);
  199. block = prev_block;
  200. }
  201. ut_ad(block);
  202. /* Set the free field of block */
  203. mem_block_set_free(block, old_top - (byte*)block); 
  204. #ifdef UNIV_MEM_DEBUG
  205. ut_ad(mem_block_get_start(block) <= mem_block_get_free(block));
  206. /* In the debug version erase block from top up */
  207. mem_erase_buf(old_top, (byte*)block + block->len - old_top);
  208. /* Update allocated memory count */
  209. mutex_enter(&mem_hash_mutex);
  210. mem_current_allocated_memory -= (total_size - size);
  211. mutex_exit(&mem_hash_mutex);
  212. #endif
  213. /* If free == start, we may free the block if it is not the first
  214. one */
  215. if ((heap != block) && (mem_block_get_free(block) == 
  216.    mem_block_get_start(block))) {
  217. mem_heap_block_free(heap, block);
  218. }
  219. }
  220. /*********************************************************************
  221. Empties a memory heap. The first memory block of the heap is not freed. */
  222. UNIV_INLINE
  223. void
  224. mem_heap_empty(
  225. /*===========*/
  226. mem_heap_t*    heap) /* in: heap to empty */
  227. {
  228. mem_heap_free_heap_top(heap, (byte*)heap + mem_block_get_start(heap));
  229. if (heap->free_block) {
  230. mem_heap_free_block_free(heap);
  231. }
  232. }
  233. /*********************************************************************
  234. Returns a pointer to the topmost element in a memory heap. The size of the
  235. element must be given. */
  236. UNIV_INLINE
  237. void*
  238. mem_heap_get_top(
  239. /*=============*/     
  240. /* out: pointer to the topmost element */
  241. mem_heap_t*    heap,  /* in: memory heap */
  242. ulint           n)      /* in: size of the topmost element */
  243. {
  244. mem_block_t* block;
  245. void* buf;
  246. ut_ad(mem_heap_check(heap));
  247. block = UT_LIST_GET_LAST(heap->base);
  248. buf = (byte*)block + mem_block_get_free(block) - MEM_SPACE_NEEDED(n);
  249. #ifdef UNIV_MEM_DEBUG
  250. ut_ad(mem_block_get_start(block) <=(ulint)((byte*)buf - (byte*)block));
  251. /* In the debug version, advance buf to point at the storage which
  252. was given to the caller in the allocation*/
  253. buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
  254. /* Check that the field lengths agree */
  255. ut_ad(n == (ulint)mem_field_header_get_len(buf));
  256. #endif
  257. return(buf);
  258. /*********************************************************************
  259. Frees the topmost element in a memory heap. The size of the element must be
  260. given. */
  261. UNIV_INLINE
  262. void
  263. mem_heap_free_top(
  264. /*==============*/    
  265. mem_heap_t*    heap,  /* in: memory heap */
  266. ulint           n)      /* in: size of the topmost element */
  267. {
  268. mem_block_t* block;
  269. ut_ad(mem_heap_check(heap));
  270. block = UT_LIST_GET_LAST(heap->base);
  271. /* Subtract the free field of block */
  272. mem_block_set_free(block, mem_block_get_free(block)
  273. - MEM_SPACE_NEEDED(n));
  274. #ifdef UNIV_MEM_DEBUG
  275. ut_ad(mem_block_get_start(block) <= mem_block_get_free(block));
  276. /* In the debug version check the consistency, and erase field */
  277. mem_field_erase((byte*)block + mem_block_get_free(block), n);
  278. #endif
  279. /* If free == start, we may free the block if it is not the first
  280. one */
  281. if ((heap != block) && (mem_block_get_free(block) == 
  282.    mem_block_get_start(block))) {
  283. mem_heap_block_free(heap, block);
  284. }
  285. }
  286. /*********************************************************************
  287. NOTE: Use the corresponding macros instead of this function. Creates a
  288. memory heap which allocates memory from dynamic space. For debugging
  289. purposes, takes also the file name and line as argument in the debug
  290. version. */
  291. UNIV_INLINE
  292. mem_heap_t*
  293. mem_heap_create_func(
  294. /*=================*/
  295. /* out, own: memory heap */
  296. ulint n, /* in: desired start block size,
  297. this means that a single user buffer
  298. of size n will fit in the block, 
  299. 0 creates a default size block;
  300. if init_block is not NULL, n tells
  301. its size in bytes */
  302. void* init_block, /* in: if very fast creation is
  303. wanted, the caller can reserve some
  304. memory from its stack, for example,
  305. and pass it as the the initial block
  306. to the heap: then no OS call of malloc
  307. is needed at the creation. CAUTION:
  308. the caller must make sure the initial
  309. block is not unintentionally erased
  310. (if allocated in the stack), before
  311. the memory heap is explicitly freed. */
  312. ulint type, /* in: MEM_HEAP_DYNAMIC
  313. or MEM_HEAP_BUFFER */ 
  314. const char* file_name, /* in: file name where created */
  315. ulint line /* in: line where created */
  316. )
  317. {
  318. mem_block_t*   block; 
  319. if (n > 0) {
  320. block = mem_heap_create_block(NULL, n, init_block, type,
  321. file_name, line);
  322. } else {
  323. block = mem_heap_create_block(NULL, MEM_BLOCK_START_SIZE, 
  324. init_block, type, file_name, line);
  325. }
  326. ut_ad(block);
  327. UT_LIST_INIT(block->base);
  328. /* Add the created block itself as the first block in the list */
  329. UT_LIST_ADD_FIRST(list, block->base, block);
  330. #ifdef UNIV_MEM_DEBUG
  331. if (block == NULL) {
  332. return(block);
  333. }
  334. mem_hash_insert(block, file_name, line);
  335. #endif
  336. return(block);
  337. }
  338. /*********************************************************************
  339. NOTE: Use the corresponding macro instead of this function. Frees the space
  340. occupied by a memory heap. In the debug version erases the heap memory
  341. blocks. */
  342. UNIV_INLINE
  343. void
  344. mem_heap_free_func(
  345. /*===============*/
  346. mem_heap_t*    heap,   /* in, own: heap to be freed */
  347. const char* file_name __attribute__((unused)),
  348. /* in: file name where freed */
  349. ulint     line  __attribute__((unused)))
  350. {
  351. mem_block_t* block;
  352. mem_block_t* prev_block;
  353. ut_ad(mem_heap_check(heap));
  354. block = UT_LIST_GET_LAST(heap->base);
  355. #ifdef UNIV_MEM_DEBUG
  356. /* In the debug version remove the heap from the hash table of heaps
  357. and check its consistency */
  358. mem_hash_remove(heap, file_name, line); 
  359. #endif
  360. if (heap->free_block) {
  361. mem_heap_free_block_free(heap);
  362. }
  363. while (block != NULL) { 
  364. /* Store the contents of info before freeing current block
  365. (it is erased in freeing) */
  366. prev_block = UT_LIST_GET_PREV(list, block);
  367. mem_heap_block_free(heap, block);
  368. block = prev_block;
  369. }
  370. }
  371. /*******************************************************************
  372. NOTE: Use the corresponding macro instead of this function.
  373. Allocates a single buffer of memory from the dynamic memory of
  374. the C compiler. Is like malloc of C. The buffer must be freed 
  375. with mem_free. */
  376. UNIV_INLINE
  377. void*
  378. mem_alloc_func(
  379. /*===========*/
  380. /* out, own: free storage, NULL
  381. if did not succeed */
  382. ulint n, /* in: desired number of bytes */
  383. const char* file_name, /* in: file name where created */
  384. ulint line /* in: line where created */
  385. )
  386. {
  387. mem_heap_t*    heap; 
  388. void*           buf;
  389. heap = mem_heap_create_func(n, NULL, MEM_HEAP_DYNAMIC, file_name,
  390. line);
  391. if (heap == NULL) {
  392. return(NULL);
  393. }
  394. /* Note that as we created the first block in the heap big enough
  395. for the buffer requested by the caller, the buffer will be in the
  396. first block and thus we can calculate the pointer to the heap from
  397. the pointer to the buffer when we free the memory buffer. */
  398. buf = mem_heap_alloc(heap, n);
  399. ut_a((byte*)heap == (byte*)buf - MEM_BLOCK_HEADER_SIZE
  400. - MEM_FIELD_HEADER_SIZE);
  401. return(buf);
  402. }
  403. /*******************************************************************
  404. NOTE: Use the corresponding macro instead of this function. Frees a single
  405. buffer of storage from the dynamic memory of the C compiler. Similar to the
  406. free of C. */
  407. UNIV_INLINE
  408. void
  409. mem_free_func(
  410. /*==========*/
  411. void* ptr, /* in, own: buffer to be freed */
  412. const char* file_name, /* in: file name where created */
  413. ulint line /* in: line where created */
  414. )
  415. {
  416. mem_heap_t*   heap; 
  417. heap = (mem_heap_t*)((byte*)ptr - MEM_BLOCK_HEADER_SIZE
  418.   - MEM_FIELD_HEADER_SIZE);
  419. mem_heap_free_func(heap, file_name, line);
  420. }
  421. /*********************************************************************
  422. Returns the space in bytes occupied by a memory heap. */
  423. UNIV_INLINE
  424. ulint
  425. mem_heap_get_size(
  426. /*==============*/
  427. mem_heap_t*    heap)   /* in: heap */
  428. {
  429. mem_block_t*   block;
  430. ulint           size = 0;
  431. ut_ad(mem_heap_check(heap));
  432. block = heap;
  433. while (block != NULL) { 
  434. size += mem_block_get_len(block);
  435. block = UT_LIST_GET_NEXT(list, block);
  436. }
  437. if (heap->free_block) {
  438. size += UNIV_PAGE_SIZE;
  439. }
  440. return(size);
  441. }
  442. /**************************************************************************
  443. Duplicates a NUL-terminated string. */
  444. UNIV_INLINE
  445. char*
  446. mem_strdup(
  447. /*=======*/
  448. /* out, own: a copy of the string,
  449. must be deallocated with mem_free */
  450. const char* str) /* in: string to be copied */
  451. {
  452. ulint len = strlen(str) + 1;
  453. return(memcpy(mem_alloc(len), str, len));
  454. }
  455. /**************************************************************************
  456. Makes a NUL-terminated copy of a nonterminated string. */
  457. UNIV_INLINE
  458. char*
  459. mem_strdupl(
  460. /*========*/
  461. /* out, own: a copy of the string,
  462. must be deallocated with mem_free */
  463. const char* str, /* in: string to be copied */
  464. ulint len) /* in: length of str, in bytes */
  465. {
  466. char* s = mem_alloc(len + 1);
  467. s[len] = 0;
  468. return(memcpy(s, str, len));
  469. }
  470. /**************************************************************************
  471. Makes a NUL-terminated quoted copy of a NUL-terminated string. */
  472. UNIV_INLINE
  473. char*
  474. mem_strdupq(
  475. /*========*/
  476. /* out, own: a quoted copy of the string,
  477. must be deallocated with mem_free */
  478. const char* str, /* in: string to be copied */
  479. char q) /* in: quote character */
  480. {
  481. char* dst;
  482. char* d;
  483. const char* s = str;
  484. size_t len = strlen(str) + 3;
  485. /* calculate the number of quote characters in the string */
  486. while((s = strchr(s, q)) != NULL) {
  487. s++;
  488. len++;
  489. }
  490. /* allocate the quoted string, and copy it */
  491. d = dst = mem_alloc(len);
  492. *d++ = q;
  493. s = str;
  494. while(*s) {
  495. if ((*d++ = *s++) == q) {
  496. *d++ = q;
  497. }
  498. }
  499. *d++ = q;
  500. *d++ = '';
  501. ut_ad(len == d - dst);
  502. return(dst);
  503. }
  504. /**************************************************************************
  505. Makes a NUL-terminated copy of a nonterminated string,
  506. allocated from a memory heap. */
  507. UNIV_INLINE
  508. char*
  509. mem_heap_strdupl(
  510. /*=============*/
  511. /* out, own: a copy of the string */
  512. mem_heap_t* heap, /* in: memory heap where string is allocated */
  513. const char* str, /* in: string to be copied */
  514. ulint len) /* in: length of str, in bytes */
  515. {
  516. char* s = mem_heap_alloc(heap, len + 1);
  517. s[len] = 0;
  518. return(memcpy(s, str, len));
  519. }