@mikrojs/native 0.18.2 → 0.19.0-pr-352.20260829215534

package/src/mem.cpp

@@ -9,15 +9,56 @@
 
 /*
  * QuickJS uses malloc_usable_size to track memory consumption against its
- * memory limit. ESP-IDF lacks a standard malloc_usable_size, and the
- * heap_caps_get_allocated_size alternative reports block sizes including
- * allocator overhead, causing QuickJS to over-count usage.
+ * memory limit. When the platform reports live-allocation sizes
+ * (malloc_usable_size hook: libc malloc_usable_size / malloc_size,
+ * heap_caps_get_allocated_size on ESP-IDF), allocations are returned as-is
+ * and QuickJS accounts blocks by their real (rounded-up) size.
  *
- * We prepend each allocation with a size_t header storing the requested size.
+ * Without the hook, each allocation is prepended with a size_t header
+ * storing the requested size. That costs one word of RAM per live block —
+ * ~13 KB across a loaded app's ~3400 blocks on a 32-bit device — which is
+ * why the hook path is preferred.
+ *
+ * The mode is latched at the first allocation and never changes, so every
+ * pointer is freed the same way it was allocated. Platforms install before
+ * the first runtime exists (ESP32 and node have theirs as the compile-time
+ * default), so the latch sees the final platform. The latch is a single
+ * word-sized store (null = unlatched, mik__hdr_usable_size = header mode),
+ * so concurrent first allocations on a dual-core target can at worst both
+ * compute and store the same value — there is no two-variable ordering to
+ * observe half-done.
  */
 
 #define HDR_SIZE sizeof(size_t)
 
+static inline size_t hdr_read(void* user) {
+    size_t sz;
+    memcpy(&sz, static_cast<char*>(user) - HDR_SIZE, sizeof(sz));
+    return sz;
+}
+
+/* Header-mode usable_size; doubles as the latch marker for that mode. */
+static size_t mik__hdr_usable_size(const void* ptr) {
+    return hdr_read(const_cast<void*>(ptr));
+}
+
+typedef size_t (*MIKUsableSizeFn)(const void*);
+static MIKUsableSizeFn g_usable_size_fn = nullptr; /* null = not latched yet */
+
+static inline MIKUsableSizeFn usable_size_fn(void) {
+    MIKUsableSizeFn fn = g_usable_size_fn;
+    if (!fn) {
+        const MIKPlatform* p = MIK_GetPlatform();
+        fn = (p && p->malloc_usable_size) ? p->malloc_usable_size : mik__hdr_usable_size;
+        g_usable_size_fn = fn;
+    }
+    return fn;
+}
+
+static inline size_t hdr_size(void) {
+    return usable_size_fn() == mik__hdr_usable_size ? HDR_SIZE : 0;
+}
+
 /* Fault injection for the host OOM tests: fail the JS-heap allocators after
  * a countdown, and keep a net live-allocation counter across every allocator
  * here (all of them free through mik__free, so one counter balances). */
@@ -39,6 +80,11 @@ static bool oom_inject_should_fail(void) {
     g_oom_countdown--;
     return false;
 }
+
+void mik__usable_size_latch_override(size_t (*fn)(const void*)) {
+    g_usable_size_fn = fn ? fn : mik__hdr_usable_size;
+}
+
 #define OOM_INJECT_FAIL() oom_inject_should_fail()
 #define LIVE_ALLOCS_ADD(d) (g_live_allocs += (d))
 #else
