2014-05-03 18:27:38 -04:00
|
|
|
/*
|
2017-06-30 03:22:17 -04:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 18:27:38 -04:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
2019-05-14 08:51:57 -04:00
|
|
|
* Copyright (c) 2014 Paul Sokolovsky
|
2014-05-03 18:27:38 -04:00
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2014-04-20 04:45:16 -04:00
|
|
|
#include <assert.h>
|
2013-10-21 18:45:08 -04:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2015-01-01 15:27:54 -05:00
|
|
|
#include "py/gc.h"
|
|
|
|
#include "py/runtime.h"
|
2014-04-03 17:55:12 -04:00
|
|
|
|
2021-08-27 10:02:03 -04:00
|
|
|
#if MICROPY_DEBUG_VALGRIND
|
|
|
|
#include <valgrind/memcheck.h>
|
|
|
|
#endif
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2019-03-08 18:29:14 -05:00
|
|
|
#include "supervisor/shared/safe_mode.h"
|
|
|
|
|
2020-07-15 20:58:38 -04:00
|
|
|
#if CIRCUITPY_MEMORYMONITOR
|
2020-07-16 22:01:43 -04:00
|
|
|
#include "shared-module/memorymonitor/__init__.h"
|
2020-07-15 20:58:38 -04:00
|
|
|
#endif
|
|
|
|
|
2014-01-07 10:20:33 -05:00
|
|
|
#if MICROPY_ENABLE_GC
|
|
|
|
|
2017-07-24 12:55:14 -04:00
|
|
|
#if MICROPY_DEBUG_VERBOSE // print debugging info
|
2014-02-10 14:45:54 -05:00
|
|
|
#define DEBUG_PRINT (1)
|
2014-02-16 11:11:42 -05:00
|
|
|
#define DEBUG_printf DEBUG_printf
|
2014-02-10 14:45:54 -05:00
|
|
|
#else // don't print debugging info
|
2014-11-05 16:16:41 -05:00
|
|
|
#define DEBUG_PRINT (0)
|
2014-02-26 17:40:35 -05:00
|
|
|
#define DEBUG_printf(...) (void)0
|
2014-02-10 14:45:54 -05:00
|
|
|
#endif
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2018-01-23 19:22:05 -05:00
|
|
|
// Uncomment this if you want to use a debugger to capture state at every allocation and free.
|
|
|
|
// #define LOG_HEAP_ACTIVITY 1
|
|
|
|
|
2014-08-28 18:06:38 -04:00
|
|
|
// make this 1 to dump the heap each time it changes
|
|
|
|
#define EXTENSIVE_HEAP_PROFILING (0)
|
|
|
|
|
2017-12-07 17:10:44 -05:00
|
|
|
// make this 1 to zero out swept memory to more eagerly
|
|
|
|
// detect untraced object still in use
|
|
|
|
#define CLEAR_ON_SWEEP (0)
|
|
|
|
|
2023-08-08 20:41:17 -04:00
|
|
|
#define WORDS_PER_BLOCK ((MICROPY_BYTES_PER_GC_BLOCK) / MP_BYTES_PER_OBJ_WORD)
|
|
|
|
#define BYTES_PER_BLOCK (MICROPY_BYTES_PER_GC_BLOCK)
|
|
|
|
|
2013-10-21 18:45:08 -04:00
|
|
|
// ATB = allocation table byte
|
|
|
|
// 0b00 = FREE -- free block
|
|
|
|
// 0b01 = HEAD -- head of a chain of blocks
|
|
|
|
// 0b10 = TAIL -- in the tail of a chain of blocks
|
|
|
|
// 0b11 = MARK -- marked head block
|
|
|
|
|
|
|
|
#define AT_FREE (0)
|
|
|
|
#define AT_HEAD (1)
|
|
|
|
#define AT_TAIL (2)
|
|
|
|
#define AT_MARK (3)
|
|
|
|
|
|
|
|
#define BLOCKS_PER_ATB (4)
|
2023-08-08 20:41:17 -04:00
|
|
|
#define ATB_MASK_0 (0x03)
|
|
|
|
#define ATB_MASK_1 (0x0c)
|
|
|
|
#define ATB_MASK_2 (0x30)
|
|
|
|
#define ATB_MASK_3 (0xc0)
|
|
|
|
|
|
|
|
#define ATB_0_IS_FREE(a) (((a) & ATB_MASK_0) == 0)
|
|
|
|
#define ATB_1_IS_FREE(a) (((a) & ATB_MASK_1) == 0)
|
|
|
|
#define ATB_2_IS_FREE(a) (((a) & ATB_MASK_2) == 0)
|
|
|
|
#define ATB_3_IS_FREE(a) (((a) & ATB_MASK_3) == 0)
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2023-08-02 02:48:57 -04:00
|
|
|
#define NEXT_AREA(area) ((area)->next)
|
2018-01-23 20:09:58 -05:00
|
|
|
#else
|
|
|
|
#define NEXT_AREA(area) (NULL)
|
|
|
|
#endif
|
2015-01-01 18:30:53 -05:00
|
|
|
|
2013-10-21 18:45:08 -04:00
|
|
|
#define BLOCK_SHIFT(block) (2 * ((block) & (BLOCKS_PER_ATB - 1)))
|
2018-01-23 20:09:58 -05:00
|
|
|
#define ATB_GET_KIND(area, block) (((area)->gc_alloc_table_start[(block) / BLOCKS_PER_ATB] >> BLOCK_SHIFT(block)) & 3)
|
|
|
|
#define ATB_ANY_TO_FREE(area, block) do { area->gc_alloc_table_start[(block) / BLOCKS_PER_ATB] &= (~(AT_MARK << BLOCK_SHIFT(block))); } while (0)
|
|
|
|
#define ATB_FREE_TO_HEAD(area, block) do { area->gc_alloc_table_start[(block) / BLOCKS_PER_ATB] |= (AT_HEAD << BLOCK_SHIFT(block)); } while (0)
|
|
|
|
#define ATB_FREE_TO_TAIL(area, block) do { area->gc_alloc_table_start[(block) / BLOCKS_PER_ATB] |= (AT_TAIL << BLOCK_SHIFT(block)); } while (0)
|
|
|
|
#define ATB_HEAD_TO_MARK(area, block) do { area->gc_alloc_table_start[(block) / BLOCKS_PER_ATB] |= (AT_MARK << BLOCK_SHIFT(block)); } while (0)
|
|
|
|
#define ATB_MARK_TO_HEAD(area, block) do { area->gc_alloc_table_start[(block) / BLOCKS_PER_ATB] &= (~(AT_TAIL << BLOCK_SHIFT(block))); } while (0)
|
2015-01-01 18:30:53 -05:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#define BLOCK_FROM_PTR(area, ptr) (((byte *)(ptr) - area->gc_pool_start) / BYTES_PER_BLOCK)
|
|
|
|
#define PTR_FROM_BLOCK(area, block) (((block) * BYTES_PER_BLOCK + (uintptr_t)area->gc_pool_start))
|
2013-10-21 18:45:08 -04:00
|
|
|
|
py/gc: Ensure a gap of one byte after the ATB.
Prior to this fix the follow crash occurred. With a GC layout of:
GC layout:
alloc table at 0x3fd80428, length 32001 bytes, 128004 blocks
finaliser table at 0x3fd88129, length 16001 bytes, 128008 blocks
pool at 0x3fd8bfc0, length 2048064 bytes, 128004 blocks
Block 128003 is an AT_HEAD and eventually is passed to gc_mark_subtree.
This causes gc_mark_subtree to call ATB_GET_KIND(128004). When block 1 is
created with a finaliser, the first byte of the finaliser table becomes
0x2, but ATB_GET_KIND(128004) reads these bits as AT_TAIL, and then
gc_mark_subtree references past the end of the heap, which happened to be
past the end of PSRAM on the esp32-s2.
The fix in this commit is to ensure there is a one-byte gap after the ATB
filled permanently with AT_FREE.
Fixes issue #7116.
See also https://github.com/adafruit/circuitpython/issues/5021
Signed-off-by: Jeff Epler <jepler@gmail.com>
Signed-off-by: Damien George <damien@micropython.org>
2021-08-27 10:04:32 -04:00
|
|
|
// After the ATB, there must be a byte filled with AT_FREE so that gc_mark_tree
|
|
|
|
// cannot erroneously conclude that a block extends past the end of the GC heap
|
|
|
|
// due to bit patterns in the FTB (or first block, if finalizers are disabled)
|
|
|
|
// being interpreted as AT_TAIL.
|
|
|
|
#define ALLOC_TABLE_GAP_BYTE (1)
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
|
|
|
// FTB = finaliser table byte
|
|
|
|
// if set, then the corresponding block may have a finaliser
|
|
|
|
|
|
|
|
#define BLOCKS_PER_FTB (8)
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#define FTB_GET(area, block) ((area->gc_finaliser_table_start[(block) / BLOCKS_PER_FTB] >> ((block) & 7)) & 1)
|
|
|
|
#define FTB_SET(area, block) do { area->gc_finaliser_table_start[(block) / BLOCKS_PER_FTB] |= (1 << ((block) & 7)); } while (0)
|
|
|
|
#define FTB_CLEAR(area, block) do { area->gc_finaliser_table_start[(block) / BLOCKS_PER_FTB] &= (~(1 << ((block) & 7))); } while (0)
|
2014-04-05 15:35:48 -04:00
|
|
|
#endif
|
|
|
|
|
2016-05-26 06:53:34 -04:00
|
|
|
#if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
|
2016-04-25 11:28:57 -04:00
|
|
|
#define GC_ENTER() mp_thread_mutex_lock(&MP_STATE_MEM(gc_mutex), 1)
|
|
|
|
#define GC_EXIT() mp_thread_mutex_unlock(&MP_STATE_MEM(gc_mutex))
|
|
|
|
#else
|
|
|
|
#define GC_ENTER()
|
|
|
|
#define GC_EXIT()
|
|
|
|
#endif
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2016-11-23 20:31:53 -05:00
|
|
|
#ifdef LOG_HEAP_ACTIVITY
|
|
|
|
volatile uint32_t change_me;
|
2017-05-05 15:04:20 -04:00
|
|
|
#pragma GCC push_options
|
|
|
|
#pragma GCC optimize ("O0")
|
2016-11-23 20:31:53 -05:00
|
|
|
void __attribute__ ((noinline)) gc_log_change(uint32_t start_block, uint32_t length) {
|
|
|
|
change_me += start_block;
|
|
|
|
change_me += length; // Break on this line.
|
|
|
|
}
|
2017-05-05 15:04:20 -04:00
|
|
|
#pragma GCC pop_options
|
2016-11-23 20:31:53 -05:00
|
|
|
#endif
|
|
|
|
|
2013-10-22 16:12:29 -04:00
|
|
|
// TODO waste less memory; currently requires that all entries in alloc_table have a corresponding block in pool
|
2018-01-23 20:09:58 -05:00
|
|
|
STATIC void gc_setup_area(mp_state_mem_area_t *area, void *start, void *end) {
|
2014-04-05 15:35:48 -04:00
|
|
|
// calculate parameters for GC (T=total, A=alloc table, F=finaliser table, P=pool; all in bytes):
|
|
|
|
// T = A + F + P
|
|
|
|
// F = A * BLOCKS_PER_ATB / BLOCKS_PER_FTB
|
|
|
|
// P = A * BLOCKS_PER_ATB * BYTES_PER_BLOCK
|
|
|
|
// => T = A * (1 + BLOCKS_PER_ATB / BLOCKS_PER_FTB + BLOCKS_PER_ATB * BYTES_PER_BLOCK)
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t total_byte_len = (byte *)end - (byte *)start;
|
2014-04-05 15:35:48 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2023-08-02 02:48:57 -04:00
|
|
|
area->gc_alloc_table_byte_len = (total_byte_len - ALLOC_TABLE_GAP_BYTE)
|
|
|
|
* MP_BITS_PER_BYTE
|
|
|
|
/ (
|
|
|
|
MP_BITS_PER_BYTE
|
|
|
|
+ MP_BITS_PER_BYTE * BLOCKS_PER_ATB / BLOCKS_PER_FTB
|
|
|
|
+ MP_BITS_PER_BYTE * BLOCKS_PER_ATB * BYTES_PER_BLOCK
|
|
|
|
);
|
2014-04-05 15:35:48 -04:00
|
|
|
#else
|
py/gc: Ensure a gap of one byte after the ATB.
Prior to this fix the follow crash occurred. With a GC layout of:
GC layout:
alloc table at 0x3fd80428, length 32001 bytes, 128004 blocks
finaliser table at 0x3fd88129, length 16001 bytes, 128008 blocks
pool at 0x3fd8bfc0, length 2048064 bytes, 128004 blocks
Block 128003 is an AT_HEAD and eventually is passed to gc_mark_subtree.
This causes gc_mark_subtree to call ATB_GET_KIND(128004). When block 1 is
created with a finaliser, the first byte of the finaliser table becomes
0x2, but ATB_GET_KIND(128004) reads these bits as AT_TAIL, and then
gc_mark_subtree references past the end of the heap, which happened to be
past the end of PSRAM on the esp32-s2.
The fix in this commit is to ensure there is a one-byte gap after the ATB
filled permanently with AT_FREE.
Fixes issue #7116.
See also https://github.com/adafruit/circuitpython/issues/5021
Signed-off-by: Jeff Epler <jepler@gmail.com>
Signed-off-by: Damien George <damien@micropython.org>
2021-08-27 10:04:32 -04:00
|
|
|
area->gc_alloc_table_byte_len = (total_byte_len - ALLOC_TABLE_GAP_BYTE) / (1 + MP_BITS_PER_BYTE / 2 * BYTES_PER_BLOCK);
|
2014-04-05 15:35:48 -04:00
|
|
|
#endif
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
area->gc_alloc_table_start = (byte *)start;
|
2014-04-03 17:55:12 -04:00
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t gc_finaliser_table_byte_len = (area->gc_alloc_table_byte_len * BLOCKS_PER_ATB + BLOCKS_PER_FTB - 1) / BLOCKS_PER_FTB;
|
py/gc: Ensure a gap of one byte after the ATB.
Prior to this fix the follow crash occurred. With a GC layout of:
GC layout:
alloc table at 0x3fd80428, length 32001 bytes, 128004 blocks
finaliser table at 0x3fd88129, length 16001 bytes, 128008 blocks
pool at 0x3fd8bfc0, length 2048064 bytes, 128004 blocks
Block 128003 is an AT_HEAD and eventually is passed to gc_mark_subtree.
This causes gc_mark_subtree to call ATB_GET_KIND(128004). When block 1 is
created with a finaliser, the first byte of the finaliser table becomes
0x2, but ATB_GET_KIND(128004) reads these bits as AT_TAIL, and then
gc_mark_subtree references past the end of the heap, which happened to be
past the end of PSRAM on the esp32-s2.
The fix in this commit is to ensure there is a one-byte gap after the ATB
filled permanently with AT_FREE.
Fixes issue #7116.
See also https://github.com/adafruit/circuitpython/issues/5021
Signed-off-by: Jeff Epler <jepler@gmail.com>
Signed-off-by: Damien George <damien@micropython.org>
2021-08-27 10:04:32 -04:00
|
|
|
area->gc_finaliser_table_start = area->gc_alloc_table_start + area->gc_alloc_table_byte_len + ALLOC_TABLE_GAP_BYTE;
|
2014-04-05 15:35:48 -04:00
|
|
|
#endif
|
2014-04-03 17:55:12 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t gc_pool_block_len = area->gc_alloc_table_byte_len * BLOCKS_PER_ATB;
|
|
|
|
area->gc_pool_start = (byte *)end - gc_pool_block_len * BYTES_PER_BLOCK;
|
|
|
|
area->gc_pool_end = end;
|
2013-10-22 16:12:29 -04:00
|
|
|
|
2014-08-08 07:33:49 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2018-01-23 20:09:58 -05:00
|
|
|
assert(area->gc_pool_start >= area->gc_finaliser_table_start + gc_finaliser_table_byte_len);
|
2014-08-08 07:33:49 -04:00
|
|
|
#endif
|
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
py/gc: Ensure a gap of one byte after the ATB.
Prior to this fix the follow crash occurred. With a GC layout of:
GC layout:
alloc table at 0x3fd80428, length 32001 bytes, 128004 blocks
finaliser table at 0x3fd88129, length 16001 bytes, 128008 blocks
pool at 0x3fd8bfc0, length 2048064 bytes, 128004 blocks
Block 128003 is an AT_HEAD and eventually is passed to gc_mark_subtree.
This causes gc_mark_subtree to call ATB_GET_KIND(128004). When block 1 is
created with a finaliser, the first byte of the finaliser table becomes
0x2, but ATB_GET_KIND(128004) reads these bits as AT_TAIL, and then
gc_mark_subtree references past the end of the heap, which happened to be
past the end of PSRAM on the esp32-s2.
The fix in this commit is to ensure there is a one-byte gap after the ATB
filled permanently with AT_FREE.
Fixes issue #7116.
See also https://github.com/adafruit/circuitpython/issues/5021
Signed-off-by: Jeff Epler <jepler@gmail.com>
Signed-off-by: Damien George <damien@micropython.org>
2021-08-27 10:04:32 -04:00
|
|
|
// clear ATB's and FTB's
|
|
|
|
memset(area->gc_alloc_table_start, 0, gc_finaliser_table_byte_len + area->gc_alloc_table_byte_len + ALLOC_TABLE_GAP_BYTE);
|
|
|
|
#else
|
|
|
|
// clear ATB's
|
|
|
|
memset(area->gc_alloc_table_start, 0, area->gc_alloc_table_byte_len + ALLOC_TABLE_GAP_BYTE);
|
2014-04-05 15:35:48 -04:00
|
|
|
#endif
|
2014-04-03 17:55:12 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
area->gc_last_free_atb_index = 0;
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
area->gc_last_used_block = 0;
|
2018-01-23 20:09:58 -05:00
|
|
|
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
area->next = NULL;
|
|
|
|
#endif
|
2014-04-03 17:55:12 -04:00
|
|
|
|
2022-12-07 22:11:24 -05:00
|
|
|
DEBUG_printf("GC layout:\n");
|
2023-08-02 02:48:57 -04:00
|
|
|
DEBUG_printf(" alloc table at %p, length " UINT_FMT " bytes, "
|
|
|
|
UINT_FMT " blocks\n",
|
|
|
|
area->gc_alloc_table_start, area->gc_alloc_table_byte_len,
|
|
|
|
area->gc_alloc_table_byte_len * BLOCKS_PER_ATB);
|
2023-08-08 20:41:17 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2023-08-02 02:48:57 -04:00
|
|
|
DEBUG_printf(" finaliser table at %p, length " UINT_FMT " bytes, "
|
|
|
|
UINT_FMT " blocks\n", area->gc_finaliser_table_start,
|
|
|
|
gc_finaliser_table_byte_len,
|
|
|
|
gc_finaliser_table_byte_len * BLOCKS_PER_FTB);
|
2023-08-08 20:41:17 -04:00
|
|
|
#endif
|
2023-08-02 02:48:57 -04:00
|
|
|
DEBUG_printf(" pool at %p, length " UINT_FMT " bytes, "
|
|
|
|
UINT_FMT " blocks\n", area->gc_pool_start,
|
|
|
|
gc_pool_block_len * BYTES_PER_BLOCK, gc_pool_block_len);
|
2018-01-23 20:09:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void gc_init(void *start, void *end) {
|
|
|
|
// align end pointer on block boundary
|
|
|
|
end = (void *)((uintptr_t)end & (~(BYTES_PER_BLOCK - 1)));
|
|
|
|
DEBUG_printf("Initializing GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, (byte *)end - (byte *)start);
|
|
|
|
|
|
|
|
gc_setup_area(&MP_STATE_MEM(area), start, end);
|
2020-02-11 20:06:24 -05:00
|
|
|
|
2023-08-08 20:41:17 -04:00
|
|
|
// set last free ATB index to start of heap
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
MP_STATE_MEM(gc_last_free_area) = &MP_STATE_MEM(area);
|
|
|
|
#endif
|
2014-08-22 13:17:02 -04:00
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
// unlock the GC
|
2021-05-04 09:56:43 -04:00
|
|
|
MP_STATE_THREAD(gc_lock_depth) = 0;
|
2014-04-05 15:35:48 -04:00
|
|
|
|
2014-10-31 17:30:46 -04:00
|
|
|
// allow auto collection
|
2023-08-08 20:41:17 -04:00
|
|
|
MP_STATE_MEM(gc_auto_collect_enabled) = 1;
|
2014-10-31 17:30:46 -04:00
|
|
|
|
py/gc: Implement GC running by allocation threshold.
Currently, MicroPython runs GC when it could not allocate a block of memory,
which happens when heap is exhausted. However, that policy can't work well
with "inifinity" heaps, e.g. backed by a virtual memory - there will be a
lot of swap thrashing long before VM will be exhausted. Instead, in such
cases "allocation threshold" policy is used: a GC is run after some number of
allocations have been made. Details vary, for example, number or total amount
of allocations can be used, threshold may be self-adjusting based on GC
outcome, etc.
This change implements a simple variant of such policy for MicroPython. Amount
of allocated memory so far is used for threshold, to make it useful to typical
finite-size, and small, heaps as used with MicroPython ports. And such GC policy
is indeed useful for such types of heaps too, as it allows to better control
fragmentation. For example, if a threshold is set to half size of heap, then
for an application which usually makes big number of small allocations, that
will (try to) keep half of heap memory in a nice defragmented state for an
occasional large allocation.
For an application which doesn't exhibit such behavior, there won't be any
visible effects, except for GC running more frequently, which however may
affect performance. To address this, the GC threshold is configurable, and
by default is off so far. It's configured with gc.threshold(amount_in_bytes)
call (can be queries without an argument).
2016-07-20 17:37:30 -04:00
|
|
|
#if MICROPY_GC_ALLOC_THRESHOLD
|
|
|
|
// by default, maxuint for gc threshold, effectively turning gc-by-threshold off
|
|
|
|
MP_STATE_MEM(gc_alloc_threshold) = (size_t)-1;
|
|
|
|
MP_STATE_MEM(gc_alloc_amount) = 0;
|
|
|
|
#endif
|
|
|
|
|
2020-01-22 12:19:37 -05:00
|
|
|
#if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
|
2016-04-25 11:28:57 -04:00
|
|
|
mp_thread_mutex_init(&MP_STATE_MEM(gc_mutex));
|
|
|
|
#endif
|
2013-10-22 16:12:29 -04:00
|
|
|
}
|
2016-04-25 11:28:57 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
void gc_add(void *start, void *end) {
|
|
|
|
// Place the area struct at the start of the area.
|
|
|
|
mp_state_mem_area_t *area = (mp_state_mem_area_t *)start;
|
|
|
|
start = (void *)((uintptr_t)start + sizeof(mp_state_mem_area_t));
|
2019-04-08 19:58:50 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
end = (void *)((uintptr_t)end & (~(BYTES_PER_BLOCK - 1)));
|
|
|
|
DEBUG_printf("Adding GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, (byte *)end - (byte *)start);
|
|
|
|
|
|
|
|
// Init this area
|
|
|
|
gc_setup_area(area, start, end);
|
|
|
|
|
|
|
|
// Find the last registered area in the linked list
|
|
|
|
mp_state_mem_area_t *prev_area = &MP_STATE_MEM(area);
|
|
|
|
while (prev_area->next != NULL) {
|
|
|
|
prev_area = prev_area->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add this area to the linked list
|
|
|
|
prev_area->next = area;
|
2013-10-22 16:12:29 -04:00
|
|
|
}
|
|
|
|
|
2023-08-02 02:49:44 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
|
|
|
// Try to automatically add a heap area large enough to fulfill 'failed_alloc'.
|
|
|
|
STATIC bool gc_try_add_heap(size_t failed_alloc) {
|
|
|
|
// 'needed' is the size of a heap large enough to hold failed_alloc, with
|
|
|
|
// the additional metadata overheads as calculated in gc_setup_area().
|
|
|
|
//
|
|
|
|
// Rather than reproduce all of that logic here, we approximate that adding
|
|
|
|
// (13/512) is enough overhead for sufficiently large heap areas (the
|
|
|
|
// overhead converges to 3/128, but there's some fixed overhead and some
|
|
|
|
// rounding up of partial block sizes).
|
|
|
|
size_t needed = failed_alloc + MAX(2048, failed_alloc * 13 / 512);
|
|
|
|
|
|
|
|
size_t avail = gc_get_max_new_split();
|
|
|
|
|
|
|
|
DEBUG_printf("gc_try_add_heap failed_alloc " UINT_FMT ", "
|
|
|
|
"needed " UINT_FMT ", avail " UINT_FMT " bytes \n",
|
|
|
|
failed_alloc,
|
|
|
|
needed,
|
|
|
|
avail);
|
|
|
|
|
|
|
|
if (avail < needed) {
|
|
|
|
// Can't fit this allocation, or system heap has nearly run out anyway
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Deciding how much to grow the total heap by each time is tricky:
|
|
|
|
//
|
|
|
|
// - Grow by too small amounts, leads to heap fragmentation issues.
|
|
|
|
//
|
|
|
|
// - Grow by too large amounts, may lead to system heap running out of
|
|
|
|
// space.
|
|
|
|
//
|
|
|
|
// Currently, this implementation is:
|
|
|
|
//
|
|
|
|
// - At minimum, aim to double the total heap size each time we add a new
|
|
|
|
// heap. i.e. without any large single allocations, total size will be
|
|
|
|
// 64KB -> 128KB -> 256KB -> 512KB -> 1MB, etc
|
|
|
|
//
|
|
|
|
// - If the failed allocation is too large to fit in that size, the new
|
|
|
|
// heap is made exactly large enough for that allocation. Future growth
|
|
|
|
// will double the total heap size again.
|
|
|
|
//
|
|
|
|
// - If the new heap won't fit in the available free space, add the largest
|
|
|
|
// new heap that will fit (this may lead to failed system heap allocations
|
|
|
|
// elsewhere, but some allocation will likely fail in this circumstance!)
|
|
|
|
size_t total_heap = 0;
|
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area);
|
|
|
|
area != NULL;
|
|
|
|
area = NEXT_AREA(area)) {
|
|
|
|
total_heap += area->gc_pool_end - area->gc_alloc_table_start;
|
|
|
|
total_heap += ALLOC_TABLE_GAP_BYTE + sizeof(mp_state_mem_area_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG_printf("total_heap " UINT_FMT " bytes\n", total_heap);
|
|
|
|
|
|
|
|
size_t to_alloc = MIN(avail, MAX(total_heap, needed));
|
|
|
|
|
|
|
|
mp_state_mem_area_t *new_heap = MP_PLAT_ALLOC_HEAP(to_alloc);
|
|
|
|
|
|
|
|
DEBUG_printf("MP_PLAT_ALLOC_HEAP " UINT_FMT " = %p\n",
|
|
|
|
to_alloc, new_heap);
|
|
|
|
|
|
|
|
if (new_heap == NULL) {
|
|
|
|
// This should only fail:
|
|
|
|
// - In a threaded environment if another thread has
|
|
|
|
// allocated while this function ran.
|
|
|
|
// - If there is a bug in gc_get_max_new_split().
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
gc_add(new_heap, (void *)new_heap + to_alloc);
|
|
|
|
|
|
|
|
return true;
|
2019-03-08 18:29:14 -05:00
|
|
|
}
|
2023-08-02 02:49:44 -04:00
|
|
|
#endif
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#endif
|
2019-03-08 18:29:14 -05:00
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2023-10-19 16:02:42 -04:00
|
|
|
void gc_deinit(void) {
|
2023-10-02 19:49:31 -04:00
|
|
|
// Run any finalisers before we stop using the heap. This will also free
|
|
|
|
// any additional heap areas (but not the first.)
|
2023-10-19 16:02:42 -04:00
|
|
|
gc_sweep_all();
|
|
|
|
memset(&MP_STATE_MEM(area), 0, sizeof(MP_STATE_MEM(area)));
|
|
|
|
}
|
|
|
|
|
2014-04-08 07:31:21 -04:00
|
|
|
void gc_lock(void) {
|
2021-05-04 09:56:43 -04:00
|
|
|
// This does not need to be atomic or have the GC mutex because:
|
|
|
|
// - each thread has its own gc_lock_depth so there are no races between threads;
|
|
|
|
// - a hard interrupt will only change gc_lock_depth during its execution, and
|
|
|
|
// upon return will restore the value of gc_lock_depth.
|
|
|
|
MP_STATE_THREAD(gc_lock_depth)++;
|
2014-04-08 07:31:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void gc_unlock(void) {
|
2021-05-04 09:56:43 -04:00
|
|
|
// This does not need to be atomic, See comment above in gc_lock.
|
|
|
|
MP_STATE_THREAD(gc_lock_depth)--;
|
2014-04-08 07:31:21 -04:00
|
|
|
}
|
|
|
|
|
2014-07-01 01:49:21 -04:00
|
|
|
bool gc_is_locked(void) {
|
2021-05-04 09:56:43 -04:00
|
|
|
return MP_STATE_THREAD(gc_lock_depth) != 0;
|
2014-07-01 01:49:21 -04:00
|
|
|
}
|
|
|
|
|
2023-11-08 09:08:10 -05:00
|
|
|
// CIRCUITPY-CHANGE
|
2023-10-02 19:49:31 -04:00
|
|
|
bool gc_ptr_on_heap(void *ptr) {
|
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
|
|
|
if (ptr >= (void *)area->gc_pool_start // must be above start of pool
|
|
|
|
&& ptr < (void *)area->gc_pool_end) { // must be below end of pool
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-04-13 00:26:16 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2018-01-23 20:09:58 -05:00
|
|
|
// Returns the area to which this pointer belongs, or NULL if it isn't
|
|
|
|
// allocated on the GC-managed heap.
|
|
|
|
STATIC inline mp_state_mem_area_t *gc_get_ptr_area(const void *ptr) {
|
|
|
|
if (((uintptr_t)(ptr) & (BYTES_PER_BLOCK - 1)) != 0) { // must be aligned on a block
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
|
|
|
if (ptr >= (void *)area->gc_pool_start // must be above start of pool
|
|
|
|
&& ptr < (void *)area->gc_pool_end) { // must be below end of pool
|
|
|
|
return area;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2022-04-13 00:26:16 -04:00
|
|
|
#endif
|
|
|
|
|
2023-10-02 19:49:31 -04:00
|
|
|
// ptr should be of type void*
|
|
|
|
#define VERIFY_PTR(ptr) ( \
|
|
|
|
((uintptr_t)(ptr) & (BYTES_PER_BLOCK - 1)) == 0 /* must be aligned on a block */ \
|
|
|
|
&& ptr >= (void *)MP_STATE_MEM(area).gc_pool_start /* must be above start of pool */ \
|
|
|
|
&& ptr < (void *)MP_STATE_MEM(area).gc_pool_end /* must be below end of pool */ \
|
|
|
|
)
|
2023-08-08 20:41:17 -04:00
|
|
|
|
2017-12-08 18:48:26 -05:00
|
|
|
#ifndef TRACE_MARK
|
|
|
|
#if DEBUG_PRINT
|
|
|
|
#define TRACE_MARK(block, ptr) DEBUG_printf("gc_mark(%p)\n", ptr)
|
|
|
|
#else
|
|
|
|
#define TRACE_MARK(block, ptr)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2018-02-15 11:10:13 -05:00
|
|
|
// Take the given block as the topmost block on the stack. Check all it's
|
|
|
|
// children: mark the unmarked child blocks and put those newly marked
|
|
|
|
// blocks on the stack. When all children have been checked, pop off the
|
|
|
|
// topmost block on the stack and repeat with that one.
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE: We don't instrument these functions because they occur a lot during GC and
|
2022-04-13 00:26:16 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2023-09-20 12:19:57 -04:00
|
|
|
STATIC void MP_NO_INSTRUMENT PLACE_IN_ITCM(gc_mark_subtree)(mp_state_mem_area_t * area, size_t block)
|
2022-04-13 00:26:16 -04:00
|
|
|
#else
|
2023-09-19 11:10:12 -04:00
|
|
|
STATIC void MP_NO_INSTRUMENT PLACE_IN_ITCM(gc_mark_subtree)(size_t block)
|
2022-04-13 00:26:16 -04:00
|
|
|
#endif
|
|
|
|
{
|
2018-02-15 11:10:13 -05:00
|
|
|
// Start with the block passed in the argument.
|
2018-02-15 11:22:34 -05:00
|
|
|
size_t sp = 0;
|
2018-02-15 11:10:13 -05:00
|
|
|
for (;;) {
|
2022-04-13 00:26:16 -04:00
|
|
|
#if !MICROPY_GC_SPLIT_HEAP
|
2023-03-15 17:48:16 -04:00
|
|
|
mp_state_mem_area_t *area = &MP_STATE_MEM(area);
|
2018-01-23 20:09:58 -05:00
|
|
|
#endif
|
|
|
|
|
2013-10-22 10:25:25 -04:00
|
|
|
// work out number of consecutive blocks in the chain starting with this one
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t n_blocks = 0;
|
2013-10-21 18:45:08 -04:00
|
|
|
do {
|
|
|
|
n_blocks += 1;
|
2018-01-23 20:09:58 -05:00
|
|
|
} while (ATB_GET_KIND(area, block + n_blocks) == AT_TAIL);
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2021-09-15 11:54:48 -04:00
|
|
|
// check that the consecutive blocks didn't overflow past the end of the area
|
|
|
|
assert(area->gc_pool_start + (block + n_blocks) * BYTES_PER_BLOCK <= area->gc_pool_end);
|
2013-10-21 18:45:08 -04:00
|
|
|
|
|
|
|
// check this block's children
|
2018-01-23 20:09:58 -05:00
|
|
|
void **ptrs = (void **)PTR_FROM_BLOCK(area, block);
|
2015-12-16 19:41:37 -05:00
|
|
|
for (size_t i = n_blocks * BYTES_PER_BLOCK / sizeof(void *); i > 0; i--, ptrs++) {
|
2023-03-15 17:48:16 -04:00
|
|
|
MICROPY_GC_HOOK_LOOP(i);
|
2015-12-16 19:41:37 -05:00
|
|
|
void *ptr = *ptrs;
|
2018-01-23 20:09:58 -05:00
|
|
|
// If this is a heap pointer that hasn't been marked, mark it and push
|
|
|
|
// it's children to the stack.
|
2022-04-13 00:26:16 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2018-01-23 20:09:58 -05:00
|
|
|
mp_state_mem_area_t *ptr_area = gc_get_ptr_area(ptr);
|
|
|
|
if (!ptr_area) {
|
|
|
|
// Not a heap-allocated pointer (might even be random data).
|
|
|
|
continue;
|
|
|
|
}
|
2022-04-13 00:26:16 -04:00
|
|
|
#else
|
|
|
|
if (!VERIFY_PTR(ptr)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mp_state_mem_area_t *ptr_area = area;
|
|
|
|
#endif
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t ptr_block = BLOCK_FROM_PTR(ptr_area, ptr);
|
|
|
|
if (ATB_GET_KIND(ptr_area, ptr_block) != AT_HEAD) {
|
|
|
|
// This block is already marked.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// An unmarked head. Mark it, and push it on gc stack.
|
|
|
|
TRACE_MARK(ptr_block, ptr);
|
|
|
|
ATB_HEAD_TO_MARK(ptr_area, ptr_block);
|
|
|
|
if (sp < MICROPY_ALLOC_GC_STACK_SIZE) {
|
2022-04-13 00:26:16 -04:00
|
|
|
MP_STATE_MEM(gc_block_stack)[sp] = ptr_block;
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2022-04-13 00:26:16 -04:00
|
|
|
MP_STATE_MEM(gc_area_stack)[sp] = ptr_area;
|
2018-01-23 20:09:58 -05:00
|
|
|
#endif
|
2022-04-13 00:26:16 -04:00
|
|
|
sp += 1;
|
2018-01-23 20:09:58 -05:00
|
|
|
} else {
|
|
|
|
MP_STATE_MEM(gc_stack_overflow) = 1;
|
2018-01-27 12:37:38 -05:00
|
|
|
}
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
2018-02-15 11:10:13 -05:00
|
|
|
|
|
|
|
// Are there any blocks on the stack?
|
2018-02-15 11:22:34 -05:00
|
|
|
if (sp == 0) {
|
2018-02-15 11:10:13 -05:00
|
|
|
break; // No, stack is empty, we're done.
|
|
|
|
}
|
|
|
|
|
|
|
|
// pop the next block off the stack
|
2022-04-13 00:26:16 -04:00
|
|
|
sp -= 1;
|
|
|
|
block = MP_STATE_MEM(gc_block_stack)[sp];
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
area = MP_STATE_MEM(gc_area_stack)[sp];
|
|
|
|
#endif
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-12 11:31:30 -05:00
|
|
|
STATIC void gc_deal_with_stack_overflow(void) {
|
2015-01-01 18:30:53 -05:00
|
|
|
while (MP_STATE_MEM(gc_stack_overflow)) {
|
|
|
|
MP_STATE_MEM(gc_stack_overflow) = 0;
|
2013-10-21 18:45:08 -04:00
|
|
|
|
|
|
|
// scan entire memory looking for blocks which have been marked but not their children
|
2018-01-23 20:09:58 -05:00
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
|
|
|
for (size_t block = 0; block < area->gc_alloc_table_byte_len * BLOCKS_PER_ATB; block++) {
|
2023-03-15 17:48:16 -04:00
|
|
|
MICROPY_GC_HOOK_LOOP(block);
|
2018-01-23 20:09:58 -05:00
|
|
|
// trace (again) if mark bit set
|
|
|
|
if (ATB_GET_KIND(area, block) == AT_MARK) {
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2022-04-13 00:26:16 -04:00
|
|
|
gc_mark_subtree(area, block);
|
2018-01-23 20:09:58 -05:00
|
|
|
#else
|
2022-04-13 00:26:16 -04:00
|
|
|
gc_mark_subtree(block);
|
2018-01-23 20:09:58 -05:00
|
|
|
#endif
|
|
|
|
}
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-12 11:31:30 -05:00
|
|
|
STATIC void gc_sweep(void) {
|
2014-06-05 15:48:02 -04:00
|
|
|
#if MICROPY_PY_GC_COLLECT_RETVAL
|
2015-02-07 12:24:10 -05:00
|
|
|
MP_STATE_MEM(gc_collected) = 0;
|
2014-06-05 15:48:02 -04:00
|
|
|
#endif
|
2013-10-21 18:45:08 -04:00
|
|
|
// free unmarked heads and their tails
|
|
|
|
int free_tail = 0;
|
2023-08-02 02:49:44 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
|
|
|
mp_state_mem_area_t *prev_area = NULL;
|
|
|
|
#endif
|
2018-01-23 20:09:58 -05:00
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
size_t end_block = area->gc_alloc_table_byte_len * BLOCKS_PER_ATB;
|
|
|
|
if (area->gc_last_used_block < end_block) {
|
|
|
|
end_block = area->gc_last_used_block + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t last_used_block = 0;
|
|
|
|
|
|
|
|
for (size_t block = 0; block < end_block; block++) {
|
2023-03-15 17:48:16 -04:00
|
|
|
MICROPY_GC_HOOK_LOOP(block);
|
2018-01-23 20:09:58 -05:00
|
|
|
switch (ATB_GET_KIND(area, block)) {
|
|
|
|
case AT_HEAD:
|
|
|
|
#if MICROPY_ENABLE_FINALISER
|
|
|
|
if (FTB_GET(area, block)) {
|
|
|
|
mp_obj_base_t *obj = (mp_obj_base_t *)PTR_FROM_BLOCK(area, block);
|
|
|
|
if (obj->type != NULL) {
|
|
|
|
// if the object has a type then see if it has a __del__ method
|
|
|
|
mp_obj_t dest[2];
|
|
|
|
mp_load_method_maybe(MP_OBJ_FROM_PTR(obj), MP_QSTR___del__, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// load_method returned a method, execute it in a protected environment
|
|
|
|
#if MICROPY_ENABLE_SCHEDULER
|
|
|
|
mp_sched_lock();
|
|
|
|
#endif
|
|
|
|
mp_call_function_1_protected(dest[0], dest[1]);
|
|
|
|
#if MICROPY_ENABLE_SCHEDULER
|
|
|
|
mp_sched_unlock();
|
|
|
|
#endif
|
|
|
|
}
|
2014-04-05 15:35:48 -04:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
// clear finaliser flag
|
|
|
|
FTB_CLEAR(area, block);
|
2014-04-03 17:55:12 -04:00
|
|
|
}
|
2017-12-07 17:10:44 -05:00
|
|
|
#endif
|
2018-01-23 20:09:58 -05:00
|
|
|
free_tail = 1;
|
|
|
|
DEBUG_printf("gc_sweep(%p)\n", (void *)PTR_FROM_BLOCK(area, block));
|
|
|
|
#if MICROPY_PY_GC_COLLECT_RETVAL
|
|
|
|
MP_STATE_MEM(gc_collected)++;
|
|
|
|
#endif
|
|
|
|
// fall through to free the head
|
|
|
|
MP_FALLTHROUGH
|
|
|
|
|
|
|
|
case AT_TAIL:
|
|
|
|
if (free_tail) {
|
|
|
|
ATB_ANY_TO_FREE(area, block);
|
|
|
|
#if CLEAR_ON_SWEEP
|
|
|
|
memset((void *)PTR_FROM_BLOCK(area, block), 0, BYTES_PER_BLOCK);
|
|
|
|
#endif
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
} else {
|
|
|
|
last_used_block = block;
|
2018-01-23 20:09:58 -05:00
|
|
|
}
|
|
|
|
break;
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
case AT_MARK:
|
|
|
|
ATB_MARK_TO_HEAD(area, block);
|
|
|
|
free_tail = 0;
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
last_used_block = block;
|
2018-01-23 20:09:58 -05:00
|
|
|
break;
|
|
|
|
}
|
2019-04-18 18:44:44 -04:00
|
|
|
}
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
|
|
|
|
area->gc_last_used_block = last_used_block;
|
2023-08-02 02:49:44 -04:00
|
|
|
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
|
|
|
// Free any empty area, aside from the first one
|
|
|
|
if (last_used_block == 0 && prev_area != NULL) {
|
|
|
|
DEBUG_printf("gc_sweep free empty area %p\n", area);
|
|
|
|
NEXT_AREA(prev_area) = NEXT_AREA(area);
|
|
|
|
MP_PLAT_FREE_HEAP(area);
|
|
|
|
area = prev_area;
|
|
|
|
}
|
|
|
|
prev_area = area;
|
|
|
|
#endif
|
2019-04-18 18:44:44 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-23 15:20:17 -04:00
|
|
|
void gc_collect_start(void) {
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_ENTER();
|
2021-05-04 09:56:43 -04:00
|
|
|
MP_STATE_THREAD(gc_lock_depth)++;
|
py/gc: Implement GC running by allocation threshold.
Currently, MicroPython runs GC when it could not allocate a block of memory,
which happens when heap is exhausted. However, that policy can't work well
with "inifinity" heaps, e.g. backed by a virtual memory - there will be a
lot of swap thrashing long before VM will be exhausted. Instead, in such
cases "allocation threshold" policy is used: a GC is run after some number of
allocations have been made. Details vary, for example, number or total amount
of allocations can be used, threshold may be self-adjusting based on GC
outcome, etc.
This change implements a simple variant of such policy for MicroPython. Amount
of allocated memory so far is used for threshold, to make it useful to typical
finite-size, and small, heaps as used with MicroPython ports. And such GC policy
is indeed useful for such types of heaps too, as it allows to better control
fragmentation. For example, if a threshold is set to half size of heap, then
for an application which usually makes big number of small allocations, that
will (try to) keep half of heap memory in a nice defragmented state for an
occasional large allocation.
For an application which doesn't exhibit such behavior, there won't be any
visible effects, except for GC running more frequently, which however may
affect performance. To address this, the GC threshold is configurable, and
by default is off so far. It's configured with gc.threshold(amount_in_bytes)
call (can be queries without an argument).
2016-07-20 17:37:30 -04:00
|
|
|
#if MICROPY_GC_ALLOC_THRESHOLD
|
|
|
|
MP_STATE_MEM(gc_alloc_amount) = 0;
|
|
|
|
#endif
|
2015-01-01 18:30:53 -05:00
|
|
|
MP_STATE_MEM(gc_stack_overflow) = 0;
|
py: Introduce a Python stack for scoped allocation.
This patch introduces the MICROPY_ENABLE_PYSTACK option (disabled by
default) which enables a "Python stack" that allows to allocate and free
memory in a scoped, or Last-In-First-Out (LIFO) way, similar to alloca().
A new memory allocation API is introduced along with this Py-stack. It
includes both "local" and "nonlocal" LIFO allocation. Local allocation is
intended to be equivalent to using alloca(), whereby the same function must
free the memory. Nonlocal allocation is where another function may free
the memory, so long as it's still LIFO.
Follow-up patches will convert all uses of alloca() and VLA to the new
scoped allocation API. The old behaviour (using alloca()) will still be
available, but when MICROPY_ENABLE_PYSTACK is enabled then alloca() is no
longer required or used.
The benefits of enabling this option are (or will be once subsequent
patches are made to convert alloca()/VLA):
- Toolchains without alloca() can use this feature to obtain correct and
efficient scoped memory allocation (compared to using the heap instead
of alloca(), which is slower).
- Even if alloca() is available, enabling the Py-stack gives slightly more
efficient use of stack space when calling nested Python functions, due to
the way that compilers implement alloca().
- Enabling the Py-stack with the stackless mode allows for even more
efficient stack usage, as well as retaining high performance (because the
heap is no longer used to build and destroy stackless code states).
- With Py-stack and stackless enabled, Python-calling-Python is no longer
recursive in the C mp_execute_bytecode function.
The micropython.pystack_use() function is included to measure usage of the
Python stack.
2017-11-26 07:28:40 -05:00
|
|
|
|
2015-01-01 18:30:53 -05:00
|
|
|
// Trace root pointers. This relies on the root pointers being organised
|
|
|
|
// correctly in the mp_state_ctx structure. We scan nlr_top, dict_locals,
|
|
|
|
// dict_globals, then the root pointer section of mp_state_vm.
|
|
|
|
void **ptrs = (void **)(void *)&mp_state_ctx;
|
2018-05-12 08:09:34 -04:00
|
|
|
size_t root_start = offsetof(mp_state_ctx_t, thread.dict_locals);
|
|
|
|
size_t root_end = offsetof(mp_state_ctx_t, vm.qstr_last_chunk);
|
|
|
|
gc_collect_root(ptrs + root_start / sizeof(void *), (root_end - root_start) / sizeof(void *));
|
py: Introduce a Python stack for scoped allocation.
This patch introduces the MICROPY_ENABLE_PYSTACK option (disabled by
default) which enables a "Python stack" that allows to allocate and free
memory in a scoped, or Last-In-First-Out (LIFO) way, similar to alloca().
A new memory allocation API is introduced along with this Py-stack. It
includes both "local" and "nonlocal" LIFO allocation. Local allocation is
intended to be equivalent to using alloca(), whereby the same function must
free the memory. Nonlocal allocation is where another function may free
the memory, so long as it's still LIFO.
Follow-up patches will convert all uses of alloca() and VLA to the new
scoped allocation API. The old behaviour (using alloca()) will still be
available, but when MICROPY_ENABLE_PYSTACK is enabled then alloca() is no
longer required or used.
The benefits of enabling this option are (or will be once subsequent
patches are made to convert alloca()/VLA):
- Toolchains without alloca() can use this feature to obtain correct and
efficient scoped memory allocation (compared to using the heap instead
of alloca(), which is slower).
- Even if alloca() is available, enabling the Py-stack gives slightly more
efficient use of stack space when calling nested Python functions, due to
the way that compilers implement alloca().
- Enabling the Py-stack with the stackless mode allows for even more
efficient stack usage, as well as retaining high performance (because the
heap is no longer used to build and destroy stackless code states).
- With Py-stack and stackless enabled, Python-calling-Python is no longer
recursive in the C mp_execute_bytecode function.
The micropython.pystack_use() function is included to measure usage of the
Python stack.
2017-11-26 07:28:40 -05:00
|
|
|
|
|
|
|
#if MICROPY_ENABLE_PYSTACK
|
|
|
|
// Trace root pointers from the Python stack.
|
|
|
|
ptrs = (void **)(void *)MP_STATE_THREAD(pystack_start);
|
|
|
|
gc_collect_root(ptrs, (MP_STATE_THREAD(pystack_cur) - MP_STATE_THREAD(pystack_start)) / sizeof(void *));
|
|
|
|
#endif
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2023-09-28 16:22:10 -04:00
|
|
|
void gc_collect_ptr(void *ptr) {
|
|
|
|
void *ptrs[1] = { ptr };
|
|
|
|
gc_collect_root(ptrs, 1);
|
|
|
|
}
|
|
|
|
|
2021-05-10 17:16:50 -04:00
|
|
|
// Address sanitizer needs to know that the access to ptrs[i] must always be
|
|
|
|
// considered OK, even if it's a load from an address that would normally be
|
|
|
|
// prohibited (due to being undefined, in a red zone, etc).
|
2021-06-18 00:15:37 -04:00
|
|
|
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
|
2021-05-10 17:16:50 -04:00
|
|
|
__attribute__((no_sanitize_address))
|
|
|
|
#endif
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2023-09-28 16:22:10 -04:00
|
|
|
static void *MP_NO_INSTRUMENT PLACE_IN_ITCM(gc_get_ptr)(void **ptrs, int i) {
|
2021-08-27 10:02:03 -04:00
|
|
|
#if MICROPY_DEBUG_VALGRIND
|
|
|
|
if (!VALGRIND_CHECK_MEM_IS_ADDRESSABLE(&ptrs[i], sizeof(*ptrs))) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2021-05-10 17:16:50 -04:00
|
|
|
return ptrs[i];
|
|
|
|
}
|
|
|
|
|
2015-11-27 08:07:48 -05:00
|
|
|
void gc_collect_root(void **ptrs, size_t len) {
|
2022-04-13 00:26:16 -04:00
|
|
|
#if !MICROPY_GC_SPLIT_HEAP
|
|
|
|
mp_state_mem_area_t *area = &MP_STATE_MEM(area);
|
|
|
|
#endif
|
2015-11-27 08:07:48 -05:00
|
|
|
for (size_t i = 0; i < len; i++) {
|
2023-03-15 17:48:16 -04:00
|
|
|
MICROPY_GC_HOOK_LOOP(i);
|
2021-05-10 17:16:50 -04:00
|
|
|
void *ptr = gc_get_ptr(ptrs, i);
|
2022-04-13 00:26:16 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
2018-01-23 20:09:58 -05:00
|
|
|
mp_state_mem_area_t *area = gc_get_ptr_area(ptr);
|
2022-04-13 00:26:16 -04:00
|
|
|
if (!area) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (!VERIFY_PTR(ptr)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
size_t block = BLOCK_FROM_PTR(area, ptr);
|
|
|
|
if (ATB_GET_KIND(area, block) == AT_HEAD) {
|
|
|
|
// An unmarked head: mark it, and mark all its children
|
|
|
|
ATB_HEAD_TO_MARK(area, block);
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
gc_mark_subtree(area, block);
|
|
|
|
#else
|
|
|
|
gc_mark_subtree(block);
|
|
|
|
#endif
|
2018-01-27 12:37:38 -05:00
|
|
|
}
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-23 15:20:17 -04:00
|
|
|
void gc_collect_end(void) {
|
2013-10-21 18:45:08 -04:00
|
|
|
gc_deal_with_stack_overflow();
|
|
|
|
gc_sweep();
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
MP_STATE_MEM(gc_last_free_area) = &MP_STATE_MEM(area);
|
|
|
|
#endif
|
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
|
|
|
area->gc_last_free_atb_index = 0;
|
|
|
|
}
|
2021-05-04 09:56:43 -04:00
|
|
|
MP_STATE_THREAD(gc_lock_depth)--;
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2013-10-22 10:25:25 -04:00
|
|
|
}
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2018-05-31 09:10:48 -04:00
|
|
|
void gc_sweep_all(void) {
|
|
|
|
GC_ENTER();
|
2021-05-04 09:56:43 -04:00
|
|
|
MP_STATE_THREAD(gc_lock_depth)++;
|
2018-05-31 09:10:48 -04:00
|
|
|
MP_STATE_MEM(gc_stack_overflow) = 0;
|
|
|
|
gc_collect_end();
|
|
|
|
}
|
|
|
|
|
2013-10-22 10:25:25 -04:00
|
|
|
void gc_info(gc_info_t *info) {
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_ENTER();
|
2018-01-23 20:09:58 -05:00
|
|
|
info->total = 0;
|
2013-10-22 10:25:25 -04:00
|
|
|
info->used = 0;
|
|
|
|
info->free = 0;
|
2016-06-30 17:09:55 -04:00
|
|
|
info->max_free = 0;
|
2013-10-22 10:25:25 -04:00
|
|
|
info->num_1block = 0;
|
|
|
|
info->num_2block = 0;
|
|
|
|
info->max_block = 0;
|
2018-01-23 20:09:58 -05:00
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
|
|
|
bool finish = false;
|
|
|
|
info->total += area->gc_pool_end - area->gc_pool_start;
|
|
|
|
for (size_t block = 0, len = 0, len_free = 0; !finish;) {
|
2023-03-15 17:48:16 -04:00
|
|
|
MICROPY_GC_HOOK_LOOP(block);
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t kind = ATB_GET_KIND(area, block);
|
|
|
|
switch (kind) {
|
|
|
|
case AT_FREE:
|
|
|
|
info->free += 1;
|
|
|
|
len_free += 1;
|
|
|
|
len = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AT_HEAD:
|
|
|
|
info->used += 1;
|
|
|
|
len = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AT_TAIL:
|
|
|
|
info->used += 1;
|
|
|
|
len += 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AT_MARK:
|
|
|
|
// shouldn't happen
|
|
|
|
break;
|
2016-06-29 18:59:24 -04:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
|
|
|
|
block++;
|
|
|
|
finish = (block == area->gc_alloc_table_byte_len * BLOCKS_PER_ATB);
|
|
|
|
// Get next block type if possible
|
|
|
|
if (!finish) {
|
|
|
|
kind = ATB_GET_KIND(area, block);
|
2016-06-29 18:59:24 -04:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
|
|
|
|
if (finish || kind == AT_FREE || kind == AT_HEAD) {
|
|
|
|
if (len == 1) {
|
|
|
|
info->num_1block += 1;
|
|
|
|
} else if (len == 2) {
|
|
|
|
info->num_2block += 1;
|
|
|
|
}
|
|
|
|
if (len > info->max_block) {
|
|
|
|
info->max_block = len;
|
|
|
|
}
|
|
|
|
if (finish || kind == AT_HEAD) {
|
|
|
|
if (len_free > info->max_free) {
|
|
|
|
info->max_free = len_free;
|
|
|
|
}
|
|
|
|
len_free = 0;
|
2016-06-30 17:09:55 -04:00
|
|
|
}
|
|
|
|
}
|
2016-06-29 18:59:24 -04:00
|
|
|
}
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
|
2013-10-22 10:25:25 -04:00
|
|
|
info->used *= BYTES_PER_BLOCK;
|
|
|
|
info->free *= BYTES_PER_BLOCK;
|
2023-09-04 20:58:19 -04:00
|
|
|
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
|
|
|
info->max_new_split = gc_get_max_new_split();
|
|
|
|
#endif
|
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2020-01-12 23:32:51 -05:00
|
|
|
bool gc_alloc_possible(void) {
|
2023-09-20 12:19:57 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
return MP_STATE_MEM(gc_last_free_area) != 0;
|
|
|
|
#else
|
|
|
|
return MP_STATE_MEM(area).gc_pool_start != 0;
|
|
|
|
#endif
|
2020-01-12 23:32:51 -05:00
|
|
|
}
|
|
|
|
|
2023-08-08 20:41:17 -04:00
|
|
|
void *gc_alloc(size_t n_bytes, unsigned int alloc_flags) {
|
2018-10-26 15:27:44 -04:00
|
|
|
bool has_finaliser = alloc_flags & GC_ALLOC_FLAG_HAS_FINALISER;
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t n_blocks = ((n_bytes + BYTES_PER_BLOCK - 1) & (~(BYTES_PER_BLOCK - 1))) / BYTES_PER_BLOCK;
|
2014-06-18 04:20:41 -04:00
|
|
|
DEBUG_printf("gc_alloc(" UINT_FMT " bytes -> " UINT_FMT " blocks)\n", n_bytes, n_blocks);
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
// check for 0 allocation
|
|
|
|
if (n_blocks == 0) {
|
2014-04-08 07:31:21 -04:00
|
|
|
return NULL;
|
2014-04-05 15:35:48 -04:00
|
|
|
}
|
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
// check if GC is locked
|
2021-05-04 09:56:43 -04:00
|
|
|
if (MP_STATE_THREAD(gc_lock_depth) > 0) {
|
2013-10-21 18:45:08 -04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-05-04 09:56:43 -04:00
|
|
|
GC_ENTER();
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
mp_state_mem_area_t *area;
|
2023-08-08 20:41:17 -04:00
|
|
|
size_t i;
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t end_block;
|
|
|
|
size_t start_block;
|
py/gc: In gc_alloc, reset n_free var right before search for free mem.
Otherwise there is the possibility that n_free starts out non-zero from the
previous iteration, which may have found a few (but not enough) free blocks
at the end of the heap. If this is the case, and if the very first blocks
that are scanned the second time around (starting at
gc_last_free_atb_index) are found to give enough memory (including the
blocks at the end of the heap from the previous iteration that left n_free
non-zero) then memory will be allocated starting before the location that
gc_last_free_atb_index points to, most likely leading to corruption.
This serious bug did not manifest itself in the past because a gc_collect
always resets gc_last_free_atb_index to point to the start of the GC heap,
and the first block there is almost always allocated to a long-lived
object (eg entries from sys.path, or mounted filesystem objects), which
means that n_free would be reset at the start of the search loop.
But with threading enabled with the GIL disabled it is possible to trigger
the bug via the following sequence of events:
1. Thread A runs gc_alloc, fails to find enough memory, and has a non-zero
n_free at the end of the search.
2. Thread A calls gc_collect and frees a bunch of blocks on the GC heap.
3. Just after gc_collect finishes in thread A, thread B takes gc_mutex and
does an allocation, moving gc_last_free_atb_index to point to the
interior of the heap, to a place where there is most likely a run of
available blocks.
4. Thread A regains gc_mutex and does its second search for free memory,
starting with a non-zero n_free. Since it's likely that the first block
it searches is available it will allocate memory which overlaps with the
memory before gc_last_free_atb_index.
2018-08-10 01:46:45 -04:00
|
|
|
size_t n_free;
|
2023-08-08 20:41:17 -04:00
|
|
|
int collected = !MP_STATE_MEM(gc_auto_collect_enabled);
|
2023-08-02 02:49:44 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
|
|
|
bool added = false;
|
|
|
|
#endif
|
py/gc: Implement GC running by allocation threshold.
Currently, MicroPython runs GC when it could not allocate a block of memory,
which happens when heap is exhausted. However, that policy can't work well
with "inifinity" heaps, e.g. backed by a virtual memory - there will be a
lot of swap thrashing long before VM will be exhausted. Instead, in such
cases "allocation threshold" policy is used: a GC is run after some number of
allocations have been made. Details vary, for example, number or total amount
of allocations can be used, threshold may be self-adjusting based on GC
outcome, etc.
This change implements a simple variant of such policy for MicroPython. Amount
of allocated memory so far is used for threshold, to make it useful to typical
finite-size, and small, heaps as used with MicroPython ports. And such GC policy
is indeed useful for such types of heaps too, as it allows to better control
fragmentation. For example, if a threshold is set to half size of heap, then
for an application which usually makes big number of small allocations, that
will (try to) keep half of heap memory in a nice defragmented state for an
occasional large allocation.
For an application which doesn't exhibit such behavior, there won't be any
visible effects, except for GC running more frequently, which however may
affect performance. To address this, the GC threshold is configurable, and
by default is off so far. It's configured with gc.threshold(amount_in_bytes)
call (can be queries without an argument).
2016-07-20 17:37:30 -04:00
|
|
|
|
|
|
|
#if MICROPY_GC_ALLOC_THRESHOLD
|
|
|
|
if (!collected && MP_STATE_MEM(gc_alloc_amount) >= MP_STATE_MEM(gc_alloc_threshold)) {
|
|
|
|
GC_EXIT();
|
|
|
|
gc_collect();
|
2018-05-20 23:36:21 -04:00
|
|
|
collected = 1;
|
py/gc: Implement GC running by allocation threshold.
Currently, MicroPython runs GC when it could not allocate a block of memory,
which happens when heap is exhausted. However, that policy can't work well
with "inifinity" heaps, e.g. backed by a virtual memory - there will be a
lot of swap thrashing long before VM will be exhausted. Instead, in such
cases "allocation threshold" policy is used: a GC is run after some number of
allocations have been made. Details vary, for example, number or total amount
of allocations can be used, threshold may be self-adjusting based on GC
outcome, etc.
This change implements a simple variant of such policy for MicroPython. Amount
of allocated memory so far is used for threshold, to make it useful to typical
finite-size, and small, heaps as used with MicroPython ports. And such GC policy
is indeed useful for such types of heaps too, as it allows to better control
fragmentation. For example, if a threshold is set to half size of heap, then
for an application which usually makes big number of small allocations, that
will (try to) keep half of heap memory in a nice defragmented state for an
occasional large allocation.
For an application which doesn't exhibit such behavior, there won't be any
visible effects, except for GC running more frequently, which however may
affect performance. To address this, the GC threshold is configurable, and
by default is off so far. It's configured with gc.threshold(amount_in_bytes)
call (can be queries without an argument).
2016-07-20 17:37:30 -04:00
|
|
|
GC_ENTER();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2023-08-08 20:41:17 -04:00
|
|
|
for (;;) {
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
area = MP_STATE_MEM(gc_last_free_area);
|
|
|
|
#else
|
|
|
|
area = &MP_STATE_MEM(area);
|
|
|
|
#endif
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2023-09-19 11:10:12 -04:00
|
|
|
if (area == 0) {
|
|
|
|
reset_into_safe_mode(SAFE_MODE_GC_ALLOC_OUTSIDE_VM);
|
|
|
|
}
|
|
|
|
|
2013-10-21 18:45:08 -04:00
|
|
|
// look for a run of n_blocks available blocks
|
2018-01-23 20:09:58 -05:00
|
|
|
for (; area != NULL; area = NEXT_AREA(area), i = 0) {
|
|
|
|
n_free = 0;
|
|
|
|
for (i = area->gc_last_free_atb_index; i < area->gc_alloc_table_byte_len; i++) {
|
2023-03-15 17:48:16 -04:00
|
|
|
MICROPY_GC_HOOK_LOOP(i);
|
2018-01-23 20:09:58 -05:00
|
|
|
byte a = area->gc_alloc_table_start[i];
|
|
|
|
// *FORMAT-OFF*
|
|
|
|
if (ATB_0_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 0; goto found; } } else { n_free = 0; }
|
|
|
|
if (ATB_1_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 1; goto found; } } else { n_free = 0; }
|
|
|
|
if (ATB_2_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 2; goto found; } } else { n_free = 0; }
|
|
|
|
if (ATB_3_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 3; goto found; } } else { n_free = 0; }
|
|
|
|
// *FORMAT-ON*
|
|
|
|
}
|
|
|
|
|
|
|
|
// No free blocks found on this heap. Mark this heap as
|
|
|
|
// filled, so we won't try to find free space here again until
|
|
|
|
// space is freed.
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
if (n_blocks == 1) {
|
|
|
|
area->gc_last_free_atb_index = (i + 1) / BLOCKS_PER_ATB; // or (size_t)-1
|
|
|
|
}
|
|
|
|
#endif
|
2014-08-22 13:17:02 -04:00
|
|
|
}
|
2013-10-21 18:45:08 -04:00
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2013-10-21 18:45:08 -04:00
|
|
|
// nothing found!
|
|
|
|
if (collected) {
|
2023-08-02 02:49:44 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
|
|
|
if (!added && gc_try_add_heap(n_bytes)) {
|
|
|
|
added = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
2023-10-02 19:49:31 -04:00
|
|
|
|
|
|
|
#if CIRCUITPY_DEBUG
|
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
|
|
|
#endif
|
2013-10-21 18:45:08 -04:00
|
|
|
return NULL;
|
|
|
|
}
|
2014-02-11 11:01:38 -05:00
|
|
|
DEBUG_printf("gc_alloc(" UINT_FMT "): no free mem, triggering GC\n", n_bytes);
|
2013-10-21 18:45:08 -04:00
|
|
|
gc_collect();
|
2023-08-08 20:41:17 -04:00
|
|
|
collected = 1;
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_ENTER();
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
2023-08-08 20:41:17 -04:00
|
|
|
|
|
|
|
// found, ending at block i inclusive
|
|
|
|
found:
|
|
|
|
// get starting and end blocks, both inclusive
|
|
|
|
end_block = i;
|
|
|
|
start_block = i - n_free + 1;
|
|
|
|
|
|
|
|
// Set last free ATB index to block after last block we found, for start of
|
|
|
|
// next scan. To reduce fragmentation, we only do this if we were looking
|
|
|
|
// for a single free block, which guarantees that there are no free blocks
|
|
|
|
// before this one. Also, whenever we free or shink a block we must check
|
|
|
|
// if this index needs adjusting (see gc_realloc and gc_free).
|
|
|
|
if (n_free == 1) {
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
MP_STATE_MEM(gc_last_free_area) = area;
|
|
|
|
#endif
|
|
|
|
area->gc_last_free_atb_index = (i + 1) / BLOCKS_PER_ATB;
|
2014-08-28 05:18:40 -04:00
|
|
|
}
|
2014-08-22 13:17:02 -04:00
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2016-11-23 20:31:53 -05:00
|
|
|
#ifdef LOG_HEAP_ACTIVITY
|
|
|
|
gc_log_change(start_block, end_block - start_block + 1);
|
|
|
|
#endif
|
|
|
|
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
area->gc_last_used_block = MAX(area->gc_last_used_block, end_block);
|
|
|
|
|
2013-10-21 18:45:08 -04:00
|
|
|
// mark first block as used head
|
2018-01-23 20:09:58 -05:00
|
|
|
ATB_FREE_TO_HEAD(area, start_block);
|
2013-10-21 18:45:08 -04:00
|
|
|
|
|
|
|
// mark rest of blocks as used tail
|
|
|
|
// TODO for a run of many blocks can make this more efficient
|
2015-12-16 20:09:11 -05:00
|
|
|
for (size_t bl = start_block + 1; bl <= end_block; bl++) {
|
2018-01-23 20:09:58 -05:00
|
|
|
ATB_FREE_TO_TAIL(area, bl);
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
// get pointer to first block
|
2016-05-05 06:25:08 -04:00
|
|
|
// we must create this pointer before unlocking the GC so a collection can find it
|
2018-01-23 20:09:58 -05:00
|
|
|
void *ret_ptr = (void *)(area->gc_pool_start + start_block * BYTES_PER_BLOCK);
|
2014-06-18 04:20:41 -04:00
|
|
|
DEBUG_printf("gc_alloc(%p)\n", ret_ptr);
|
2014-04-05 15:35:48 -04:00
|
|
|
|
py/gc: Implement GC running by allocation threshold.
Currently, MicroPython runs GC when it could not allocate a block of memory,
which happens when heap is exhausted. However, that policy can't work well
with "inifinity" heaps, e.g. backed by a virtual memory - there will be a
lot of swap thrashing long before VM will be exhausted. Instead, in such
cases "allocation threshold" policy is used: a GC is run after some number of
allocations have been made. Details vary, for example, number or total amount
of allocations can be used, threshold may be self-adjusting based on GC
outcome, etc.
This change implements a simple variant of such policy for MicroPython. Amount
of allocated memory so far is used for threshold, to make it useful to typical
finite-size, and small, heaps as used with MicroPython ports. And such GC policy
is indeed useful for such types of heaps too, as it allows to better control
fragmentation. For example, if a threshold is set to half size of heap, then
for an application which usually makes big number of small allocations, that
will (try to) keep half of heap memory in a nice defragmented state for an
occasional large allocation.
For an application which doesn't exhibit such behavior, there won't be any
visible effects, except for GC running more frequently, which however may
affect performance. To address this, the GC threshold is configurable, and
by default is off so far. It's configured with gc.threshold(amount_in_bytes)
call (can be queries without an argument).
2016-07-20 17:37:30 -04:00
|
|
|
#if MICROPY_GC_ALLOC_THRESHOLD
|
|
|
|
MP_STATE_MEM(gc_alloc_amount) += n_blocks;
|
|
|
|
#endif
|
|
|
|
|
2016-05-05 06:25:08 -04:00
|
|
|
GC_EXIT();
|
|
|
|
|
2016-08-26 01:35:26 -04:00
|
|
|
#if MICROPY_GC_CONSERVATIVE_CLEAR
|
|
|
|
// be conservative and zero out all the newly allocated blocks
|
|
|
|
memset((byte *)ret_ptr, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK);
|
|
|
|
#else
|
2014-04-26 17:23:42 -04:00
|
|
|
// zero out the additional bytes of the newly allocated blocks
|
py, gc: Zero out newly allocated blocks in the GC.
Also add some more debugging output to gc_dump_alloc_table().
Now that newly allocated heap is always zero'd, maybe we just make this
a policy for the uPy API to keep it simple (ie any new implementation of
memory allocation must zero all allocations). This follows the D
language philosophy.
Before this patch, a previously used memory block which had pointers in
it may still retain those pointers if the new user of that block does
not actually use the entire block. Eg, if I want 5 blocks worth of
heap, I actually get 8 (round up to nearest 4). Then I never use the
last 3, so they keep their old values, which may be pointers pointing to
the heap, hence preventing GC.
In rare (or maybe not that rare) cases, this leads to long, unintentional
"linked lists" within the GC'd heap, filling it up completely. It's
pretty rare, because you have to reuse exactly that memory which is part
of this "linked list", and reuse it in just the right way.
This should fix issue #522, and might have something to do with
issue #510.
2014-04-25 18:37:55 -04:00
|
|
|
// This is needed because the blocks may have previously held pointers
|
|
|
|
// to the heap and will not be set to something else if the caller
|
|
|
|
// doesn't actually use the entire block. As such they will continue
|
|
|
|
// to point to the heap and may prevent other blocks from being reclaimed.
|
2014-06-13 17:33:31 -04:00
|
|
|
memset((byte *)ret_ptr + n_bytes, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK - n_bytes);
|
2016-08-26 01:35:26 -04:00
|
|
|
#endif
|
py, gc: Zero out newly allocated blocks in the GC.
Also add some more debugging output to gc_dump_alloc_table().
Now that newly allocated heap is always zero'd, maybe we just make this
a policy for the uPy API to keep it simple (ie any new implementation of
memory allocation must zero all allocations). This follows the D
language philosophy.
Before this patch, a previously used memory block which had pointers in
it may still retain those pointers if the new user of that block does
not actually use the entire block. Eg, if I want 5 blocks worth of
heap, I actually get 8 (round up to nearest 4). Then I never use the
last 3, so they keep their old values, which may be pointers pointing to
the heap, hence preventing GC.
In rare (or maybe not that rare) cases, this leads to long, unintentional
"linked lists" within the GC'd heap, filling it up completely. It's
pretty rare, because you have to reuse exactly that memory which is part
of this "linked list", and reuse it in just the right way.
This should fix issue #522, and might have something to do with
issue #510.
2014-04-25 18:37:55 -04:00
|
|
|
|
2015-09-04 11:53:46 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2014-04-05 15:35:48 -04:00
|
|
|
if (has_finaliser) {
|
2014-04-26 17:23:42 -04:00
|
|
|
// clear type pointer in case it is never set
|
2015-11-27 08:07:48 -05:00
|
|
|
((mp_obj_base_t *)ret_ptr)->type = NULL;
|
2014-04-05 15:35:48 -04:00
|
|
|
// set mp_obj flag only if it has a finaliser
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_ENTER();
|
2018-01-23 20:09:58 -05:00
|
|
|
FTB_SET(area, start_block);
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2014-04-05 09:49:03 -04:00
|
|
|
}
|
2015-09-04 11:53:46 -04:00
|
|
|
#else
|
|
|
|
(void)has_finaliser;
|
|
|
|
#endif
|
2014-04-05 09:49:03 -04:00
|
|
|
|
2014-08-28 18:06:38 -04:00
|
|
|
#if EXTENSIVE_HEAP_PROFILING
|
2023-03-08 21:50:21 -05:00
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
2023-09-20 12:20:29 -04:00
|
|
|
#endif
|
2014-08-28 18:06:38 -04:00
|
|
|
|
2020-07-15 20:58:38 -04:00
|
|
|
#if CIRCUITPY_MEMORYMONITOR
|
2020-07-16 22:01:43 -04:00
|
|
|
memorymonitor_track_allocation(end_block - start_block + 1);
|
2023-09-20 12:19:57 -04:00
|
|
|
#endif
|
2020-07-15 20:58:38 -04:00
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
return ret_ptr;
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
|
|
|
|
2014-04-05 15:35:48 -04:00
|
|
|
/*
|
2014-07-03 08:25:24 -04:00
|
|
|
void *gc_alloc(mp_uint_t n_bytes) {
|
2014-04-03 17:55:12 -04:00
|
|
|
return _gc_alloc(n_bytes, false);
|
|
|
|
}
|
|
|
|
|
2014-07-03 08:25:24 -04:00
|
|
|
void *gc_alloc_with_finaliser(mp_uint_t n_bytes) {
|
2014-04-03 17:55:12 -04:00
|
|
|
return _gc_alloc(n_bytes, true);
|
|
|
|
}
|
2014-04-05 15:35:48 -04:00
|
|
|
*/
|
2014-04-03 17:55:12 -04:00
|
|
|
|
2013-10-22 15:26:36 -04:00
|
|
|
// force the freeing of a piece of memory
|
2015-11-06 17:32:47 -05:00
|
|
|
// TODO: freeing here does not call finaliser
|
2015-11-27 08:07:48 -05:00
|
|
|
void gc_free(void *ptr) {
|
2021-05-04 09:56:43 -04:00
|
|
|
if (MP_STATE_THREAD(gc_lock_depth) > 0) {
|
2023-03-02 01:32:13 -05:00
|
|
|
// Cannot free while the GC is locked. However free is an optimisation
|
|
|
|
// to reclaim the memory immediately, this means it will now be left
|
|
|
|
// until the next collection.
|
2014-04-08 07:31:21 -04:00
|
|
|
return;
|
2014-04-05 15:35:48 -04:00
|
|
|
}
|
|
|
|
|
2021-05-04 09:56:43 -04:00
|
|
|
GC_ENTER();
|
|
|
|
|
2014-06-16 04:44:29 -04:00
|
|
|
DEBUG_printf("gc_free(%p)\n", ptr);
|
2013-10-22 15:26:36 -04:00
|
|
|
|
2017-07-11 22:17:38 -04:00
|
|
|
if (ptr == NULL) {
|
2018-01-23 20:09:58 -05:00
|
|
|
// free(NULL) is a no-op
|
2017-07-11 22:17:38 -04:00
|
|
|
GC_EXIT();
|
2018-01-23 20:09:58 -05:00
|
|
|
return;
|
|
|
|
}
|
2016-04-25 11:28:57 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
// get the GC block number corresponding to this pointer
|
2022-04-13 00:26:16 -04:00
|
|
|
mp_state_mem_area_t *area;
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
area = gc_get_ptr_area(ptr);
|
2023-10-20 16:51:04 -04:00
|
|
|
// assert(area);
|
|
|
|
#else
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE: extra checking
|
2023-10-02 19:49:31 -04:00
|
|
|
if (MP_STATE_MEM(area).gc_pool_start == 0) {
|
2023-09-19 11:10:12 -04:00
|
|
|
reset_into_safe_mode(SAFE_MODE_GC_ALLOC_OUTSIDE_VM);
|
|
|
|
}
|
2022-04-13 00:26:16 -04:00
|
|
|
assert(VERIFY_PTR(ptr));
|
|
|
|
area = &MP_STATE_MEM(area);
|
|
|
|
#endif
|
2023-08-08 20:41:17 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t block = BLOCK_FROM_PTR(area, ptr);
|
|
|
|
assert(ATB_GET_KIND(area, block) == AT_HEAD);
|
2023-08-08 20:41:17 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
|
|
|
FTB_CLEAR(area, block);
|
|
|
|
#endif
|
2017-07-11 22:17:38 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
if (MP_STATE_MEM(gc_last_free_area) != area) {
|
|
|
|
// We freed something but it isn't the current area. Reset the
|
|
|
|
// last free area to the start for a rescan. Note that this won't
|
|
|
|
// give much of a performance hit, since areas that are completely
|
|
|
|
// filled will likely be skipped (the gc_last_free_atb_index
|
|
|
|
// points to the last block).
|
|
|
|
// The reason why this is necessary is because it is not possible
|
|
|
|
// to see which area came first (like it is possible to adjust
|
|
|
|
// gc_last_free_atb_index based on whether the freed block is
|
|
|
|
// before the last free block).
|
|
|
|
MP_STATE_MEM(gc_last_free_area) = &MP_STATE_MEM(area);
|
|
|
|
}
|
|
|
|
#endif
|
2017-07-11 22:17:38 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
// set the last_free pointer to this block if it's earlier in the heap
|
|
|
|
if (block / BLOCKS_PER_ATB < area->gc_last_free_atb_index) {
|
|
|
|
area->gc_last_free_atb_index = block / BLOCKS_PER_ATB;
|
2013-10-22 15:26:36 -04:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2023-09-19 11:10:12 -04:00
|
|
|
#ifdef LOG_HEAP_ACTIVITY
|
|
|
|
gc_log_change(start_block, 0);
|
|
|
|
#endif
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
// free head and all of its tail blocks
|
|
|
|
do {
|
|
|
|
ATB_ANY_TO_FREE(area, block);
|
|
|
|
block += 1;
|
|
|
|
} while (ATB_GET_KIND(area, block) == AT_TAIL);
|
|
|
|
|
|
|
|
GC_EXIT();
|
|
|
|
|
|
|
|
#if EXTENSIVE_HEAP_PROFILING
|
2023-03-08 21:50:21 -05:00
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
2018-01-23 20:09:58 -05:00
|
|
|
#endif
|
2013-10-22 15:26:36 -04:00
|
|
|
}
|
|
|
|
|
2015-11-27 08:07:48 -05:00
|
|
|
size_t gc_nbytes(const void *ptr) {
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_ENTER();
|
2022-04-13 00:26:16 -04:00
|
|
|
|
|
|
|
mp_state_mem_area_t *area;
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
area = gc_get_ptr_area(ptr);
|
|
|
|
#else
|
2013-10-22 15:26:36 -04:00
|
|
|
if (VERIFY_PTR(ptr)) {
|
2022-04-13 00:26:16 -04:00
|
|
|
area = &MP_STATE_MEM(area);
|
|
|
|
} else {
|
|
|
|
area = NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
if (area) {
|
|
|
|
size_t block = BLOCK_FROM_PTR(area, ptr);
|
|
|
|
if (ATB_GET_KIND(area, block) == AT_HEAD) {
|
2013-10-21 18:45:08 -04:00
|
|
|
// work out number of consecutive blocks in the chain starting with this on
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t n_blocks = 0;
|
2013-10-21 18:45:08 -04:00
|
|
|
do {
|
|
|
|
n_blocks += 1;
|
2018-01-23 20:09:58 -05:00
|
|
|
} while (ATB_GET_KIND(area, block + n_blocks) == AT_TAIL);
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2013-10-21 18:45:08 -04:00
|
|
|
return n_blocks * BYTES_PER_BLOCK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// invalid pointer
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2013-10-21 18:45:08 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-12 15:00:23 -04:00
|
|
|
#if 0
|
2014-04-08 07:31:21 -04:00
|
|
|
// old, simple realloc that didn't expand memory in place
|
2014-07-03 08:25:24 -04:00
|
|
|
void *gc_realloc(void *ptr, mp_uint_t n_bytes) {
|
|
|
|
mp_uint_t n_existing = gc_nbytes(ptr);
|
2014-03-06 19:21:51 -05:00
|
|
|
if (n_bytes <= n_existing) {
|
|
|
|
return ptr;
|
|
|
|
} else {
|
2014-04-25 07:44:53 -04:00
|
|
|
bool has_finaliser;
|
|
|
|
if (ptr == NULL) {
|
|
|
|
has_finaliser = false;
|
|
|
|
} else {
|
2014-04-20 04:43:38 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2014-07-03 08:25:24 -04:00
|
|
|
has_finaliser = FTB_GET(BLOCK_FROM_PTR((mp_uint_t)ptr));
|
2014-04-20 04:43:38 -04:00
|
|
|
#else
|
2014-04-25 07:44:53 -04:00
|
|
|
has_finaliser = false;
|
2014-04-20 04:43:38 -04:00
|
|
|
#endif
|
2014-04-25 07:44:53 -04:00
|
|
|
}
|
|
|
|
void *ptr2 = gc_alloc(n_bytes, has_finaliser);
|
2014-03-06 19:21:51 -05:00
|
|
|
if (ptr2 == NULL) {
|
|
|
|
return ptr2;
|
|
|
|
}
|
|
|
|
memcpy(ptr2, ptr, n_existing);
|
|
|
|
gc_free(ptr);
|
|
|
|
return ptr2;
|
|
|
|
}
|
|
|
|
}
|
2014-04-20 04:43:38 -04:00
|
|
|
|
|
|
|
#else // Alternative gc_realloc impl
|
2014-04-08 07:31:21 -04:00
|
|
|
|
2015-11-27 08:07:48 -05:00
|
|
|
void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {
|
2014-04-20 13:16:25 -04:00
|
|
|
// check for pure allocation
|
2014-03-05 16:23:04 -05:00
|
|
|
if (ptr_in == NULL) {
|
2023-08-08 20:41:17 -04:00
|
|
|
return gc_alloc(n_bytes, false);
|
2014-03-05 16:23:04 -05:00
|
|
|
}
|
|
|
|
|
2014-10-23 07:02:00 -04:00
|
|
|
// check for pure free
|
|
|
|
if (n_bytes == 0) {
|
|
|
|
gc_free(ptr_in);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-05-04 09:56:43 -04:00
|
|
|
if (MP_STATE_THREAD(gc_lock_depth) > 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-11-27 08:07:48 -05:00
|
|
|
void *ptr = ptr_in;
|
2014-04-20 13:16:25 -04:00
|
|
|
|
2016-05-04 05:14:43 -04:00
|
|
|
GC_ENTER();
|
|
|
|
|
2017-11-29 01:17:08 -05:00
|
|
|
// get the GC block number corresponding to this pointer
|
2022-04-13 00:26:16 -04:00
|
|
|
mp_state_mem_area_t *area;
|
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
area = gc_get_ptr_area(ptr);
|
2018-01-23 20:09:58 -05:00
|
|
|
assert(area);
|
2022-04-13 00:26:16 -04:00
|
|
|
#else
|
2017-11-29 01:17:08 -05:00
|
|
|
assert(VERIFY_PTR(ptr));
|
2022-04-13 00:26:16 -04:00
|
|
|
area = &MP_STATE_MEM(area);
|
|
|
|
#endif
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t block = BLOCK_FROM_PTR(area, ptr);
|
|
|
|
assert(ATB_GET_KIND(area, block) == AT_HEAD);
|
2017-11-29 01:17:08 -05:00
|
|
|
|
2014-04-20 13:16:25 -04:00
|
|
|
// compute number of new blocks that are requested
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t new_blocks = (n_bytes + BYTES_PER_BLOCK - 1) / BYTES_PER_BLOCK;
|
2014-03-05 16:23:04 -05:00
|
|
|
|
2014-10-15 14:24:47 -04:00
|
|
|
// Get the total number of consecutive blocks that are already allocated to
|
|
|
|
// this chunk of memory, and then count the number of free blocks following
|
|
|
|
// it. Stop if we reach the end of the heap, or if we find enough extra
|
|
|
|
// free blocks to satisfy the realloc. Note that we need to compute the
|
|
|
|
// total size of the existing memory chunk so we can correctly and
|
|
|
|
// efficiently shrink it (see below for shrinking code).
|
2015-12-16 20:09:11 -05:00
|
|
|
size_t n_free = 0;
|
|
|
|
size_t n_blocks = 1; // counting HEAD block
|
2018-01-23 20:09:58 -05:00
|
|
|
size_t max_block = area->gc_alloc_table_byte_len * BLOCKS_PER_ATB;
|
2015-12-16 20:09:11 -05:00
|
|
|
for (size_t bl = block + n_blocks; bl < max_block; bl++) {
|
2018-01-23 20:09:58 -05:00
|
|
|
byte block_type = ATB_GET_KIND(area, bl);
|
2014-10-15 14:24:47 -04:00
|
|
|
if (block_type == AT_TAIL) {
|
|
|
|
n_blocks++;
|
|
|
|
continue;
|
2014-03-12 15:00:23 -04:00
|
|
|
}
|
2014-10-15 14:24:47 -04:00
|
|
|
if (block_type == AT_FREE) {
|
|
|
|
n_free++;
|
|
|
|
if (n_blocks + n_free >= new_blocks) {
|
|
|
|
// stop as soon as we find enough blocks for n_bytes
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
continue;
|
2014-04-20 13:16:25 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return original ptr if it already has the requested number of blocks
|
|
|
|
if (new_blocks == n_blocks) {
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2014-04-20 13:16:25 -04:00
|
|
|
return ptr_in;
|
|
|
|
}
|
2014-03-05 16:23:04 -05:00
|
|
|
|
2014-04-20 13:16:25 -04:00
|
|
|
// check if we can shrink the allocated area
|
|
|
|
if (new_blocks < n_blocks) {
|
|
|
|
// free unneeded tail blocks
|
2015-12-16 20:09:11 -05:00
|
|
|
for (size_t bl = block + new_blocks, count = n_blocks - new_blocks; count > 0; bl++, count--) {
|
2018-01-23 20:09:58 -05:00
|
|
|
ATB_ANY_TO_FREE(area, bl);
|
2014-04-20 04:45:16 -04:00
|
|
|
}
|
2014-08-28 18:06:38 -04:00
|
|
|
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP
|
|
|
|
if (MP_STATE_MEM(gc_last_free_area) != area) {
|
|
|
|
// See comment in gc_free.
|
|
|
|
MP_STATE_MEM(gc_last_free_area) = &MP_STATE_MEM(area);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-08-28 18:06:38 -04:00
|
|
|
// set the last_free pointer to end of this block if it's earlier in the heap
|
2018-01-23 20:09:58 -05:00
|
|
|
if ((block + new_blocks) / BLOCKS_PER_ATB < area->gc_last_free_atb_index) {
|
|
|
|
area->gc_last_free_atb_index = (block + new_blocks) / BLOCKS_PER_ATB;
|
2014-08-28 18:06:38 -04:00
|
|
|
}
|
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
|
|
|
|
2014-08-28 18:06:38 -04:00
|
|
|
#if EXTENSIVE_HEAP_PROFILING
|
2023-03-08 21:50:21 -05:00
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
2014-08-28 18:06:38 -04:00
|
|
|
#endif
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2016-11-23 20:31:53 -05:00
|
|
|
#ifdef LOG_HEAP_ACTIVITY
|
|
|
|
gc_log_change(block, new_blocks);
|
|
|
|
#endif
|
|
|
|
|
2020-07-15 20:58:38 -04:00
|
|
|
#if CIRCUITPY_MEMORYMONITOR
|
2020-07-16 22:01:43 -04:00
|
|
|
memorymonitor_track_allocation(new_blocks);
|
2020-07-15 20:58:38 -04:00
|
|
|
#endif
|
|
|
|
|
2014-04-20 13:16:25 -04:00
|
|
|
return ptr_in;
|
|
|
|
}
|
2014-04-20 04:45:16 -04:00
|
|
|
|
2014-04-20 13:16:25 -04:00
|
|
|
// check if we can expand in place
|
|
|
|
if (new_blocks <= n_blocks + n_free) {
|
|
|
|
// mark few more blocks as used tail
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
size_t end_block = block + new_blocks;
|
|
|
|
for (size_t bl = block + n_blocks; bl < end_block; bl++) {
|
2018-01-23 20:09:58 -05:00
|
|
|
assert(ATB_GET_KIND(area, bl) == AT_FREE);
|
|
|
|
ATB_FREE_TO_TAIL(area, bl);
|
2014-04-20 13:16:25 -04:00
|
|
|
}
|
py, gc: Zero out newly allocated blocks in the GC.
Also add some more debugging output to gc_dump_alloc_table().
Now that newly allocated heap is always zero'd, maybe we just make this
a policy for the uPy API to keep it simple (ie any new implementation of
memory allocation must zero all allocations). This follows the D
language philosophy.
Before this patch, a previously used memory block which had pointers in
it may still retain those pointers if the new user of that block does
not actually use the entire block. Eg, if I want 5 blocks worth of
heap, I actually get 8 (round up to nearest 4). Then I never use the
last 3, so they keep their old values, which may be pointers pointing to
the heap, hence preventing GC.
In rare (or maybe not that rare) cases, this leads to long, unintentional
"linked lists" within the GC'd heap, filling it up completely. It's
pretty rare, because you have to reuse exactly that memory which is part
of this "linked list", and reuse it in just the right way.
This should fix issue #522, and might have something to do with
issue #510.
2014-04-25 18:37:55 -04:00
|
|
|
|
py/gc: Speed up incremental GC cycles by tracking the last used block.
In applications that use little memory and run GC regularly, the cost of
the sweep phase quickly becomes prohibitives as the amount of RAM
increases.
On an ESP32-S3 with 2 MB of external SPIRAM, for example, a trivial GC
cycle takes a minimum of 40ms, virtually all of it in the sweep phase.
Similarly, on the UNIX port with 1 GB of heap, a trivial GC takes 47 ms,
again virtually all of it in the sweep phase.
This commit speeds up the sweep phase in the case most of the heap is empty
by keeping track of the ID of the highest block we allocated in an area
since the last GC.
The performance benchmark run on PYBV10 shows between +0 and +2%
improvement across the existing performance tests. These tests don't
really stress the GC, so they were also run with gc.threshold(30000) and
gc.threshold(10000). For the 30000 case, performance improved by up to
+10% with this commit. For the 10000 case, performance improved by at
least +10% on 6 tests, and up to +25%.
Signed-off-by: Damien George <damien@micropython.org>
2022-12-15 17:09:19 -05:00
|
|
|
area->gc_last_used_block = MAX(area->gc_last_used_block, end_block);
|
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
|
|
|
|
2016-08-26 01:35:26 -04:00
|
|
|
#if MICROPY_GC_CONSERVATIVE_CLEAR
|
|
|
|
// be conservative and zero out all the newly allocated blocks
|
|
|
|
memset((byte *)ptr_in + n_blocks * BYTES_PER_BLOCK, 0, (new_blocks - n_blocks) * BYTES_PER_BLOCK);
|
|
|
|
#else
|
2014-04-26 17:23:42 -04:00
|
|
|
// zero out the additional bytes of the newly allocated blocks (see comment above in gc_alloc)
|
2014-06-12 11:42:20 -04:00
|
|
|
memset((byte *)ptr_in + n_bytes, 0, new_blocks * BYTES_PER_BLOCK - n_bytes);
|
2016-08-26 01:35:26 -04:00
|
|
|
#endif
|
py, gc: Zero out newly allocated blocks in the GC.
Also add some more debugging output to gc_dump_alloc_table().
Now that newly allocated heap is always zero'd, maybe we just make this
a policy for the uPy API to keep it simple (ie any new implementation of
memory allocation must zero all allocations). This follows the D
language philosophy.
Before this patch, a previously used memory block which had pointers in
it may still retain those pointers if the new user of that block does
not actually use the entire block. Eg, if I want 5 blocks worth of
heap, I actually get 8 (round up to nearest 4). Then I never use the
last 3, so they keep their old values, which may be pointers pointing to
the heap, hence preventing GC.
In rare (or maybe not that rare) cases, this leads to long, unintentional
"linked lists" within the GC'd heap, filling it up completely. It's
pretty rare, because you have to reuse exactly that memory which is part
of this "linked list", and reuse it in just the right way.
This should fix issue #522, and might have something to do with
issue #510.
2014-04-25 18:37:55 -04:00
|
|
|
|
2014-08-28 18:06:38 -04:00
|
|
|
#if EXTENSIVE_HEAP_PROFILING
|
2023-03-08 21:50:21 -05:00
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
2014-08-28 18:06:38 -04:00
|
|
|
#endif
|
|
|
|
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE
|
2016-11-23 20:31:53 -05:00
|
|
|
#ifdef LOG_HEAP_ACTIVITY
|
|
|
|
gc_log_change(block, new_blocks);
|
|
|
|
#endif
|
|
|
|
|
2020-07-15 20:58:38 -04:00
|
|
|
#if CIRCUITPY_MEMORYMONITOR
|
2020-07-16 22:01:43 -04:00
|
|
|
memorymonitor_track_allocation(new_blocks);
|
2020-07-15 20:58:38 -04:00
|
|
|
#endif
|
|
|
|
|
2014-04-20 13:16:25 -04:00
|
|
|
return ptr_in;
|
|
|
|
}
|
2014-03-05 16:23:04 -05:00
|
|
|
|
2016-05-04 05:14:43 -04:00
|
|
|
#if MICROPY_ENABLE_FINALISER
|
2018-01-23 20:09:58 -05:00
|
|
|
bool ftb_state = FTB_GET(area, block);
|
2016-05-04 05:14:43 -04:00
|
|
|
#else
|
|
|
|
bool ftb_state = false;
|
|
|
|
#endif
|
|
|
|
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
|
|
|
|
2015-06-13 16:53:22 -04:00
|
|
|
if (!allow_move) {
|
|
|
|
// not allowed to move memory block so return failure
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-20 13:16:25 -04:00
|
|
|
// can't resize inplace; try to find a new contiguous chain
|
2023-08-08 20:41:17 -04:00
|
|
|
void *ptr_out = gc_alloc(n_bytes, ftb_state);
|
2014-04-20 13:16:25 -04:00
|
|
|
|
|
|
|
// check that the alloc succeeded
|
|
|
|
if (ptr_out == NULL) {
|
|
|
|
return NULL;
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
2014-03-05 16:23:04 -05:00
|
|
|
|
2014-06-16 04:44:29 -04:00
|
|
|
DEBUG_printf("gc_realloc(%p -> %p)\n", ptr_in, ptr_out);
|
2014-04-20 13:16:25 -04:00
|
|
|
memcpy(ptr_out, ptr_in, n_blocks * BYTES_PER_BLOCK);
|
|
|
|
gc_free(ptr_in);
|
|
|
|
return ptr_out;
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
2014-04-20 04:43:38 -04:00
|
|
|
#endif // Alternative gc_realloc impl
|
2014-03-12 15:00:23 -04:00
|
|
|
|
2023-03-08 21:50:21 -05:00
|
|
|
void gc_dump_info(const mp_print_t *print) {
|
2014-02-11 11:01:38 -05:00
|
|
|
gc_info_t info;
|
|
|
|
gc_info(&info);
|
2023-08-02 02:49:44 -04:00
|
|
|
mp_printf(print, "GC: total: %u, used: %u, free: %u",
|
2015-12-18 07:52:45 -05:00
|
|
|
(uint)info.total, (uint)info.used, (uint)info.free);
|
2023-08-02 02:49:44 -04:00
|
|
|
#if MICROPY_GC_SPLIT_HEAP_AUTO
|
2023-09-04 20:58:19 -04:00
|
|
|
mp_printf(print, ", max new split: %u", (uint)info.max_new_split);
|
2023-08-02 02:49:44 -04:00
|
|
|
#endif
|
|
|
|
mp_printf(print, "\n No. of 1-blocks: %u, 2-blocks: %u, max blk sz: %u, max free sz: %u\n",
|
2016-06-30 17:09:55 -04:00
|
|
|
(uint)info.num_1block, (uint)info.num_2block, (uint)info.max_block, (uint)info.max_free);
|
2014-02-11 11:01:38 -05:00
|
|
|
}
|
|
|
|
|
2023-03-08 21:50:21 -05:00
|
|
|
void gc_dump_alloc_table(const mp_print_t *print) {
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_ENTER();
|
2015-12-16 20:09:11 -05:00
|
|
|
static const size_t DUMP_BYTES_PER_LINE = 64;
|
2018-01-23 20:09:58 -05:00
|
|
|
for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
|
|
|
|
#if !EXTENSIVE_HEAP_PROFILING
|
|
|
|
// When comparing heap output we don't want to print the starting
|
|
|
|
// pointer of the heap because it changes from run to run.
|
2023-03-08 21:50:21 -05:00
|
|
|
mp_printf(print, "GC memory layout; from %p:", area->gc_pool_start);
|
2018-01-23 20:09:58 -05:00
|
|
|
#endif
|
|
|
|
for (size_t bl = 0; bl < area->gc_alloc_table_byte_len * BLOCKS_PER_ATB; bl++) {
|
|
|
|
if (bl % DUMP_BYTES_PER_LINE == 0) {
|
|
|
|
// a new line of blocks
|
|
|
|
{
|
|
|
|
// check if this line contains only free blocks
|
|
|
|
size_t bl2 = bl;
|
|
|
|
while (bl2 < area->gc_alloc_table_byte_len * BLOCKS_PER_ATB && ATB_GET_KIND(area, bl2) == AT_FREE) {
|
|
|
|
bl2++;
|
2014-10-17 10:12:57 -04:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
if (bl2 - bl >= 2 * DUMP_BYTES_PER_LINE) {
|
|
|
|
// there are at least 2 lines containing only free blocks, so abbreviate their printing
|
2023-03-08 21:50:21 -05:00
|
|
|
mp_printf(print, "\n (%u lines all free)", (uint)(bl2 - bl) / DUMP_BYTES_PER_LINE);
|
2018-01-23 20:09:58 -05:00
|
|
|
bl = bl2 & (~(DUMP_BYTES_PER_LINE - 1));
|
|
|
|
if (bl >= area->gc_alloc_table_byte_len * BLOCKS_PER_ATB) {
|
|
|
|
// got to end of heap
|
2014-10-17 10:12:57 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
// print header for new line of blocks
|
|
|
|
// (the cast to uint32_t is for 16-bit ports)
|
2023-03-08 21:50:21 -05:00
|
|
|
mp_printf(print, "\n%08x: ", (uint)(bl * BYTES_PER_BLOCK));
|
2014-10-17 10:12:57 -04:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
int c = ' ';
|
|
|
|
switch (ATB_GET_KIND(area, bl)) {
|
|
|
|
case AT_FREE:
|
|
|
|
c = '.';
|
|
|
|
break;
|
|
|
|
/* this prints out if the object is reachable from BSS or STACK (for unix only)
|
|
|
|
case AT_HEAD: {
|
2015-01-11 09:37:06 -05:00
|
|
|
c = 'h';
|
2018-01-23 20:09:58 -05:00
|
|
|
void **ptrs = (void**)(void*)&mp_state_ctx;
|
|
|
|
mp_uint_t len = offsetof(mp_state_ctx_t, vm.stack_top) / sizeof(mp_uint_t);
|
|
|
|
for (mp_uint_t i = 0; i < len; i++) {
|
|
|
|
mp_uint_t ptr = (mp_uint_t)ptrs[i];
|
|
|
|
if (gc_get_ptr_area(ptr) && BLOCK_FROM_PTR(ptr) == bl) {
|
|
|
|
c = 'B';
|
2015-01-11 09:37:06 -05:00
|
|
|
break;
|
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
}
|
|
|
|
if (c == 'h') {
|
|
|
|
ptrs = (void**)&c;
|
|
|
|
len = ((mp_uint_t)MP_STATE_THREAD(stack_top) - (mp_uint_t)&c) / sizeof(mp_uint_t);
|
|
|
|
for (mp_uint_t i = 0; i < len; i++) {
|
|
|
|
mp_uint_t ptr = (mp_uint_t)ptrs[i];
|
|
|
|
if (gc_get_ptr_area(ptr) && BLOCK_FROM_PTR(ptr) == bl) {
|
|
|
|
c = 'S';
|
2015-01-11 09:37:06 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
/* this prints the uPy object type of the head block */
|
|
|
|
case AT_HEAD: {
|
2023-10-19 16:42:36 -04:00
|
|
|
// CIRCUITPY-CHANGE: compiler warning avoidance
|
2023-09-28 16:22:10 -04:00
|
|
|
#pragma GCC diagnostic push
|
|
|
|
#pragma GCC diagnostic ignored "-Wcast-align"
|
2018-01-23 20:09:58 -05:00
|
|
|
void **ptr = (void **)(area->gc_pool_start + bl * BYTES_PER_BLOCK);
|
2023-09-28 16:22:10 -04:00
|
|
|
#pragma GCC diagnostic pop
|
2018-01-23 20:09:58 -05:00
|
|
|
if (*ptr == &mp_type_tuple) {
|
|
|
|
c = 'T';
|
|
|
|
} else if (*ptr == &mp_type_list) {
|
|
|
|
c = 'L';
|
|
|
|
} else if (*ptr == &mp_type_dict) {
|
|
|
|
c = 'D';
|
|
|
|
} else if (*ptr == &mp_type_str || *ptr == &mp_type_bytes) {
|
|
|
|
c = 'S';
|
|
|
|
}
|
|
|
|
#if MICROPY_PY_BUILTINS_BYTEARRAY
|
|
|
|
else if (*ptr == &mp_type_bytearray) {
|
|
|
|
c = 'A';
|
|
|
|
}
|
2015-01-11 09:37:06 -05:00
|
|
|
#endif
|
2018-01-23 20:09:58 -05:00
|
|
|
#if MICROPY_PY_ARRAY
|
|
|
|
else if (*ptr == &mp_type_array) {
|
|
|
|
c = 'A';
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#if MICROPY_PY_BUILTINS_FLOAT
|
|
|
|
else if (*ptr == &mp_type_float) {
|
|
|
|
c = 'F';
|
|
|
|
}
|
2015-01-11 09:37:06 -05:00
|
|
|
#endif
|
2018-01-23 20:09:58 -05:00
|
|
|
else if (*ptr == &mp_type_fun_bc) {
|
|
|
|
c = 'B';
|
|
|
|
} else if (*ptr == &mp_type_module) {
|
|
|
|
c = 'M';
|
|
|
|
} else {
|
|
|
|
c = 'h';
|
|
|
|
#if 0
|
|
|
|
// This code prints "Q" for qstr-pool data, and "q" for qstr-str
|
|
|
|
// data. It can be useful to see how qstrs are being allocated,
|
|
|
|
// but is disabled by default because it is very slow.
|
|
|
|
for (qstr_pool_t *pool = MP_STATE_VM(last_pool); c == 'h' && pool != NULL; pool = pool->prev) {
|
|
|
|
if ((qstr_pool_t *)ptr == pool) {
|
|
|
|
c = 'Q';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
for (const byte **q = pool->qstrs, **q_top = pool->qstrs + pool->len; q < q_top; q++) {
|
|
|
|
if ((const byte *)ptr == *q) {
|
|
|
|
c = 'q';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
break;
|
2015-01-11 09:37:06 -05:00
|
|
|
}
|
2018-01-23 20:09:58 -05:00
|
|
|
case AT_TAIL:
|
|
|
|
c = '=';
|
|
|
|
break;
|
|
|
|
case AT_MARK:
|
|
|
|
c = 'm';
|
|
|
|
break;
|
py, gc: Zero out newly allocated blocks in the GC.
Also add some more debugging output to gc_dump_alloc_table().
Now that newly allocated heap is always zero'd, maybe we just make this
a policy for the uPy API to keep it simple (ie any new implementation of
memory allocation must zero all allocations). This follows the D
language philosophy.
Before this patch, a previously used memory block which had pointers in
it may still retain those pointers if the new user of that block does
not actually use the entire block. Eg, if I want 5 blocks worth of
heap, I actually get 8 (round up to nearest 4). Then I never use the
last 3, so they keep their old values, which may be pointers pointing to
the heap, hence preventing GC.
In rare (or maybe not that rare) cases, this leads to long, unintentional
"linked lists" within the GC'd heap, filling it up completely. It's
pretty rare, because you have to reuse exactly that memory which is part
of this "linked list", and reuse it in just the right way.
This should fix issue #522, and might have something to do with
issue #510.
2014-04-25 18:37:55 -04:00
|
|
|
}
|
2023-03-08 21:50:21 -05:00
|
|
|
mp_printf(print, "%c", c);
|
2013-10-22 10:25:25 -04:00
|
|
|
}
|
2023-03-08 21:50:21 -05:00
|
|
|
mp_print_str(print, "\n");
|
2013-10-22 10:25:25 -04:00
|
|
|
}
|
2016-04-25 11:28:57 -04:00
|
|
|
GC_EXIT();
|
2013-10-22 10:25:25 -04:00
|
|
|
}
|
|
|
|
|
2018-08-02 00:17:24 -04:00
|
|
|
#if 0
|
|
|
|
// For testing the GC functions
|
2014-02-10 14:45:54 -05:00
|
|
|
void gc_test(void) {
|
2014-07-03 08:25:24 -04:00
|
|
|
mp_uint_t len = 500;
|
|
|
|
mp_uint_t *heap = malloc(len);
|
|
|
|
gc_init(heap, heap + len / sizeof(mp_uint_t));
|
2013-10-21 18:45:08 -04:00
|
|
|
void *ptrs[100];
|
|
|
|
{
|
2014-07-03 08:25:24 -04:00
|
|
|
mp_uint_t **p = gc_alloc(16, false);
|
2014-04-05 15:35:48 -04:00
|
|
|
p[0] = gc_alloc(64, false);
|
|
|
|
p[1] = gc_alloc(1, false);
|
|
|
|
p[2] = gc_alloc(1, false);
|
|
|
|
p[3] = gc_alloc(1, false);
|
2014-07-03 08:25:24 -04:00
|
|
|
mp_uint_t ***p2 = gc_alloc(16, false);
|
2013-10-21 18:45:08 -04:00
|
|
|
p2[0] = p;
|
|
|
|
p2[1] = p;
|
|
|
|
ptrs[0] = p2;
|
|
|
|
}
|
2014-02-10 14:45:54 -05:00
|
|
|
for (int i = 0; i < 25; i += 2) {
|
2014-07-03 08:25:24 -04:00
|
|
|
mp_uint_t *p = gc_alloc(i, false);
|
2013-10-21 18:45:08 -04:00
|
|
|
printf("p=%p\n", p);
|
|
|
|
if (i & 3) {
|
|
|
|
// ptrs[i] = p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-10 14:45:54 -05:00
|
|
|
printf("Before GC:\n");
|
2023-03-08 21:50:21 -05:00
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
2014-02-10 14:45:54 -05:00
|
|
|
printf("Starting GC...\n");
|
|
|
|
gc_collect_start();
|
|
|
|
gc_collect_root(ptrs, sizeof(ptrs) / sizeof(void *));
|
|
|
|
gc_collect_end();
|
|
|
|
printf("After GC:\n");
|
2023-03-08 21:50:21 -05:00
|
|
|
gc_dump_alloc_table(&mp_plat_print);
|
2013-10-21 18:45:08 -04:00
|
|
|
}
|
2014-02-10 14:45:54 -05:00
|
|
|
#endif
|
2014-01-07 10:20:33 -05:00
|
|
|
|
|
|
|
#endif // MICROPY_ENABLE_GC
|