Track peak live memory via SP_FREE; report peak in banner

Author: dance858

include/utils/tracked_alloc.h

@@ -21,20 +21,61 @@
 #include <stddef.h>
 #include <stdlib.h>
 
-extern size_t g_allocated_bytes;
+/* Platform shim for "how many usable bytes are at this malloc'd pointer".
+   Apple's malloc_size, glibc's malloc_usable_size, MSVC's _msize. The
+   returned size is the *usable* size (may exceed the requested size by a
+   few bytes of allocator rounding), but alloc and free use the same
+   function so the running totals stay symmetric. */
+#if defined(__APPLE__)
+#include <malloc/malloc.h>
+#define TRACKED_BLOCK_SIZE(p) malloc_size(p)
+#elif defined(_WIN32) || defined(_WIN64)
+#include <malloc.h>
+#define TRACKED_BLOCK_SIZE(p) _msize(p)
+#else
+#include <malloc.h>
+#define TRACKED_BLOCK_SIZE(p) malloc_usable_size(p)
+#endif
+
+extern size_t g_allocated_bytes; /* current live bytes */
+extern size_t g_peak_bytes;      /* high-water mark since last reset */
 
 static inline void *SP_MALLOC(size_t size)
 {
     void *ptr = malloc(size);
-    if (ptr) g_allocated_bytes += size;
+    if (ptr)
+    {
+        g_allocated_bytes += TRACKED_BLOCK_SIZE(ptr);
+        if (g_allocated_bytes > g_peak_bytes) g_peak_bytes = g_allocated_bytes;
+    }
     return ptr;
 }
 
 static inline void *SP_CALLOC(size_t count, size_t size)
 {
     void *ptr = calloc(count, size);
-    if (ptr) g_allocated_bytes += count * size;
+    if (ptr)
+    {
+        g_allocated_bytes += TRACKED_BLOCK_SIZE(ptr);
+        if (g_allocated_bytes > g_peak_bytes) g_peak_bytes = g_allocated_bytes;
+    }
     return ptr;
 }
 
+static inline void SP_FREE(void *ptr)
+{
+    if (ptr)
+    {
+        g_allocated_bytes -= TRACKED_BLOCK_SIZE(ptr);
+        free(ptr);
+    }
+}
+
+/* Auto-route plain malloc/calloc/free in caller translation units through
+   the tracked wrappers. Defined AFTER the wrapper bodies so SP_MALLOC /
+   SP_CALLOC / SP_FREE themselves still see the real stdlib symbols. */
+#define malloc SP_MALLOC
+#define calloc SP_CALLOC
+#define free SP_FREE
+
 #endif /* TRACKED_ALLOC_H */

src/problem.c

@@ -32,7 +32,11 @@ static void problem_lagrange_hess_fill_sparsity(problem *prob, int *iwork);
 problem *new_problem(expr *objective, expr **constraints, int n_constraints,
                      bool verbose)
 {
-    g_allocated_bytes = 0;
+    /* Baseline the peak watermark to the current live bytes — peak then
+       captures any growth during this problem's lifetime. Don't reset
+       g_allocated_bytes itself: allocations made before new_problem are
+       still alive, and their frees would subtract from this counter. */
+    g_peak_bytes = g_allocated_bytes;
     problem *prob = (problem *) SP_CALLOC(1, sizeof(problem));
     if (!prob) return NULL;
 
@@ -321,7 +325,7 @@ static inline void print_end_message(const Diff_engine_stats *stats)
     printf("  Lagrange Hessian (nnz):                 %d\n", stats->nnz_hessian);
     char mem_buf[64];
     format_memory(stats->memory_bytes, mem_buf, sizeof(mem_buf));
-    printf("  Allocated memory:                       %s\n", mem_buf);
+    printf("  Peak memory:                            %s\n", mem_buf);
 
     printf("\nTiming (seconds):\n");
     printf("  Derivative structure (sparsity):     %8.3f\n",
@@ -349,7 +353,7 @@ void free_problem(problem *prob)
 
     if (prob->verbose)
     {
-        prob->stats.memory_bytes = g_allocated_bytes;
+        prob->stats.memory_bytes = g_peak_bytes;
         print_end_message(&prob->stats);
     }
 

src/utils/tracked_alloc.c

@@ -18,3 +18,4 @@
 #include "utils/tracked_alloc.h"
 
 size_t g_allocated_bytes = 0;
+size_t g_peak_bytes = 0;