@@ -46,27 +92,22 @@ static bool oom_inject_should_fail(void) {
 #define LIVE_ALLOCS_ADD(d) ((void)0)
 #endif
 
-static inline size_t hdr_read(void* user) {
-    size_t sz;
-    memcpy(&sz, static_cast<char*>(user) - HDR_SIZE, sizeof(sz));
-    return sz;
-}
-
-static inline void hdr_write(void* raw, size_t sz) {
-    memcpy(raw, &sz, sizeof(sz));
+static inline void hdr_write(void* raw, size_t size, size_t hdr) {
+    if (hdr) memcpy(raw, &size, sizeof(size));
 }
 
 size_t mik__malloc_usable_size(const void* ptr) {
     if (!ptr) return 0;
-    return hdr_read(const_cast<void*>(ptr));
+    return usable_size_fn()(ptr);
 }
 
 void* mik__malloc(size_t size) {
-    void* raw = malloc(size + HDR_SIZE);
+    size_t hdr = hdr_size();
+    void* raw = malloc(size + hdr);
     if (!raw) return nullptr;
-    hdr_write(raw, size);
+    hdr_write(raw, size, hdr);
     LIVE_ALLOCS_ADD(1);
-    return static_cast<char*>(raw) + HDR_SIZE;
+    return static_cast<char*>(raw) + hdr;
 }
 
 void* mik__mallocz(size_t size) { return mik__calloc(1, size); }
@@ -74,26 +115,28 @@ void* mik__mallocz(size_t size) { return mik__calloc(1, size); }
 void* mik__calloc(size_t count, size_t size) {
     if (size && count > SIZE_MAX / size) return nullptr;
     size_t total = count * size;
-    void* raw = calloc(1, total + HDR_SIZE);
+    size_t hdr = hdr_size();
+    void* raw = calloc(1, total + hdr);
     if (!raw) return nullptr;
-    hdr_write(raw, total);
+    hdr_write(raw, total, hdr);
     LIVE_ALLOCS_ADD(1);
-    return static_cast<char*>(raw) + HDR_SIZE;
+    return static_cast<char*>(raw) + hdr;
 }
 
 void mik__free(void* ptr) {
     if (!ptr) return;
     LIVE_ALLOCS_ADD(-1);
-    free(static_cast<char*>(ptr) - HDR_SIZE);
+    free(static_cast<char*>(ptr) - hdr_size());
 }
 
 void* mik__realloc(void* ptr, size_t size) {
-    void* raw = ptr ? static_cast<char*>(ptr) - HDR_SIZE : nullptr;
-    raw = realloc(raw, size + HDR_SIZE);
+    size_t hdr = hdr_size();
+    void* raw = ptr ? static_cast<char*>(ptr) - hdr : nullptr;
+    raw = realloc(raw, size + hdr);
     if (!raw) return nullptr;
-    hdr_write(raw, size);
+    hdr_write(raw, size, hdr);
     if (!ptr) LIVE_ALLOCS_ADD(1);
-    return static_cast<char*>(raw) + HDR_SIZE;
+    return static_cast<char*>(raw) + hdr;
 }
 
 /* QuickJS-heap allocator. When the PSRAM flag is set, route through the
@@ -115,51 +158,54 @@ bool mik__is_quickjs_heap_psram(void) {
 
 void* mik__js_malloc(size_t size) {
     if (OOM_INJECT_FAIL()) return nullptr;
+    size_t hdr = hdr_size();
     void* raw = nullptr;
     if (g_quickjs_heap_psram) {
         const MIKPlatform* p = MIK_GetPlatform();
         if (p && p->malloc_psram) {
-            raw = p->malloc_psram(size + HDR_SIZE);
+            raw = p->malloc_psram(size + hdr);
         }
     }
-    if (!raw) raw = malloc(size + HDR_SIZE);
+    if (!raw) raw = malloc(size + hdr);
     if (!raw) return nullptr;
-    hdr_write(raw, size);
+    hdr_write(raw, size, hdr);
     LIVE_ALLOCS_ADD(1);
-    return static_cast<char*>(raw) + HDR_SIZE;
+    return static_cast<char*>(raw) + hdr;
 }
 
 void* mik__js_calloc(size_t count, size_t size) {
     if (OOM_INJECT_FAIL()) return nullptr;
     if (size && count > SIZE_MAX / size) return nullptr;
     size_t total = count * size;
+    size_t hdr = hdr_size();
     void* raw = nullptr;
     if (g_quickjs_heap_psram) {
         const MIKPlatform* p = MIK_GetPlatform();
         if (p && p->calloc_psram) {
-            raw = p->calloc_psram(1, total + HDR_SIZE);
+            raw = p->calloc_psram(1, total + hdr);
         }
     }
-    if (!raw) raw = calloc(1, total + HDR_SIZE);
+    if (!raw) raw = calloc(1, total + hdr);
     if (!raw) return nullptr;
-    hdr_write(raw, total);
+    hdr_write(raw, total, hdr);
     LIVE_ALLOCS_ADD(1);
-    return static_cast<char*>(raw) + HDR_SIZE;
+    return static_cast<char*>(raw) + hdr;
 }
 
 void* mik__js_realloc(void* ptr, size_t size) {
     if (OOM_INJECT_FAIL()) return nullptr;
-    void* raw = ptr ? static_cast<char*>(ptr) - HDR_SIZE : nullptr;
+    size_t hdr = hdr_size();
+    void* raw = ptr ? static_cast<char*>(ptr) - hdr : nullptr;
     void* new_raw = nullptr;
     if (g_quickjs_heap_psram) {
         const MIKPlatform* p = MIK_GetPlatform();
         if (p && p->realloc_psram) {
-            new_raw = p->realloc_psram(raw, size + HDR_SIZE);
+            new_raw = p->realloc_psram(raw, size + hdr);
         }
     }
-    if (!new_raw) new_raw = realloc(raw, size + HDR_SIZE);
+    if (!new_raw) new_raw = realloc(raw, size + hdr);
     if (!new_raw) return nullptr;
-    hdr_write(new_raw, size);
+    hdr_write(new_raw, size, hdr);
     if (!ptr) LIVE_ALLOCS_ADD(1);
-    return static_cast<char*>(new_raw) + HDR_SIZE;
+    return static_cast<char*>(new_raw) + hdr;
 }

package/src/mik_app_config.cpp

@@ -337,7 +337,15 @@ int MIK_LoadConfig(const char* base_path, MIKConfig* config) {
                 config->stack_size = (size_t)num_val;
             }
             if (mik__json_get_number(buf, "memReserved", &num_val)) {
-                config->mem_reserved = (uint32_t)num_val;
+                /* The uint32 cast would wrap a negative value into a ~4 GB
+                 * reserve; keep the default instead. */
+                if (num_val < 0) {
+                    platform->log(MIK_LOG_WARN, TAG,
+                                  "Ignoring negative memReserved (%ld); using default",
+                                  (long)num_val);
+                } else {
+                    config->mem_reserved = (uint32_t)num_val;
+                }
             }
             if (mik__json_get_number(buf, "fsReadMax", &num_val)) {
                 config->fs_read_max = (uint32_t)num_val;