rg_system: Removed app->lowMemoryMode

It's too arbitrary. Applications can decide for themselves if they want to disable features by checking `rg_system_get_stats().totalMemory` or `freeMemory`.

Author: ducalex

components/retro-go/rg_system.c

@@ -162,19 +162,21 @@ static void update_memory_statistics(void)
 #ifdef ESP_PLATFORM
     multi_heap_info_t heap_info;
     heap_caps_get_info(&heap_info, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    statistics.totalMemoryInt = heap_info.total_free_bytes + heap_info.total_allocated_bytes;
     statistics.freeMemoryInt = heap_info.total_free_bytes;
     statistics.freeBlockInt = heap_info.largest_free_block;
-    statistics.totalMemoryInt = heap_info.total_free_bytes + heap_info.total_allocated_bytes;
     heap_caps_get_info(&heap_info, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+    statistics.totalMemoryExt = heap_info.total_free_bytes + heap_info.total_allocated_bytes;
     statistics.freeMemoryExt = heap_info.total_free_bytes;
     statistics.freeBlockExt = heap_info.largest_free_block;
-    statistics.totalMemoryExt = heap_info.total_free_bytes + heap_info.total_allocated_bytes;
-
+    // FIXME: We should check all the tasks' HWM to be better informed!
     statistics.freeStackMain = uxTaskGetStackHighWaterMark(tasks[0].handle);
 #else
-    statistics.freeMemoryInt = statistics.freeBlockInt = statistics.totalMemoryInt = (1 << 28);
-    statistics.freeMemoryExt = statistics.freeBlockExt = statistics.totalMemoryExt = (1 << 28);
+    statistics.freeMemoryInt = statistics.freeBlockInt = statistics.totalMemoryInt = 0x40000000;
 #endif
+    statistics.totalMemory = statistics.totalMemoryInt + statistics.totalMemoryExt;
+    statistics.freeMemory = statistics.freeMemoryInt + statistics.freeMemoryExt;
+    statistics.freeBlock = RG_MAX(statistics.freeBlockInt, statistics.freeBlockExt);
 }
 
 static void update_statistics(void)
@@ -401,7 +403,6 @@ rg_app_t *rg_system_init(const rg_config_t *config)
         .tickTimeout = 3000000,
         .frameTime = 1000000 / 60,
         .frameskip = 1, // This can be overriden on a per-app basis if needed, do not set 0 here!
-        .lowMemoryMode = false,
         .enWatchdog = true,
         .isColdBoot = true,
         .isLauncher = false,
@@ -431,6 +432,7 @@ rg_app_t *rg_system_init(const rg_config_t *config)
     printf("%s %s (%s)\n", app.name, app.version, app.buildDate);
     printf(" built for: %s. type: %s\n", RG_TARGET_NAME, app.isRelease ? "release" : "dev");
     printf("========================================================\n\n");
+    update_memory_statistics(); // Do this early in case any of our init routines needs to know
 
 #ifdef RG_I2C_GPIO_DRIVER
     rg_i2c_init();
@@ -479,19 +481,13 @@ rg_app_t *rg_system_init(const rg_config_t *config)
     memset(&panicTrace, 0, sizeof(panicTrace));
     panicTraceCleared = true;
 
-    update_memory_statistics();
-    app.lowMemoryMode = statistics.totalMemoryExt == 0;
-
     app.indicatorsMask = rg_settings_get_number(NS_GLOBAL, SETTING_INDICATOR_MASK, app.indicatorsMask);
     app.romPath = app.bootArgs ?: ""; // For whatever reason some of our code isn't NULL-aware, sigh..
 
     rg_gui_draw_hourglass();
 
     if (config)
     {
-        app.sampleRate = config->sampleRate;
-        app.tickRate = config->frameRate;
-        // app.frameskip = config->frameSkip;
         if (config->storageRequired && !rg_storage_ready())
         {
             rg_display_clear(C_SKY_BLUE);
@@ -503,31 +499,30 @@ rg_app_t *rg_system_init(const rg_config_t *config)
             // show rom picking dialog
             // app.romPath = rg_gui_file_picker(_("Choose ROM"), RG_BASE_PATH_ROMS, NULL, true, false);
         }
-        if (config->mallocAlwaysInternal > 0)
-        {
         #ifdef ESP_PLATFORM
+        if (config->mallocAlwaysInternal > 0)
             heap_caps_malloc_extmem_enable(config->mallocAlwaysInternal);
         #endif
-        }
+        app.sampleRate = config->sampleRate;
+        app.tickRate = config->frameRate;
+        // app.frameskip = config->frameSkip;
         app.isLauncher = config->isLauncher;
         app.handlers = config->handlers;
     }
 
     if (app.sampleRate > 0)
-    {
         rg_audio_init(app.sampleRate);
-    }
 
     rg_system_set_tick_rate(app.tickRate);
     rg_system_set_timezone(rg_settings_get_string(NS_GLOBAL, SETTING_TIMEZONE, "EST+5"));
     rg_system_load_time();
 
-    if (app.lowMemoryMode)
-        rg_gui_alert("External memory not detected", "Boot will continue but it will surely crash...");
-
     if (app.bootFlags & RG_BOOT_ONCE)
         update_boot_config(RG_APP_LAUNCHER, NULL, NULL, 0, 0);
 
+    if (statistics.totalMemory < 0x200000)
+        rg_gui_alert("External memory not detected", "Boot will continue but it will surely crash...");
+
     rg_task_create("rg_sysmon", &system_monitor_task, NULL, 3 * 1024, RG_TASK_PRIORITY_5, -1);
     app.initialized = true;
 

components/retro-go/rg_system.h

@@ -138,14 +138,16 @@ typedef struct
 // Instead, consider adding `disableThing`.
 typedef struct
 {
-    int sampleRate;
-    int frameRate; // tickRate
-    // int frameSkip;
-    int mallocAlwaysInternal;
-    bool storageRequired;
-    bool romRequired;
-    bool isLauncher;
-    rg_handlers_t handlers;
+    int sampleRate;             // Audio sample rate
+    int frameRate;              // Frame rate (should match how often rg_system_tick is called per second)
+    // int frameSkip;              // Initial frame skip value (-1 to disable auto frameskip)
+    // int tickRate;               // For now retro-go doesn't distinguish between tick rate and frame rate...
+    bool storageRequired;       // Will refuse to continue if storage mount fails
+    bool romRequired;           // Will show a file picker if no ROM is configured
+    bool isLauncher;            // Set to true if app is launcher
+    rg_handlers_t handlers;     // App handlers for certain actions (save states, screenshot, etc)
+    // Lower-level tweaks
+    int mallocAlwaysInternal;   // See heap_caps_malloc_extmem_enable
 } rg_config_t;
 
 typedef struct
@@ -164,7 +166,6 @@ typedef struct
     int tickTimeout;
     int frameTime;
     int frameskip;
-    bool lowMemoryMode;
     bool enWatchdog;
     bool isColdBoot;
     bool isLauncher;
@@ -191,10 +192,13 @@ typedef struct
     int uptime;
     int totalMemoryInt;
     int totalMemoryExt;
+    int totalMemory;
     int freeMemoryInt;
     int freeMemoryExt;
+    int freeMemory;
     int freeBlockInt;
     int freeBlockExt;
+    int freeBlock;
     int freeStackMain;
 } rg_stats_t;
 

