PicoVector: Add tracked memory alloc, track the node buffer.

Gadgetoid · Gadgetoid · commit e3a5365a39f3 · 2025-05-08T16:28:11.000+01:00
With a low GC threshold the node buffer was being collected (despite guards against this)
and causing further drawing operations to be corrupted.

Add a new tracked malloc method and use it for node buffers and font data.

Tweak pp_poly_add_path to accept a point count, avoiding many successive rellocs when
dealing with a known quantity of points (copying from an af_glyph_t.)
diff --git a/libraries/pico_vector/af-memory.c b/libraries/pico_vector/af-memory.c
@@ -3,6 +3,18 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+void *af_tracked_malloc(size_t size) {
+    return malloc(size);
+}
+
+void *af_tracked_realloc(void *p, size_t size) {
+    return realloc(p, size);
+}
+
+void af_tracked_free(void *p) {
+    free(p);
+}
+
 void *af_malloc(size_t size) {
     return malloc(size);
 }
diff --git a/libraries/pico_vector/af-memory.h b/libraries/pico_vector/af-memory.h
@@ -3,6 +3,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+    void *af_tracked_malloc(size_t size);
+    void *af_tracked_realloc(void *p, size_t size);
+    void af_tracked_free(void *p);
+
     void *af_malloc(size_t size);
     void *af_realloc(void *p, size_t size);
     void af_free(void *p);
diff --git a/libraries/pico_vector/alright-fonts.h b/libraries/pico_vector/alright-fonts.h
@@ -40,6 +40,10 @@
     #define PP_MALLOC(size)         AF_MALLOC(size)
     #define PP_REALLOC(p, size)     AF_REALLOC(p, size)
     #define PP_FREE(p)              AF_FREE(p)
+
+    #define PP_TRACKED_MALLOC(size)     AF_TRACKED_MALLOC(size)
+    #define PP_TRACKED_REALLOC(p, size) AF_TRACKED_REALLOC(p, size)
+    #define PP_TRACKED_FREE(p)          AF_TRACKED_FREE(p)
   #endif // PP_MALLOC
 #endif // AF_MALLOC
 
