mirror
/
micropython
kopia lustrzana https://github.com/micropython/micropython
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
micropython/py/gc.c

950 wiersze
33 KiB
C
Czysty Zwykły widok Historia

Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 22:27:38 +00:00
/*
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 07:22:17 +00:00
* This file is part of the MicroPython project, http://micropython.org/
Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 22:27:38 +00:00
*
* The MIT License (MIT)
*
* Copyright (c) 2013, 2014 Damien P. George
*
* 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.
*/
gc: "new" gc_realloc: Rewrite in plain C, fixing bunch of bugs. There were typos, various rounding errors trying to do concurrent counting in bytes vs blocks, complex conditional paths, superfluous variables, etc., etc., all leading to obscure segfaults.
2014-04-20 08:45:16 +00:00
#include <assert.h>
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
#include <stdio.h>
#include <string.h>
py: Move to guarded includes, everywhere in py/ core. Addresses issue #1022.
2015-01-01 20:27:54 +00:00
#include "py/gc.h"
#include "py/runtime.h"
Implement del
2014-04-03 21:55:12 +00:00
Factor and simplify Makefile's and mpconfig, part 2.
2014-01-07 15:20:33 +00:00
#if MICROPY_ENABLE_GC
py: Add verbose debug compile-time flag MICROPY_DEBUG_VERBOSE. It enables all the DEBUG_printf outputs in the py/ source code.
2017-07-24 16:55:14 +00:00
#if MICROPY_DEBUG_VERBOSE // print debugging info
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
#define DEBUG_PRINT (1)
Make DEBUG_printf() a proper function, implementation is port-dependent. In particular, unix outputs to stderr, to allow to run testsuite against micropython built with debug output (by redirecting stderr to /dev/null).
2014-02-16 16:11:42 +00:00
#define DEBUG_printf DEBUG_printf
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
#else // don't print debugging info
py: Fix some macros defines; cleanup some includes.
2014-11-05 21:16:41 +00:00
#define DEBUG_PRINT (0)
py: Remove more var arg names fro macros with var args.
2014-02-26 22:40:35 +00:00
#define DEBUG_printf(...) (void)0
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
#endif
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
// make this 1 to dump the heap each time it changes
#define EXTENSIVE_HEAP_PROFILING (0)
py/gc: Add CLEAR_ON_SWEEP option to debug mis-traced objects. Accessing them will crash immediately instead still working for some time, until overwritten by some other data, leading to much less deterministic crashes.
2017-12-07 22:10:44 +00:00
// make this 1 to zero out swept memory to more eagerly
// detect untraced object still in use
#define CLEAR_ON_SWEEP (0)
py/gc: Make GC block size be configurable.
2015-12-02 23:40:52 +00:00
#define WORDS_PER_BLOCK ((MICROPY_BYTES_PER_GC_BLOCK) / BYTES_PER_WORD)
#define BYTES_PER_BLOCK (MICROPY_BYTES_PER_GC_BLOCK)
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00: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)
#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)
#define BLOCK_SHIFT(block) (2 * ((block) & (BLOCKS_PER_ATB - 1)))
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
#define ATB_GET_KIND(block) ((MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] >> BLOCK_SHIFT(block)) & 3)
#define ATB_ANY_TO_FREE(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] &= (~(AT_MARK << BLOCK_SHIFT(block))); } while (0)
#define ATB_FREE_TO_HEAD(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] |= (AT_HEAD << BLOCK_SHIFT(block)); } while (0)
#define ATB_FREE_TO_TAIL(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] |= (AT_TAIL << BLOCK_SHIFT(block)); } while (0)
#define ATB_HEAD_TO_MARK(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] |= (AT_MARK << BLOCK_SHIFT(block)); } while (0)
#define ATB_MARK_TO_HEAD(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] &= (~(AT_TAIL << BLOCK_SHIFT(block))); } while (0)
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
#define BLOCK_FROM_PTR(ptr) (((byte*)(ptr) - MP_STATE_MEM(gc_pool_start)) / BYTES_PER_BLOCK)
#define PTR_FROM_BLOCK(block) (((block) * BYTES_PER_BLOCK + (uintptr_t)MP_STATE_MEM(gc_pool_start)))
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
#define ATB_FROM_BLOCK(bl) ((bl) / BLOCKS_PER_ATB)
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#if MICROPY_ENABLE_FINALISER
// FTB = finaliser table byte
// if set, then the corresponding block may have a finaliser
#define BLOCKS_PER_FTB (8)
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
#define FTB_GET(block) ((MP_STATE_MEM(gc_finaliser_table_start)[(block) / BLOCKS_PER_FTB] >> ((block) & 7)) & 1)
#define FTB_SET(block) do { MP_STATE_MEM(gc_finaliser_table_start)[(block) / BLOCKS_PER_FTB] |= (1 << ((block) & 7)); } while (0)
#define FTB_CLEAR(block) do { MP_STATE_MEM(gc_finaliser_table_start)[(block) / BLOCKS_PER_FTB] &= (~(1 << ((block) & 7))); } while (0)
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#endif
py: Don't use gc or qstr mutex when the GIL is enabled. There is no need since the GIL already makes gc and qstr operations atomic.
2016-05-26 10:53:34 +00:00
#if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00: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
gc: reserve first block; lexer: free vstr.
2013-10-22 20:12:29 +00:00
// TODO waste less memory; currently requires that all entries in alloc_table have a corresponding block in pool
void gc_init(void *start, void *end) {
// align end pointer on block boundary
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
end = (void*)((uintptr_t)end & (~(BYTES_PER_BLOCK - 1)));
gc: Keep debug statements at beginning of scope where possible
2014-06-18 08:20:41 +00:00
DEBUG_printf("Initializing GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, (byte*)end - (byte*)start);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00: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)
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t total_byte_len = (byte*)end - (byte*)start;
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#if MICROPY_ENABLE_FINALISER
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_alloc_table_byte_len) = total_byte_len * BITS_PER_BYTE / (BITS_PER_BYTE + BITS_PER_BYTE * BLOCKS_PER_ATB / BLOCKS_PER_FTB + BITS_PER_BYTE * BLOCKS_PER_ATB * BYTES_PER_BLOCK);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#else
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_alloc_table_byte_len) = total_byte_len / (1 + BITS_PER_BYTE / 2 * BYTES_PER_BLOCK);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#endif
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_alloc_table_start) = (byte*)start;
Implement del
2014-04-03 21:55:12 +00:00
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#if MICROPY_ENABLE_FINALISER
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t gc_finaliser_table_byte_len = (MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB + BLOCKS_PER_FTB - 1) / BLOCKS_PER_FTB;
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_finaliser_table_start) = MP_STATE_MEM(gc_alloc_table_start) + MP_STATE_MEM(gc_alloc_table_byte_len);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#endif
Implement del
2014-04-03 21:55:12 +00:00
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t gc_pool_block_len = MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB;
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
MP_STATE_MEM(gc_pool_start) = (byte*)end - gc_pool_block_len * BYTES_PER_BLOCK;
MP_STATE_MEM(gc_pool_end) = end;
gc: reserve first block; lexer: free vstr.
2013-10-22 20:12:29 +00:00
py: Fix bug where GC finaliser table was not completely zeroed out. This was a nasty bug to track down. It only had consequences when the heap size was just the right size to expose the rounding error in the calculation of the finaliser table size. And, a script had to allocate a small (1 or 2 cell) object at the very end of the heap. And, this object must not have a finaliser. And, the initial state of the heap must have been all bits set to 1. All these conspire on the pyboard, but only if your run the script fresh (so unused memory is all 1's), and if your script allocates a lot of small objects (eg 2-char strings that are not interned).
2014-08-08 11:33:49 +00:00
#if MICROPY_ENABLE_FINALISER
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
assert(MP_STATE_MEM(gc_pool_start) >= MP_STATE_MEM(gc_finaliser_table_start) + gc_finaliser_table_byte_len);
py: Fix bug where GC finaliser table was not completely zeroed out. This was a nasty bug to track down. It only had consequences when the heap size was just the right size to expose the rounding error in the calculation of the finaliser table size. And, a script had to allocate a small (1 or 2 cell) object at the very end of the heap. And, this object must not have a finaliser. And, the initial state of the heap must have been all bits set to 1. All these conspire on the pyboard, but only if your run the script fresh (so unused memory is all 1's), and if your script allocates a lot of small objects (eg 2-char strings that are not interned).
2014-08-08 11:33:49 +00:00
#endif
gc: reserve first block; lexer: free vstr.
2013-10-22 20:12:29 +00:00
// clear ATBs
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
memset(MP_STATE_MEM(gc_alloc_table_start), 0, MP_STATE_MEM(gc_alloc_table_byte_len));
gc: reserve first block; lexer: free vstr.
2013-10-22 20:12:29 +00:00
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#if MICROPY_ENABLE_FINALISER
// clear FTBs
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
memset(MP_STATE_MEM(gc_finaliser_table_start), 0, gc_finaliser_table_byte_len);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#endif
Implement del
2014-04-03 21:55:12 +00:00
py: Speed up GC allocation. This simple patch gives a very significant speed up for memory allocation with the GC. Eg, on PYBv1.0: tests/basics/dict_del.py: 3.55 seconds -> 1.19 seconds tests/misc/rge_sm.py: 15.3 seconds -> 2.48 seconds
2014-08-22 17:17:02 +00:00
// set last free ATB index to start of heap
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_last_free_atb_index) = 0;
py: Speed up GC allocation. This simple patch gives a very significant speed up for memory allocation with the GC. Eg, on PYBv1.0: tests/basics/dict_del.py: 3.55 seconds -> 1.19 seconds tests/misc/rge_sm.py: 15.3 seconds -> 2.48 seconds
2014-08-22 17:17:02 +00:00
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
// unlock the GC
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_lock_depth) = 0;
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
py: Make gc.enable/disable just control auto-GC; alloc is still allowed. gc.enable/disable are now the same as CPython: they just control whether automatic garbage collection is enabled or not. If disabled, you can still allocate heap memory, and initiate a manual collection.
2014-10-31 21:30:46 +00:00
// allow auto collection
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_auto_collect_enabled) = 1;
py: Make gc.enable/disable just control auto-GC; alloc is still allowed. gc.enable/disable are now the same as CPython: they just control whether automatic garbage collection is enabled or not. If disabled, you can still allocate heap memory, and initiate a manual collection.
2014-10-31 21:30:46 +00: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 21:37:30 +00: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
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
#if MICROPY_PY_THREAD
mp_thread_mutex_init(&MP_STATE_MEM(gc_mutex));
#endif
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
DEBUG_printf("GC layout:\n");
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
DEBUG_printf(" alloc table at %p, length " UINT_FMT " bytes, " UINT_FMT " blocks\n", MP_STATE_MEM(gc_alloc_table_start), MP_STATE_MEM(gc_alloc_table_byte_len), MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#if MICROPY_ENABLE_FINALISER
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
DEBUG_printf(" finaliser table at %p, length " UINT_FMT " bytes, " UINT_FMT " blocks\n", MP_STATE_MEM(gc_finaliser_table_start), gc_finaliser_table_byte_len, gc_finaliser_table_byte_len * BLOCKS_PER_FTB);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#endif
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
DEBUG_printf(" pool at %p, length " UINT_FMT " bytes, " UINT_FMT " blocks\n", MP_STATE_MEM(gc_pool_start), gc_pool_block_len * BYTES_PER_BLOCK, gc_pool_block_len);
gc: reserve first block; lexer: free vstr.
2013-10-22 20:12:29 +00:00
}
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
void gc_lock(void) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_lock_depth)++;
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
}
void gc_unlock(void) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_lock_depth)--;
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
}
Try not to cause a MemoryError when raising an exception during nterrupt handling. Step 1 fixes #732
2014-07-01 05:49:21 +00:00
bool gc_is_locked(void) {
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
return MP_STATE_MEM(gc_lock_depth) != 0;
Try not to cause a MemoryError when raising an exception during nterrupt handling. Step 1 fixes #732
2014-07-01 05:49:21 +00:00
}
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
// ptr should be of type void*
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
#define VERIFY_PTR(ptr) ( \
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
((uintptr_t)(ptr) & (BYTES_PER_BLOCK - 1)) == 0 /* must be aligned on a block */ \
&& ptr >= (void*)MP_STATE_MEM(gc_pool_start) /* must be above start of pool */ \
&& ptr < (void*)MP_STATE_MEM(gc_pool_end) /* must be below end of pool */ \
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
)
py/gc: Factor out a macro to trace GC mark operations. To allow easier override it for custom tracing.
2017-12-08 23:48:26 +00: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
py/gc: Rename gc_drain_stack to gc_mark_subtree and pass it first block. This saves a bit in code size: minimal CROSS=1: -44 unix: -96
2018-02-15 16:10:13 +00: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.
STATIC void gc_mark_subtree(size_t block) {
// Start with the block passed in the argument.
py/gc: Make GC stack pointer a local variable. This saves a bit in code size, and saves some precious .bss RAM: .text .bss minimal CROSS=1: -28 -4 unix (64-bit): -64 -8
2018-02-15 16:22:34 +00:00
size_t sp = 0;
py/gc: Rename gc_drain_stack to gc_mark_subtree and pass it first block. This saves a bit in code size: minimal CROSS=1: -44 unix: -96
2018-02-15 16:10:13 +00:00
for (;;) {
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
// work out number of consecutive blocks in the chain starting with this one
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t n_blocks = 0;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
do {
n_blocks += 1;
} while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);
// check this block's children
py/gc: Scan GC blocks as an array of pointers, not an array of objects. The GC should search for pointers within the heap. This patch makes a difference when an object is larger than a pointer (eg 64-bit NaN boxing).
2015-12-17 00:41:37 +00:00
void **ptrs = (void**)PTR_FROM_BLOCK(block);
for (size_t i = n_blocks * BYTES_PER_BLOCK / sizeof(void*); i > 0; i--, ptrs++) {
void *ptr = *ptrs;
py/gc: Reduce code size by specialising VERIFY_MARK_AND_PUSH macro. This macro is written out explicitly in the two locations that it is used and then the code is optimised, opening possibilities for further optimisations and reducing code size: unix: -48 minimal CROSS=1: -32 stm32: -32
2018-01-27 17:37:38 +00:00
if (VERIFY_PTR(ptr)) {
// Mark and push this pointer
size_t childblock = BLOCK_FROM_PTR(ptr);
if (ATB_GET_KIND(childblock) == AT_HEAD) {
// an unmarked head, mark it, and push it on gc stack
TRACE_MARK(childblock, ptr);
ATB_HEAD_TO_MARK(childblock);
py/gc: Make GC stack pointer a local variable. This saves a bit in code size, and saves some precious .bss RAM: .text .bss minimal CROSS=1: -28 -4 unix (64-bit): -64 -8
2018-02-15 16:22:34 +00:00
if (sp < MICROPY_ALLOC_GC_STACK_SIZE) {
MP_STATE_MEM(gc_stack)[sp++] = childblock;
py/gc: Reduce code size by specialising VERIFY_MARK_AND_PUSH macro. This macro is written out explicitly in the two locations that it is used and then the code is optimised, opening possibilities for further optimisations and reducing code size: unix: -48 minimal CROSS=1: -32 stm32: -32
2018-01-27 17:37:38 +00:00
} else {
MP_STATE_MEM(gc_stack_overflow) = 1;
}
}
}
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
py/gc: Rename gc_drain_stack to gc_mark_subtree and pass it first block. This saves a bit in code size: minimal CROSS=1: -44 unix: -96
2018-02-15 16:10:13 +00:00
// Are there any blocks on the stack?
py/gc: Make GC stack pointer a local variable. This saves a bit in code size, and saves some precious .bss RAM: .text .bss minimal CROSS=1: -28 -4 unix (64-bit): -64 -8
2018-02-15 16:22:34 +00:00
if (sp == 0) {
py/gc: Rename gc_drain_stack to gc_mark_subtree and pass it first block. This saves a bit in code size: minimal CROSS=1: -44 unix: -96
2018-02-15 16:10:13 +00:00
break; // No, stack is empty, we're done.
}
// pop the next block off the stack
py/gc: Make GC stack pointer a local variable. This saves a bit in code size, and saves some precious .bss RAM: .text .bss minimal CROSS=1: -28 -4 unix (64-bit): -64 -8
2018-02-15 16:22:34 +00:00
block = MP_STATE_MEM(gc_stack)[--sp];
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
}
Replace global "static" -> "STATIC", to allow "analysis builds". Part 2.
2014-02-12 16:31:30 +00:00
STATIC void gc_deal_with_stack_overflow(void) {
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
while (MP_STATE_MEM(gc_stack_overflow)) {
MP_STATE_MEM(gc_stack_overflow) = 0;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
// scan entire memory looking for blocks which have been marked but not their children
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
for (size_t block = 0; block < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; block++) {
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
// trace (again) if mark bit set
if (ATB_GET_KIND(block) == AT_MARK) {
py/gc: Rename gc_drain_stack to gc_mark_subtree and pass it first block. This saves a bit in code size: minimal CROSS=1: -44 unix: -96
2018-02-15 16:10:13 +00:00
gc_mark_subtree(block);
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
}
}
}
Replace global "static" -> "STATIC", to allow "analysis builds". Part 2.
2014-02-12 16:31:30 +00:00
STATIC void gc_sweep(void) {
modgc: Implement return value for gc.collect(), enable on Unix.
2014-06-05 19:48:02 +00:00
#if MICROPY_PY_GC_COLLECT_RETVAL
py: Put mp_sys_path, mp_sys_argv and gc_collected in mp_state_ctx_t. Without mp_sys_path and mp_sys_argv in the root pointer section of the state, their memory was being incorrectly collected by GC.
2015-02-07 17:24:10 +00:00
MP_STATE_MEM(gc_collected) = 0;
modgc: Implement return value for gc.collect(), enable on Unix.
2014-06-05 19:48:02 +00:00
#endif
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
// free unmarked heads and their tails
int free_tail = 0;
py/gc: For finaliser, interpret a pointer into the heap as concrete obj.
2015-12-17 00:45:42 +00:00
for (size_t block = 0; block < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; block++) {
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
switch (ATB_GET_KIND(block)) {
case AT_HEAD:
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#if MICROPY_ENABLE_FINALISER
if (FTB_GET(block)) {
py/gc: For finaliser, interpret a pointer into the heap as concrete obj.
2015-12-17 00:45:42 +00:00
mp_obj_base_t *obj = (mp_obj_base_t*)PTR_FROM_BLOCK(block);
if (obj->type != NULL) {
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
// if the object has a type then see if it has a __del__ method
mp_obj_t dest[2];
py/gc: For finaliser, interpret a pointer into the heap as concrete obj.
2015-12-17 00:45:42 +00:00
mp_load_method_maybe(MP_OBJ_FROM_PTR(obj), MP_QSTR___del__, dest);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
if (dest[0] != MP_OBJ_NULL) {
py/gc: Execute finaliser code in a protected environment. If a finaliser raises an exception then it must not propagate through the GC sweep function. This patch protects against such a thing by running finaliser code via the mp_call_function_1_protected call. This patch also adds scheduler lock/unlock calls around the finaliser execution to further protect against any possible reentrancy issues: the memory manager is already locked when doing a collection, but we also don't want to allow any scheduled code to run, KeyboardInterrupts to interupt the code, nor threads to switch.
2017-04-12 03:52:04 +00:00
// 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
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
}
Implement del
2014-04-03 21:55:12 +00:00
}
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
// clear finaliser flag
FTB_CLEAR(block);
Implement del
2014-04-03 21:55:12 +00:00
}
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
#endif
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
free_tail = 1;
py/gc: In sweep debug output, print pointer as a pointer. Or it will be truncated on a 64-bit platform.
2017-12-08 23:54:01 +00:00
DEBUG_printf("gc_sweep(%p)\n", PTR_FROM_BLOCK(block));
modgc: Implement return value for gc.collect(), enable on Unix.
2014-06-05 19:48:02 +00:00
#if MICROPY_PY_GC_COLLECT_RETVAL
py: Put mp_sys_path, mp_sys_argv and gc_collected in mp_state_ctx_t. Without mp_sys_path and mp_sys_argv in the root pointer section of the state, their memory was being incorrectly collected by GC.
2015-02-07 17:24:10 +00:00
MP_STATE_MEM(gc_collected)++;
modgc: Implement return value for gc.collect(), enable on Unix.
2014-06-05 19:48:02 +00:00
#endif
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
// fall through to free the head
case AT_TAIL:
if (free_tail) {
ATB_ANY_TO_FREE(block);
py/gc: Add CLEAR_ON_SWEEP option to debug mis-traced objects. Accessing them will crash immediately instead still working for some time, until overwritten by some other data, leading to much less deterministic crashes.
2017-12-07 22:10:44 +00:00
#if CLEAR_ON_SWEEP
memset((void*)PTR_FROM_BLOCK(block), 0, BYTES_PER_BLOCK);
#endif
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
break;
case AT_MARK:
ATB_MARK_TO_HEAD(block);
free_tail = 0;
break;
}
}
}
Fix func decls with no arguments: () -> (void).
2013-10-23 19:20:17 +00:00
void gc_collect_start(void) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
MP_STATE_MEM(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 21:37:30 +00:00
#if MICROPY_GC_ALLOC_THRESHOLD
MP_STATE_MEM(gc_alloc_amount) = 0;
#endif
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00: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 12:28:40 +00:00
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00: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;
py/mpstate.h: Adjust start of root pointer section to exclude non-ptrs. This patch moves the start of the root pointer section in mp_state_ctx_t so that it skips entries that are not pointers and don't need scanning. Previously, the start of the root pointer section was at the very beginning of the mp_state_ctx_t struct (which is the beginning of mp_state_thread_t). This was the original assembler version of the NLR code was hard-coded to have the nlr_top pointer at the start of this state structure. But now that the NLR code is partially written in C there is no longer this restriction on the location of nlr_top (and a comment to this effect has been removed in this patch). So now the root pointer section starts part way through the mp_state_thread_t structure, after the entries which are not root pointers. This patch also moves the non-pointer entries for MICROPY_ENABLE_SCHEDULER outside the root pointer section. Moving non-pointer entries out of the root pointer section helps to make the GC more precise and should help to prevent some cases of collectable garbage being kept. This patch also has a measurable improvement in performance of the pystone.py benchmark: on unix x86-64 and stm32 there was an improvement of roughly 0.6% (tested with both gcc 7.3 and gcc 8.1).
2018-05-12 12:09:34 +00: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 12:28:40 +00: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
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void gc_collect_root(void **ptrs, size_t len) {
for (size_t i = 0; i < len; i++) {
void *ptr = ptrs[i];
py/gc: Reduce code size by specialising VERIFY_MARK_AND_PUSH macro. This macro is written out explicitly in the two locations that it is used and then the code is optimised, opening possibilities for further optimisations and reducing code size: unix: -48 minimal CROSS=1: -32 stm32: -32
2018-01-27 17:37:38 +00:00
if (VERIFY_PTR(ptr)) {
size_t block = BLOCK_FROM_PTR(ptr);
if (ATB_GET_KIND(block) == AT_HEAD) {
py/gc: Update comment now that gc_drain_stack is called gc_mark_subtree.
2018-02-19 05:08:20 +00:00
// An unmarked head: mark it, and mark all its children
py/gc: Reduce code size by specialising VERIFY_MARK_AND_PUSH macro. This macro is written out explicitly in the two locations that it is used and then the code is optimised, opening possibilities for further optimisations and reducing code size: unix: -48 minimal CROSS=1: -32 stm32: -32
2018-01-27 17:37:38 +00:00
TRACE_MARK(block, ptr);
ATB_HEAD_TO_MARK(block);
py/gc: Rename gc_drain_stack to gc_mark_subtree and pass it first block. This saves a bit in code size: minimal CROSS=1: -44 unix: -96
2018-02-15 16:10:13 +00:00
gc_mark_subtree(block);
py/gc: Reduce code size by specialising VERIFY_MARK_AND_PUSH macro. This macro is written out explicitly in the two locations that it is used and then the code is optimised, opening possibilities for further optimisations and reducing code size: unix: -48 minimal CROSS=1: -32 stm32: -32
2018-01-27 17:37:38 +00:00
}
}
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
}
Fix func decls with no arguments: () -> (void).
2013-10-23 19:20:17 +00:00
void gc_collect_end(void) {
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
gc_deal_with_stack_overflow();
gc_sweep();
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_last_free_atb_index) = 0;
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
MP_STATE_MEM(gc_lock_depth)--;
GC_EXIT();
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
}
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
py/gc: Add gc_sweep_all() function to run all remaining finalisers. This patch adds the gc_sweep_all() function which does a garbage collection without tracing any root pointers, so frees all the memory, and most importantly runs any remaining finalisers. This helps primarily for soft reset: it will close any open files, any open sockets, and help to get the system back to a clean state upon soft reset.
2018-05-31 13:10:48 +00:00
void gc_sweep_all(void) {
GC_ENTER();
MP_STATE_MEM(gc_lock_depth)++;
MP_STATE_MEM(gc_stack_overflow) = 0;
gc_collect_end();
}
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
void gc_info(gc_info_t *info) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
info->total = MP_STATE_MEM(gc_pool_end) - MP_STATE_MEM(gc_pool_start);
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
info->used = 0;
info->free = 0;
py/gc: Calculate (and report) maximum contiguous free block size. Just as maximum allocated block size, it's reported in allocation units (not bytes).
2016-06-30 21:09:55 +00:00
info->max_free = 0;
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
info->num_1block = 0;
info->num_2block = 0;
info->max_block = 0;
py/gc: Be sure to count last allocated block at heap end in stats. Previously, if there was chain of allocated blocks ending with the last block of heap, it wasn't included in number of 1/2-block or max block size stats.
2016-06-29 22:59:24 +00:00
bool finish = false;
py/gc: Calculate (and report) maximum contiguous free block size. Just as maximum allocated block size, it's reported in allocation units (not bytes).
2016-06-30 21:09:55 +00:00
for (size_t block = 0, len = 0, len_free = 0; !finish;) {
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t kind = ATB_GET_KIND(block);
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
switch (kind) {
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
case AT_FREE:
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
info->free += 1;
py/gc: Calculate (and report) maximum contiguous free block size. Just as maximum allocated block size, it's reported in allocation units (not bytes).
2016-06-30 21:09:55 +00:00
len_free += 1;
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
len = 0;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
break;
case AT_HEAD:
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
info->used += 1;
len = 1;
break;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
case AT_TAIL:
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
info->used += 1;
len += 1;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
break;
case AT_MARK:
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
// shouldn't happen
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
break;
}
py/gc: Be sure to count last allocated block at heap end in stats. Previously, if there was chain of allocated blocks ending with the last block of heap, it wasn't included in number of 1/2-block or max block size stats.
2016-06-29 22:59:24 +00:00
block++;
finish = (block == MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB);
// Get next block type if possible
if (!finish) {
kind = ATB_GET_KIND(block);
}
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;
}
py/gc: Calculate (and report) maximum contiguous free block size. Just as maximum allocated block size, it's reported in allocation units (not bytes).
2016-06-30 21:09:55 +00:00
if (finish || kind == AT_HEAD) {
if (len_free > info->max_free) {
info->max_free = len_free;
}
len_free = 0;
}
py/gc: Be sure to count last allocated block at heap end in stats. Previously, if there was chain of allocated blocks ending with the last block of heap, it wasn't included in number of 1/2-block or max block size stats.
2016-06-29 22:59:24 +00:00
}
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
info->used *= BYTES_PER_BLOCK;
info->free *= BYTES_PER_BLOCK;
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void *gc_alloc(size_t n_bytes, bool has_finaliser) {
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t n_blocks = ((n_bytes + BYTES_PER_BLOCK - 1) & (~(BYTES_PER_BLOCK - 1))) / BYTES_PER_BLOCK;
gc: Keep debug statements at beginning of scope where possible
2014-06-18 08:20:41 +00:00
DEBUG_printf("gc_alloc(" UINT_FMT " bytes -> " UINT_FMT " blocks)\n", n_bytes, n_blocks);
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
// check for 0 allocation
if (n_blocks == 0) {
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
return NULL;
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
}
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
// check if GC is locked
if (MP_STATE_MEM(gc_lock_depth) > 0) {
GC_EXIT();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
return NULL;
}
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t i;
size_t end_block;
size_t start_block;
size_t n_free = 0;
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
int collected = !MP_STATE_MEM(gc_auto_collect_enabled);
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 21:37:30 +00:00
#if MICROPY_GC_ALLOC_THRESHOLD
if (!collected && MP_STATE_MEM(gc_alloc_amount) >= MP_STATE_MEM(gc_alloc_threshold)) {
GC_EXIT();
gc_collect();
py/gc: When GC threshold is hit don't unnecessarily collect twice. Without this, if GC threshold is hit and there is not enough memory left to satisfy the request, gc_collect() will run a second time and the search for memory will happen again and will fail again. Thanks to @adritium for pointing out this issue, see #3786.
2018-05-21 03:36:21 +00: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 21:37:30 +00:00
GC_ENTER();
}
#endif
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
for (;;) {
// look for a run of n_blocks available blocks
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
for (i = MP_STATE_MEM(gc_last_free_atb_index); i < MP_STATE_MEM(gc_alloc_table_byte_len); i++) {
byte a = MP_STATE_MEM(gc_alloc_table_start)[i];
py: Speed up GC allocation. This simple patch gives a very significant speed up for memory allocation with the GC. Eg, on PYBv1.0: tests/basics/dict_del.py: 3.55 seconds -> 1.19 seconds tests/misc/rge_sm.py: 15.3 seconds -> 2.48 seconds
2014-08-22 17:17:02 +00:00
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; }
}
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
// nothing found!
if (collected) {
return NULL;
}
More GC debugging improvements.
2014-02-11 16:01:38 +00:00
DEBUG_printf("gc_alloc(" UINT_FMT "): no free mem, triggering GC\n", n_bytes);
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
gc_collect();
collected = 1;
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
// found, ending at block i inclusive
found:
// get starting and end blocks, both inclusive
end_block = i;
start_block = i - n_free + 1;
py: Reduce fragmentation of GC heap. Recent speed up of GC allocation made the GC have a fragmented heap. This patch restores "original fragmentation behaviour" whilst still retaining relatively fast allocation. This patch works because there is always going to be a single block allocated now and then, which advances the gc_last_free_atb_index pointer often enough so that the whole heap doesn't need scanning. Should address issue #836.
2014-08-28 09:18:40 +00:00
// 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
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
// 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).
py: Reduce fragmentation of GC heap. Recent speed up of GC allocation made the GC have a fragmented heap. This patch restores "original fragmentation behaviour" whilst still retaining relatively fast allocation. This patch works because there is always going to be a single block allocated now and then, which advances the gc_last_free_atb_index pointer often enough so that the whole heap doesn't need scanning. Should address issue #836.
2014-08-28 09:18:40 +00:00
if (n_free == 1) {
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
MP_STATE_MEM(gc_last_free_atb_index) = (i + 1) / BLOCKS_PER_ATB;
py: Reduce fragmentation of GC heap. Recent speed up of GC allocation made the GC have a fragmented heap. This patch restores "original fragmentation behaviour" whilst still retaining relatively fast allocation. This patch works because there is always going to be a single block allocated now and then, which advances the gc_last_free_atb_index pointer often enough so that the whole heap doesn't need scanning. Should address issue #836.
2014-08-28 09:18:40 +00:00
}
py: Speed up GC allocation. This simple patch gives a very significant speed up for memory allocation with the GC. Eg, on PYBv1.0: tests/basics/dict_del.py: 3.55 seconds -> 1.19 seconds tests/misc/rge_sm.py: 15.3 seconds -> 2.48 seconds
2014-08-22 17:17:02 +00:00
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
// mark first block as used head
ATB_FREE_TO_HEAD(start_block);
// mark rest of blocks as used tail
// TODO for a run of many blocks can make this more efficient
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
for (size_t bl = start_block + 1; bl <= end_block; bl++) {
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
ATB_FREE_TO_TAIL(bl);
}
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
// get pointer to first block
py/gc: Fix GC+thread bug where ptr gets lost because it's not computed. GC_EXIT() can cause a pending thread (waiting on the mutex) to be scheduled right away. This other thread may trigger a garbage collection. If the pointer to the newly-allocated block (allocated by the original thread) is not computed before the switch (so it's just left as a block number) then the block will be wrongly reclaimed. This patch makes sure the pointer is computed before allowing any thread switch to occur.
2016-05-05 10:25:08 +00:00
// we must create this pointer before unlocking the GC so a collection can find it
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void *ret_ptr = (void*)(MP_STATE_MEM(gc_pool_start) + start_block * BYTES_PER_BLOCK);
gc: Keep debug statements at beginning of scope where possible
2014-06-18 08:20:41 +00:00
DEBUG_printf("gc_alloc(%p)\n", ret_ptr);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00: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 21:37:30 +00:00
#if MICROPY_GC_ALLOC_THRESHOLD
MP_STATE_MEM(gc_alloc_amount) += n_blocks;
#endif
py/gc: Fix GC+thread bug where ptr gets lost because it's not computed. GC_EXIT() can cause a pending thread (waiting on the mutex) to be scheduled right away. This other thread may trigger a garbage collection. If the pointer to the newly-allocated block (allocated by the original thread) is not computed before the switch (so it's just left as a block number) then the block will be wrongly reclaimed. This patch makes sure the pointer is computed before allowing any thread switch to occur.
2016-05-05 10:25:08 +00:00
GC_EXIT();
py/gc: Add MICROPY_GC_CONSERVATIVE_CLEAR option to always zero memory. There can be stray pointers in memory blocks that are not properly zero'd after allocation. This patch adds a new config option to always zero all allocated memory (via gc_alloc and gc_realloc) and hence help to eliminate stray pointers. See issue #2195.
2016-08-26 05:35:26 +00: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
py, gc: Only zero out the extra bytes at the end of the heap chunk. This is a small optimisation to zero out only the additional bytes that the caller did not ask for.
2014-04-26 21:23:42 +00: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 22:37:55 +00: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.
py, gc: Revert ret_ptr to void*, casting to byte* for memset.
2014-06-13 21:33:31 +00:00
memset((byte*)ret_ptr + n_bytes, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK - n_bytes);
py/gc: Add MICROPY_GC_CONSERVATIVE_CLEAR option to always zero memory. There can be stray pointers in memory blocks that are not properly zero'd after allocation. This patch adds a new config option to always zero all allocated memory (via gc_alloc and gc_realloc) and hence help to eliminate stray pointers. See issue #2195.
2016-08-26 05:35:26 +00: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 22:37:55 +00:00
py: Eliminate some cases which trigger unused parameter warnings.
2015-09-04 15:53:46 +00:00
#if MICROPY_ENABLE_FINALISER
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
if (has_finaliser) {
py, gc: Only zero out the extra bytes at the end of the heap chunk. This is a small optimisation to zero out only the additional bytes that the caller did not ask for.
2014-04-26 21:23:42 +00:00
// clear type pointer in case it is never set
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
((mp_obj_base_t*)ret_ptr)->type = NULL;
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
// set mp_obj flag only if it has a finaliser
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
FTB_SET(start_block);
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
Move del to locals
2014-04-05 13:49:03 +00:00
}
py: Eliminate some cases which trigger unused parameter warnings.
2015-09-04 15:53:46 +00:00
#else
(void)has_finaliser;
#endif
Move del to locals
2014-04-05 13:49:03 +00:00
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
#if EXTENSIVE_HEAP_PROFILING
gc_dump_alloc_table();
#endif
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
return ret_ptr;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
/*
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
void *gc_alloc(mp_uint_t n_bytes) {
Implement del
2014-04-03 21:55:12 +00:00
return _gc_alloc(n_bytes, false);
}
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
void *gc_alloc_with_finaliser(mp_uint_t n_bytes) {
Implement del
2014-04-03 21:55:12 +00:00
return _gc_alloc(n_bytes, true);
}
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
*/
Implement del
2014-04-03 21:55:12 +00:00
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
// force the freeing of a piece of memory
py: Clear finalizer flag when calling gc_free. Currently, the only place that clears the bit is in gc_collect. So if a block with a finalizer is allocated, and subsequently freed, and then the block is reallocated with no finalizer then the bit remains set. This could also be fixed by having gc_alloc clear the bit, but I'm pretty sure that free is called way less than alloc, so doing it in free is more efficient.
2015-11-06 22:32:47 +00:00
// TODO: freeing here does not call finaliser
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void gc_free(void *ptr) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
if (MP_STATE_MEM(gc_lock_depth) > 0) {
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
// TODO how to deal with this error?
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
return;
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
}
gc: More verbose debugging Add more DEBUG_printf statements to trace gc behaviour
2014-06-16 08:44:29 +00:00
DEBUG_printf("gc_free(%p)\n", ptr);
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
py/gc: Refactor assertions in gc_free function. gc_free() expects either NULL or a valid pointer into the heap, so the checks for a valid pointer can be turned into assertions.
2017-07-12 02:17:38 +00:00
if (ptr == NULL) {
GC_EXIT();
} else {
// get the GC block number corresponding to this pointer
assert(VERIFY_PTR(ptr));
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t block = BLOCK_FROM_PTR(ptr);
py/gc: Refactor assertions in gc_free function. gc_free() expects either NULL or a valid pointer into the heap, so the checks for a valid pointer can be turned into assertions.
2017-07-12 02:17:38 +00:00
assert(ATB_GET_KIND(block) == AT_HEAD);
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
py/gc: Refactor assertions in gc_free function. gc_free() expects either NULL or a valid pointer into the heap, so the checks for a valid pointer can be turned into assertions.
2017-07-12 02:17:38 +00:00
#if MICROPY_ENABLE_FINALISER
FTB_CLEAR(block);
#endif
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
py/gc: Refactor assertions in gc_free function. gc_free() expects either NULL or a valid pointer into the heap, so the checks for a valid pointer can be turned into assertions.
2017-07-12 02:17:38 +00:00
// set the last_free pointer to this block if it's earlier in the heap
if (block / BLOCKS_PER_ATB < MP_STATE_MEM(gc_last_free_atb_index)) {
MP_STATE_MEM(gc_last_free_atb_index) = block / BLOCKS_PER_ATB;
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
}
py/gc: Refactor assertions in gc_free function. gc_free() expects either NULL or a valid pointer into the heap, so the checks for a valid pointer can be turned into assertions.
2017-07-12 02:17:38 +00:00
// free head and all of its tail blocks
do {
ATB_ANY_TO_FREE(block);
block += 1;
} while (ATB_GET_KIND(block) == AT_TAIL);
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py/gc: Refactor assertions in gc_free function. gc_free() expects either NULL or a valid pointer into the heap, so the checks for a valid pointer can be turned into assertions.
2017-07-12 02:17:38 +00:00
#if EXTENSIVE_HEAP_PROFILING
gc_dump_alloc_table();
#endif
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
}
}
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
size_t gc_nbytes(const void *ptr) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
Add gc_free function to force a block to be freed.
2013-10-22 19:26:36 +00:00
if (VERIFY_PTR(ptr)) {
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t block = BLOCK_FROM_PTR(ptr);
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
if (ATB_GET_KIND(block) == AT_HEAD) {
// work out number of consecutive blocks in the chain starting with this on
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t n_blocks = 0;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
do {
n_blocks += 1;
} while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
return n_blocks * BYTES_PER_BLOCK;
}
}
// invalid pointer
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
return 0;
}
Fix realloc
2014-03-12 19:00:23 +00:00
#if 0
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
// old, simple realloc that didn't expand memory in place
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
void *gc_realloc(void *ptr, mp_uint_t n_bytes) {
mp_uint_t n_existing = gc_nbytes(ptr);
py: Revert to old gc_realloc for now.
2014-03-07 00:21:51 +00:00
if (n_bytes <= n_existing) {
return ptr;
} else {
py, gc: Fix old gc_realloc for case when NULL is passed in as ptr.
2014-04-25 11:44:53 +00:00
bool has_finaliser;
if (ptr == NULL) {
has_finaliser = false;
} else {
gc: Recover simple gc_realloc implementation, make easier to switch between.
2014-04-20 08:43:38 +00:00
#if MICROPY_ENABLE_FINALISER
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
has_finaliser = FTB_GET(BLOCK_FROM_PTR((mp_uint_t)ptr));
gc: Recover simple gc_realloc implementation, make easier to switch between.
2014-04-20 08:43:38 +00:00
#else
py, gc: Fix old gc_realloc for case when NULL is passed in as ptr.
2014-04-25 11:44:53 +00:00
has_finaliser = false;
gc: Recover simple gc_realloc implementation, make easier to switch between.
2014-04-20 08:43:38 +00:00
#endif
py, gc: Fix old gc_realloc for case when NULL is passed in as ptr.
2014-04-25 11:44:53 +00:00
}
void *ptr2 = gc_alloc(n_bytes, has_finaliser);
py: Revert to old gc_realloc for now.
2014-03-07 00:21:51 +00:00
if (ptr2 == NULL) {
return ptr2;
}
memcpy(ptr2, ptr, n_existing);
gc_free(ptr);
return ptr2;
}
}
gc: Recover simple gc_realloc implementation, make easier to switch between.
2014-04-20 08:43:38 +00:00
#else // Alternative gc_realloc impl
py: Improve GC locking/unlocking, and make it part of the API.
2014-04-08 11:31:21 +00:00
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
// check for pure allocation
Fix gc_realloc to expand in place * Issue #322
2014-03-05 21:23:04 +00:00
if (ptr_in == NULL) {
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00:00
return gc_alloc(n_bytes, false);
Fix gc_realloc to expand in place * Issue #322
2014-03-05 21:23:04 +00:00
}
py: Clean up edge cases of malloc/realloc/free.
2014-10-23 11:02:00 +00:00
// check for pure free
if (n_bytes == 0) {
gc_free(ptr_in);
return NULL;
}
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void *ptr = ptr_in;
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
py/gc: Fix 2 cases of concurrent access to ATB and FTB.
2016-05-04 09:14:43 +00:00
GC_ENTER();
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
if (MP_STATE_MEM(gc_lock_depth) > 0) {
GC_EXIT();
return NULL;
}
py/gc: In gc_realloc, convert pointer sanity checks to assertions. These checks are assumed to be true in all cases where gc_realloc is called with a valid pointer, so no need to waste code space and time checking them in a non-debug build.
2017-11-29 06:17:08 +00:00
// get the GC block number corresponding to this pointer
assert(VERIFY_PTR(ptr));
size_t block = BLOCK_FROM_PTR(ptr);
assert(ATB_GET_KIND(block) == AT_HEAD);
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
// compute number of new blocks that are requested
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t new_blocks = (n_bytes + BYTES_PER_BLOCK - 1) / BYTES_PER_BLOCK;
Fix gc_realloc to expand in place * Issue #322
2014-03-05 21:23:04 +00:00
py: Fix GC realloc issue, where memory chunks were never shrunk. Previously, a realloc to a smaller memory chunk size would not free the unused blocks in the tail of the chunk.
2014-10-15 18:24:47 +00: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).
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t n_free = 0;
size_t n_blocks = 1; // counting HEAD block
size_t max_block = MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB;
for (size_t bl = block + n_blocks; bl < max_block; bl++) {
py: Fix GC realloc issue, where memory chunks were never shrunk. Previously, a realloc to a smaller memory chunk size would not free the unused blocks in the tail of the chunk.
2014-10-15 18:24:47 +00:00
byte block_type = ATB_GET_KIND(bl);
if (block_type == AT_TAIL) {
n_blocks++;
continue;
Fix realloc
2014-03-12 19:00:23 +00:00
}
py: Fix GC realloc issue, where memory chunks were never shrunk. Previously, a realloc to a smaller memory chunk size would not free the unused blocks in the tail of the chunk.
2014-10-15 18:24:47 +00: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;
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
}
break;
}
// return original ptr if it already has the requested number of blocks
if (new_blocks == n_blocks) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
return ptr_in;
}
Fix gc_realloc to expand in place * Issue #322
2014-03-05 21:23:04 +00:00
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
// check if we can shrink the allocated area
if (new_blocks < n_blocks) {
// free unneeded tail blocks
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
for (size_t bl = block + new_blocks, count = n_blocks - new_blocks; count > 0; bl++, count--) {
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
ATB_ANY_TO_FREE(bl);
gc: "new" gc_realloc: Rewrite in plain C, fixing bunch of bugs. There were typos, various rounding errors trying to do concurrent counting in bytes vs blocks, complex conditional paths, superfluous variables, etc., etc., all leading to obscure segfaults.
2014-04-20 08:45:16 +00:00
}
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
// set the last_free pointer to end of this block if it's earlier in the heap
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
if ((block + new_blocks) / BLOCKS_PER_ATB < MP_STATE_MEM(gc_last_free_atb_index)) {
MP_STATE_MEM(gc_last_free_atb_index) = (block + new_blocks) / BLOCKS_PER_ATB;
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
}
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
#if EXTENSIVE_HEAP_PROFILING
gc_dump_alloc_table();
#endif
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
return ptr_in;
}
gc: "new" gc_realloc: Rewrite in plain C, fixing bunch of bugs. There were typos, various rounding errors trying to do concurrent counting in bytes vs blocks, complex conditional paths, superfluous variables, etc., etc., all leading to obscure segfaults.
2014-04-20 08:45:16 +00:00
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
// check if we can expand in place
if (new_blocks <= n_blocks + n_free) {
// mark few more blocks as used tail
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
for (size_t bl = block + n_blocks; bl < block + new_blocks; bl++) {
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
assert(ATB_GET_KIND(bl) == AT_FREE);
ATB_FREE_TO_TAIL(bl);
}
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 22:37:55 +00:00
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py/gc: Add MICROPY_GC_CONSERVATIVE_CLEAR option to always zero memory. There can be stray pointers in memory blocks that are not properly zero'd after allocation. This patch adds a new config option to always zero all allocated memory (via gc_alloc and gc_realloc) and hence help to eliminate stray pointers. See issue #2195.
2016-08-26 05:35:26 +00: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
py, gc: Only zero out the extra bytes at the end of the heap chunk. This is a small optimisation to zero out only the additional bytes that the caller did not ask for.
2014-04-26 21:23:42 +00:00
// zero out the additional bytes of the newly allocated blocks (see comment above in gc_alloc)
gc: Use byte* pointers instead of void* for pointer arithmetic void* is of unknown size
2014-06-12 15:42:20 +00:00
memset((byte*)ptr_in + n_bytes, 0, new_blocks * BYTES_PER_BLOCK - n_bytes);
py/gc: Add MICROPY_GC_CONSERVATIVE_CLEAR option to always zero memory. There can be stray pointers in memory blocks that are not properly zero'd after allocation. This patch adds a new config option to always zero all allocated memory (via gc_alloc and gc_realloc) and hence help to eliminate stray pointers. See issue #2195.
2016-08-26 05:35:26 +00: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 22:37:55 +00:00
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
#if EXTENSIVE_HEAP_PROFILING
gc_dump_alloc_table();
#endif
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
return ptr_in;
}
Fix gc_realloc to expand in place * Issue #322
2014-03-05 21:23:04 +00:00
py/gc: Fix 2 cases of concurrent access to ATB and FTB.
2016-05-04 09:14:43 +00:00
#if MICROPY_ENABLE_FINALISER
bool ftb_state = FTB_GET(block);
#else
bool ftb_state = false;
#endif
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
py: Improve allocation policy of qstr data. Previous to this patch all interned strings lived in their own malloc'd chunk. On average this wastes N/2 bytes per interned string, where N is the number-of-bytes for a quanta of the memory allocator (16 bytes on 32 bit archs). With this patch interned strings are concatenated into the same malloc'd chunk when possible. Such chunks are enlarged inplace when possible, and shrunk to fit when a new chunk is needed. RAM savings with this patch are highly varied, but should always show an improvement (unless only 3 or 4 strings are interned). New version typically uses about 70% of previous memory for the qstr data, and can lead to savings of around 10% of total memory footprint of a running script. Costs about 120 bytes code size on Thumb2 archs (depends on how many calls to gc_realloc are made).
2015-06-13 20:53:22 +00:00
if (!allow_move) {
// not allowed to move memory block so return failure
return NULL;
}
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
// can't resize inplace; try to find a new contiguous chain
py/gc: Fix 2 cases of concurrent access to ATB and FTB.
2016-05-04 09:14:43 +00:00
void *ptr_out = gc_alloc(n_bytes, ftb_state);
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
// check that the alloc succeeded
if (ptr_out == NULL) {
return NULL;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
Fix gc_realloc to expand in place * Issue #322
2014-03-05 21:23:04 +00:00
gc: More verbose debugging Add more DEBUG_printf statements to trace gc behaviour
2014-06-16 08:44:29 +00:00
DEBUG_printf("gc_realloc(%p -> %p)\n", ptr_in, ptr_out);
py, gc: Further simplify coding-style of gc_realloc. No logic changes, just coding style to make it easy to read.
2014-04-20 17:16:25 +00:00
memcpy(ptr_out, ptr_in, n_blocks * BYTES_PER_BLOCK);
gc_free(ptr_in);
return ptr_out;
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
gc: Recover simple gc_realloc implementation, make easier to switch between.
2014-04-20 08:43:38 +00:00
#endif // Alternative gc_realloc impl
Fix realloc
2014-03-12 19:00:23 +00:00
py, unix, lib: Allow to compile with -Wold-style-definition.
2015-01-12 22:34:38 +00:00
void gc_dump_info(void) {
More GC debugging improvements.
2014-02-11 16:01:38 +00:00
gc_info_t info;
gc_info(&info);
py/gc: When printing info, use %u instead of UINT_FMT for size_t args. Ideally we'd use %zu for size_t args, but that's unlikely to be supported by all runtimes, and we would then need to implement it in mp_printf. So simplest and most portable option is to use %u and cast the argument to uint(=unsigned int). Note: reason for the change is that UINT_FMT can be %llu (size suitable for mp_uint_t) which is wider than size_t and prints incorrect results.
2015-12-18 12:52:45 +00:00
mp_printf(&mp_plat_print, "GC: total: %u, used: %u, free: %u\n",
(uint)info.total, (uint)info.used, (uint)info.free);
py/gc: Calculate (and report) maximum contiguous free block size. Just as maximum allocated block size, it's reported in allocation units (not bytes).
2016-06-30 21:09:55 +00:00
mp_printf(&mp_plat_print, " No. of 1-blocks: %u, 2-blocks: %u, max blk sz: %u, max free sz: %u\n",
(uint)info.num_1block, (uint)info.num_2block, (uint)info.max_block, (uint)info.max_free);
More GC debugging improvements.
2014-02-11 16:01:38 +00:00
}
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
void gc_dump_alloc_table(void) {
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_ENTER();
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
static const size_t DUMP_BYTES_PER_LINE = 64;
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
#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.
py: Convert occurrences of non-debug printf to mp_printf.
2015-04-11 11:15:47 +00:00
mp_printf(&mp_plat_print, "GC memory layout; from %p:", MP_STATE_MEM(gc_pool_start));
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
#endif
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
for (size_t bl = 0; bl < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; bl++) {
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
if (bl % DUMP_BYTES_PER_LINE == 0) {
// a new line of blocks
{
// check if this line contains only free blocks
py/gc: Use size_t instead of mp_uint_t to count things related to heap. size_t is the correct type to use to count things related to the size of the address space. Using size_t (instead of mp_uint_t) is important for the efficiency of ports that configure mp_uint_t to larger than the machine word size.
2015-12-17 01:09:11 +00:00
size_t bl2 = bl;
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
while (bl2 < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB && ATB_GET_KIND(bl2) == AT_FREE) {
py: Improve memory usage debugging; better GC AT dumping. In unix port, mem_info(1) now prints pretty GC alloc table.
2014-10-24 22:12:25 +00:00
bl2++;
}
if (bl2 - bl >= 2 * DUMP_BYTES_PER_LINE) {
// there are at least 2 lines containing only free blocks, so abbreviate their printing
py/gc: When printing info, use %u instead of UINT_FMT for size_t args. Ideally we'd use %zu for size_t args, but that's unlikely to be supported by all runtimes, and we would then need to implement it in mp_printf. So simplest and most portable option is to use %u and cast the argument to uint(=unsigned int). Note: reason for the change is that UINT_FMT can be %llu (size suitable for mp_uint_t) which is wider than size_t and prints incorrect results.
2015-12-18 12:52:45 +00:00
mp_printf(&mp_plat_print, "\n (%u lines all free)", (uint)(bl2 - bl) / DUMP_BYTES_PER_LINE);
py: Improve memory usage debugging; better GC AT dumping. In unix port, mem_info(1) now prints pretty GC alloc table.
2014-10-24 22:12:25 +00:00
bl = bl2 & (~(DUMP_BYTES_PER_LINE - 1));
py: Put all global state together in state structures. This patch consolidates all global variables in py/ core into one place, in a global structure. Root pointers are all located together to make GC tracing easier and more efficient.
2015-01-01 23:30:53 +00:00
if (bl >= MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB) {
py: Improve memory usage debugging; better GC AT dumping. In unix port, mem_info(1) now prints pretty GC alloc table.
2014-10-24 22:12:25 +00:00
// got to end of heap
py, gc: Further reduce heap fragmentation with new, faster gc alloc. The heap allocation is now exactly as it was before the "faster gc alloc" patch, but it's still nearly as fast. It is fixed by being careful to always update the "last free block" pointer whenever the heap changes (eg free or realloc). Tested on all tests by enabling EXTENSIVE_HEAP_PROFILING in py/gc.c: old and new allocator have exactly the same behaviour, just the new one is much faster.
2014-08-28 22:06:38 +00:00
break;
}
}
}
// print header for new line of blocks
py: Make heap printing compatible with 16-bit word size.
2015-03-31 22:07:02 +00:00
// (the cast to uint32_t is for 16-bit ports)
py/gc: gc_dump_alloc_table(): Dump heap offset instead of actual address. Address printed was truncated anyway and in general confusing to outsider. A line which dumps it is still left in the source, commented, for peculiar cases when it may be needed (e.g. when running under debugger).
2016-05-12 21:16:38 +00:00
//mp_printf(&mp_plat_print, "\n%05x: ", (uint)(PTR_FROM_BLOCK(bl) & (uint32_t)0xfffff));
py: Convert occurrences of non-debug printf to mp_printf.
2015-04-11 11:15:47 +00:00
mp_printf(&mp_plat_print, "\n%05x: ", (uint)((bl * BYTES_PER_BLOCK) & (uint32_t)0xfffff));
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
}
int c = ' ';
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
switch (ATB_GET_KIND(bl)) {
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
case AT_FREE: c = '.'; break;
py: Add more debug printing code in gc_dump_alloc_table.
2014-10-17 14:12:57 +00:00
/* this prints out if the object is reachable from BSS or STACK (for unix only)
case AT_HEAD: {
c = 'h';
Remove obsolete bss-related code/build features GC for unix/windows builds doesn't make use of the bss section anymore, so we do not need the (sometimes complicated) build features and code related to it
2015-01-08 09:32:45 +00:00
void **ptrs = (void**)(void*)&mp_state_ctx;
mp_uint_t len = offsetof(mp_state_ctx_t, vm.stack_top) / sizeof(mp_uint_t);
py: Add more debug printing code in gc_dump_alloc_table.
2014-10-17 14:12:57 +00:00
for (mp_uint_t i = 0; i < len; i++) {
mp_uint_t ptr = (mp_uint_t)ptrs[i];
if (VERIFY_PTR(ptr) && BLOCK_FROM_PTR(ptr) == bl) {
c = 'B';
break;
}
}
if (c == 'h') {
ptrs = (void**)&c;
py: Add MP_STATE_THREAD to hold state specific to a given thread.
2016-04-22 22:44:56 +00:00
len = ((mp_uint_t)MP_STATE_THREAD(stack_top) - (mp_uint_t)&c) / sizeof(mp_uint_t);
py: Add more debug printing code in gc_dump_alloc_table.
2014-10-17 14:12:57 +00:00
for (mp_uint_t i = 0; i < len; i++) {
mp_uint_t ptr = (mp_uint_t)ptrs[i];
if (VERIFY_PTR(ptr) && BLOCK_FROM_PTR(ptr) == bl) {
c = 'S';
break;
}
}
}
break;
}
*/
py: Improve memory usage debugging; better GC AT dumping. In unix port, mem_info(1) now prints pretty GC alloc table.
2014-10-24 22:12:25 +00:00
/* this prints the uPy object type of the head block */
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 22:37:55 +00:00
case AT_HEAD: {
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
void **ptr = (void**)(MP_STATE_MEM(gc_pool_start) + bl * BYTES_PER_BLOCK);
if (*ptr == &mp_type_tuple) { c = 'T'; }
else if (*ptr == &mp_type_list) { c = 'L'; }
else if (*ptr == &mp_type_dict) { c = 'D'; }
py/gc: gc_dump_alloc_table(): Show byte/str and (byte)array objects. These are typical consumers of large chunks of memory, so it's useful to see at least their number (how much memory isn't clearly shown, as the data for these objects is allocated elsewhere).
2016-05-11 15:52:46 +00:00
else if (*ptr == &mp_type_str || *ptr == &mp_type_bytes) { c = 'S'; }
py/gc: Make (byte)array type dumping conditional on these types being enabled.
2016-05-11 16:21:53 +00:00
#if MICROPY_PY_BUILTINS_BYTEARRAY
else if (*ptr == &mp_type_bytearray) { c = 'A'; }
#endif
#if MICROPY_PY_ARRAY
else if (*ptr == &mp_type_array) { c = 'A'; }
#endif
py: Fix some macros defines; cleanup some includes.
2014-11-05 21:16:41 +00:00
#if MICROPY_PY_BUILTINS_FLOAT
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
else if (*ptr == &mp_type_float) { c = 'F'; }
py: Fix some macros defines; cleanup some includes.
2014-11-05 21:16:41 +00:00
#endif
py/gc: Move away from using mp_uint_t, instead use uintptr_t and size_t. The GC works with concrete pointers and so the types should reflect this.
2015-11-27 13:07:48 +00:00
else if (*ptr == &mp_type_fun_bc) { c = 'B'; }
else if (*ptr == &mp_type_module) { c = 'M'; }
py: Add (commented out) code to gc_dump_alloc_table for qstr info.
2015-01-11 14:37:06 +00:00
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
}
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 22:37:55 +00:00
break;
}
gc: gc_dump_alloc_table(): Use '=' char for tail blocks. '=' is pretty natural character for tail, and gives less dense picture where it's easier to see what object types are actually there.
2016-05-12 21:16:38 +00:00
case AT_TAIL: c = '='; break;
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
case AT_MARK: c = 'm'; break;
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
}
py: Convert occurrences of non-debug printf to mp_printf.
2015-04-11 11:15:47 +00:00
mp_printf(&mp_plat_print, "%c", c);
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
}
py: Convert occurrences of non-debug printf to mp_printf.
2015-04-11 11:15:47 +00:00
mp_print_str(&mp_plat_print, "\n");
py/gc: Make memory manager and garbage collector thread safe. By using a single, global mutex, all memory-related functions (alloc, free, realloc, collect, etc) are made thread safe. This means that only one thread can be in such a function at any one time.
2016-04-25 15:28:57 +00:00
GC_EXIT();
Clear ATBs on gc_init; better gc_info.
2013-10-22 14:25:25 +00:00
}
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
#if DEBUG_PRINT
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
void gc_test(void) {
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
mp_uint_t len = 500;
mp_uint_t *heap = malloc(len);
gc_init(heap, heap + len / sizeof(mp_uint_t));
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
void *ptrs[100];
{
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
mp_uint_t **p = gc_alloc(16, false);
Improve GC finalisation code; add option to disable it.
2014-04-05 19:35:48 +00: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);
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
mp_uint_t ***p2 = gc_alloc(16, false);
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
p2[0] = p;
p2[1] = p;
ptrs[0] = p2;
}
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
for (int i = 0; i < 25; i+=2) {
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 12:25:24 +00:00
mp_uint_t *p = gc_alloc(i, false);
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
printf("p=%p\n", p);
if (i & 3) {
//ptrs[i] = p;
}
}
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
printf("Before GC:\n");
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
gc_dump_alloc_table();
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
printf("Starting GC...\n");
gc_collect_start();
gc_collect_root(ptrs, sizeof(ptrs) / sizeof(void*));
gc_collect_end();
printf("After GC:\n");
GC: Fix printf formats for debugging; add gc_dump_alloc_table.
2014-02-26 22:55:59 +00:00
gc_dump_alloc_table();
Add mark-sweep garbage collector.
2013-10-21 22:45:08 +00:00
}
gc: Make debug output configurable, revamp test function. Test function needs to be called by something else. Test heap size reduced so its dump fits on a screenful of a typical terminal.
2014-02-10 19:45:54 +00:00
#endif
Factor and simplify Makefile's and mpconfig, part 2.
2014-01-07 15:20:33 +00:00
#endif // MICROPY_ENABLE_GC