fmsx/main/main.c

@@ -423,6 +423,7 @@ void app_main(void)
         .sampleRate = AUDIO_SAMPLE_RATE,
         .frameRate = 55, // This is probably not right, but the emulator outputs 440 samples per frame??
         .storageRequired = true,
+        .romRequired = false,
         .handlers = {
             .loadState = &load_state_handler,
             .saveState = &save_state_handler,

launcher/main/applications.c

@@ -697,6 +697,6 @@ void applications_init(void)
     // Special app to bootstrap native esp32 binaries from the SD card
     // application("Bootstrap", "apps", "bin elf", "bootstrap", 0);
 
-    if (!rg_system_get_app()->lowMemoryMode)
+    if (rg_system_get_stats().freeMemory > 0x100000)
         crc_cache_init();
 }

launcher/main/gui.c

@@ -45,8 +45,8 @@ void gui_init(bool cold_boot)
     gui.browse = gui.start_screen == START_SCREEN_BROWSER || (gui.start_screen == START_SCREEN_AUTO && !cold_boot);
     gui.theme = &gui.themes[gui.color_theme % RG_COUNT(gui.themes)];
     gui.http_lock = false;
-    gui.low_memory_mode = rg_system_get_app()->lowMemoryMode;
     gui.surface = rg_surface_create(gui.width, gui.height, RG_PIXEL_565_LE, MEM_SLOW);
