Merged rg_bucket from master

rg_bucket is meant to avoid filling internal memory with tiny allocations (thousands of strdup -> a few  4096 blocks).

Of course making a strdup that always allocates in external memory might have been a better/simpler idea...

Author: ducalex

components/retro-go/rg_gui.c

@@ -1043,6 +1043,7 @@ typedef struct
 {
     rg_gui_option_t *options;
     size_t count;
+    rg_bucket_t *filenames;
     bool (*validator)(const char *path);
 } file_picker_opts_t;
 
@@ -1054,7 +1055,7 @@ static int file_picker_cb(const rg_scandir_t *entry, void *arg)
     rg_gui_option_t *options = realloc(f->options, (f->count + 2) * sizeof(rg_gui_option_t));
     if (!options)
         return RG_SCANDIR_STOP;
-    char *name = strdup(entry->basename);
+    char *name = rg_bucket_insert(f->filenames, entry->basename, strlen(entry->basename) + 1);
     f->options = options;
     f->options[f->count++] = (rg_gui_option_t){(intptr_t)name, name, NULL, RG_DIALOG_FLAG_NORMAL, NULL};
     return RG_SCANDIR_CONTINUE;
@@ -1065,6 +1066,7 @@ char *rg_gui_file_picker(const char *title, const char *path, bool (*validator)(
     file_picker_opts_t options = {
         .options = calloc(8, sizeof(rg_gui_option_t)),
         .count = 0,
+        .filenames = rg_bucket_create(4096),
         .validator = validator,
     };
     char *filepath = NULL;
@@ -1098,8 +1100,7 @@ char *rg_gui_file_picker(const char *title, const char *path, bool (*validator)(
     }
 
 cleanup:
-    for (size_t i = 0; i < options.count; ++i)
-        free((void *)(options.options[i].arg));
+    rg_bucket_free(options.filenames);
     free(options.options);
     return filepath;
 }

components/retro-go/rg_utils.c

@@ -351,9 +351,63 @@ const char *rg_unique_string(const char *str)
     return obj->data;
 }
 
-// Note: You should use calloc/malloc everywhere possible. This function is used to ensure
-// that some memory is put in specific regions for performance or hardware reasons.
-// Memory from this function should be freed with free()
+typedef struct rg_bucket_s
+{
+    size_t capacity;
+    size_t cursor;
+    rg_bucket_t *prev;
+    rg_bucket_t *next;
+    uint8_t data[];
+} rg_bucket_t;
+
+rg_bucket_t *rg_bucket_create(size_t capacity_bytes)
+{
+    rg_bucket_t *bucket = calloc(1, sizeof(rg_bucket_t) + capacity_bytes);
+    if (!bucket)
+        return NULL;
+    bucket->capacity = capacity_bytes;
+    return bucket;
+}
+
+void *rg_bucket_insert(rg_bucket_t *bucket, const void *item, size_t item_bytes)
+{
+    if (!bucket || bucket->capacity < item_bytes)
+    {
+        RG_LOGW("Item size exceeds bucket capacity!");
+        return NULL;
+    }
+    while (bucket->cursor + item_bytes > bucket->capacity)
+    {
+        if (!bucket->next) // End of the list, must allocate
+        {
+            rg_bucket_t *new_bucket = rg_bucket_create(bucket->capacity);
+            if (!new_bucket)
+                return NULL;
+            new_bucket->prev = bucket;
+            bucket->next = new_bucket;
+            bucket = new_bucket;
+            break;
+        }
+        bucket = bucket->next;
+    }
+    void *ptr = bucket->data + bucket->cursor;
+    if (item)
+        memcpy(ptr, item, item_bytes);
+    bucket->cursor += ((item_bytes + (sizeof(int) - 1)) / sizeof(int)) * sizeof(int);
+    // bucket->cursor += item_bytes;
+    return ptr;
+}
+
+void rg_bucket_free(rg_bucket_t *bucket)
+{
+    while (bucket)
+    {
+        rg_bucket_t *next = bucket->next;
+        free(bucket);
+        bucket = next;
+    }
+}
+
 void *rg_alloc(size_t size, uint32_t caps)
 {
     char caps_list[36] = "";

components/retro-go/rg_utils.h

@@ -47,7 +47,6 @@
  * they cannot be freed. unique avoids keeping multiple copies of an identical string (eg a path)
  * Things like unique_string("abc") == unique_string("abc") are guaranteed to be true
 */
-const char *rg_const_string(const char *str);
 const char *rg_unique_string(const char *str);
 char *rg_strtolower(char *str);
 char *rg_strtoupper(char *str);
@@ -73,7 +72,19 @@ const char *rg_relpath(const char *path);
 uint32_t rg_crc32(uint32_t crc, const uint8_t *buf, size_t len);
 uint32_t rg_hash(const char *buf, size_t len);
 
+/* Bucket allocator */
+// The bucket allocator is basically a linked-list of fixed-size buckets that can contain variable-sized items.
+// It does not keep track of individual items and items cannot be removed or resized.
+// Its purpose is to replace the thousands of small allocations that fill internal memory (eg strdup)
+typedef struct rg_bucket_s rg_bucket_t;
+rg_bucket_t *rg_bucket_create(size_t capacity_bytes);
+void *rg_bucket_insert(rg_bucket_t *bucket, const void *item, size_t item_bytes);
+void rg_bucket_free(rg_bucket_t *bucket);
+
 /* Misc */
+// Note: You should use calloc/malloc everywhere possible. This function is used to ensure
+// that some memory is put in specific regions for performance or hardware reasons.
+// Memory from this function should be freed with free()
 void *rg_alloc(size_t size, uint32_t caps);
 // rg_usleep behaves like usleep in libc: it will sleep for *at least* `us` microseconds, but possibly more
 // due to scheduling. You should use rg_task_delay() if you don't need more than 10-15ms granularity.

launcher/main/applications.c

@@ -61,8 +61,15 @@ static int scan_folder_cb(const rg_scandir_t *entry, void *arg)
         app->files_capacity = new_capacity;
     }
 
+    char *name = rg_bucket_insert(app->filenames, entry->basename, strlen(entry->basename) + 1);
+    if (!name)
+    {
+        RG_LOGW("Ran out of memory for names, file scanning stopped at %d entries ...", app->files_count);
+        return RG_SCANDIR_STOP;
+    }
+
     app->files[app->files_count++] = (retro_file_t) {
-        .name = strdup(entry->basename),
+        .name = name,
         .folder = rg_unique_string(entry->dirname),
         .checksum = 0,
         .missing_cover = 0,
@@ -417,8 +424,8 @@ static void event_handler(gui_event_t event, tab_t *tab)
     {
         if (app && app->initialized)
         {
-            for (size_t i = 0; i < app->files_count; ++i)
-                free((char *)app->files[i].name);
+            rg_bucket_free(app->filenames);
+            app->filenames = rg_bucket_create(4096);
             app->files_count = 0;
             app->initialized = false;
         }
@@ -669,6 +676,7 @@ static void application(const char *desc, const char *name, const char *exts, co
     app->available = rg_system_have_app(app->partition);
     app->files = calloc(100, sizeof(retro_file_t));
     app->files_capacity = 100;
+    app->filenames = rg_bucket_create(4096);
     app->crc_offset = crc_offset;
 
     gui_add_tab(app->short_name, app->description, app, event_handler);

launcher/main/applications.h

@@ -40,6 +40,7 @@ typedef struct retro_app_s
     retro_file_t *files;
     size_t files_capacity;
     size_t files_count;
+    rg_bucket_t *filenames;
     bool use_crc_covers;
     bool initialized;
     bool available;