revamp supervisor allocations

These now interact better with the GC heap, through the magic of a little
layer violation.

New Supervisor Allocator

 * The supervisor_allocation structure is now placed in static storage by
   each user of supervisor allocations. The max number of supervisor allocations
   must still be statically known, but it's known implicitly instead of
   explicitly
 * the structures get placed into a single-linked list so that they they
   can be traversed
 * 'doing' a supervisor allocation initializes the gc heap if necessary
   because the implementation is JUST a gc_alloc plus bookkeeping!
 * a layer violation in gc is introduced to support gc-reset surviving
   allocations:  gc_reserve() takes a pointer and length, and marks it as
   an allocated gc block sans finalizer
 * the "high address" allocation is specifically for the C stack, since it
   must be contiguous with the statically allocated stack.
 * objects are allowed to register a move callback function.  A "simple
   move" function uses memmove; NULL specifies not movable; and
   the special value SUPERVISOR_STACK_ALLOCATION indicates the stack
   allocation which is both high-address and non-movable

of course it doesn't boot.

Author: jepler

main.c

@@ -126,13 +126,15 @@ uint8_t value_out = 0;
 static size_t PLACE_IN_DTCM_BSS(_pystack[CIRCUITPY_PYSTACK_SIZE / sizeof(size_t)]);
 #endif
 
+supervisor_allocation prev_traceback;
+
 static void reset_devices(void) {
     #if CIRCUITPY_BLEIO_HCI
     bleio_reset();
     #endif
 }
 
