Lines Matching refs:heap
285 zend_mm_heap *heap; member
371 static ZEND_COLD ZEND_NORETURN void zend_mm_safe_error(zend_mm_heap *heap, in zend_mm_safe_error() argument
381 heap->overflow = 1; in zend_mm_safe_error()
393 heap->overflow = 0; in zend_mm_safe_error()
772 static void *zend_mm_chunk_alloc(zend_mm_heap *heap, size_t size, size_t alignment) argument
775 if (UNEXPECTED(heap->storage)) {
776 void *ptr = heap->storage->handlers.chunk_alloc(heap->storage, size, alignment);
784 static void zend_mm_chunk_free(zend_mm_heap *heap, void *addr, size_t size) argument
787 if (UNEXPECTED(heap->storage)) {
788 heap->storage->handlers.chunk_free(heap->storage, addr, size);
795 static int zend_mm_chunk_truncate(zend_mm_heap *heap, void *addr, size_t old_size, size_t new_size) argument
798 if (UNEXPECTED(heap->storage)) {
799 if (heap->storage->handlers.chunk_truncate) {
800 return heap->storage->handlers.chunk_truncate(heap->storage, addr, old_size, new_size);
814 static int zend_mm_chunk_extend(zend_mm_heap *heap, void *addr, size_t old_size, size_t new_size) argument
817 if (UNEXPECTED(heap->storage)) {
818 if (heap->storage->handlers.chunk_extend) {
819 return heap->storage->handlers.chunk_extend(heap->storage, addr, old_size, new_size);
841 static zend_always_inline void zend_mm_chunk_init(zend_mm_heap *heap, zend_mm_chunk *chunk) argument
843 chunk->heap = heap;
844 chunk->next = heap->main_chunk;
845 chunk->prev = heap->main_chunk->prev;
862 static size_t zend_mm_get_huge_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE…
863 static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR…
864 static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D…
867 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_s…
869 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LIN…
877 static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count, size_t size ZEND_FILE_LI… argument
879 static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count ZEND_FILE_LINE_DC ZEND_FI…
882 zend_mm_chunk *chunk = heap->main_chunk;
1001 if (chunk->next == heap->main_chunk) {
1003 if (heap->cached_chunks) {
1004 heap->cached_chunks_count--;
1005 chunk = heap->cached_chunks;
1006 heap->cached_chunks = chunk->next;
1009 if (UNEXPECTED(ZEND_MM_CHUNK_SIZE > heap->limit - heap->real_size)) {
1010 if (zend_mm_gc(heap)) {
1012 } else if (heap->overflow == 0) {
1014 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1016 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1022 chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE);
1025 if (zend_mm_gc(heap) &&
1026 …(chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE)) != NUL…
1030 zend_mm_safe_error(heap, "Out of memory");
1032 …zend_mm_safe_error(heap, "Out of memory (allocated %zu bytes) at %s:%d (tried to allocate %zu byte…
1034 …zend_mm_safe_error(heap, "Out of memory (allocated %zu bytes) (tried to allocate %zu bytes)", heap…
1041 size_t size = heap->real_size + ZEND_MM_CHUNK_SIZE;
1042 size_t peak = MAX(heap->real_peak, size);
1043 heap->real_size = size;
1044 heap->real_peak = peak;
1047 heap->real_size += ZEND_MM_CHUNK_SIZE;
1051 heap->chunks_count++;
1052 if (heap->chunks_count > heap->peak_chunks_count) {
1053 heap->peak_chunks_count = heap->chunks_count;
1055 zend_mm_chunk_init(heap, chunk);
1070 chunk->next = heap->main_chunk->next;
1071 chunk->prev = heap->main_chunk;
1085 static zend_always_inline void *zend_mm_alloc_large_ex(zend_mm_heap *heap, size_t size ZEND_FILE_LI… argument
1089 …void *ptr = zend_mm_alloc_pages(heap, pages_count, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORI…
1091 …void *ptr = zend_mm_alloc_pages(heap, pages_count ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELA…
1095 size_t size = heap->size + pages_count * ZEND_MM_PAGE_SIZE;
1096 size_t peak = MAX(heap->peak, size);
1097 heap->size = size;
1098 heap->peak = peak;
1105 static zend_never_inline void *zend_mm_alloc_large(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1107 return zend_mm_alloc_large_ex(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1110 static zend_never_inline void *zend_mm_alloc_large(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1112 return zend_mm_alloc_large_ex(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1116 static zend_always_inline void zend_mm_delete_chunk(zend_mm_heap *heap, zend_mm_chunk *chunk) argument
1120 heap->chunks_count--;
1121 if (heap->chunks_count + heap->cached_chunks_count < heap->avg_chunks_count + 0.1
1122 || (heap->chunks_count == heap->last_chunks_delete_boundary
1123 && heap->last_chunks_delete_count >= 4)) {
1125 heap->cached_chunks_count++;
1126 chunk->next = heap->cached_chunks;
1127 heap->cached_chunks = chunk;
1130 heap->real_size -= ZEND_MM_CHUNK_SIZE;
1132 if (!heap->cached_chunks) {
1133 if (heap->chunks_count != heap->last_chunks_delete_boundary) {
1134 heap->last_chunks_delete_boundary = heap->chunks_count;
1135 heap->last_chunks_delete_count = 0;
1137 heap->last_chunks_delete_count++;
1140 if (!heap->cached_chunks || chunk->num > heap->cached_chunks->num) {
1141 zend_mm_chunk_free(heap, chunk, ZEND_MM_CHUNK_SIZE);
1144 chunk->next = heap->cached_chunks->next;
1145 zend_mm_chunk_free(heap, heap->cached_chunks, ZEND_MM_CHUNK_SIZE);
1146 heap->cached_chunks = chunk;
1151 static zend_always_inline void zend_mm_free_pages_ex(zend_mm_heap *heap, zend_mm_chunk *chunk, uint… argument
1160 …if (free_chunk && chunk != heap->main_chunk && chunk->free_pages == ZEND_MM_PAGES - ZEND_MM_FIRST_…
1161 zend_mm_delete_chunk(heap, chunk);
1165 static zend_never_inline void zend_mm_free_pages(zend_mm_heap *heap, zend_mm_chunk *chunk, int page… argument
1167 zend_mm_free_pages_ex(heap, chunk, page_num, pages_count, 1);
1170 static zend_always_inline void zend_mm_free_large(zend_mm_heap *heap, zend_mm_chunk *chunk, int pag… argument
1173 heap->size -= pages_count * ZEND_MM_PAGE_SIZE;
1175 zend_mm_free_pages(heap, chunk, page_num, pages_count);
1244 static zend_never_inline void *zend_mm_alloc_small_slow(zend_mm_heap *heap, uint32_t bin_num ZEND_F… argument
1252 …bin = (zend_mm_bin*)zend_mm_alloc_pages(heap, bin_pages[bin_num], bin_data_size[bin_num] ZEND_FILE…
1254 …bin = (zend_mm_bin*)zend_mm_alloc_pages(heap, bin_pages[bin_num] ZEND_FILE_LINE_RELAY_CC ZEND_FILE…
1275 heap->free_slot[bin_num] = p = (zend_mm_free_slot*)((char*)bin + bin_data_size[bin_num]);
1300 static zend_always_inline void *zend_mm_alloc_small(zend_mm_heap *heap, int bin_num ZEND_FILE_LINE_… argument
1304 size_t size = heap->size + bin_data_size[bin_num];
1305 size_t peak = MAX(heap->peak, size);
1306 heap->size = size;
1307 heap->peak = peak;
1311 if (EXPECTED(heap->free_slot[bin_num] != NULL)) {
1312 zend_mm_free_slot *p = heap->free_slot[bin_num];
1313 heap->free_slot[bin_num] = p->next_free_slot;
1316 …return zend_mm_alloc_small_slow(heap, bin_num ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC…
1320 static zend_always_inline void zend_mm_free_small(zend_mm_heap *heap, void *ptr, int bin_num) argument
1325 heap->size -= bin_data_size[bin_num];
1336 p->next_free_slot = heap->free_slot[bin_num];
1337 heap->free_slot[bin_num] = p;
1345 static zend_always_inline zend_mm_debug_info *zend_mm_get_debug_info(zend_mm_heap *heap, void *ptr) argument
1356 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1368 static zend_always_inline void *zend_mm_alloc_heap(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D… argument
1384 …ptr = zend_mm_alloc_small(heap, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_…
1386 dbg = zend_mm_get_debug_info(heap, ptr);
1395 ptr = zend_mm_alloc_large(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1397 dbg = zend_mm_get_debug_info(heap, ptr);
1409 return zend_mm_alloc_huge(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1413 static zend_always_inline void zend_mm_free_heap(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZE… argument
1419 zend_mm_free_huge(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1426 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1428 zend_mm_free_small(heap, ptr, ZEND_MM_SRUN_BIN_NUM(info));
1433 zend_mm_free_large(heap, chunk, page_num, pages_count);
1438 static size_t zend_mm_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) argument
1443 …return zend_mm_get_huge_block_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1447 zend_mm_debug_info *dbg = zend_mm_get_debug_info(heap, ptr);
1456 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1466 static zend_never_inline void *zend_mm_realloc_slow(zend_mm_heap *heap, void *ptr, size_t size, siz… argument
1472 size_t orig_peak = heap->peak;
1474 ret = zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1476 zend_mm_free_heap(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1478 heap->peak = MAX(orig_peak, heap->size);
1484 static zend_never_inline void *zend_mm_realloc_huge(zend_mm_heap *heap, void *ptr, size_t size, siz… argument
1492 …old_size = zend_mm_get_huge_block_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY…
1512 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1514 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1519 if (zend_mm_chunk_truncate(heap, ptr, old_size, new_size)) {
1521 heap->real_size -= old_size - new_size;
1524 heap->size -= old_size - new_size;
1527 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1529 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1535 if (UNEXPECTED(new_size - old_size > heap->limit - heap->real_size)) {
1536 if (zend_mm_gc(heap) && new_size - old_size <= heap->limit - heap->real_size) {
1538 } else if (heap->overflow == 0) {
1540 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1542 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1549 if (zend_mm_chunk_extend(heap, ptr, old_size, new_size)) {
1551 heap->real_size += new_size - old_size;
1554 heap->real_peak = MAX(heap->real_peak, heap->real_size);
1555 heap->size += new_size - old_size;
1556 heap->peak = MAX(heap->peak, heap->size);
1559 …zend_mm_change_huge_block_size(heap, ptr, new_size, real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LI…
1561 …zend_mm_change_huge_block_size(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_REL…
1568 …return zend_mm_realloc_slow(heap, ptr, size, MIN(old_size, copy_size) ZEND_FILE_LINE_RELAY_CC ZEND…
1571 static zend_always_inline void *zend_mm_realloc_heap(zend_mm_heap *heap, void *ptr, size_t size, bo… argument
1584 return _zend_mm_alloc(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1586 …return zend_mm_realloc_huge(heap, ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG…
1598 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1610 …ret = zend_mm_alloc_small(heap, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_…
1613 zend_mm_free_small(heap, ptr, old_bin_num);
1623 size_t orig_peak = heap->peak;
1625 …ret = zend_mm_alloc_small(heap, ZEND_MM_SMALL_SIZE_TO_BIN(size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_…
1628 zend_mm_free_small(heap, ptr, old_bin_num);
1630 heap->peak = MAX(orig_peak, heap->size);
1639 dbg = zend_mm_get_debug_info(heap, ret);
1656 dbg = zend_mm_get_debug_info(heap, ptr);
1670 heap->size -= rest_pages_count * ZEND_MM_PAGE_SIZE;
1676 dbg = zend_mm_get_debug_info(heap, ptr);
1693 size_t size = heap->size + (new_size - old_size);
1694 size_t peak = MAX(heap->peak, size);
1695 heap->size = size;
1696 heap->peak = peak;
1703 dbg = zend_mm_get_debug_info(heap, ptr);
1721 …return zend_mm_realloc_slow(heap, ptr, size, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG…
1729 static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_size ZEND… argument
1731 static void zend_mm_add_huge_block(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC ZEN…
1734 …zend_mm_huge_list *list = (zend_mm_huge_list*)zend_mm_alloc_heap(heap, sizeof(zend_mm_huge_list) Z…
1737 list->next = heap->huge_list;
1745 heap->huge_list = list;
1748 static size_t zend_mm_del_huge_block(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE… argument
1751 zend_mm_huge_list *list = heap->huge_list;
1759 heap->huge_list = list->next;
1762 zend_mm_free_heap(heap, list ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1772 static size_t zend_mm_get_huge_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE… argument
1774 zend_mm_huge_list *list = heap->huge_list;
1786 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size, size_t dbg_s… argument
1788 static void zend_mm_change_huge_block_size(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LIN…
1791 zend_mm_huge_list *list = heap->huge_list;
1808 static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR… argument
1827 if (UNEXPECTED(new_size > heap->limit - heap->real_size)) {
1828 if (zend_mm_gc(heap) && new_size <= heap->limit - heap->real_size) {
1830 } else if (heap->overflow == 0) {
1832 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %…
1834 …zend_mm_safe_error(heap, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)…
1840 ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE);
1843 if (zend_mm_gc(heap) &&
1844 (ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE)) != NULL) {
1848 zend_mm_safe_error(heap, "Out of memory");
1850 …zend_mm_safe_error(heap, "Out of memory (allocated %zu bytes) at %s:%d (tried to allocate %zu byte…
1852 …zend_mm_safe_error(heap, "Out of memory (allocated %zu bytes) (tried to allocate %zu bytes)", heap…
1858 …zend_mm_add_huge_block(heap, ptr, new_size, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY…
1860 zend_mm_add_huge_block(heap, ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1864 size_t size = heap->real_size + new_size;
1865 size_t peak = MAX(heap->real_peak, size);
1866 heap->real_size = size;
1867 heap->real_peak = peak;
1870 size_t size = heap->size + new_size;
1871 size_t peak = MAX(heap->peak, size);
1872 heap->size = size;
1873 heap->peak = peak;
1876 heap->real_size += new_size;
1881 static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D… argument
1886 size = zend_mm_del_huge_block(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
1887 zend_mm_chunk_free(heap, ptr, size);
1889 heap->real_size -= size;
1892 heap->size -= size;
1903 zend_mm_heap *heap; local
1911 heap = &chunk->heap_slot;
1912 chunk->heap = heap;
1920 heap->main_chunk = chunk;
1921 heap->cached_chunks = NULL;
1922 heap->chunks_count = 1;
1923 heap->peak_chunks_count = 1;
1924 heap->cached_chunks_count = 0;
1925 heap->avg_chunks_count = 1.0;
1926 heap->last_chunks_delete_boundary = 0;
1927 heap->last_chunks_delete_count = 0;
1929 heap->real_size = ZEND_MM_CHUNK_SIZE;
1932 heap->real_peak = ZEND_MM_CHUNK_SIZE;
1933 heap->size = 0;
1934 heap->peak = 0;
1937 heap->limit = (size_t)Z_L(-1) >> 1;
1938 heap->overflow = 0;
1941 heap->use_custom_heap = ZEND_MM_CUSTOM_HEAP_NONE;
1944 heap->storage = NULL;
1946 heap->huge_list = NULL;
1947 return heap;
1950 ZEND_API size_t zend_mm_gc(zend_mm_heap *heap) argument
1962 if (heap->use_custom_heap) {
1969 p = heap->free_slot[i];
1972 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
1997 q = &heap->free_slot[i];
2001 ZEND_MM_CHECK(chunk->heap == heap, "zend_mm_heap corrupted");
2025 chunk = heap->main_chunk;
2037 zend_mm_free_pages_ex(heap, chunk, i, pages_count, 0);
2054 zend_mm_delete_chunk(heap, chunk);
2059 } while (chunk != heap->main_chunk);
2096 static zend_long zend_mm_find_leaks(zend_mm_heap *heap, zend_mm_chunk *p, uint32_t i, zend_leak_inf… argument
2123 } while (p != heap->main_chunk);
2127 static zend_long zend_mm_find_leaks_huge(zend_mm_heap *heap, zend_mm_huge_list *list) argument
2136 zend_mm_chunk_free(heap, p->ptr, p->size);
2137 zend_mm_free_heap(heap, p, NULL, 0, NULL, 0);
2148 static void zend_mm_check_leaks(zend_mm_heap *heap) argument
2158 list = heap->huge_list;
2171 repeated = zend_mm_find_leaks_huge(heap, list);
2177 heap->huge_list = list = list->next;
2178 zend_mm_chunk_free(heap, q->ptr, q->size);
2179 zend_mm_free_heap(heap, q, NULL, 0, NULL, 0);
2183 p = heap->main_chunk;
2210 zend_mm_find_leaks(heap, p, i + bin_pages[bin_num], &leak);
2236 repeated = zend_mm_find_leaks(heap, p, i + pages_count, &leak);
2248 } while (p != heap->main_chunk);
2260 void zend_mm_shutdown(zend_mm_heap *heap, bool full, bool silent) argument
2266 if (heap->use_custom_heap) {
2267 if (heap->custom_heap.std._malloc == tracked_malloc) {
2271 zend_hash_clean(heap->tracked_allocs);
2273 zend_hash_destroy(heap->tracked_allocs);
2274 free(heap->tracked_allocs);
2276 heap->custom_heap.std._free = free;
2278 heap->size = 0;
2282 if (ZEND_DEBUG && heap->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
2283 heap->custom_heap.debug._free(heap ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
2285 heap->custom_heap.std._free(heap);
2294 zend_mm_check_leaks(heap);
2299 list = heap->huge_list;
2300 heap->huge_list = NULL;
2304 zend_mm_chunk_free(heap, q->ptr, q->size);
2308 p = heap->main_chunk->next;
2309 while (p != heap->main_chunk) {
2311 p->next = heap->cached_chunks;
2312 heap->cached_chunks = p;
2314 heap->chunks_count--;
2315 heap->cached_chunks_count++;
2320 while (heap->cached_chunks) {
2321 p = heap->cached_chunks;
2322 heap->cached_chunks = p->next;
2323 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2326 zend_mm_chunk_free(heap, heap->main_chunk, ZEND_MM_CHUNK_SIZE);
2329 heap->avg_chunks_count = (heap->avg_chunks_count + (double)heap->peak_chunks_count) / 2.0;
2330 while ((double)heap->cached_chunks_count + 0.9 > heap->avg_chunks_count &&
2331 heap->cached_chunks) {
2332 p = heap->cached_chunks;
2333 heap->cached_chunks = p->next;
2334 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2335 heap->cached_chunks_count--;
2338 p = heap->cached_chunks;
2347 p = heap->main_chunk;
2348 p->heap = &p->heap_slot;
2356 heap->size = heap->peak = 0;
2358 memset(heap->free_slot, 0, sizeof(heap->free_slot));
2360 heap->real_size = (heap->cached_chunks_count + 1) * ZEND_MM_CHUNK_SIZE;
2363 heap->real_peak = (heap->cached_chunks_count + 1) * ZEND_MM_CHUNK_SIZE;
2365 heap->chunks_count = 1;
2366 heap->peak_chunks_count = 1;
2367 heap->last_chunks_delete_boundary = 0;
2368 heap->last_chunks_delete_count = 0;
2380 ZEND_API void* ZEND_FASTCALL _zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_… argument
2382 return zend_mm_alloc_heap(heap, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2385 ZEND_API void ZEND_FASTCALL _zend_mm_free(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZEND_FILE… argument
2387 zend_mm_free_heap(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2390 void* ZEND_FASTCALL _zend_mm_realloc(zend_mm_heap *heap, void *ptr, size_t size ZEND_FILE_LINE_DC Z… argument
2392 …return zend_mm_realloc_heap(heap, ptr, size, 0, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_R…
2395 void* ZEND_FASTCALL _zend_mm_realloc2(zend_mm_heap *heap, void *ptr, size_t size, size_t copy_size … argument
2397 …return zend_mm_realloc_heap(heap, ptr, size, 1, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_O…
2400 ZEND_API size_t ZEND_FASTCALL _zend_mm_block_size(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC Z… argument
2402 return zend_mm_size(heap, ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
2548 ZEND_MM_CHECK(chunk->heap == AG(mm_heap), "zend_mm_heap corrupted"); \
2560 ZEND_MM_CHECK(chunk->heap == AG(mm_heap), "zend_mm_heap corrupted"); \
2577 …ZEND_MM_CHECK(chunk->heap == AG(mm_heap) && ZEND_MM_ALIGNED_OFFSET(page_offset, ZEND_MM_PAGE_SIZE)…
2723 zend_mm_heap *heap = AG(mm_heap); local
2725 if (UNEXPECTED(memory_limit < heap->real_size)) {
2726 if (memory_limit >= heap->real_size - heap->cached_chunks_count * ZEND_MM_CHUNK_SIZE) {
2729 zend_mm_chunk *p = heap->cached_chunks;
2730 heap->cached_chunks = p->next;
2731 zend_mm_chunk_free(heap, p, ZEND_MM_CHUNK_SIZE);
2732 heap->cached_chunks_count--;
2733 heap->real_size -= ZEND_MM_CHUNK_SIZE;
2734 } while (memory_limit < heap->real_size);
2798 static zend_always_inline void tracked_add(zend_mm_heap *heap, void *ptr, size_t size) { argument
2803 zend_hash_index_add_new(heap->tracked_allocs, h, &size_zv);
2806 static zend_always_inline zval *tracked_get_size_zv(zend_mm_heap *heap, void *ptr) { argument
2808 zval *size_zv = zend_hash_index_find(heap->tracked_allocs, h);
2813 static zend_always_inline void tracked_check_limit(zend_mm_heap *heap, size_t add_size) { argument
2814 if (add_size > heap->limit - heap->size && !heap->overflow) {
2816 zend_mm_safe_error(heap,
2818 heap->limit, "file", 0, add_size);
2820 zend_mm_safe_error(heap,
2822 heap->limit, add_size);
2829 zend_mm_heap *heap = AG(mm_heap); local
2830 tracked_check_limit(heap, size);
2837 tracked_add(heap, ptr, size);
2838 heap->size += size;
2847 zend_mm_heap *heap = AG(mm_heap); local
2848 zval *size_zv = tracked_get_size_zv(heap, ptr);
2849 heap->size -= Z_LVAL_P(size_zv);
2850 zend_hash_del_bucket(heap->tracked_allocs, (Bucket *) size_zv);
2855 zend_mm_heap *heap = AG(mm_heap); local
2859 old_size_zv = tracked_get_size_zv(heap, ptr);
2864 tracked_check_limit(heap, new_size - old_size);
2869 zend_hash_del_bucket(heap->tracked_allocs, (Bucket *) old_size_zv);
2873 tracked_add(heap, ptr, new_size);
2874 heap->size += new_size - old_size;
2972 ZEND_API void zend_mm_set_custom_handlers(zend_mm_heap *heap, argument
2978 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2991 ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap, argument
2997 zend_mm_heap *_heap = (zend_mm_heap*)heap;
2999 if (heap->use_custom_heap) {
3016 ZEND_API void zend_mm_set_custom_debug_handlers(zend_mm_heap *heap, argument
3022 zend_mm_heap *_heap = (zend_mm_heap*)heap;
3032 ZEND_API zend_mm_storage *zend_mm_get_storage(zend_mm_heap *heap) argument
3035 return heap->storage;
3051 zend_mm_heap *heap; local
3062 heap = &chunk->heap_slot;
3063 chunk->heap = heap;
3071 heap->main_chunk = chunk;
3072 heap->cached_chunks = NULL;
3073 heap->chunks_count = 1;
3074 heap->peak_chunks_count = 1;
3075 heap->cached_chunks_count = 0;
3076 heap->avg_chunks_count = 1.0;
3077 heap->last_chunks_delete_boundary = 0;
3078 heap->last_chunks_delete_count = 0;
3080 heap->real_size = ZEND_MM_CHUNK_SIZE;
3083 heap->real_peak = ZEND_MM_CHUNK_SIZE;
3084 heap->size = 0;
3085 heap->peak = 0;
3088 heap->limit = (size_t)Z_L(-1) >> 1;
3089 heap->overflow = 0;
3092 heap->use_custom_heap = 0;
3094 heap->storage = &tmp_storage;
3095 heap->huge_list = NULL;
3096 memset(heap->free_slot, 0, sizeof(heap->free_slot));
3097 …storage = _zend_mm_alloc(heap, sizeof(zend_mm_storage) + data_size ZEND_FILE_LINE_CC ZEND_FILE_LIN…
3110 heap->storage = storage;
3111 return heap;
