Add gLifetimeArena for program-lifetime allocations

Add a global Arena* gLifetimeArena (GetLifetimeArena/DestroyLifetimeArena in
TempAllocator) for allocations that live until the program exits, so they don't
need per-allocation frees and can be tracked. On exit, log its lifetime
allocation count and peak bytes (same format as the temp allocator).

Route gAppDataDir through it as a first, clearly-safe conversion (allocated once,
only replaced via -appdata); drop its explicit free in DeleteAppTools.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: kjk

src/AppTools.cpp

@@ -116,7 +116,8 @@ bool IsInstallerOrUninstallerExe() {
 static char* gAppDataDir = nullptr;
 
 void DeleteAppTools() {
-    str::FreePtr(&gAppDataDir);
+    // gAppDataDir is allocated from gLifetimeArena (freed wholesale on exit)
+    gAppDataDir = nullptr;
 }
 
 void SetAppDataDir(const char* dir) {
@@ -131,7 +132,10 @@ void SetAppDataDir(const char* dir) {
             ReportIf(true);
         }
     }
-    str::ReplaceWithCopy(&gAppDataDir, dir);
+    // lives for the whole program: allocate from the lifetime arena. SetAppDataDir
+    // is called at most a couple of times (default + a -appdata override), so the
+    // (rare) replaced value being retained until exit is negligible.
+    gAppDataDir = str::Dup(GetLifetimeArena(), dir);
 }
 
 TempStr GetAppDataDirTemp() {

src/SumatraStartup.cpp

@@ -711,16 +711,18 @@ static void ResetTempAllocatorWithLogging() {
     ResetTempAllocator();
 }
 
-// Logs the temp allocator's lifetime allocation count and peak bytes. Call on
-// exit, before logging is torn down.
-static void LogTempAllocatorLifetimeStats() {
-    Arena* a = GetTempAllocator();
+// Logs an arena's lifetime allocation count and peak bytes. Call on exit, before
+// logging is torn down.
+static void LogArenaLifetimeStats(const char* what, Arena* a) {
+    if (!a) {
+        return;
+    }
     u64 nAllocs = a->nAllocsLifetime;
     u64 peakBytes = a->peakBytesLifetime;
     char human[32];
     FormatSizeHumanIntoBuf(peakBytes, Str(human, (int)sizeof(human)));
-    logf("temp allocator lifetime: %s allocations, peak %s bytes (%s)\n",
-         str::FormatNumWithThousandSepTemp((i64)nAllocs), str::FormatNumWithThousandSepTemp((i64)peakBytes), human);
+    logf("%s lifetime: %s allocations, peak %s bytes (%s)\n", what, str::FormatNumWithThousandSepTemp((i64)nAllocs),
+         str::FormatNumWithThousandSepTemp((i64)peakBytes), human);
 }
 
 static int RunMessageLoop() {
@@ -2231,9 +2233,11 @@ int APIENTRY WinMain(_In_ HINSTANCE /*hInstance*/, _In_opt_ HINSTANCE, _In_ LPST
         UninstallCrashHandler();
     }
     DeleteAppTools();
-    LogTempAllocatorLifetimeStats();
+    LogArenaLifetimeStats("temp allocator", GetTempAllocator());
+    LogArenaLifetimeStats("lifetime arena", gLifetimeArena);
     DestroyLogging();
     DestroyTempAllocator();
+    DestroyLifetimeArena();
 
     return exitCode;
 }

src/scratch2.txt

@@ -1,4 +1,3 @@
-
 Ideas for refactorings:
 
 - change all size_t => int
@@ -7,142 +6,8 @@ Ideas for refactorings:
 
 ------------------------------------------------------------------
 
-static void ClearPixmap(fz_pixmap* pixmap) {
-    auto stride = pixmap->stride;
-    size_t dx = (size_t)pixmap->w;
-    size_t dy = (size_t)pixmap->h;
-    u8* samples = pixmap->samples;
-    ReportIf(pixmap->n != 3);
-    for (size_t y = 0; y < dy; y++) {
-        u8* d = samples + (stride * y);
-        for (size_t x = 0; x < dx; x++) {
-            d[0] = 255;
-            d[1] = 0;
-            d[2] = 0;
-            d += pixmap->n;
-            if (false) {
-                if (x % 2 == 0) {
-                    *d++ = 255;
-                    *d++ = 0;
-                    *d++ = 0;
-                } else {
-                    *d++ = 0;
-                    *d++ = 0;
-                    *d++ = 255;
-                }
-            }
-        }
-    }
-}
-
-------------------------------------------------------------------
-
-// Select random files to test. We want to test each file type equally, so
-// we first group them by file extension and then select up to maxPerType
-// for each extension, randomly, and inter-leave the files with different
-// extensions, so their testing is evenly distributed.
-// Returns result in <files>.
-static void RandomizeFiles(StrVec& files, int maxPerType) {
-    StrVec fileExts;
-    Vec<StrVec*> filesPerType;
-
-    for (int i = 0; i < files.Size(); i++) {
-        char* file = files.at(i);
-        char* ext = path::GetExtTemp(file);
-        CrashAlwaysIf(!ext);
-        int typeNo = fileExts.FindI(ext);
-        if (-1 == typeNo) {
-            fileExts.Append(ext);
-            filesPerType.Append(new StrVec());
-            typeNo = filesPerType.Size() - 1;
-        }
-        filesPerType.at(typeNo)->Append(file);
-    }
-
-    for (size_t j = 0; j < filesPerType.size(); j++) {
-        StrVec* all = filesPerType.at(j);
-        StrVec* random = new StrVec();
-
-        for (int n = 0; n < maxPerType && all->Size() > 0; n++) {
-            int idx = rand() % all->Size();
-            char* file = all->at(idx);
-            random->Append(file);
-            all->RemoveAt(idx);
-        }
-
-        filesPerType.at(j) = random;
-        delete all;
-    }
-
-    files.Reset();
-
-    bool gotAll = false;
-    while (!gotAll) {
-        gotAll = true;
-        for (size_t j = 0; j < filesPerType.size(); j++) {
-            StrVec* random = filesPerType.at(j);
-            if (random->Size() > 0) {
-                gotAll = false;
-                char* file = random->at(0);
-                files.Append(file);
-                random->RemoveAt(0);
-            }
-        }
-    }
-
-    for (size_t j = 0; j < filesPerType.size(); j++) {
-        delete filesPerType.at(j);
-    }
-}
-
-------------------------------------------------------------------
-
 StrVec2 ideas:
 - optimize for SetAt(): when removing last string from a page, free its memory (update currEnd)
 - implement StrVec2::InsertAt()
 
 ------------------------------------------------------------------
-
-struct ClosureData;
-typedef void (*closureFunc)(ClosureData*);
-
-struct ClosureData {
-    closureFunc func;
-    virtual ~ClosureData() = 0;
-    virtual operator()() {
-        func(this);
-    }
-};
-
-template <typename T>
-ClosureData* newClosure(void (*func)(T*)) {
-    T* res = new T();
-    res->func = (closureFunc)func;
-    return res;
-}
-
-struct UpdateCheckData : ClosureData {
-    ~UpdateCheckData() override {
-    }
-};
-
-void updateCheck(UpdateCheckData* d) {
-    // ...
-    delete d;
-}
-
-auto res = newClosure<UpdateCheckData>(updateCheck);
-
-------------------------------------------------------------------
-
-Delegates ideas:
-https://github.com/rosbacke/delegate
-https://github.com/rosbacke/MCU-tools/tree/master/src/callback
-https://github.com/Naios/function2
-https://gist.github.com/twoscomplement/030818a6c38c5a983482dc3a385a3ab8
-https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0792r3.html
-https://github.com/vittorioromeo/Experiments/blob/master/function_ref.cpp
-https://blog.stratifylabs.dev/device/2022-12-01-Callback-and-Lambdas-in-embedded-cpp/
-
-CmdOpenAttachment,,Open Attachment,ver 3.6+
-CmdSaveAttachment,,Save Attachment,ver 3.6+

src/utils/TempAllocator.cpp

@@ -37,6 +37,23 @@ void ResetTempAllocator() {
     }
 }
 
+// Arena for allocations that live for the whole lifetime of the program (i.e.
+// never freed until exit). Allocating them here avoids per-allocation frees and
+// lets us track how much such memory we use (logged on exit). Never Reset().
+Arena* gLifetimeArena = nullptr;
+
+Arena* GetLifetimeArena() {
+    if (!gLifetimeArena) {
+        gLifetimeArena = ArenaNew();
+    }
+    return gLifetimeArena;
+}
+
+void DestroyLifetimeArena() {
+    ArenaDelete(gLifetimeArena);
+    gLifetimeArena = nullptr;
+}
+
 namespace str {
 TempStr DupTemp(const char* s, size_t cb) {
     return str::Dup(GetTempAllocator(), s, cb);

src/utils/TempAllocator.h

@@ -7,6 +7,11 @@ Arena* GetTempAllocator();
 void DestroyTempAllocator();
 void ResetTempAllocator();
 
+// arena for allocations that live until the program exits (see TempAllocator.cpp)
+extern Arena* gLifetimeArena;
+Arena* GetLifetimeArena();
+void DestroyLifetimeArena();
+
 template <typename T>
 FORCEINLINE T* AllocArrayTemp(size_t n) {
     if (!mulSafe<size_t>(&n, sizeof(T))) {