/* =========================================================================== * sleela_memmgr.c -- the SLeeLa Memory Manager implementation. * * Allocation layout. Every block the manager returns is preceded by a small * aligned header carrying the payload size (and a magic tag to catch a raw * pointer being handed back by mistake). free()/realloc() read the header to * update the running byte total exactly, so no external bookkeeping table is * required. * * +-------------------+---------------------------------------------------+ * | SLMMHeader (pad) | payload (what the caller sees, returned pointer) | * +-------------------+---------------------------------------------------+ * * The manager is thread-safe via a single mutex and can be enabled/disabled at * runtime. When disabled, allocations still get a header (so free() always * works) but are not counted against the limit or the live-byte total. * =========================================================================== */ #include "sleela_memmgr.h" #include "sleela_memory.h" #include "sleela_thread.h" #include #include #define SLMM_MAGIC 0x534C4D4Du /* 'SLMM' */ /* Header prefixed to every managed block. Sized to a 16-byte multiple so the * payload stays suitably aligned for any scalar the caller might store. */ typedef struct { uint32_t magic; uint32_t counted; /* 1 if this block's bytes are in live_bytes */ size_t size; /* payload size in bytes */ size_t _pad; /* keep the struct a 16-byte multiple on LP64 & ILP32 */ } SLMMHeader; /* ---- process-wide state, guarded by g_lock -------------------------------- */ static SLThreadMutex g_lock; static int g_lock_ready = 0; static int g_enabled = 0; static size_t g_limit = SLMM_DEFAULT_MEMORY_BYTES; static size_t g_live_bytes = 0; static size_t g_peak_bytes = 0; static size_t g_live_allocs = 0; static uint64_t g_total_allocs = 0; static uint64_t g_total_frees = 0; static uint64_t g_refused = 0; static SLMMStatus g_last_status = SLMM_OK; /* Lazily initialize the guard mutex. Not itself lock-protected; callers reach * it through slmm_enable() / the alloc family, which the front end drives from * a single thread before any worker threads exist. */ static void ensure_lock(void) { if (!g_lock_ready) { slthread_mutex_init(&g_lock); g_lock_ready = 1; } } static void lock(void) { ensure_lock(); slthread_mutex_lock(&g_lock); } static void unlock(void) { slthread_mutex_unlock(&g_lock); } static size_t header_span(void) { /* Round the header up so the payload begins on a 16-byte boundary. */ size_t h = sizeof(SLMMHeader); size_t a = 16u; return (h + (a - 1)) & ~(a - 1); } static SLMMHeader* header_of(void* payload) { return (SLMMHeader*)((unsigned char*)payload - header_span()); } static void* payload_of(SLMMHeader* h) { return (unsigned char*)h + header_span(); } /* ---- public API ----------------------------------------------------------- */ int slmm_valid_limit(size_t limit_bytes) { return limit_bytes >= SLMM_MIN_MEMORY_BYTES && limit_bytes <= SLMM_MAX_MEMORY_BYTES; } static size_t normalize_limit(size_t limit_bytes) { return limit_bytes == 0 ? SLMM_DEFAULT_MEMORY_BYTES : limit_bytes; } int slmm_enable(size_t limit_bytes) { size_t normalized = normalize_limit(limit_bytes); if (!slmm_valid_limit(normalized)) return -1; lock(); g_enabled = 1; g_limit = normalized; g_last_status = SLMM_OK; unlock(); return 0; } void slmm_disable(void) { lock(); g_enabled = 0; unlock(); } int slmm_is_enabled(void) { int e; lock(); e = g_enabled; unlock(); return e; } size_t slmm_limit(void) { size_t l; lock(); l = g_limit; unlock(); return l; } void slmm_set_limit(size_t limit_bytes) { size_t normalized = normalize_limit(limit_bytes); if (!slmm_valid_limit(normalized)) return; lock(); g_limit = normalized; unlock(); } /* Allocate size payload bytes plus the header. Assumes g_lock is held. */ static void* alloc_locked(size_t size) { size_t span = header_span(); size_t total; SLMMHeader* h; if (size > (size_t)-1 - span) { /* size + header overflow */ g_refused++; g_last_status = SLMM_OVERFLOW; return NULL; } total = span + size; if (g_enabled && g_limit && (size > g_limit || g_live_bytes > g_limit - size)) { g_refused++; g_last_status = SLMM_LIMIT; return NULL; } h = (SLMMHeader*)slmemory_alloc(total); if (!h) { g_refused++; g_last_status = SLMM_OOM; return NULL; } h->magic = SLMM_MAGIC; h->size = size; h->counted = g_enabled ? 1u : 0u; h->_pad = 0; if (h->counted) { g_live_bytes += size; if (g_live_bytes > g_peak_bytes) g_peak_bytes = g_live_bytes; g_live_allocs++; g_total_allocs++; } g_last_status = g_enabled ? SLMM_OK : SLMM_DISABLED; return payload_of(h); } void* slmm_alloc(size_t size) { void* p; lock(); p = alloc_locked(size); unlock(); return p; } void* slmm_calloc(size_t count, size_t size) { size_t bytes; void* p; if (count && size > (size_t)-1 / count) { /* count*size overflow */ lock(); g_refused++; g_last_status = SLMM_OVERFLOW; unlock(); return NULL; } bytes = count * size; lock(); p = alloc_locked(bytes); unlock(); if (p) memset(p, 0, bytes); return p; } void slmm_free(void* ptr) { SLMMHeader* h; if (!ptr) return; h = header_of(ptr); if (h->magic != SLMM_MAGIC) { /* Not one of ours -- refuse to corrupt the heap by guessing. */ return; } lock(); if (h->counted) { if (g_live_bytes >= h->size) g_live_bytes -= h->size; else g_live_bytes = 0; if (g_live_allocs) g_live_allocs--; g_total_frees++; } h->magic = 0; /* poison so a double free is caught above */ unlock(); slmemory_free(h); } void* slmm_realloc(void* ptr, size_t size) { SLMMHeader* oldh; size_t oldsize; int oldcounted; void* np; if (!ptr) return slmm_alloc(size); if (size == 0) { slmm_free(ptr); return NULL; } oldh = header_of(ptr); if (oldh->magic != SLMM_MAGIC) return NULL; oldsize = oldh->size; oldcounted = oldh->counted ? 1 : 0; /* The old block is about to be replaced, so its bytes do not count against * the limit while the new size is checked: growing a block whose RESULT * fits under the limit must not fail just because old + new would not. * Allocate new, copy, then release old. On failure the old block is * untouched and its accounting is restored, as with realloc(). */ lock(); if (oldcounted) g_live_bytes = g_live_bytes >= oldsize ? g_live_bytes - oldsize : 0; np = alloc_locked(size); if (!np) { if (oldcounted) g_live_bytes += oldsize; unlock(); return NULL; } if (oldcounted) { if (g_live_allocs) g_live_allocs--; g_total_frees++; } oldh->magic = 0; /* poison so a double free is caught */ unlock(); /* Both blocks are private to this caller, so the copy needs no lock. */ memcpy(np, ptr, oldsize < size ? oldsize : size); slmemory_free(oldh); return np; } void slmm_stats(SLMMStats* out) { if (!out) return; lock(); out->enabled = g_enabled; out->limit_bytes = g_limit; out->live_bytes = g_live_bytes; out->peak_bytes = g_peak_bytes; out->live_allocs = g_live_allocs; out->total_allocs = g_total_allocs; out->total_frees = g_total_frees; out->refused = g_refused; out->last_status = g_last_status; unlock(); } SLMMStatus slmm_last_status(void) { SLMMStatus s; lock(); s = g_last_status; unlock(); return s; } const char* slmm_status_name(SLMMStatus status) { switch (status) { case SLMM_OK: return "ok"; case SLMM_DISABLED: return "disabled"; case SLMM_LIMIT: return "limit-exceeded"; case SLMM_OOM: return "out-of-memory"; case SLMM_OVERFLOW: return "size-overflow"; default: return "unknown"; } } void slmm_reset(void) { lock(); /* Preserve live accounting when blocks are still outstanding. Resetting * live_bytes/live_allocs while those headers remain alive would corrupt the * manager's invariants. Counters are fully reset only for an empty manager. */ if (g_live_allocs != 0 || g_live_bytes != 0) { g_peak_bytes = g_live_bytes; g_total_allocs = 0; g_total_frees = 0; g_refused = 0; g_last_status = SLMM_OK; unlock(); return; } g_live_bytes = 0; g_peak_bytes = 0; g_live_allocs = 0; g_total_allocs = 0; g_total_frees = 0; g_refused = 0; g_last_status = SLMM_OK; unlock(); } /* Group an unsigned value with thousands separators into `out` for the memory * manager's own report lines (SYSTEM-side presentation; user print(...) output * never routes through here). */ static const char* slmm_group(unsigned long long v, char* out, size_t cap) { char tmp[32]; int n = snprintf(tmp, sizeof tmp, "%llu", v); size_t o = 0; for (int i = 0; i < n; ++i) { if (i > 0 && (n - i) % 3 == 0 && o + 1 < cap) out[o++] = ','; if (o + 1 < cap) out[o++] = tmp[i]; } out[o < cap ? o : cap - 1] = 0; return out; } int slmm_format_report(char* buf, size_t cap) { SLMMStats s; slmm_stats(&s); char gl[32], gv[32], gp[32], gla[32], ga[32], gf[32], gr[32]; return snprintf(buf, cap, "[memory-manager] backend=%s enabled=%s limit=%s bytes\n" "[memory-manager] live=%s bytes peak=%s bytes live-allocs=%s\n" "[memory-manager] allocs=%s frees=%s refused=%s last=%s\n", slmemory_platform_name(), s.enabled ? "yes" : "no", slmm_group((unsigned long long)s.limit_bytes, gl, sizeof gl), slmm_group((unsigned long long)s.live_bytes, gv, sizeof gv), slmm_group((unsigned long long)s.peak_bytes, gp, sizeof gp), slmm_group((unsigned long long)s.live_allocs, gla, sizeof gla), slmm_group((unsigned long long)s.total_allocs, ga, sizeof ga), slmm_group((unsigned long long)s.total_frees, gf, sizeof gf), slmm_group((unsigned long long)s.refused, gr, sizeof gr), slmm_status_name(s.last_status)); }