+    gui.low_memory_mode = rg_system_get_stats().freeMemory < 0x100000;
     gui_update_theme();
 }
 

launcher/main/main.c

@@ -449,15 +449,14 @@ void app_main(void)
     app = rg_system_init(&(const rg_config_t){
         .sampleRate = 32000,
         .frameRate = 0,
-        // The launcher makes a lot of small allocations and it sometimes fills internal RAM, causing the SD Card driver to
-        // stop working. Lowering CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL and manually using rg_alloc to do internal allocs when
-        // needed is a better solution, but that would have to be done for every app. This is a good workaround for now.
-        .mallocAlwaysInternal = 1024,
         .storageRequired = true,
         .isLauncher = true,
         .handlers.event = &event_handler,
         .handlers.options = &options_handler,
         .handlers.about = &about_handler,
+        // The launcher makes a lot of small allocations and it sometimes fills internal RAM,
+        // causing the SD Card driver to stop working.
+        .mallocAlwaysInternal = 1024,
     });
     app->configNs = "launcher";
 

prboom-go/main/main.c

@@ -532,10 +532,6 @@ void app_main()
     const rg_config_t config = {
         .sampleRate = AUDIO_SAMPLE_RATE,
         .frameRate = TICRATE,
-        // Some things might be nice to place in internal RAM, but I do not have time to find such
-        // structures. So for now, prefer external RAM for most things except the framebuffer which
-        // is allocated below.
-        .mallocAlwaysInternal = 1, // I want 0 but 0 will be ignored, so 1 it is!
         .storageRequired = true,
         .romRequired = false,
         .handlers = {
@@ -546,6 +542,10 @@ void app_main()
             .event = &event_handler,
             .options = &options_handler,
         },
+        // Some things might be nice to place in internal RAM, but I do not have time to find such
+        // structures. So for now, prefer external RAM for most things except the framebuffer which
+        // is allocated below.
+        .mallocAlwaysInternal = 1, // I want 0 but 0 will be ignored, so 1 it is!
     };
     app = rg_system_init(&config);
 

snes9x/main/main_snes.c

@@ -344,15 +344,16 @@ void app_main(void)
 {
     const rg_config_t config = {
         .sampleRate = AUDIO_SAMPLE_RATE,
+        .frameRate = 60, // Will be adjusted later if a PAL ROM is loaded
         .storageRequired = true,
         .romRequired = true,
-        .mallocAlwaysInternal = 0x10000,
         .handlers.loadState = &load_state_handler,
         .handlers.saveState = &save_state_handler,
         .handlers.reset = &reset_handler,
         .handlers.screenshot = &screenshot_handler,
         .handlers.event = &event_handler,
         .handlers.options = &options_handler,
+        .mallocAlwaysInternal = 0x10000,
     };
     app = rg_system_init(&config);
 

tools/mkfw.py

@@ -61,9 +61,9 @@ def create_firmware(fw_type, partitions, icon_file, name, version, target):
 
 def create_image(chip_type, partitions, bootloader_file, name, version, target):
     bootloader_offset, table_offset, prog_offset = {
+        "esp32":   (0x1000, 0x8000, 0x10000),
         "esp32s3": (0x0000, 0x8000, 0x10000),
         "esp32p4": (0x2000, 0x8000, 0x10000),
-        "esp32": (0x1000, 0x8000, 0x10000),
     }.get(chip_type)
     partitions = [
         (1, 0x02, "nvs", 0x9000, 0x4000, b""),
@@ -90,7 +90,7 @@ def create_image(chip_type, partitions, bootloader_file, name, version, target):
     # (Maybe I could hide it somewhere else to avoid changing the size of the image)
     output_data += struct.pack(
         "<8s28s28s28sII156s",
-        "RG_IMG_0".encode(),    # Magic number "RG01"
+        "RG_IMG_0".encode(),    # Magic number
         name.encode(),          # Project name
         version.encode(),       # Project version
         target.encode(),        # Project target device
@@ -119,6 +119,7 @@ def create_image(chip_type, partitions, bootloader_file, name, version, target):
     else:
         partitions = get_partitions(args.partitions, 0x10000)
         data = create_image(args.type, partitions, args.bootloader, args.name, args.version, args.target)
+
     with open(args.output_file, "wb") as fp:
         fp.write(data)