@@ -157,7 +161,7 @@ bool af_load_font_file(AF_FILE file, af_face_t *face) {
   size_t point_buffer_size = sizeof(af_point_t) * point_count;
 
   // allocate buffer to store font glyph, path, and point data
-  uint8_t *buffer = (uint8_t *)AF_MALLOC(glyph_buffer_size + path_buffer_size + point_buffer_size);
+  uint8_t *buffer = (uint8_t *)AF_TRACKED_MALLOC(glyph_buffer_size + path_buffer_size + point_buffer_size);
 
   if(!buffer) {
     return false; // failed memory allocation
@@ -224,7 +228,7 @@ void af_render_glyph(af_glyph_t* glyph, af_text_metrics_t *tm) {
 
   pp_poly_t *poly = pp_poly_new();
   for(uint32_t i = 0; i < glyph->path_count; i++) {
-    pp_path_t *path = pp_poly_add_path(poly);
+    pp_path_t *path = pp_poly_add_path(poly, glyph->paths[i].point_count);
     for(uint32_t j = 0; j < glyph->paths[i].point_count; j++) {
       pp_path_add_point(path, {
         glyph->paths[i].points[j].x,
diff --git a/libraries/pico_vector/pico_vector.hpp b/libraries/pico_vector/pico_vector.hpp
@@ -10,10 +10,18 @@
 #define AF_REALLOC(p, size)     af_realloc(p, size)
 #define AF_FREE(p)              af_free(p)
 
+#define AF_TRACKED_MALLOC(size)         af_tracked_malloc(size)
+#define AF_TRACKED_REALLOC(p, size)     af_tracked_realloc(p, size)
+#define AF_TRACKED_FREE(p)              af_tracked_free(p)
+
 #define PP_MALLOC(size)         af_malloc(size)
 #define PP_REALLOC(p, size)     af_realloc(p, size)
 #define PP_FREE(p)              af_free(p)
 
+#define PP_TRACKED_MALLOC(size)         af_tracked_malloc(size)
+#define PP_TRACKED_REALLOC(p, size)     af_tracked_realloc(p, size)
+#define PP_TRACKED_FREE(p)              af_tracked_free(p)
+
 #define AF_DEBUG(...)          af_debug(__VA_ARGS__)
 
 #include "pretty-poly.h"
@@ -108,10 +116,10 @@ namespace pimoroni {
 
             bool set_font(std::string_view font_path, unsigned int font_size) {
                 if(text_metrics.face) {
-                    af_free(text_metrics.face->glyphs);
-                    af_free(text_metrics.face);
+                    af_tracked_free(text_metrics.face->glyphs);
+                    af_tracked_free(text_metrics.face);
                 }
-                text_metrics.face = (af_face_t *)af_malloc(sizeof(af_face_t));
+                text_metrics.face = (af_face_t *)af_tracked_malloc(sizeof(af_face_t));
                 //bool result = text_metrics.face.load(font_path);
                 void* font = fileio_open(font_path.data());
                 bool result = af_load_font_file(font, text_metrics.face);
@@ -123,10 +131,10 @@ namespace pimoroni {
 
             bool set_font(void* font,  unsigned int font_size) {
                 if(text_metrics.face) {
-                    af_free(text_metrics.face->glyphs);
-                    af_free(text_metrics.face);
+                    af_tracked_free(text_metrics.face->glyphs);
+                    af_tracked_free(text_metrics.face);
                 }
-                text_metrics.face = (af_face_t *)af_malloc(sizeof(af_face_t));
+                text_metrics.face = (af_face_t *)af_tracked_malloc(sizeof(af_face_t));
                 bool result = af_load_font_file(font, text_metrics.face);
 
                 set_font_size(font_size);
diff --git a/libraries/pico_vector/pretty-poly.h b/libraries/pico_vector/pretty-poly.h
@@ -114,7 +114,7 @@ typedef struct {
 pp_poly_t *pp_poly_new();
 void pp_poly_free(pp_poly_t *poly);
 pp_path_t* pp_poly_tail_path(pp_poly_t *p);
-pp_path_t* pp_poly_add_path(pp_poly_t *p);
+pp_path_t* pp_poly_add_path(pp_poly_t *p, int32_t points = -1);
 pp_rect_t pp_poly_bounds(pp_poly_t *p);
 int pp_poly_path_count(pp_poly_t *p);
 void pp_poly_merge(pp_poly_t *p, pp_poly_t *m);
@@ -154,6 +154,12 @@ void pp_deinit();
 #define PP_FREE(p)              free(p)
 #endif
 
+#ifndef PP_TRACKED_MALLOC
+#define PP_TRACKED_MALLOC(size)         malloc(size)
+#define PP_TRACKED_REALLOC(p, size)     realloc(p, size)
+#define PP_TRACKED_FREE(p)              free(p)
+#endif
+
 #ifdef PP_DEBUG
 #define debug(...) printf(__VA_ARGS__)
 #else
@@ -270,10 +276,10 @@ pp_poly_t *pp_poly_new() {
   return poly;
 }
 
-pp_path_t *pp_path_new() {
+pp_path_t *pp_path_new(int32_t points = -1) {
   pp_path_t *path = (pp_path_t *)PP_MALLOC(sizeof(pp_path_t));
   memset(path, 0, sizeof(pp_path_t));
-  path->storage = 8;
+  path->storage = points > -1 ? points : 8;
   path->points = (pp_point_t *)PP_MALLOC(sizeof(pp_point_t) * path->storage);
   return path;
 }
@@ -313,8 +319,8 @@ int pp_poly_path_count(pp_poly_t *poly) {
   return i;
 }
 
-pp_path_t* pp_poly_add_path(pp_poly_t *poly) {
-  pp_path_t *path = pp_path_new();
+pp_path_t* pp_poly_add_path(pp_poly_t *poly, int32_t points) {
+  pp_path_t *path = pp_path_new(points);
 
   if(!poly->paths) {
     poly->paths = path;
@@ -411,13 +417,13 @@ uint8_t _pp_alpha_map_x16[17] = {0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160,
 
 void pp_init(uint32_t max_nodes_per_scanline) {
   _pp_max_nodes_per_scanline = max_nodes_per_scanline;
-  pp_nodes = (int32_t *)PP_MALLOC(PP_TILE_BUFFER_SIZE * 4 * max_nodes_per_scanline * 2 * sizeof(int32_t));
-  pp_node_counts = (uint32_t *)PP_MALLOC(PP_TILE_BUFFER_SIZE * 4 * sizeof(uint32_t));
+  pp_nodes = (int32_t *)PP_TRACKED_MALLOC(PP_TILE_BUFFER_SIZE * 4 * max_nodes_per_scanline * 2 * sizeof(int32_t));
+  pp_node_counts = (uint32_t *)PP_TRACKED_MALLOC(PP_TILE_BUFFER_SIZE * 4 * sizeof(uint32_t));
 }
 
 void pp_deinit() {
-  PP_FREE(pp_nodes);
-  PP_FREE(pp_node_counts);
+  PP_TRACKED_FREE(pp_nodes);
+  PP_TRACKED_FREE(pp_node_counts);
 }
 
 void pp_clip(int32_t x, int32_t y, int32_t w, int32_t h) {
diff --git a/micropython/modules/picovector/picovector.c b/micropython/modules/picovector/picovector.c
@@ -100,6 +100,10 @@ static MP_DEFINE_CONST_FUN_OBJ_1(VECTOR_get_transform_obj, VECTOR_get_transform)
 
 static MP_DEFINE_CONST_FUN_OBJ_2(VECTOR_draw_obj, VECTOR_draw);
 
+/* Stats */
+
+static MP_DEFINE_CONST_FUN_OBJ_1(MALLOC_get_stats_obj, MALLOC_get_stats);
+
 static const mp_rom_map_elem_t VECTOR_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_text), MP_ROM_PTR(&VECTOR_text_obj) },
     { MP_ROM_QSTR(MP_QSTR_measure_text), MP_ROM_PTR(&VECTOR_measure_text_obj) },
@@ -116,6 +120,8 @@ static const mp_rom_map_elem_t VECTOR_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_get_transform), MP_ROM_PTR(&VECTOR_get_transform_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_draw), MP_ROM_PTR(&VECTOR_draw_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_malloc_get_stats), MP_ROM_PTR(&MALLOC_get_stats_obj) },
 };
 
 static MP_DEFINE_CONST_DICT(VECTOR_locals_dict, VECTOR_locals_dict_table);
diff --git a/micropython/modules/picovector/picovector.cpp b/micropython/modules/picovector/picovector.cpp
@@ -62,28 +62,83 @@ void af_debug(const char *fmt, ...) {
 #define mp_picovector_get_point_type mp_obj_get_float
 #define mp_picovector_set_point_type mp_obj_new_float
 
+uint32_t _af_malloc_count = 0;
+uint32_t _af_malloc_bytes = 0;
+uint32_t _af_realloc_count = 0;
+
+uint32_t _af_tracked_malloc_count = 0;
+uint32_t _af_tracked_malloc_bytes = 0;
+uint32_t _af_tracked_realloc_count = 0;
+
 
 void *af_malloc(size_t size) {
-    //mp_printf(&mp_plat_print, "af_malloc %lu\n", size);
-    //__printf_debug_flush();
-    //void *addr = m_tracked_calloc(sizeof(uint8_t), size);
+    _af_malloc_count++;
+    _af_malloc_bytes += size;
     void *addr = m_malloc(size);
-    //mp_printf(&mp_plat_print, "addr %lu\n", addr);
-    //__printf_debug_flush();
     return addr;
 }
 
+
 void *af_realloc(void *p, size_t size) {
-    return m_realloc(p, size);
+    _af_realloc_count++;
+    void *addr = m_realloc(p, size);
+    return addr;
 }
 
 void af_free(void *p) {
-    //mp_printf(&mp_plat_print, "af_free\n");
-    //__printf_debug_flush();
-    //m_tracked_free(p);
     m_free(p);
 }
 
+void *af_tracked_malloc(size_t size) {
+    _af_tracked_malloc_count++;
+    _af_tracked_malloc_bytes += size;
+
+    // Allocate an extra sizeof(size_t) bytes
+    size_t *addr = (size_t *)m_tracked_calloc(sizeof(uint8_t), size + sizeof(size_t));
+    // Tag our memory with its allocated size
+    *addr = size;
+    // Skip past the size_t size
+    addr++;
+
+#if DEBUG
+    mp_printf(&mp_plat_print, "af_tracked_malloc %lu %p : %p\n", size, addr, (uint8_t *)addr + size);
+    __printf_debug_flush();
+#endif
+
+    return (void *)addr;
+}
+
+void *af_tracked_realloc(void *p, size_t size) {
+    _af_tracked_realloc_count++;
+
+    void *addr = af_tracked_malloc(size);
+    size_t old_size = *((size_t *)p - 1);
+    memcpy(addr, p, std::min(old_size, size));
+
+#if DEBUG
+    mp_printf(&mp_plat_print, "af_tracked_realloc %lu -> %lu, %p -> %p : %p\n", old_size, size, p, addr, (uint8_t *)addr + size);
+    __printf_debug_flush();
+#endif
+
+    af_tracked_free(p);
+
+    return addr;
+}
+
+void af_tracked_free(void *p) {
+    size_t *pp = (size_t *)p;   // Convert our void pointer to size_t* so we can read the size marker
+    pp--;                       // Skip back to get our real start
+
+#if DEBUG
+    size_t size = *pp;          // First "size_t" should be the allocated size
+    mp_printf(&mp_plat_print, "af_tracked_free %p (size %d)\n", p, size);
+    __printf_debug_flush();
+#endif
+
+    m_tracked_free((void *)pp);
+    //m_free(p);
+}
+
 void* fileio_open(const char *filename) {
     mp_obj_t fn = mp_obj_new_str(filename, (mp_uint_t)strlen(filename));
 
@@ -857,4 +912,27 @@ mp_obj_t VECTOR_draw(mp_obj_t self_in, mp_obj_t poly_in) {
     return mp_const_none;
 }
 
+mp_obj_t MALLOC_get_stats(mp_obj_t self_in) {
+    (void)self_in;
+
+    mp_obj_t tuple[6];
+    tuple[0] = mp_obj_new_int(_af_malloc_count);
+    tuple[1] = mp_obj_new_int(_af_realloc_count);
+    tuple[2] = mp_obj_new_int(_af_malloc_bytes);
+
+    tuple[3] = mp_obj_new_int(_af_tracked_malloc_count);
+    tuple[4] = mp_obj_new_int(_af_tracked_realloc_count);
+    tuple[5] = mp_obj_new_int(_af_tracked_malloc_bytes);
+
+    _af_malloc_count = 0;
+    _af_realloc_count = 0;
+    _af_malloc_bytes = 0;
+
+    _af_tracked_malloc_count = 0;
+    _af_tracked_realloc_count = 0;
+    _af_tracked_malloc_bytes = 0;
+    
+    return mp_obj_new_tuple(6, tuple);
+}
+
 }
diff --git a/micropython/modules/picovector/picovector.h b/micropython/modules/picovector/picovector.h
@@ -51,4 +51,8 @@ extern mp_obj_t VECTOR_get_transform(mp_obj_t self_in);
 
 extern mp_obj_t VECTOR_draw(mp_obj_t self_in, mp_obj_t poly_in);
 extern mp_obj_t VECTOR_rotate(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
-extern mp_obj_t VECTOR_translate(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t VECTOR_translate(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+/* Stats */
+
+extern mp_obj_t MALLOC_get_stats(mp_obj_t self_in);
