Nothing missing. Grow too little though

Author: tannewt

ports/raspberrypi/supervisor/port.c

@@ -259,17 +259,23 @@ void *port_malloc(size_t size, bool dma_capable) {
     if (!dma_capable && _psram_size > 0) {
         void *block = tlsf_malloc(_psram_heap, size);
         if (block) {
+            console_uart_printf("port_malloc(%d) psram = %p\n", size, block);
             return block;
+        } else {
+            console_uart_printf("port_malloc(%d) psram failed\n", size);
         }
     }
     void *block = tlsf_malloc(_heap, size);
+    console_uart_printf("port_malloc(%d) = %p\n", size, block);
     return block;
 }
 
 void port_free(void *ptr) {
     if (((size_t)ptr) < SRAM_BASE) {
+        console_uart_printf("port_free(%p) psram\n", ptr);
         tlsf_free(_psram_heap, ptr);
     } else {
+        console_uart_printf("port_free(%p)\n", ptr);
         tlsf_free(_heap, ptr);
     }
 }
@@ -278,10 +284,13 @@ void *port_realloc(void *ptr, size_t size, bool dma_capable) {
     if (_psram_size > 0 && ((ptr != NULL && ((size_t)ptr) < SRAM_BASE) || (ptr == NULL && !dma_capable))) {
         void *block = tlsf_realloc(_psram_heap, ptr, size);
         if (block) {
+            console_uart_printf("port_realloc(%d) psram = %p\n", size, block);
             return block;
         }
     }
-    return tlsf_realloc(_heap, ptr, size);
+    void *block = tlsf_realloc(_heap, ptr, size);
+    console_uart_printf("port_realloc(%d) = %p\n", size, block);
+    return block;
 }
 
 static bool max_size_walker(void *ptr, size_t size, int used, void *user) {

py/gc.c

@@ -188,6 +188,8 @@ static void gc_setup_area(mp_state_mem_area_t *area, void *start, void *end) {
 
     // Total number of blocks in the pool
     size_t gc_pool_block_len = area->gc_alloc_table_byte_len * BLOCKS_PER_ATB;
+    console_uart_printf("gc_pool_block_len = %d\r\n", gc_pool_block_len);
+    console_uart_printf("total free %d\r\n", gc_pool_block_len * BYTES_PER_BLOCK);
 
     // Calculate table sizes and set start pointers
     #if MICROPY_ENABLE_FINALISER
@@ -294,16 +296,36 @@ void gc_add(void *start, void *end) {
 }
 
 #if MICROPY_GC_SPLIT_HEAP_AUTO
+static size_t compute_heap_size(size_t total_blocks) {
+    console_uart_printf("total_blocks = %d\r\n", total_blocks);
+    // Compute bytes needed to build a heap with total_blocks blocks.
+    size_t total_heap =
+        (total_blocks + BLOCKS_PER_ATB - 1) / BLOCKS_PER_ATB
+        #if MICROPY_ENABLE_FINALISER
+        + (total_blocks + BLOCKS_PER_FTB - 1) / BLOCKS_PER_FTB
+        #endif
+        #if MICROPY_ENABLE_SELECTIVE_COLLECT
+        + (total_blocks + BLOCKS_PER_CTB - 1) / BLOCKS_PER_CTB
+        #endif
+        + total_blocks * BYTES_PER_BLOCK
+        + ALLOC_TABLE_GAP_BYTE
+        + sizeof(mp_state_mem_area_t);
+
+    // Round up size to the nearest multiple of BYTES_PER_BLOCK.
+    total_heap = (total_heap + BYTES_PER_BLOCK - 1) / BYTES_PER_BLOCK;
+    return total_heap;
+}
+
 // Try to automatically add a heap area large enough to fulfill 'failed_alloc'.
 static bool gc_try_add_heap(size_t failed_alloc) {
     // 'needed' is the size of a heap large enough to hold failed_alloc, with
     // the additional metadata overheads as calculated in gc_setup_area().
     //
     // Rather than reproduce all of that logic here, we approximate that adding
     // (13/512) is enough overhead for sufficiently large heap areas (the
-    // overhead converges to 3/128, but there's some fixed overhead and some
+    // overhead converges to 12/512, but there's some fixed overhead and some
     // rounding up of partial block sizes).
-    size_t needed = failed_alloc + MAX(2048, failed_alloc * 13 / 512);
+    size_t needed = compute_heap_size((failed_alloc + BYTES_PER_BLOCK - 1) / BYTES_PER_BLOCK);
 
     size_t avail = gc_get_max_new_split();
 
@@ -312,6 +334,7 @@ static bool gc_try_add_heap(size_t failed_alloc) {
         failed_alloc,
         needed,
         avail);
+    console_uart_printf("gc_try_add_heap failed_alloc %d, needed %d, avail %d\r\n", failed_alloc, needed, avail);
 
     if (avail < needed) {
         // Can't fit this allocation, or system heap has nearly run out anyway
@@ -347,27 +370,18 @@ static bool gc_try_add_heap(size_t failed_alloc) {
         total_blocks += area->gc_alloc_table_byte_len * BLOCKS_PER_ATB;
     }
 
-    // Compute bytes needed to build a heap with total_blocks blocks.
-    size_t total_heap =
-        total_blocks / BLOCKS_PER_ATB
-        #if MICROPY_ENABLE_FINALISER
-        + total_blocks / BLOCKS_PER_FTB
-        #endif
-        + total_blocks * BYTES_PER_BLOCK
-        + ALLOC_TABLE_GAP_BYTE
-        + sizeof(mp_state_mem_area_t);
-
-    // Round up size to the nearest multiple of BYTES_PER_BLOCK.
-    total_heap = (total_heap + BYTES_PER_BLOCK - 1) & (~(BYTES_PER_BLOCK - 1));
+    size_t total_heap = compute_heap_size(total_blocks);
 
     DEBUG_printf("total_heap " UINT_FMT " bytes\n", total_heap);
 
     size_t to_alloc = MIN(avail, MAX(total_heap, needed));
 
+    console_uart_printf("avail = %d\r\n", avail);
+    console_uart_printf("to_alloc = %d\r\n", to_alloc);
+
     mp_state_mem_area_t *new_heap = MP_PLAT_ALLOC_HEAP(to_alloc);
 
-    DEBUG_printf("MP_PLAT_ALLOC_HEAP " UINT_FMT " = %p\n",
-        to_alloc, new_heap);
+    console_uart_printf("MP_PLAT_ALLOC_HEAP %d = %p\r\n", to_alloc, new_heap);
 
     if (new_heap == NULL) {
         // This should only fail:

supervisor/shared/usb/usb_msc_flash.c

@@ -249,6 +249,8 @@ bool tud_msc_is_writable_cb(uint8_t lun) {
     // Lock the blockdev once we say we're writable.
     if (!locked[lun] && !blockdev_lock(vfs)) {
         console_uart_printf("lun %u could not be locked\r\n", lun);
+        console_uart_printf("locked[%u] = %d\r\n", lun, locked[lun]);
+        console_uart_printf("vfs %p\r\n", vfs);
         return false;
     }
     locked[lun] = true;