Lines Matching refs:heap
283 zend_mm_heap *heap; member
369 static ZEND_COLD ZEND_NORETURN void zend_mm_safe_error(zend_mm_heap *heap, in zend_mm_safe_error() argument
379 heap->overflow = 1; in zend_mm_safe_error()
391 heap->overflow = 0; in zend_mm_safe_error()
714 static void *zend_mm_chunk_alloc(zend_mm_heap *heap, size_t size, size_t alignment) argument
717 if (UNEXPECTED(heap->storage)) {
718 void *ptr = heap->storage->handlers.chunk_alloc(heap->storage, size, alignment);
726 static void zend_mm_chunk_free(zend_mm_heap *heap, void *addr, size_t size) argument
729 if (UNEXPECTED(heap->storage)) {
730 heap->storage->handlers.chunk_free(heap->storage, addr, size);
737 static int zend_mm_chunk_truncate(zend_mm_heap *heap, void *addr, size_t old_size, size_t new_size) argument
740 if (UNEXPECTED(heap->storage)) {
741 if (heap->storage->handlers.chunk_truncate) {
742 return heap->storage->handlers.chunk_truncate(heap->storage, addr, old_size, new_size);
756 static int zend_mm_chunk_extend(zend_mm_heap *heap, void *addr, size_t old_size, size_t new_size) argument
759 if (UNEXPECTED(heap->storage)) {
760 if (heap->storage->handlers.chunk_extend) {
761 return heap->storage->handlers.chunk_extend(heap->storage, addr, old_size, new_size);
783 static zend_always_inline void zend_mm_chunk_init(zend_mm_heap *heap, zend_mm_chunk *chunk) argument
785 chunk->heap = heap;
786 chunk->next = heap->main_chunk;
787 chunk->prev = heap->main_chunk->prev;
804 static size_t zend_mm_get_huge_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE…
805 static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR…
806 static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D…
809 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_s…
811 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LIN…
819 static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count, size_t size ZEND_FILE_LI… argument
821 static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count ZEND_FILE_LINE_DC ZEND_FI…
824 zend_mm_chunk *chunk = heap->main_chunk;
943 if (chunk->next == heap->main_chunk) {
945 if (heap->cached_chunks) {
946 heap->cached_chunks_count--;
947 chunk = heap->cached_chunks;
948 heap->cached_chunks = chunk->next;
951 if (UNEXPECTED(ZEND_MM_CHUNK_SIZE > heap->limit - heap->real_size)) {
952 if (zend_mm_gc(heap)) {
954 } else if (heap->overflow == 0) {
956 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
958 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
964 chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE);
967 if (zend_mm_gc(heap) &&
968 …(chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE)) != NUL…
972 zend_mm_safe_error(heap, "Out of memory");
974 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) at %s:%d (tried to allocate %zu bytes)", h…
976 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) (tried to allocate %zu bytes)", heap->real…
983 size_t size = heap->real_size + ZEND_MM_CHUNK_SIZE;
984 size_t peak = MAX(heap->real_peak, size);
985 heap->real_size = size;
986 heap->real_peak = peak;
989 heap->real_size += ZEND_MM_CHUNK_SIZE;
993 heap->chunks_count++;
994 if (heap->chunks_count > heap->peak_chunks_count) {
995 heap->peak_chunks_count = heap->chunks_count;
997 zend_mm_chunk_init(heap, chunk);
1012 chunk->next = heap->main_chunk->next;
1013 chunk->prev = heap->main_chunk;
1027 static zend_always_inline void *zend_mm_alloc_large_ex(zend_mm_heap *heap, size_t size ZEND_FILE_LI… argument
1031 …void *ptr = zend_mm_alloc_pages(heap, pages_count, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORI…
1033 …void *ptr = zend_mm_alloc_pages(heap, pages_count ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELA…
1037 size_t size = heap->size + pages_count * ZEND_MM_PAGE_SIZE;
1038 size_t peak = MAX(heap->peak, size);
1039 heap->size = size;
1040 heap->peak = peak;
1047 static zend_never_inline void *zend_mm_alloc_large(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1049 return zend_mm_alloc_large_ex(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1052 static zend_never_inline void *zend_mm_alloc_large(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1054 return zend_mm_alloc_large_ex(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1058 static zend_always_inline void zend_mm_delete_chunk(zend_mm_heap *heap, zend_mm_chunk *chunk) argument
1062 heap->chunks_count--;
1063 if (heap->chunks_count + heap->cached_chunks_count < heap->avg_chunks_count + 0.1
1064 || (heap->chunks_count == heap->last_chunks_delete_boundary
1065 && heap->last_chunks_delete_count >= 4)) {
1067 heap->cached_chunks_count++;
1068 chunk->next = heap->cached_chunks;
1069 heap->cached_chunks = chunk;
1072 heap->real_size -= ZEND_MM_CHUNK_SIZE;
1074 if (!heap->cached_chunks) {
1075 if (heap->chunks_count != heap->last_chunks_delete_boundary) {
1076 heap->last_chunks_delete_boundary = heap->chunks_count;
1077 heap->last_chunks_delete_count = 0;
1079 heap->last_chunks_delete_count++;
1082 if (!heap->cached_chunks || chunk->num > heap->cached_chunks->num) {
1083 zend_mm_chunk_free(heap, chunk, ZEND_MM_CHUNK_SIZE);
1086 chunk->next = heap->cached_chunks->next;
1087 zend_mm_chunk_free(heap, heap->cached_chunks, ZEND_MM_CHUNK_SIZE);
1088 heap->cached_chunks = chunk;
1093 static zend_always_inline void zend_mm_free_pages_ex(zend_mm_heap *heap, zend_mm_chunk *chunk, uint… argument
1102 …if (free_chunk && chunk != heap->main_chunk && chunk->free_pages == ZEND_MM_PAGES - ZEND_MM_FIRST_…
1103 zend_mm_delete_chunk(heap, chunk);
1107 static zend_never_inline void zend_mm_free_pages(zend_mm_heap *heap, zend_mm_chunk *chunk, int page… argument
1109 zend_mm_free_pages_ex(heap, chunk, page_num, pages_count, 1);
1112 static zend_always_inline void zend_mm_free_large(zend_mm_heap *heap, zend_mm_chunk *chunk, int pag… argument
1115 heap->size -= pages_count * ZEND_MM_PAGE_SIZE;
1117 zend_mm_free_pages(heap, chunk, page_num, pages_count);
1186 static zend_never_inline void *zend_mm_alloc_small_slow(zend_mm_heap *heap, uint32_t bin_num ZEND_F… argument
1194 …bin = (zend_mm_bin*)zend_mm_alloc_pages(heap, bin_pages[bin_num], bin_data_size[bin_num] ZEND_FILE…
1196 …bin = (zend_mm_bin*)zend_mm_alloc_pages(heap, bin_pages[bin_num] ZEND_FILE_LINE_RELAY_CC ZEND_FILE…
1217 heap->free_slot[bin_num] = p = (zend_mm_free_slot*)((char*)bin + bin_data_size[bin_num]);
1242 static zend_always_inline void *zend_mm_alloc_small(zend_mm_heap *heap, int bin_num ZEND_FILE_LINE_… argument
1246 size_t size = heap->size + bin_data_size[bin_num];
1247 size_t peak = MAX(heap->peak, size);
1248 heap->size = size;
1249 heap->peak = peak;
1253 if (EXPECTED(heap->free_slot[bin_num] != NULL)) {
1254 zend_mm_free_slot *p = heap->free_slot[bin_num];
1255 heap->free_slot[bin_num] = p->next_free_slot;
1258 …return zend_mm_alloc_small_slow(heap, bin_num ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC…
1262 static zend_always_inline void zend_mm_free_small(zend_mm_heap *heap, void *ptr, int bin_num) argument
1267 heap->size -= bin_data_size[bin_num];
1278 p->next_free_slot = heap->free_slot[bin_num];
1279 heap->free_slot[bin_num] = p;
1287 static zend_always_inline zend_mm_debug_info *zend_mm_get_debug_info(zend_mm_heap *heap, void *ptr) argument
1298 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1310 static zend_always_inline void *zend_mm_alloc_heap(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1326 …ptr = zend_mm_alloc_small(heap, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_…
1328 dbg = zend_mm_get_debug_info(heap, ptr);
1337 ptr = zend_mm_alloc_large(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1339 dbg = zend_mm_get_debug_info(heap, ptr);
1351 return zend_mm_alloc_huge(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1355 static zend_always_inline void zend_mm_free_heap(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZE… argument
1361 zend_mm_free_huge(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1368 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1370 zend_mm_free_small(heap, ptr, ZEND_MM_SRUN_BIN_NUM(info));
1375 zend_mm_free_large(heap, chunk, page_num, pages_count);
1380 static size_t zend_mm_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) argument
1385 …return zend_mm_get_huge_block_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1389 zend_mm_debug_info *dbg = zend_mm_get_debug_info(heap, ptr);
1398 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1408 static zend_never_inline void *zend_mm_realloc_slow(zend_mm_heap *heap, void *ptr, size_t size, siz… argument
1414 size_t orig_peak = heap->peak;
1416 ret = zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1418 zend_mm_free_heap(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1420 heap->peak = MAX(orig_peak, heap->size);
1426 static zend_never_inline void *zend_mm_realloc_huge(zend_mm_heap *heap, void *ptr, size_t size, siz… argument
1434 …old_size = zend_mm_get_huge_block_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY…
1454 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1456 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1461 if (zend_mm_chunk_truncate(heap, ptr, old_size, new_size)) {
1463 heap->real_size -= old_size - new_size;
1466 heap->size -= old_size - new_size;
1469 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1471 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1477 if (UNEXPECTED(new_size - old_size > heap->limit - heap->real_size)) {
1478 if (zend_mm_gc(heap) && new_size - old_size <= heap->limit - heap->real_size) {
1480 } else if (heap->overflow == 0) {
1482 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1484 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1491 if (zend_mm_chunk_extend(heap, ptr, old_size, new_size)) {
1493 heap->real_size += new_size - old_size;
1496 heap->real_peak = MAX(heap->real_peak, heap->real_size);
1497 heap->size += new_size - old_size;
1498 heap->peak = MAX(heap->peak, heap->size);
1501 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1503 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1510 …return zend_mm_realloc_slow(heap, ptr, size, MIN(old_size, copy_size) ZEND_FILE_LINE_RELAY_CC ZEND…
1513 static zend_always_inline void *zend_mm_realloc_heap(zend_mm_heap *heap, void *ptr, size_t size, ze… argument
1526 return _zend_mm_alloc(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1528 …return zend_mm_realloc_huge(heap, ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG…
1540 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1552 …ret = zend_mm_alloc_small(heap, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_…
1555 zend_mm_free_small(heap, ptr, old_bin_num);
1565 size_t orig_peak = heap->peak;
1567 …ret = zend_mm_alloc_small(heap, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_…
1570 zend_mm_free_small(heap, ptr, old_bin_num);
1572 heap->peak = MAX(orig_peak, heap->size);
1581 dbg = zend_mm_get_debug_info(heap, ret);
1598 dbg = zend_mm_get_debug_info(heap, ptr);
1612 heap->size -= rest_pages_count * ZEND_MM_PAGE_SIZE;
1618 dbg = zend_mm_get_debug_info(heap, ptr);
1635 size_t size = heap->size + (new_size - old_size);
1636 size_t peak = MAX(heap->peak, size);
1637 heap->size = size;
1638 heap->peak = peak;
1645 dbg = zend_mm_get_debug_info(heap, ptr);
1663 …return zend_mm_realloc_slow(heap, ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG…
1671 static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_size ZEND… argument
1673 static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEN…
1676 …zend_mm_huge_list *list = (zend_mm_huge_list*)zend_mm_alloc_heap(heap, sizeof(zend_mm_huge_list) Z…
1679 list->next = heap->huge_list;
1687 heap->huge_list = list;
1690 static size_t zend_mm_del_huge_block(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE… argument
1693 zend_mm_huge_list *list = heap->huge_list;
1701 heap->huge_list = list->next;
1704 zend_mm_free_heap(heap, list ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1714 static size_t zend_mm_get_huge_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE… argument
1716 zend_mm_huge_list *list = heap->huge_list;
1728 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_s… argument
1730 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LIN…
1733 zend_mm_huge_list *list = heap->huge_list;
1750 static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR… argument
1769 if (UNEXPECTED(new_size > heap->limit - heap->real_size)) {
1770 if (zend_mm_gc(heap) && new_size <= heap->limit - heap->real_size) {
1772 } else if (heap->overflow == 0) {
1774 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1776 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1782 ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE);
1785 if (zend_mm_gc(heap) &&
1786 (ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE)) != NULL) {
1790 zend_mm_safe_error(heap, "Out of memory");
1792 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) at %s:%d (tried to allocate %zu bytes)", h…
1794 …zend_mm_safe_error(heap, "Out of memory (allocated %zu) (tried to allocate %zu bytes)", heap->real…
1800 …zend_mm_add_huge_block(heap, ptr, new_size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY…
1802 zend_mm_add_huge_block(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1806 size_t size = heap->real_size + new_size;
1807 size_t peak = MAX(heap->real_peak, size);
1808 heap->real_size = size;
1809 heap->real_peak = peak;
1812 size_t size = heap->size + new_size;
1813 size_t peak = MAX(heap->peak, size);
1814 heap->size = size;
1815 heap->peak = peak;
1818 heap->real_size += new_size;
1823 static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D… argument
1828 size = zend_mm_del_huge_block(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1829 zend_mm_chunk_free(heap, ptr, size);
1831 heap->real_size -= size;
1834 heap->size -= size;
1845 zend_mm_heap *heap; local
1857 heap = &chunk->heap_slot;
1858 chunk->heap = heap;
1866 heap->main_chunk = chunk;
1867 heap->cached_chunks = NULL;
1868 heap->chunks_count = 1;
1869 heap->peak_chunks_count = 1;
1870 heap->cached_chunks_count = 0;
1871 heap->avg_chunks_count = 1.0;
1872 heap->last_chunks_delete_boundary = 0;
1873 heap->last_chunks_delete_count = 0;
1875 heap->real_size = ZEND_MM_CHUNK_SIZE;
1878 heap->real_peak = ZEND_MM_CHUNK_SIZE;
1879 heap->size = 0;
1880 heap->peak = 0;
1883 heap->limit = ((size_t)Z_L(-1) >> (size_t)Z_L(1));
1884 heap->overflow = 0;
1887 heap->use_custom_heap = ZEND_MM_CUSTOM_HEAP_NONE;
1890 heap->storage = NULL;
1892 heap->huge_list = NULL;
1893 return heap;
1896 ZEND_API size_t zend_mm_gc(zend_mm_heap *heap) argument
1908 if (heap->use_custom_heap) {
1915 p = heap->free_slot[i];
1918 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1943 q = &heap->free_slot[i];
1947 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1971 chunk = heap->main_chunk;
1983 zend_mm_free_pages_ex(heap, chunk, i, pages_count, 0);
2000 zend_mm_delete_chunk(heap, chunk);
2005 } while (chunk != heap->main_chunk);
2042 static zend_long zend_mm_find_leaks(zend_mm_heap *heap, zend_mm_chunk *p, uint32_t i, zend_leak_inf… argument
2069 } while (p != heap->main_chunk);
2073 static zend_long zend_mm_find_leaks_huge(zend_mm_heap *heap, zend_mm_huge_list *list) argument
2082 zend_mm_chunk_free(heap, p->ptr, p->size);
2083 zend_mm_free_heap(heap, p, NULL, 0, NULL, 0);
2094 static void zend_mm_check_leaks(zend_mm_heap *heap) argument
2104 list = heap->huge_list;
2117 repeated = zend_mm_find_leaks_huge(heap, list);
2123 heap->huge_list = list = list->next;
2124 zend_mm_chunk_free(heap, q->ptr, q->size);
2125 zend_mm_free_heap(heap, q, NULL, 0, NULL, 0);
2129 p = heap->main_chunk;
2156 zend_mm_find_leaks(heap, p, i + bin_pages[bin_num], &leak);
2182 repeated = zend_mm_find_leaks(heap, p, i + pages_count, &leak);
2194 } while (p != heap->main_chunk);
2206 void zend_mm_shutdown(zend_mm_heap *heap, bool full, bool silent) argument
2212 if (heap->use_custom_heap) {
2213 if (heap->custom_heap.std._malloc == tracked_malloc) {
2217 zend_hash_clean(heap->tracked_allocs);
2219 zend_hash_destroy(heap->tracked_allocs);
2220 free(heap->tracked_allocs);
2222 heap->custom_heap.std._free = free;
2224 heap->size = 0;
2228 if (ZEND_DEBUG && heap->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
2229 heap->custom_heap.debug._free(heap ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
2231 heap->custom_heap.std._free(heap);
2240 zend_mm_check_leaks(heap);
2245 list = heap->huge_list;
2246 heap->huge_list = NULL;
2250 zend_mm_chunk_free(heap, q->ptr, q->size);
2254 p = heap->main_chunk->next;
2255 while (p != heap->main_chunk) {
2257 p->next = heap->cached_chunks;
2258 heap->cached_chunks = p;
2260 heap->chunks_count--;
2261 heap->cached_chunks_count++;
2266 while (heap->cached_chunks) {
2267 p = heap->cached_chunks;
2268 heap->cached_chunks = p->next;
2269 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2272 zend_mm_chunk_free(heap, heap->main_chunk, ZEND_MM_CHUNK_SIZE);
2275 heap->avg_chunks_count = (heap->avg_chunks_count + (double)heap->peak_chunks_count) / 2.0;
2276 while ((double)heap->cached_chunks_count + 0.9 > heap->avg_chunks_count &&
2277 heap->cached_chunks) {
2278 p = heap->cached_chunks;
2279 heap->cached_chunks = p->next;
2280 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2281 heap->cached_chunks_count--;
2284 p = heap->cached_chunks;
2293 p = heap->main_chunk;
2294 p->heap = &p->heap_slot;
2302 heap->size = heap->peak = 0;
2304 memset(heap->free_slot, 0, sizeof(heap->free_slot));
2306 heap->real_size = (heap->cached_chunks_count + 1) * ZEND_MM_CHUNK_SIZE;
2309 heap->real_peak = (heap->cached_chunks_count + 1) * ZEND_MM_CHUNK_SIZE;
2311 heap->chunks_count = 1;
2312 heap->peak_chunks_count = 1;
2313 heap->last_chunks_delete_boundary = 0;
2314 heap->last_chunks_delete_count = 0;
2326 ZEND_API void* ZEND_FASTCALL _zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_… argument
2328 return zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2331 ZEND_API void ZEND_FASTCALL _zend_mm_free(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE… argument
2333 zend_mm_free_heap(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2336 void* ZEND_FASTCALL _zend_mm_realloc(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC Z… argument
2338 …return zend_mm_realloc_heap(heap, ptr, size, 0, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_R…
2341 void* ZEND_FASTCALL _zend_mm_realloc2(zend_mm_heap *heap, void *ptr, size_t size, size_t copy_size … argument
2343 …return zend_mm_realloc_heap(heap, ptr, size, 1, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_O…
2346 ZEND_API size_t ZEND_FASTCALL _zend_mm_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC Z… argument
2348 return zend_mm_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2489 ZEND_MM_CHECK(chunk->heap == AG(mm_heap), "zend_mm_heap corrupted"); \
2501 ZEND_MM_CHECK(chunk->heap == AG(mm_heap), "zend_mm_heap corrupted"); \
2518 …ZEND_MM_CHECK(chunk->heap == AG(mm_heap) && ZEND_MM_ALIGNED_OFFSET(page_offset, ZEND_MM_PAGE_SIZE)…
2663 zend_mm_heap *heap = AG(mm_heap); local
2668 if (UNEXPECTED(memory_limit < heap->real_size)) {
2669 if (memory_limit >= heap->real_size - heap->cached_chunks_count * ZEND_MM_CHUNK_SIZE) {
2672 zend_mm_chunk *p = heap->cached_chunks;
2673 heap->cached_chunks = p->next;
2674 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2675 heap->cached_chunks_count--;
2676 heap->real_size -= ZEND_MM_CHUNK_SIZE;
2677 } while (memory_limit < heap->real_size);
2725 static zend_always_inline void tracked_add(zend_mm_heap *heap, void *ptr, size_t size) { argument
2730 zend_hash_index_add_new(heap->tracked_allocs, h, &size_zv);
2733 static zend_always_inline zval *tracked_get_size_zv(zend_mm_heap *heap, void *ptr) { argument
2735 zval *size_zv = zend_hash_index_find(heap->tracked_allocs, h);
2740 static zend_always_inline void tracked_check_limit(zend_mm_heap *heap, size_t add_size) { argument
2741 if (add_size > heap->limit - heap->size && !heap->overflow) {
2743 zend_mm_safe_error(heap,
2745 heap->limit, "file", 0, add_size);
2747 zend_mm_safe_error(heap,
2749 heap->limit, add_size);
2756 zend_mm_heap *heap = AG(mm_heap); local
2757 tracked_check_limit(heap, size);
2760 tracked_add(heap, ptr, size);
2761 heap->size += size;
2770 zend_mm_heap *heap = AG(mm_heap); local
2771 zval *size_zv = tracked_get_size_zv(heap, ptr);
2772 heap->size -= Z_LVAL_P(size_zv);
2773 zend_hash_del_bucket(heap->tracked_allocs, (Bucket *) size_zv);
2778 zend_mm_heap *heap = AG(mm_heap); local
2782 old_size_zv = tracked_get_size_zv(heap, ptr);
2787 tracked_check_limit(heap, new_size - old_size);
2792 zend_hash_del_bucket(heap->tracked_allocs, (Bucket *) old_size_zv);
2796 tracked_add(heap, ptr, new_size);
2797 heap->size += new_size - old_size;
2895 ZEND_API void zend_mm_set_custom_handlers(zend_mm_heap *heap, argument
2901 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2914 ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap, argument
2920 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2922 if (heap->use_custom_heap) {
2939 ZEND_API void zend_mm_set_custom_debug_handlers(zend_mm_heap *heap, argument
2945 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2955 ZEND_API zend_mm_storage *zend_mm_get_storage(zend_mm_heap *heap) argument
2958 return heap->storage;
2974 zend_mm_heap *heap; local
2989 heap = &chunk->heap_slot;
2990 chunk->heap = heap;
2998 heap->main_chunk = chunk;
2999 heap->cached_chunks = NULL;
3000 heap->chunks_count = 1;
3001 heap->peak_chunks_count = 1;
3002 heap->cached_chunks_count = 0;
3003 heap->avg_chunks_count = 1.0;
3004 heap->last_chunks_delete_boundary = 0;
3005 heap->last_chunks_delete_count = 0;
3007 heap->real_size = ZEND_MM_CHUNK_SIZE;
3010 heap->real_peak = ZEND_MM_CHUNK_SIZE;
3011 heap->size = 0;
3012 heap->peak = 0;
3015 heap->limit = (Z_L(-1) >> Z_L(1));
3016 heap->overflow = 0;
3019 heap->use_custom_heap = 0;
3021 heap->storage = &tmp_storage;
3022 heap->huge_list = NULL;
3023 memset(heap->free_slot, 0, sizeof(heap->free_slot));
3024 …storage = _zend_mm_alloc(heap, sizeof(zend_mm_storage) + data_size ZEND_FILE_LINE_CC ZEND_FILE_LIN…
3041 heap->storage = storage;
3042 return heap;
