Lines Matching refs:heap
280 zend_mm_heap *heap; member
366 static ZEND_COLD ZEND_NORETURN void zend_mm_safe_error(zend_mm_heap *heap, in zend_mm_safe_error() argument
376 heap->overflow = 1; in zend_mm_safe_error()
388 heap->overflow = 0; in zend_mm_safe_error()
755 static void *zend_mm_chunk_alloc(zend_mm_heap *heap, size_t size, size_t alignment) argument
758 if (UNEXPECTED(heap->storage)) {
759 void *ptr = heap->storage->handlers.chunk_alloc(heap->storage, size, alignment);
767 static void zend_mm_chunk_free(zend_mm_heap *heap, void *addr, size_t size) argument
770 if (UNEXPECTED(heap->storage)) {
771 heap->storage->handlers.chunk_free(heap->storage, addr, size);
778 static int zend_mm_chunk_truncate(zend_mm_heap *heap, void *addr, size_t old_size, size_t new_size) argument
781 if (UNEXPECTED(heap->storage)) {
782 if (heap->storage->handlers.chunk_truncate) {
783 return heap->storage->handlers.chunk_truncate(heap->storage, addr, old_size, new_size);
797 static int zend_mm_chunk_extend(zend_mm_heap *heap, void *addr, size_t old_size, size_t new_size) argument
800 if (UNEXPECTED(heap->storage)) {
801 if (heap->storage->handlers.chunk_extend) {
802 return heap->storage->handlers.chunk_extend(heap->storage, addr, old_size, new_size);
815 static zend_always_inline void zend_mm_chunk_init(zend_mm_heap *heap, zend_mm_chunk *chunk) argument
817 chunk->heap = heap;
818 chunk->next = heap->main_chunk;
819 chunk->prev = heap->main_chunk->prev;
836 static size_t zend_mm_get_huge_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE…
837 static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR…
838 static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D…
841 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_s…
843 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LIN…
851 static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count, size_t size ZEND_FILE_LI… argument
853 static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count ZEND_FILE_LINE_DC ZEND_FI…
856 zend_mm_chunk *chunk = heap->main_chunk;
975 if (chunk->next == heap->main_chunk) {
977 if (heap->cached_chunks) {
978 heap->cached_chunks_count--;
979 chunk = heap->cached_chunks;
980 heap->cached_chunks = chunk->next;
983 if (UNEXPECTED(ZEND_MM_CHUNK_SIZE > heap->limit - heap->real_size)) {
984 if (zend_mm_gc(heap)) {
986 } else if (heap->overflow == 0) {
988 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
990 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
996 chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE);
999 if (zend_mm_gc(heap) &&
1000 …(chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE)) != NUL…
1004 zend_mm_safe_error(heap, "Out of memory");
1006 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) at %s:%d (tried to allocate %zu bytes)", h…
1008 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) (tried to allocate %zu bytes)", heap->real…
1015 size_t size = heap->real_size + ZEND_MM_CHUNK_SIZE;
1016 size_t peak = MAX(heap->real_peak, size);
1017 heap->real_size = size;
1018 heap->real_peak = peak;
1021 heap->real_size += ZEND_MM_CHUNK_SIZE;
1025 heap->chunks_count++;
1026 if (heap->chunks_count > heap->peak_chunks_count) {
1027 heap->peak_chunks_count = heap->chunks_count;
1029 zend_mm_chunk_init(heap, chunk);
1044 chunk->next = heap->main_chunk->next;
1045 chunk->prev = heap->main_chunk;
1059 static zend_always_inline void *zend_mm_alloc_large(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_… argument
1063 …void *ptr = zend_mm_alloc_pages(heap, pages_count, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORI…
1065 …void *ptr = zend_mm_alloc_pages(heap, pages_count ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELA…
1069 size_t size = heap->size + pages_count * ZEND_MM_PAGE_SIZE;
1070 size_t peak = MAX(heap->peak, size);
1071 heap->size = size;
1072 heap->peak = peak;
1078 static zend_always_inline void zend_mm_delete_chunk(zend_mm_heap *heap, zend_mm_chunk *chunk) argument
1082 heap->chunks_count--;
1083 if (heap->chunks_count + heap->cached_chunks_count < heap->avg_chunks_count + 0.1
1084 || (heap->chunks_count == heap->last_chunks_delete_boundary
1085 && heap->last_chunks_delete_count >= 4)) {
1087 heap->cached_chunks_count++;
1088 chunk->next = heap->cached_chunks;
1089 heap->cached_chunks = chunk;
1092 heap->real_size -= ZEND_MM_CHUNK_SIZE;
1094 if (!heap->cached_chunks) {
1095 if (heap->chunks_count != heap->last_chunks_delete_boundary) {
1096 heap->last_chunks_delete_boundary = heap->chunks_count;
1097 heap->last_chunks_delete_count = 0;
1099 heap->last_chunks_delete_count++;
1102 if (!heap->cached_chunks || chunk->num > heap->cached_chunks->num) {
1103 zend_mm_chunk_free(heap, chunk, ZEND_MM_CHUNK_SIZE);
1106 chunk->next = heap->cached_chunks->next;
1107 zend_mm_chunk_free(heap, heap->cached_chunks, ZEND_MM_CHUNK_SIZE);
1108 heap->cached_chunks = chunk;
1113 static zend_always_inline void zend_mm_free_pages_ex(zend_mm_heap *heap, zend_mm_chunk *chunk, uint… argument
1123 zend_mm_delete_chunk(heap, chunk);
1127 static void zend_mm_free_pages(zend_mm_heap *heap, zend_mm_chunk *chunk, int page_num, int pages_co… argument
1129 zend_mm_free_pages_ex(heap, chunk, page_num, pages_count, 1);
1132 static zend_always_inline void zend_mm_free_large(zend_mm_heap *heap, zend_mm_chunk *chunk, int pag… argument
1135 heap->size -= pages_count * ZEND_MM_PAGE_SIZE;
1137 zend_mm_free_pages(heap, chunk, page_num, pages_count);
1206 static zend_never_inline void *zend_mm_alloc_small_slow(zend_mm_heap *heap, uint32_t bin_num ZEND_F… argument
1214 …bin = (zend_mm_bin*)zend_mm_alloc_pages(heap, bin_pages[bin_num], bin_data_size[bin_num] ZEND_FILE…
1216 …bin = (zend_mm_bin*)zend_mm_alloc_pages(heap, bin_pages[bin_num] ZEND_FILE_LINE_RELAY_CC ZEND_FILE…
1237 heap->free_slot[bin_num] = p = (zend_mm_free_slot*)((char*)bin + bin_data_size[bin_num]);
1262 static zend_always_inline void *zend_mm_alloc_small(zend_mm_heap *heap, size_t size, int bin_num ZE… argument
1266 size_t size = heap->size + bin_data_size[bin_num];
1267 size_t peak = MAX(heap->peak, size);
1268 heap->size = size;
1269 heap->peak = peak;
1273 if (EXPECTED(heap->free_slot[bin_num] != NULL)) {
1274 zend_mm_free_slot *p = heap->free_slot[bin_num];
1275 heap->free_slot[bin_num] = p->next_free_slot;
1278 …return zend_mm_alloc_small_slow(heap, bin_num ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC…
1282 static zend_always_inline void zend_mm_free_small(zend_mm_heap *heap, void *ptr, int bin_num) argument
1287 heap->size -= bin_data_size[bin_num];
1298 p->next_free_slot = heap->free_slot[bin_num];
1299 heap->free_slot[bin_num] = p;
1307 static zend_always_inline zend_mm_debug_info *zend_mm_get_debug_info(zend_mm_heap *heap, void *ptr) argument
1318 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1330 static zend_always_inline void *zend_mm_alloc_heap(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1346 …ptr = zend_mm_alloc_small(heap, size, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND…
1348 dbg = zend_mm_get_debug_info(heap, ptr);
1357 ptr = zend_mm_alloc_large(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1359 dbg = zend_mm_get_debug_info(heap, ptr);
1371 return zend_mm_alloc_huge(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1375 static zend_always_inline void zend_mm_free_heap(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZE… argument
1381 zend_mm_free_huge(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1388 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1390 zend_mm_free_small(heap, ptr, ZEND_MM_SRUN_BIN_NUM(info));
1395 zend_mm_free_large(heap, chunk, page_num, pages_count);
1400 static size_t zend_mm_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) argument
1405 …return zend_mm_get_huge_block_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1409 zend_mm_debug_info *dbg = zend_mm_get_debug_info(heap, ptr);
1418 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1428 static void *zend_mm_realloc_heap(zend_mm_heap *heap, void *ptr, size_t size, size_t copy_size ZEND… argument
1442 return zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1444 …old_size = zend_mm_get_huge_block_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY…
1464 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1466 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1471 if (zend_mm_chunk_truncate(heap, ptr, old_size, new_size)) {
1473 heap->real_size -= old_size - new_size;
1476 heap->size -= old_size - new_size;
1479 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1481 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1487 if (UNEXPECTED(new_size - old_size > heap->limit - heap->real_size)) {
1488 if (zend_mm_gc(heap) && new_size - old_size <= heap->limit - heap->real_size) {
1490 } else if (heap->overflow == 0) {
1492 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1494 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1501 if (zend_mm_chunk_extend(heap, ptr, old_size, new_size)) {
1503 heap->real_size += new_size - old_size;
1506 heap->real_peak = MAX(heap->real_peak, heap->real_size);
1507 heap->size += new_size - old_size;
1508 heap->peak = MAX(heap->peak, heap->size);
1511 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1513 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1529 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1537 dbg = zend_mm_get_debug_info(heap, ptr);
1554 dbg = zend_mm_get_debug_info(heap, ptr);
1568 heap->size -= rest_pages_count * ZEND_MM_PAGE_SIZE;
1574 dbg = zend_mm_get_debug_info(heap, ptr);
1591 size_t size = heap->size + (new_size - old_size);
1592 size_t peak = MAX(heap->peak, size);
1593 heap->size = size;
1594 heap->peak = peak;
1601 dbg = zend_mm_get_debug_info(heap, ptr);
1621 size_t orig_peak = heap->peak;
1622 size_t orig_real_peak = heap->real_peak;
1624 ret = zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1626 zend_mm_free_heap(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1628 heap->peak = MAX(orig_peak, heap->size);
1629 heap->real_peak = MAX(orig_real_peak, heap->real_size);
1640 static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_size ZEND… argument
1642 static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEN…
1645 …zend_mm_huge_list *list = (zend_mm_huge_list*)zend_mm_alloc_heap(heap, sizeof(zend_mm_huge_list) Z…
1648 list->next = heap->huge_list;
1656 heap->huge_list = list;
1659 static size_t zend_mm_del_huge_block(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE… argument
1662 zend_mm_huge_list *list = heap->huge_list;
1670 heap->huge_list = list->next;
1673 zend_mm_free_heap(heap, list ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1683 static size_t zend_mm_get_huge_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE… argument
1685 zend_mm_huge_list *list = heap->huge_list;
1697 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_s… argument
1699 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LIN…
1702 zend_mm_huge_list *list = heap->huge_list;
1719 static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR… argument
1738 if (UNEXPECTED(new_size > heap->limit - heap->real_size)) {
1739 if (zend_mm_gc(heap) && new_size <= heap->limit - heap->real_size) {
1741 } else if (heap->overflow == 0) {
1743 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1745 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1751 ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE);
1754 if (zend_mm_gc(heap) &&
1755 (ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE)) != NULL) {
1759 zend_mm_safe_error(heap, "Out of memory");
1761 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) at %s:%d (tried to allocate %zu bytes)", h…
1763 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) (tried to allocate %zu bytes)", heap->real…
1769 …zend_mm_add_huge_block(heap, ptr, new_size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY…
1771 zend_mm_add_huge_block(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1775 size_t size = heap->real_size + new_size;
1776 size_t peak = MAX(heap->real_peak, size);
1777 heap->real_size = size;
1778 heap->real_peak = peak;
1781 size_t size = heap->size + new_size;
1782 size_t peak = MAX(heap->peak, size);
1783 heap->size = size;
1784 heap->peak = peak;
1787 heap->real_size += new_size;
1792 static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D… argument
1797 size = zend_mm_del_huge_block(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1798 zend_mm_chunk_free(heap, ptr, size);
1800 heap->real_size -= size;
1803 heap->size -= size;
1814 zend_mm_heap *heap; local
1826 heap = &chunk->heap_slot;
1827 chunk->heap = heap;
1835 heap->main_chunk = chunk;
1836 heap->cached_chunks = NULL;
1837 heap->chunks_count = 1;
1838 heap->peak_chunks_count = 1;
1839 heap->cached_chunks_count = 0;
1840 heap->avg_chunks_count = 1.0;
1841 heap->last_chunks_delete_boundary = 0;
1842 heap->last_chunks_delete_count = 0;
1844 heap->real_size = ZEND_MM_CHUNK_SIZE;
1847 heap->real_peak = ZEND_MM_CHUNK_SIZE;
1848 heap->size = 0;
1849 heap->peak = 0;
1852 heap->limit = ((size_t)Z_L(-1) >> (size_t)Z_L(1));
1853 heap->overflow = 0;
1856 heap->use_custom_heap = ZEND_MM_CUSTOM_HEAP_NONE;
1859 heap->storage = NULL;
1861 heap->huge_list = NULL;
1862 return heap;
1865 ZEND_API size_t zend_mm_gc(zend_mm_heap *heap) argument
1877 if (heap->use_custom_heap) {
1884 p = heap->free_slot[i];
1887 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1912 q = &heap->free_slot[i];
1916 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1940 chunk = heap->main_chunk;
1952 zend_mm_free_pages_ex(heap, chunk, i, pages_count, 0);
1969 zend_mm_delete_chunk(heap, chunk);
1974 } while (chunk != heap->main_chunk);
2011 static zend_long zend_mm_find_leaks(zend_mm_heap *heap, zend_mm_chunk *p, uint32_t i, zend_leak_inf… argument
2037 } while (p != heap->main_chunk);
2041 static zend_long zend_mm_find_leaks_huge(zend_mm_heap *heap, zend_mm_huge_list *list) argument
2050 zend_mm_chunk_free(heap, p->ptr, p->size);
2051 zend_mm_free_heap(heap, p, NULL, 0, NULL, 0);
2062 static void zend_mm_check_leaks(zend_mm_heap *heap) argument
2072 list = heap->huge_list;
2085 repeated = zend_mm_find_leaks_huge(heap, list);
2091 heap->huge_list = list = list->next;
2092 zend_mm_chunk_free(heap, q->ptr, q->size);
2093 zend_mm_free_heap(heap, q, NULL, 0, NULL, 0);
2097 p = heap->main_chunk;
2124 zend_mm_find_leaks(heap, p, i + bin_pages[bin_num], &leak);
2150 repeated = zend_mm_find_leaks(heap, p, i + pages_count, &leak);
2162 } while (p != heap->main_chunk);
2169 void zend_mm_shutdown(zend_mm_heap *heap, int full, int silent) argument
2175 if (heap->use_custom_heap) {
2177 if (ZEND_DEBUG && heap->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
2178 heap->custom_heap.debug._free(heap ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
2180 heap->custom_heap.std._free(heap);
2189 zend_mm_check_leaks(heap);
2194 list = heap->huge_list;
2195 heap->huge_list = NULL;
2199 zend_mm_chunk_free(heap, q->ptr, q->size);
2203 p = heap->main_chunk->next;
2204 while (p != heap->main_chunk) {
2206 p->next = heap->cached_chunks;
2207 heap->cached_chunks = p;
2209 heap->chunks_count--;
2210 heap->cached_chunks_count++;
2215 while (heap->cached_chunks) {
2216 p = heap->cached_chunks;
2217 heap->cached_chunks = p->next;
2218 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2221 zend_mm_chunk_free(heap, heap->main_chunk, ZEND_MM_CHUNK_SIZE);
2226 heap->avg_chunks_count = (heap->avg_chunks_count + (double)heap->peak_chunks_count) / 2.0;
2227 while ((double)heap->cached_chunks_count + 0.9 > heap->avg_chunks_count &&
2228 heap->cached_chunks) {
2229 p = heap->cached_chunks;
2230 heap->cached_chunks = p->next;
2231 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2232 heap->cached_chunks_count--;
2235 p = heap->cached_chunks;
2244 old_heap = *heap;
2245 p = heap->main_chunk;
2247 *heap = old_heap;
2248 memset(heap->free_slot, 0, sizeof(heap->free_slot));
2249 heap->main_chunk = p;
2250 p->heap = &p->heap_slot;
2257 heap->chunks_count = 1;
2258 heap->peak_chunks_count = 1;
2259 heap->last_chunks_delete_boundary = 0;
2260 heap->last_chunks_delete_count = 0;
2262 heap->real_size = ZEND_MM_CHUNK_SIZE;
2265 heap->real_peak = ZEND_MM_CHUNK_SIZE;
2266 heap->size = heap->peak = 0;
2275 ZEND_API void* ZEND_FASTCALL _zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_… argument
2277 return zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2280 ZEND_API void ZEND_FASTCALL _zend_mm_free(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE… argument
2282 zend_mm_free_heap(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2285 void* ZEND_FASTCALL _zend_mm_realloc(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC Z… argument
2287 …return zend_mm_realloc_heap(heap, ptr, size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELA…
2290 void* ZEND_FASTCALL _zend_mm_realloc2(zend_mm_heap *heap, void *ptr, size_t size, size_t copy_size … argument
2292 …return zend_mm_realloc_heap(heap, ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG…
2295 ZEND_API size_t ZEND_FASTCALL _zend_mm_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC Z… argument
2297 return zend_mm_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2383 ZEND_MM_CHECK(chunk->heap == AG(mm_heap), "zend_mm_heap corrupted"); \
2395 ZEND_MM_CHECK(chunk->heap == AG(mm_heap), "zend_mm_heap corrupted"); \
2413 …ZEND_MM_CHECK(chunk->heap == AG(mm_heap) && ZEND_MM_ALIGNED_OFFSET(page_offset, ZEND_MM_PAGE_SIZE)…
2678 ZEND_API void zend_mm_set_custom_handlers(zend_mm_heap *heap, argument
2684 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2693 ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap, argument
2699 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2701 if (heap->use_custom_heap) {
2718 ZEND_API void zend_mm_set_custom_debug_handlers(zend_mm_heap *heap, argument
2724 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2734 ZEND_API zend_mm_storage *zend_mm_get_storage(zend_mm_heap *heap) argument
2737 return heap->storage;
2753 zend_mm_heap *heap; local
2768 heap = &chunk->heap_slot;
2769 chunk->heap = heap;
2777 heap->main_chunk = chunk;
2778 heap->cached_chunks = NULL;
2779 heap->chunks_count = 1;
2780 heap->peak_chunks_count = 1;
2781 heap->cached_chunks_count = 0;
2782 heap->avg_chunks_count = 1.0;
2783 heap->last_chunks_delete_boundary = 0;
2784 heap->last_chunks_delete_count = 0;
2786 heap->real_size = ZEND_MM_CHUNK_SIZE;
2789 heap->real_peak = ZEND_MM_CHUNK_SIZE;
2790 heap->size = 0;
2791 heap->peak = 0;
2794 heap->limit = (Z_L(-1) >> Z_L(1));
2795 heap->overflow = 0;
2798 heap->use_custom_heap = 0;
2800 heap->storage = &tmp_storage;
2801 heap->huge_list = NULL;
2802 memset(heap->free_slot, 0, sizeof(heap->free_slot));
2803 …storage = _zend_mm_alloc(heap, sizeof(zend_mm_storage) + data_size ZEND_FILE_LINE_CC ZEND_FILE_LIN…
2820 heap->storage = storage;
2821 return heap;