-STATIC void start_mp(supervisor_allocation *heap) {
+STATIC void start_mp(void) {
     supervisor_workflow_reset();
 
     // Stack limit should be less than real stack size, so we have a chance
@@ -163,9 +165,7 @@ STATIC void start_mp(supervisor_allocation *heap) {
     mp_pystack_init(_pystack, _pystack + (sizeof(_pystack) / sizeof(size_t)));
     #endif
 
-    #if MICROPY_ENABLE_GC
-    gc_init(heap->ptr, heap->ptr + get_allocation_length(heap) / 4);
-    #endif
+    supervisor_gc_init();
     mp_init();
     mp_obj_list_init((mp_obj_list_t *)mp_sys_path, 0);
     mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
@@ -196,7 +196,7 @@ STATIC void stop_mp(void) {
     usb_background();
     #endif
 
-    gc_deinit();
+    supervisor_gc_deinit();
 }
 
 STATIC const char *_current_executing_filename = NULL;
@@ -264,30 +264,29 @@ STATIC void count_strn(void *data, const char *str, size_t len) {
     *(size_t *)data += len;
 }
 
-STATIC void cleanup_after_vm(supervisor_allocation *heap, mp_obj_t exception) {
+STATIC void cleanup_after_vm(mp_obj_t exception) {
     // Get the traceback of any exception from this run off the heap.
     // MP_OBJ_SENTINEL means "this run does not contribute to traceback storage, don't touch it"
     // MP_OBJ_NULL (=0) means "this run completed successfully, clear any stored traceback"
     if (exception != MP_OBJ_SENTINEL) {
-        free_memory(prev_traceback_allocation);
+        free_memory(&prev_traceback);
         // ReloadException is exempt from traceback printing in pyexec_file(), so treat it as "no
         // traceback" here too.
         if (exception && exception != MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception))) {
             size_t traceback_len = 0;
             mp_print_t print_count = {&traceback_len, count_strn};
             mp_obj_print_exception(&print_count, exception);
-            prev_traceback_allocation = allocate_memory(align32_size(traceback_len + 1), false, true);
             // Empirically, this never fails in practice - even when the heap is totally filled up
             // with single-block-sized objects referenced by a root pointer, exiting the VM frees
             // up several hundred bytes, sufficient for the traceback (which tends to be shortened
             // because there wasn't memory for the full one). There may be convoluted ways of
             // making it fail, but at this point I believe they are not worth spending code on.
-            if (prev_traceback_allocation != NULL) {
+            if (allocate_memory(&prev_traceback, traceback_len + 1, supervisor_simple_move)) {
                 vstr_t vstr;
-                vstr_init_fixed_buf(&vstr, traceback_len, (char *)prev_traceback_allocation->ptr);
+                vstr_init_fixed_buf(&vstr, traceback_len + 1, (char *)prev_traceback_allocation->ptr);
                 mp_print_t print = {&vstr, (mp_print_strn_t)vstr_add_strn};
                 mp_obj_print_exception(&print, exception);
-                ((char *)prev_traceback_allocation->ptr)[traceback_len] = '\0';
+                vstr_null_terminated_str(&vstr);
             }
         } else {
             prev_traceback_allocation = NULL;
@@ -344,8 +343,6 @@ STATIC void cleanup_after_vm(supervisor_allocation *heap, mp_obj_t exception) {
     // Free the heap last because other modules may reference heap memory and need to shut down.
     filesystem_flush();
     stop_mp();
-    free_memory(heap);
-    supervisor_move_memory();
 
     // Let the workflows know we've reset in case they want to restart.
     supervisor_workflow_reset();
@@ -399,18 +396,16 @@ STATIC bool run_code_py(safe_mode_t safe_mode, bool *simulate_reset) {
         };
         #endif
 
-        supervisor_allocation *heap = allocate_remaining_memory();
-
         // Prepare the VM state.
-        start_mp(heap);
+        start_mp();
 
         #if CIRCUITPY_USB
         usb_setup_with_vm();
         #endif
 
         // Check if a different run file has been allocated
-        if (next_code_allocation) {
-            next_code_info_t *info = ((next_code_info_t *)next_code_allocation->ptr);
+        if (next_code_allocation.ptr) {
+            next_code_info_t *info = ((next_code_info_t *)next_code_allocation.ptr);
             info->options &= ~SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET;
             next_code_options = info->options;
             if (info->filename[0] != '\0') {
@@ -450,15 +445,15 @@ STATIC bool run_code_py(safe_mode_t safe_mode, bool *simulate_reset) {
 
 
         // Finished executing python code. Cleanup includes filesystem flush and a board reset.
-        cleanup_after_vm(heap, _exec_result.exception);
+        cleanup_after_vm(_exec_result.exception);
         _exec_result.exception = NULL;
 
         // If a new next code file was set, that is a reason to keep it (obviously). Stuff this into
         // the options because it can be treated like any other reason-for-stickiness bit. The
         // source is different though: it comes from the options that will apply to the next run,
         // while the rest of next_code_options is what applied to this run.
-        if (next_code_allocation != NULL &&
-            (((next_code_info_t *)next_code_allocation->ptr)->options & SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET)) {
+        if (next_code_allocation.ptr &&
+            (((next_code_info_t *)next_code_allocation.ptr)->options & SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET)) {
             next_code_options |= SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET;
         }
 
@@ -706,8 +701,7 @@ STATIC bool run_code_py(safe_mode_t safe_mode, bool *simulate_reset) {
 
     // free code allocation if unused
     if ((next_code_options & next_code_stickiness_situation) == 0) {
-        free_memory(next_code_allocation);
-        next_code_allocation = NULL;
+        free_memory(&next_code_allocation);
     }
 
     #if CIRCUITPY_STATUS_LED
@@ -746,9 +740,7 @@ STATIC void __attribute__ ((noinline)) run_boot_py(safe_mode_t safe_mode) {
 
     // Do USB setup even if boot.py is not run.
 
-    supervisor_allocation *heap = allocate_remaining_memory();
-
-    start_mp(heap);
+    start_mp();
 
     #if CIRCUITPY_USB
     // Set up default USB values after boot.py VM starts but before running boot.py.
@@ -834,7 +826,7 @@ STATIC void __attribute__ ((noinline)) run_boot_py(safe_mode_t safe_mode) {
 
     port_post_boot_py(true);
 
-    cleanup_after_vm(heap, _exec_result.exception);
+    cleanup_after_vm(_exec_result.exception);
     _exec_result.exception = NULL;
 
     port_post_boot_py(false);
@@ -849,8 +841,7 @@ STATIC int run_repl(void) {
     int exit_code = PYEXEC_FORCED_EXIT;
     stack_resize();
     filesystem_flush();
-    supervisor_allocation *heap = allocate_remaining_memory();
-    start_mp(heap);
+    start_mp();
 
     #if CIRCUITPY_USB
     usb_setup_with_vm();
@@ -893,7 +884,7 @@ STATIC int run_repl(void) {
         exit_code = PYEXEC_DEEP_SLEEP;
     }
     #endif
-    cleanup_after_vm(heap, MP_OBJ_SENTINEL);
+    cleanup_after_vm(MP_OBJ_SENTINEL);
 
     // Also reset bleio. The above call omits it in case workflows should continue. In this case,
     // we're switching straight to another VM so we want to reset.

ports/espressif/common-hal/espidf/__init__.c

@@ -74,7 +74,7 @@ bool common_hal_espidf_set_reserved_psram(size_t amount) {
     #endif
 }
 
-supervisor_allocation *psram_for_idf;
+supervisor_allocation psram_for_idf;
 
 void common_hal_espidf_reserve_psram(void) {
     #ifdef CONFIG_SPIRAM
@@ -83,8 +83,7 @@ void common_hal_espidf_reserve_psram(void) {
         if (reserved_psram == 0) {
             return;
         }
-        psram_for_idf = allocate_memory(reserved_psram, true, false);
-        if (psram_for_idf) {
+        if (allocate_memory(&psram_for_idf, reserved_psram, NULL)) {
             intptr_t psram_for_idf_start = (intptr_t)psram_for_idf->ptr;
             intptr_t psram_for_idf_end = psram_for_idf_start + reserved_psram;
             ESP_LOGI(TAG, "Reserved %x..%x", psram_for_idf_start, psram_for_idf_end);

py/gc.c

@@ -500,6 +500,23 @@ bool gc_alloc_possible(void) {
     return MP_STATE_MEM(gc_pool_start) != 0;
 }
 
+void gc_reserve_blocks(size_t start_block, size_t end_block) {
+    // 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
+    for (size_t bl = start_block + 1; bl <= end_block; bl++) {
+        ATB_FREE_TO_TAIL(bl);
+    }
+}
+
+void gc_reserve(void *ptr, size_t n_bytes) {
+    size_t start_block = BLOCK_FROM_PTR(ptr);
+    size_t n_blocks = ((n_bytes + BYTES_PER_BLOCK - 1) & (~(BYTES_PER_BLOCK - 1))) / BYTES_PER_BLOCK;
+    gc_reserve_blocks(start_block, start_block + n_blocks);
+}
+
 // We place long lived objects at the end of the heap rather than the start. This reduces
 // fragmentation by localizing the heap churn to one portion of memory (the start of the heap.)
 void *gc_alloc(size_t n_bytes, unsigned int alloc_flags, bool long_lived) {
@@ -623,14 +640,7 @@ void *gc_alloc(size_t n_bytes, unsigned int alloc_flags, bool long_lived) {
     gc_log_change(start_block, end_block - start_block + 1);
     #endif
 
-    // 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
-    for (size_t bl = start_block + 1; bl <= end_block; bl++) {
-        ATB_FREE_TO_TAIL(bl);
-    }
+    gc_reserve_blocks(start_block, end_block);
 
     // get pointer to first block
     // we must create this pointer before unlocking the GC so a collection can find it

py/gc.h

@@ -79,6 +79,8 @@ size_t gc_nbytes(const void *ptr);
 bool gc_has_finaliser(const void *ptr);
 void *gc_make_long_lived(void *old_ptr);
 void *gc_realloc(void *ptr, size_t n_bytes, bool allow_move);
+void gc_reserve(void *ptr, size_t n_bytes);
+void gc_reserve_blocks(size_t start_block, size_t end_block);
 
 // Prevents a pointer from ever being freed because it establishes a permanent reference to it. Use
 // very sparingly because it can leak memory.

shared-bindings/supervisor/__init__.c

@@ -153,18 +153,13 @@ STATIC mp_obj_t supervisor_set_next_code_file(size_t n_args, const mp_obj_t *pos
     }
     size_t len;
     const char *filename = mp_obj_str_get_data(args.filename.u_obj, &len);
-    free_memory(next_code_allocation);
+    free_memory(&next_code_allocation);
     if (options != 0 || len != 0) {
-        next_code_allocation = allocate_memory(align32_size(sizeof(next_code_info_t) + len + 1), false, true);
-        if (next_code_allocation == NULL) {
-            m_malloc_fail(sizeof(next_code_info_t) + len + 1);
-        }
-        next_code_info_t *next_code = (next_code_info_t *)next_code_allocation->ptr;
+        allocate_memory_throw(&next_code_allocation, sizeof(next_code_info_t) + len + 1, supervisor_simple_move);
+        next_code_info_t *next_code = (next_code_info_t *)next_code_allocation.ptr;
         next_code->options = options | SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET;
         memcpy(&next_code->filename, filename, len);
         next_code->filename[len] = '\0';
-    } else {
-        next_code_allocation = NULL;
     }
     return mp_const_none;
 }
@@ -293,10 +288,10 @@ STATIC mp_obj_t supervisor_set_usb_identification(size_t n_args, const mp_obj_t
     } args;
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
 
-    if (!usb_identification_allocation) {
-        usb_identification_allocation = allocate_memory(sizeof(usb_identification_t), false, true);
+    if (!usb_identification_allocation.ptr) {
+        allocate_memory_throw(&usb_identification_allocation, sizeof(usb_identification_t), supervisor_simple_move);
     }
-    usb_identification_t *identification = (usb_identification_t *)usb_identification_allocation->ptr;
+    usb_identification_t *identification = (usb_identification_t *)usb_identification_allocation.ptr;
 
     mp_arg_validate_int_range(args.vid.u_int, -1, (1 << 16) - 1, MP_QSTR_vid);
     mp_arg_validate_int_range(args.pid.u_int, -1, (1 << 16) - 1, MP_QSTR_pid);

shared-module/is31fl3741/FrameBuffer.c

@@ -61,14 +61,14 @@ void common_hal_is31fl3741_FrameBuffer_construct(is31fl3741_FrameBuffer_obj_t *s
         mp_raise_ValueError(translate("LED mappings must match display size"));
     }
 
-    self->mapping = common_hal_is31fl3741_allocator_impl(sizeof(uint16_t) * len);
+    allocate_memory_throw(&self->mapping_allocation, sizeof(uint16_t) * len, supervisor_simple_move);
     for (size_t i = 0; i < len; i++) {
         mp_int_t value = mp_obj_get_int(items[i]);
         // We only store up to 16 bits
         if (value > 0xFFFF) {
             value = 0xFFFF;
         }
-        self->mapping[i] = (uint16_t)value;
+        self->mapping_allocation.ptr[i] = (uint16_t)value;
     }
 
     common_hal_is31fl3741_FrameBuffer_reconstruct(self, framebuffer);
@@ -89,10 +89,11 @@ void common_hal_is31fl3741_FrameBuffer_reconstruct(is31fl3741_FrameBuffer_obj_t
         // verify that the matrix is big enough
         mp_get_index(mp_obj_get_type(self->framebuffer), self->bufinfo.len, MP_OBJ_NEW_SMALL_INT(self->bufsize - 1), false);
     } else {
-        common_hal_is31fl3741_free_impl(self->bufinfo.buf);
+        free_memory(&self->framebuffer_allocation);
+        allocate_memory(&self->framebuffer_allocation, self->bufsize, supervisor_simple_move);
 
         self->framebuffer = NULL;
-        self->bufinfo.buf = common_hal_is31fl3741_allocator_impl(self->bufsize);
+        self->bufinfo.buf = self->framebuffer_allocation.buf;
         self->bufinfo.len = self->bufsize;
         self->bufinfo.typecode = 'H' | MP_OBJ_ARRAY_TYPECODE_FLAG_RW;
     }
@@ -117,10 +118,8 @@ void common_hal_is31fl3741_FrameBuffer_deinit(is31fl3741_FrameBuffer_obj_t *self
 
     common_hal_is31fl3741_IS31FL3741_deinit(self->is31fl3741);
 
-    if (self->mapping != 0) {
-        common_hal_is31fl3741_free_impl(self->mapping);
-        self->mapping = 0;
-    }
+    supervisor_free(&self->framebuffer_allocation);
+    supervisor_free(&self->mapping_allocation);
 
     self->base.type = NULL;
 
@@ -212,17 +211,3 @@ int common_hal_is31fl3741_FrameBuffer_get_width(is31fl3741_FrameBuffer_obj_t *se
 int common_hal_is31fl3741_FrameBuffer_get_height(is31fl3741_FrameBuffer_obj_t *self) {
     return self->height;
 }
-
-void *common_hal_is31fl3741_allocator_impl(size_t sz) {
-    supervisor_allocation *allocation = allocate_memory(align32_size(sz), false, true);
-    return allocation ? allocation->ptr : NULL;
-}
-
-void common_hal_is31fl3741_free_impl(void *ptr_in) {
-    free_memory(allocation_from_ptr(ptr_in));
-}
-
-void is31fl3741_FrameBuffer_collect_ptrs(is31fl3741_FrameBuffer_obj_t *self) {
-    gc_collect_ptr(self->framebuffer);
-    gc_collect_ptr(self->mapping);
-}

shared-module/is31fl3741/allocator.h

@@ -25,11 +25,3 @@
  */
 
 #pragma once
-
-#include <stdbool.h>
-#include "py/gc.h"
-#include "py/misc.h"
-#include "supervisor/memory.h"
-
-extern void *common_hal_is31fl3741_allocator_impl(size_t sz);
-extern void common_hal_is31fl3741_free_impl(void *);

shared-module/rgbmatrix/RGBMatrix.c

@@ -41,6 +41,7 @@
 #include "shared-module/framebufferio/FramebufferDisplay.h"
 
 extern Protomatter_core *_PM_protoPtr;
+static supervisor_allocation allocation_slots[4];
 
 void common_hal_rgbmatrix_rgbmatrix_construct(rgbmatrix_rgbmatrix_obj_t *self, int width, int bit_depth, uint8_t rgb_count, uint8_t *rgb_pins, uint8_t addr_count, uint8_t *addr_pins, uint8_t clock_pin, uint8_t latch_pin, uint8_t oe_pin, bool doublebuffer, mp_obj_t framebuffer, int8_t tile, bool serpentine, void *timer) {
     self->width = width;
@@ -214,9 +215,22 @@ int common_hal_rgbmatrix_rgbmatrix_get_height(rgbmatrix_rgbmatrix_obj_t *self) {
     return computed_height;
 }
 
+STATIC supervisor_allocation *get_allocation_slot(void) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(allocation_slots); i++) {
+        if (!allocation_slots[i].ptr) {
+            return &allocation_slots[i];
+        }
+    }
+    return NULL;
+}
+
 void *common_hal_rgbmatrix_allocator_impl(size_t sz) {
-    supervisor_allocation *allocation = allocate_memory(align32_size(sz), false, true);
-    return allocation ? allocation->ptr : NULL;
+    supervisor_allocation *allocation = get_allocation_slot();
+    if (!allocation) {
+        return NULL;
+    }
+    allocate_memory(allocation, sz, NULL);
+    return allocation->ptr;
 }
 
 void common_hal_rgbmatrix_free_impl(void *ptr_in) {