perf(dat): batch fetch tickles into one request per worker pass

A read miss now queues its file id (still throttled per id) instead of firing
the trigger immediately; the worker flushes the accumulated ids to the client
as a single FUN_0082da30(count, ids, 0x2) call after each poll. A burst of
missing files (e.g. a full icon grid on a fresh streamed install) becomes one
game-thread task and one request batch instead of one per file, so no per-file
hitch. TriggerFn is now (ids, count); undelivered tickles are dropped on stop.

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

Author: 3vcloud

GWToolboxdll/Modules/GwDatTextureModule.cpp

@@ -37,10 +37,13 @@ namespace {
             return;
         }
         Log::Log("[GwDat] game file-request trigger resolved at %p", reinterpret_cast<void*>(RequestFiles_Func));
-        GwDatArchive::Instance().SetTrigger([](uint32_t file_id) {
-            GW::GameThread::Enqueue([file_id] { // touches client state; run on the game thread
-                if (RequestFiles_Func)
-                    RequestFiles_Func(1, &file_id, kTriggerFlags);
+        GwDatArchive::Instance().SetTrigger([](const uint32_t* ids, size_t count) {
+            if (!count)
+                return;
+            std::vector<uint32_t> batch(ids, ids + count); // copy for the game-thread lambda
+            GW::GameThread::Enqueue([batch = std::move(batch)] { // touches client state; run on the game thread
+                if (RequestFiles_Func && !batch.empty())
+                    RequestFiles_Func(static_cast<uint32_t>(batch.size()), batch.data(), kTriggerFlags);
             });
         });
     }

GWToolboxdll/Utils/GwDat/GwDatArchive.cpp

@@ -154,6 +154,7 @@ void GwDatArchive::WorkerLoop()
         if (task)
             task();
         ProcessPendingReads();
+        FlushTickles(); // send the reads' fetch requests as one batch
     }
 }
 
@@ -182,8 +183,12 @@ void GwDatArchive::StopWorker()
         std::scoped_lock<std::mutex> lock(m_task_mutex);
         m_worker_running = false;
     }
-    std::scoped_lock<std::mutex> lock(m_pending_mutex);
-    m_pending_reads.clear(); // undelivered async reads are dropped on stop
+    {
+        std::scoped_lock<std::mutex> lock(m_pending_mutex);
+        m_pending_reads.clear(); // undelivered async reads are dropped on stop
+    }
+    std::scoped_lock<std::mutex> tlock(m_trigger_mutex);
+    m_tickle_batch.clear(); // undelivered fetch requests are dropped on stop
 }
 
 void GwDatArchive::EnqueueTask(std::function<void()> task)
@@ -448,23 +453,34 @@ void GwDatArchive::SetTrigger(TriggerFn trigger)
     m_trigger = std::move(trigger);
 }
 
-// Ask the client to fetch a just-missed file so a later read may find it; throttled per id so a
-// per-frame retry loop doesn't spam. Fires the trigger outside the lock.
+// Queue a just-missed file for the client to fetch so a later read may find it; throttled per id so a
+// per-frame retry loop doesn't spam. The batch is sent by FlushTickles (worker thread).
 void GwDatArchive::TickleFetch(uint32_t file_id)
 {
+    std::scoped_lock<std::mutex> lock(m_trigger_mutex);
+    if (!m_trigger)
+        return;
+    const uint32_t now = GetTickCount();
+    const auto it = m_tickled_at.find(file_id);
+    if (it != m_tickled_at.end() && now - it->second < kTickleThrottleMs)
+        return; // asked recently (elapsed is unsigned, wrap-safe for a session)
+    m_tickled_at[file_id] = now;
+    m_tickle_batch.push_back(file_id);
+}
+
+// Hand every queued fetch id to the client in one request instead of one call per file.
+void GwDatArchive::FlushTickles()
+{
+    std::vector<uint32_t> batch;
     TriggerFn trigger;
     {
         std::scoped_lock<std::mutex> lock(m_trigger_mutex);
-        if (!m_trigger)
+        if (m_tickle_batch.empty() || !m_trigger)
             return;
-        const uint32_t now = GetTickCount();
-        const auto it = m_tickled_at.find(file_id);
-        if (it != m_tickled_at.end() && now - it->second < kTickleThrottleMs)
-            return; // asked recently (elapsed is unsigned, wrap-safe for a session)
-        m_tickled_at[file_id] = now;
+        batch.swap(m_tickle_batch);
         trigger = m_trigger;
     }
-    trigger(file_id);
+    trigger(batch.data(), batch.size());
 }
 
 // Worker pass: deliver resolved reads and time out stale ones. A miss tickles the client via ReadFile.

GWToolboxdll/Utils/GwDat/GwDatArchive.h

@@ -43,10 +43,10 @@ class GwDatArchive {
     using ReadCallback = std::function<void(std::vector<uint8_t>&)>;
     void ReadFileAsync(uint32_t file_id, ReadCallback callback, uint32_t stream_id = 0);
 
-    // Optional hook to ask the client to fetch a file id. ReadFile calls it (throttled per id) whenever
-    // a read misses, so a streamed-only file gets pulled in for a later read. Wired by the GWCA layer;
-    // the reader works with or without it.
-    using TriggerFn = std::function<void(uint32_t file_id)>;
+    // Optional hook to ask the client to fetch file ids. Read misses accumulate (throttled per id) and
+    // are handed to this in batches by the worker, so a burst of missing files is one request, not one
+    // per file. Wired by the GWCA layer; the reader works with or without it.
+    using TriggerFn = std::function<void(const uint32_t* file_ids, size_t count)>;
     void SetTrigger(TriggerFn trigger);
 
     // Dedicated worker so reads/decodes run off the caller's thread; EnqueueTask runs inline if not started.
@@ -59,7 +59,8 @@ class GwDatArchive {
 
     void WorkerLoop();
     void ProcessPendingReads();         // deliver/expire queued ReadFileAsync requests (worker thread)
-    void TickleFetch(uint32_t file_id); // ask the client to fetch a missed file (throttled per id)
+    void TickleFetch(uint32_t file_id); // queue a missed file for the client to fetch (throttled per id)
+    void FlushTickles();                // hand the queued fetch ids to the trigger as one batch (worker thread)
 
 #pragma pack(push, 1)
     struct MainHeader {
@@ -119,9 +120,10 @@ class GwDatArchive {
     std::mutex m_pending_mutex; // guards m_pending_reads
     std::vector<PendingRead> m_pending_reads;
 
-    std::mutex m_trigger_mutex; // guards m_trigger + m_tickled_at
+    std::mutex m_trigger_mutex; // guards m_trigger + m_tickled_at + m_tickle_batch
     TriggerFn m_trigger;
     std::unordered_map<uint32_t, uint32_t> m_tickled_at; // file_id -> GetTickCount() of last fetch tickle
+    std::vector<uint32_t> m_tickle_batch;                // file ids queued for the next FlushTickles
     std::shared_mutex m_index_mutex;               // guards m_mapping/m_slots/m_fileid_to_slot against MaybeRefresh
     uint32_t m_last_refresh_ms = 0;                // GetTickCount of the last re-parse, to throttle refreshes
     long long m_indexed_size = 0;                  // dat size at the last parse; skip re-parsing if unchanged (guarded by m_load_mutex, like m_last_refresh_ms)