Enable StressLogAnalyzer to read stress logs from old coreclr running with a new clrgc. (#88852)

jkoritzinsky · web-flow · commit 9e21a91bedc0 · 2023-07-14T07:08:56.000-07:00
diff --git a/src/coreclr/inc/stresslog.h b/src/coreclr/inc/stresslog.h
@@ -372,7 +372,9 @@ class StressLog {
     {
         size_t        headerSize;               // size of this header including size field and moduleImage
         uint32_t      magic;                    // must be 'STRL'
-        uint32_t      version;                  // must be 0x00010001
+        uint32_t      version;                  // must be >=0x00010001.
+                                                // 0x00010001 is the legacy short-offset format.
+                                                // 0x00010002 is the large-module-offset format introduced in .NET 8.
         uint8_t*      memoryBase;               // base address of the memory mapped file
         uint8_t*      memoryCur;                // highest address currently used
         uint8_t*      memoryLimit;              // limit that can be used
diff --git a/src/coreclr/tools/StressLogAnalyzer/StressLogDump.cpp b/src/coreclr/tools/StressLogAnalyzer/StressLogDump.cpp
@@ -22,10 +22,11 @@ class MapViewHolder
 #endif // STRESS_LOG
 #define STRESS_LOG_READONLY
 #include "../../../inc/stresslog.h"
+#include "StressMsgReader.h"
 
 
 void GcHistClear();
-void GcHistAddLog(LPCSTR msg, StressMsg* stressMsg);
+void GcHistAddLog(LPCSTR msg, StressMsgReader stressMsg);
 
 
 /*********************************************************************************/
@@ -57,7 +58,7 @@ ThreadStressLog* ThreadStressLog::FindLatestThreadLog() const
     for (const ThreadStressLog* ptr = this; ptr != NULL; ptr = ptr->next)
     {
         if (ptr->readPtr != NULL)
-            if (latestLog == 0 || ptr->readPtr->GetTimeStamp() > latestLog->readPtr->GetTimeStamp())
+            if (latestLog == 0 || StressMsgReader(ptr->readPtr).GetTimeStamp() > StressMsgReader(latestLog->readPtr).GetTimeStamp())
                 latestLog = ptr;
     }
     return const_cast<ThreadStressLog*>(latestLog);
@@ -423,9 +424,9 @@ HRESULT StressLog::Dump(ULONG64 outProcLog, const char* fileName, struct IDebugD
 
         // TODO: fix on 64 bit
         inProcPtr->Activate ();
-        if (inProcPtr->readPtr->GetTimeStamp() > lastTimeStamp)
+        if (StressMsgReader(inProcPtr->readPtr).GetTimeStamp() > lastTimeStamp)
         {
-            lastTimeStamp = inProcPtr->readPtr->GetTimeStamp();
+            lastTimeStamp = StressMsgReader(inProcPtr->readPtr).GetTimeStamp();
         }
 
         outProcPtr = TO_CDADDR(inProcPtr->next);
@@ -488,40 +489,40 @@ HRESULT StressLog::Dump(ULONG64 outProcLog, const char* fileName, struct IDebugD
             break;
         }
 
-        StressMsg* latestMsg = latestLog->readPtr;
-        if (latestMsg->GetFormatOffset() != 0 && !latestLog->CompletedDump())
+        StressMsgReader latestMsg = latestLog->readPtr;
+        if (latestMsg.GetFormatOffset() != 0 && !latestLog->CompletedDump())
         {
-            TADDR taFmt = (latestMsg->GetFormatOffset()) + TO_TADDR(g_hThisInst);
+            TADDR taFmt = (latestMsg.GetFormatOffset()) + TO_TADDR(g_hThisInst);
             hr = memCallBack->ReadVirtual(TO_CDADDR(taFmt), format, 256, 0);
             if (hr != S_OK)
                 strcpy_s(format, ARRAY_SIZE(format), "Could not read address of format string");
 
-            double deltaTime = ((double) (latestMsg->GetTimeStamp() - inProcLog.startTimeStamp)) / inProcLog.tickFrequency;
+            double deltaTime = ((double) (latestMsg.GetTimeStamp() - inProcLog.startTimeStamp)) / inProcLog.tickFrequency;
             if (bDoGcHist)
             {
                 if (strcmp(format, ThreadStressLog::TaskSwitchMsg()) == 0)
                 {
-                    latestLog->threadId = (unsigned)(size_t)latestMsg->args[0];
+                    latestLog->threadId = (unsigned)(size_t)latestMsg.GetArgs()[0];
                 }
                 GcHistAddLog(format, latestMsg);
             }
             else
             {
                 if (strcmp(format, ThreadStressLog::TaskSwitchMsg()) == 0)
                 {
-                    fprintf (file, "Task was switched from %x\n", (unsigned)(size_t)latestMsg->args[0]);
-                    latestLog->threadId = (unsigned)(size_t)latestMsg->args[0];
+                    fprintf (file, "Task was switched from %x\n", (unsigned)(size_t)latestMsg.GetArgs()[0]);
+                    latestLog->threadId = (unsigned)(size_t)latestMsg.GetArgs()[0];
                 }
                 else
                 {
-                    args = latestMsg->args;
-                    formatOutput(memCallBack, file, format, (unsigned)latestLog->threadId, deltaTime, latestMsg->GetFacility(), args);
+                    args = latestMsg.GetArgs();
+                    formatOutput(memCallBack, file, format, (unsigned)latestLog->threadId, deltaTime, latestMsg.GetFacility(), args);
                 }
             }
             msgCtr++;
         }
 
-        latestLog->readPtr = latestLog->AdvanceRead(latestMsg->GetNumberOfArgs());
+        latestLog->readPtr = latestLog->AdvanceRead(latestMsg.GetNumberOfArgs());
         if (latestLog->CompletedDump())
         {
             latestLog->readPtr = NULL;
diff --git a/src/coreclr/tools/StressLogAnalyzer/StressLogPlugin.cpp b/src/coreclr/tools/StressLogAnalyzer/StressLogPlugin.cpp
@@ -40,6 +40,7 @@ bool IsInCantAllocStressLogRegion()
 
 #include <stddef.h>
 #include "../../../inc/stresslog.h"
+#include "StressMsgReader.h"
 
 size_t StressLog::writing_base_address;
 size_t StressLog::reading_base_address;
@@ -67,7 +68,7 @@ void GcHistClear()
 {
 }
 
-void GcHistAddLog(LPCSTR msg, StressMsg* stressMsg)
+void GcHistAddLog(LPCSTR msg, StressMsgReader stressMsg)
 {
 }
 
@@ -531,7 +532,7 @@ bool FilterMessage(StressLog::StressLogHeader* hdr, ThreadStressLog* tsl, uint32
 struct StressThreadAndMsg
 {
     uint64_t    threadId;
-    StressMsg* msg;
+    StressMsgReader msg;
     uint64_t    msgId;
 };
 
@@ -540,9 +541,9 @@ int CmpMsg(const void* p1, const void* p2)
     const StressThreadAndMsg* msg1 = (const StressThreadAndMsg*)p1;
     const StressThreadAndMsg* msg2 = (const StressThreadAndMsg*)p2;
 
-    if (msg1->msg->GetTimeStamp() < msg2->msg->GetTimeStamp())
+    if (msg1->msg.GetTimeStamp() < msg2->msg.GetTimeStamp())
         return 1;
-    if (msg1->msg->GetTimeStamp() > msg2->msg->GetTimeStamp())
+    if (msg1->msg.GetTimeStamp() > msg2->msg.GetTimeStamp())
         return -11;
 
     if (msg1->threadId < msg2->threadId)
@@ -564,7 +565,7 @@ struct ThreadStressLogDesc
     volatile LONG workStarted;
     volatile LONG workFinished;
     ThreadStressLog* tsl;
-    StressMsg* earliestMessage;
+    StressMsgReader earliestMessage;
 
     ThreadStressLogDesc() : workStarted(0), workFinished(0), tsl(nullptr), earliestMessage(nullptr)
     {
@@ -584,7 +585,7 @@ static double s_timeFilterStart = 0;
 static double s_timeFilterEnd = 0;
 static const char* s_outputFileName = nullptr;
 
-static StressLog::StressLogHeader* s_hdr;
+StressLog::StressLogHeader* s_hdr;
 
 static bool s_fPrintFormatStrings;
 
@@ -1056,7 +1057,7 @@ bool ParseOptions(int argc, char* argv[])
     return true;
 }
 
-static void IncludeMessage(uint64_t threadId, StressMsg* msg)
+static void IncludeMessage(uint64_t threadId, StressMsgReader msg)
 {
     LONGLONG msgCount = InterlockedIncrement64(&s_msgCount) - 1;
     if (msgCount < MAX_MESSAGE_COUNT)
@@ -1089,10 +1090,10 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)
             wrappedWriteThreadCount++;
         }
         // printf("thread: %zx\n", tsl->threadId);
-        StressMsg* msg = StressLog::TranslateMemoryMappedPointer(tsl->curPtr);
+        void* msg = StressLog::TranslateMemoryMappedPointer(tsl->curPtr);
         StressLogChunk* slc = StressLog::TranslateMemoryMappedPointer(tsl->curWriteChunk);
         int chunkCount = 0;
-        StressMsg* prevMsg = nullptr;
+        void* prevMsg = nullptr;
         while (true)
         {
             // printf("stress log chunk %zx\n", (size_t)slc);
@@ -1135,14 +1136,15 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)
             {
                 while (p < end && *p == 0)
                     p++;
-                msg = (StressMsg*)p;
+                msg = (void*)p;
             }
-            StressMsg* endMsg = (StressMsg*)end;
+            void* endMsg = (void*)end;
             while (msg < endMsg)
             {
+                StressMsgReader msgReader(msg);
                 totalMsgCount++;
-                char* format = (char*)(hdr->moduleImage + msg->GetFormatOffset());
-                double deltaTime = ((double)(msg->GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;
+                char* format = (char*)(hdr->moduleImage + msgReader.GetFormatOffset());
+                double deltaTime = ((double)(msgReader.GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;
                 bool fIgnoreMessage = false;
                 if (fTimeFilter)
                 {
@@ -1156,17 +1158,17 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)
                         fIgnoreMessage = true;
                     }
                 }
-                int numberOfArgs = msg->GetNumberOfArgs();
+                int numberOfArgs = msgReader.GetNumberOfArgs();
                 if (!fIgnoreMessage)
                 {
-                    bool fIncludeMessage = s_showAllMessages || FilterMessage(hdr, tsl, msg->GetFacility(), format, deltaTime, numberOfArgs, msg->args);
+                    bool fIncludeMessage = s_showAllMessages || FilterMessage(hdr, tsl, msgReader.GetFacility(), format, deltaTime, numberOfArgs, msgReader.GetArgs());
                     if (!fIncludeMessage && s_valueFilterCount > 0)
                     {
                         for (int i = 0; i < numberOfArgs; i++)
                         {
                             for (int j = 0; j < s_valueFilterCount; j++)
                             {
-                                if (s_valueFilter[j].start <= (size_t)msg->args[i] && (size_t)msg->args[i] <= s_valueFilter[j].end)
+                                if (s_valueFilter[j].start <= (size_t)msgReader.GetArgs()[i] && (size_t)msgReader.GetArgs()[i] <= s_valueFilter[j].end)
                                 {
                                     fIncludeMessage = true;
                                     break;
@@ -1182,7 +1184,7 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)
                     }
                 }
                 prevMsg = msg;
-                msg = (StressMsg*)&msg->args[numberOfArgs];
+                msg = (StressMsg*)&msgReader.GetArgs()[numberOfArgs];
             }
             if (slc == StressLog::TranslateMemoryMappedPointer(tsl->chunkListTail) && !tsl->writeHasWrapped)
                 break;
@@ -1233,16 +1235,16 @@ static void PrintFriendlyNumber(LONGLONG n)
         printf("%11.9f billion", n / 1000000000.0);
 }
 
-static void PrintMessage(CorClrData& corClrData, FILE *outputFile, uint64_t threadId, StressMsg* msg)
+static void PrintMessage(CorClrData& corClrData, FILE *outputFile, uint64_t threadId, StressMsgReader msg)
 {
     void* argBuffer[StressMsg::maxArgCnt];
-    char* format = (char*)(s_hdr->moduleImage + msg->GetFormatOffset());
-    int numberOfArgs = msg->GetNumberOfArgs();
+    char* format = (char*)(s_hdr->moduleImage + msg.GetFormatOffset());
+    int numberOfArgs = msg.GetNumberOfArgs();
     for (int i = 0; i < numberOfArgs; i++)
     {
-        argBuffer[i] = msg->args[i];
+        argBuffer[i] = msg.GetArgs()[i];
     }
-    double deltaTime = ((double)(msg->GetTimeStamp() - s_hdr->startTimeStamp)) / s_hdr->tickFrequency;
+    double deltaTime = ((double)(msg.GetTimeStamp() - s_hdr->startTimeStamp)) / s_hdr->tickFrequency;
     if (!s_printHexTidForGcThreads)
     {
         GcThread gcThread;
@@ -1255,7 +1257,7 @@ static void PrintMessage(CorClrData& corClrData, FILE *outputFile, uint64_t thre
                 threadId |= 0x4000000000000000;
         }
     }
-    formatOutput(&corClrData, outputFile, format, threadId, deltaTime, msg->GetFacility(), argBuffer, s_fPrintFormatStrings);
+    formatOutput(&corClrData, outputFile, format, threadId, deltaTime, msg.GetFacility(), argBuffer, s_fPrintFormatStrings);
 }
 
 int ProcessStressLog(void* baseAddress, int argc, char* argv[])
@@ -1301,7 +1303,8 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])
     StressLog::StressLogHeader* hdr = (StressLog::StressLogHeader*)baseAddress;
     if (hdr->headerSize != sizeof(*hdr) ||
         hdr->magic != *(uint32_t*)"LRTS" ||
-        hdr->version != 0x00010001)
+        (hdr->version != 0x00010001 &&
+            hdr->version != 0x00010002))
     {
         printf("Unrecognized file format\n");
         return 1;
@@ -1383,8 +1386,8 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])
         int remMsgCount = 0;
         for (int msgIndex = 0; msgIndex < s_msgCount; msgIndex++)
         {
-            StressMsg* msg = s_threadMsgBuf[msgIndex].msg;
-            double deltaTime = ((double)(msg->GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;
+            StressMsgReader msg = s_threadMsgBuf[msgIndex].msg;
+            double deltaTime = ((double)(msg.GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;
             if (startTime <= deltaTime && deltaTime <= endTime)
             {
                 s_threadMsgBuf[remMsgCount] = s_threadMsgBuf[msgIndex];
@@ -1463,7 +1466,7 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])
     for (LONGLONG i = 0; i < s_msgCount; i++)
     {
         uint64_t threadId = (unsigned)s_threadMsgBuf[i].threadId;
-        StressMsg* msg = s_threadMsgBuf[i].msg;
+        StressMsgReader msg = s_threadMsgBuf[i].msg;
         PrintMessage(corClrData, outputFile, threadId, msg);
     }
 
@@ -1500,7 +1503,7 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])
         LONGLONG earliestStartCount = s_msgCount;
         for (int threadStressLogIndex = 0; threadStressLogIndex < s_threadStressLogCount; threadStressLogIndex++)
         {
-            StressMsg* msg = s_threadStressLogDesc[threadStressLogIndex].earliestMessage;
+            StressMsgReader msg = s_threadStressLogDesc[threadStressLogIndex].earliestMessage;
             if (msg == nullptr)
                 continue;
             bool fIncludeMessage = s_printEarliestMessages;
@@ -1525,7 +1528,7 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])
         for (LONGLONG i = earliestStartCount; i < s_msgCount; i++)
         {
             uint64_t threadId = (unsigned)s_threadMsgBuf[i].threadId;
-            StressMsg* msg = s_threadMsgBuf[i].msg;
+            StressMsgReader msg = s_threadMsgBuf[i].msg;
             PrintMessage(corClrData, outputFile, threadId, msg);
         }
     }
diff --git a/src/coreclr/tools/StressLogAnalyzer/StressMsgReader.h b/src/coreclr/tools/StressLogAnalyzer/StressMsgReader.h
@@ -0,0 +1,80 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include <stdint.h>
+
+extern StressLog::StressLogHeader* s_hdr;
+
+// A version-aware reader for memory-mapped stress log messages.
+struct StressMsgReader
+{
+private:
+    struct StressMsgSmallOffset
+    {
+        uint32_t numberOfArgsLow  : 3;                   // at most 7 arguments here
+        uint32_t formatOffset  : 26;                     // low bits offset of format string in modules
+        uint32_t numberOfArgsHigh : 3;                   // extend number of args in a backward compat way
+        uint32_t facility;                               // facility used to log the entry
+        uint64_t timeStamp;                              // time when mssg was logged
+        void* args[0];                                   // variable number of arguments
+    };
+
+    void* m_rawMsg;
+public:
+    StressMsgReader() = default;
+
+    StressMsgReader(void* msg)
+        :m_rawMsg(msg)
+    {
+    }
+
+    uint64_t GetFormatOffset() const
+    {
+        if (s_hdr->version == 0x00010001)
+        {
+            return ((StressMsgSmallOffset*)m_rawMsg)->formatOffset;
+        }
+        return ((StressMsg*)m_rawMsg)->GetFormatOffset();
+    }
+
+    uint32_t GetNumberOfArgs() const
+    {
+        if (s_hdr->version == 0x00010001)
+        {
+            return ((StressMsgSmallOffset*)m_rawMsg)->numberOfArgsHigh << 3 | ((StressMsgSmallOffset*)m_rawMsg)->numberOfArgsLow;
+        }
+        return ((StressMsg*)m_rawMsg)->GetNumberOfArgs();
+    }
+
+    uint32_t GetFacility() const
+    {
+        if (s_hdr->version == 0x00010001)
+        {
+            return ((StressMsgSmallOffset*)m_rawMsg)->facility;
+        }
+        return ((StressMsg*)m_rawMsg)->GetFacility();
+    }
+
+    uint64_t GetTimeStamp() const
+    {
+        if (s_hdr->version == 0x00010001)
+        {
+            return ((StressMsgSmallOffset*)m_rawMsg)->timeStamp;
+        }
+        return ((StressMsg*)m_rawMsg)->GetTimeStamp();
+    }
+
+    void** GetArgs() const
+    {
+        if (s_hdr->version == 0x00010001)
+        {
+            return ((StressMsgSmallOffset*)m_rawMsg)->args;
+        }
+        return ((StressMsg*)m_rawMsg)->args;
+    }
+
+    bool operator==(std::nullptr_t) const
+    {
+        return m_rawMsg == nullptr;
+    }
+};
diff --git a/src/coreclr/utilcode/stresslog.cpp b/src/coreclr/utilcode/stresslog.cpp
@@ -266,7 +266,7 @@ void StressLog::Initialize(unsigned facilities, unsigned level, unsigned maxByte
             StressLogHeader* hdr = (StressLogHeader*)(uint8_t*)(void*)theLog.hMapView;
             hdr->headerSize = sizeof(StressLogHeader);
             hdr->magic = *(uint32_t*)"LRTS";
-            hdr->version = 0x00010001;
+            hdr->version = 0x00010002;
             hdr->memoryBase = (uint8_t*)hdr;
             hdr->memoryCur = hdr->memoryBase + sizeof(StressLogHeader);
             hdr->memoryLimit = hdr->memoryBase + maxBytesTotal;

Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,11 @@ class MapViewHolder`
`22`	`22`	`#endif // STRESS_LOG`
`23`	`23`	`#define STRESS_LOG_READONLY`
`24`	`24`	`#include "../../../inc/stresslog.h"`
	`25`	`+#include "StressMsgReader.h"`
`25`	`26`
`26`	`27`
`27`	`28`	`void GcHistClear();`
`28`		`-void GcHistAddLog(LPCSTR msg, StressMsg* stressMsg);`
	`29`	`+void GcHistAddLog(LPCSTR msg, StressMsgReader stressMsg);`
`29`	`30`
`30`	`31`
`31`	`32`	`/*********************************************************************************/`
`@@ -57,7 +58,7 @@ ThreadStressLog* ThreadStressLog::FindLatestThreadLog() const`
`57`	`58`	`for (const ThreadStressLog* ptr = this; ptr != NULL; ptr = ptr->next)`
`58`	`59`	`{`
`59`	`60`	`if (ptr->readPtr != NULL)`
`60`		`- if (latestLog == 0 \|\| ptr->readPtr->GetTimeStamp() > latestLog->readPtr->GetTimeStamp())`
	`61`	`+ if (latestLog == 0 \|\| StressMsgReader(ptr->readPtr).GetTimeStamp() > StressMsgReader(latestLog->readPtr).GetTimeStamp())`
`61`	`62`	`latestLog = ptr;`
`62`	`63`	`}`
`63`	`64`	`return const_cast<ThreadStressLog*>(latestLog);`
`@@ -423,9 +424,9 @@ HRESULT StressLog::Dump(ULONG64 outProcLog, const char* fileName, struct IDebugD`
`423`	`424`
`424`	`425`	`// TODO: fix on 64 bit`
`425`	`426`	`inProcPtr->Activate ();`
`426`		`- if (inProcPtr->readPtr->GetTimeStamp() > lastTimeStamp)`
	`427`	`+ if (StressMsgReader(inProcPtr->readPtr).GetTimeStamp() > lastTimeStamp)`
`427`	`428`	`{`
`428`		`- lastTimeStamp = inProcPtr->readPtr->GetTimeStamp();`
	`429`	`+ lastTimeStamp = StressMsgReader(inProcPtr->readPtr).GetTimeStamp();`
`429`	`430`	`}`
`430`	`431`
`431`	`432`	`outProcPtr = TO_CDADDR(inProcPtr->next);`
`@@ -488,40 +489,40 @@ HRESULT StressLog::Dump(ULONG64 outProcLog, const char* fileName, struct IDebugD`
`488`	`489`	`break;`
`489`	`490`	`}`
`490`	`491`
`491`		`- StressMsg* latestMsg = latestLog->readPtr;`
`492`		`- if (latestMsg->GetFormatOffset() != 0 && !latestLog->CompletedDump())`
	`492`	`+ StressMsgReader latestMsg = latestLog->readPtr;`
	`493`	`+ if (latestMsg.GetFormatOffset() != 0 && !latestLog->CompletedDump())`
`493`	`494`	`{`
`494`		`- TADDR taFmt = (latestMsg->GetFormatOffset()) + TO_TADDR(g_hThisInst);`
	`495`	`+ TADDR taFmt = (latestMsg.GetFormatOffset()) + TO_TADDR(g_hThisInst);`
`495`	`496`	`hr = memCallBack->ReadVirtual(TO_CDADDR(taFmt), format, 256, 0);`
`496`	`497`	`if (hr != S_OK)`
`497`	`498`	`strcpy_s(format, ARRAY_SIZE(format), "Could not read address of format string");`
`498`	`499`
`499`		`- double deltaTime = ((double) (latestMsg->GetTimeStamp() - inProcLog.startTimeStamp)) / inProcLog.tickFrequency;`
	`500`	`+ double deltaTime = ((double) (latestMsg.GetTimeStamp() - inProcLog.startTimeStamp)) / inProcLog.tickFrequency;`
`500`	`501`	`if (bDoGcHist)`
`501`	`502`	`{`
`502`	`503`	`if (strcmp(format, ThreadStressLog::TaskSwitchMsg()) == 0)`
`503`	`504`	`{`
`504`		`- latestLog->threadId = (unsigned)(size_t)latestMsg->args[0];`
	`505`	`+ latestLog->threadId = (unsigned)(size_t)latestMsg.GetArgs()[0];`
`505`	`506`	`}`
`506`	`507`	`GcHistAddLog(format, latestMsg);`
`507`	`508`	`}`
`508`	`509`	`else`
`509`	`510`	`{`
`510`	`511`	`if (strcmp(format, ThreadStressLog::TaskSwitchMsg()) == 0)`
`511`	`512`	`{`
`512`		`- fprintf (file, "Task was switched from %x\n", (unsigned)(size_t)latestMsg->args[0]);`
`513`		`- latestLog->threadId = (unsigned)(size_t)latestMsg->args[0];`
	`513`	`+ fprintf (file, "Task was switched from %x\n", (unsigned)(size_t)latestMsg.GetArgs()[0]);`
	`514`	`+ latestLog->threadId = (unsigned)(size_t)latestMsg.GetArgs()[0];`
`514`	`515`	`}`
`515`	`516`	`else`
`516`	`517`	`{`
`517`		`- args = latestMsg->args;`
`518`		`- formatOutput(memCallBack, file, format, (unsigned)latestLog->threadId, deltaTime, latestMsg->GetFacility(), args);`
	`518`	`+ args = latestMsg.GetArgs();`
	`519`	`+ formatOutput(memCallBack, file, format, (unsigned)latestLog->threadId, deltaTime, latestMsg.GetFacility(), args);`
`519`	`520`	`}`
`520`	`521`	`}`
`521`	`522`	`msgCtr++;`
`522`	`523`	`}`
`523`	`524`
`524`		`- latestLog->readPtr = latestLog->AdvanceRead(latestMsg->GetNumberOfArgs());`
	`525`	`+ latestLog->readPtr = latestLog->AdvanceRead(latestMsg.GetNumberOfArgs());`
`525`	`526`	`if (latestLog->CompletedDump())`
`526`	`527`	`{`
`527`	`528`	`latestLog->readPtr = NULL;`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ bool IsInCantAllocStressLogRegion()`
`40`	`40`
`41`	`41`	`#include <stddef.h>`
`42`	`42`	`#include "../../../inc/stresslog.h"`
	`43`	`+#include "StressMsgReader.h"`
`43`	`44`
`44`	`45`	`size_t StressLog::writing_base_address;`
`45`	`46`	`size_t StressLog::reading_base_address;`
`@@ -67,7 +68,7 @@ void GcHistClear()`
`67`	`68`	`{`
`68`	`69`	`}`
`69`	`70`
`70`		`-void GcHistAddLog(LPCSTR msg, StressMsg* stressMsg)`
	`71`	`+void GcHistAddLog(LPCSTR msg, StressMsgReader stressMsg)`
`71`	`72`	`{`
`72`	`73`	`}`
`73`	`74`
`@@ -531,7 +532,7 @@ bool FilterMessage(StressLog::StressLogHeader* hdr, ThreadStressLog* tsl, uint32`
`531`	`532`	`struct StressThreadAndMsg`
`532`	`533`	`{`
`533`	`534`	`uint64_t threadId;`
`534`		`- StressMsg* msg;`
	`535`	`+ StressMsgReader msg;`
`535`	`536`	`uint64_t msgId;`
`536`	`537`	`};`
`537`	`538`
`@@ -540,9 +541,9 @@ int CmpMsg(const void* p1, const void* p2)`
`540`	`541`	`const StressThreadAndMsg* msg1 = (const StressThreadAndMsg*)p1;`
`541`	`542`	`const StressThreadAndMsg* msg2 = (const StressThreadAndMsg*)p2;`
`542`	`543`
`543`		`- if (msg1->msg->GetTimeStamp() < msg2->msg->GetTimeStamp())`
	`544`	`+ if (msg1->msg.GetTimeStamp() < msg2->msg.GetTimeStamp())`
`544`	`545`	`return 1;`
`545`		`- if (msg1->msg->GetTimeStamp() > msg2->msg->GetTimeStamp())`
	`546`	`+ if (msg1->msg.GetTimeStamp() > msg2->msg.GetTimeStamp())`
`546`	`547`	`return -11;`
`547`	`548`
`548`	`549`	`if (msg1->threadId < msg2->threadId)`
`@@ -564,7 +565,7 @@ struct ThreadStressLogDesc`
`564`	`565`	`volatile LONG workStarted;`
`565`	`566`	`volatile LONG workFinished;`
`566`	`567`	`ThreadStressLog* tsl;`
`567`		`- StressMsg* earliestMessage;`
	`568`	`+ StressMsgReader earliestMessage;`
`568`	`569`
`569`	`570`	`ThreadStressLogDesc() : workStarted(0), workFinished(0), tsl(nullptr), earliestMessage(nullptr)`
`570`	`571`	`{`
`@@ -584,7 +585,7 @@ static double s_timeFilterStart = 0;`
`584`	`585`	`static double s_timeFilterEnd = 0;`
`585`	`586`	`static const char* s_outputFileName = nullptr;`
`586`	`587`
`587`		`-static StressLog::StressLogHeader* s_hdr;`
	`588`	`+StressLog::StressLogHeader* s_hdr;`
`588`	`589`
`589`	`590`	`static bool s_fPrintFormatStrings;`
`590`	`591`
`@@ -1056,7 +1057,7 @@ bool ParseOptions(int argc, char* argv[])`
`1056`	`1057`	`return true;`
`1057`	`1058`	`}`
`1058`	`1059`
`1059`		`-static void IncludeMessage(uint64_t threadId, StressMsg* msg)`
	`1060`	`+static void IncludeMessage(uint64_t threadId, StressMsgReader msg)`
`1060`	`1061`	`{`
`1061`	`1062`	`LONGLONG msgCount = InterlockedIncrement64(&s_msgCount) - 1;`
`1062`	`1063`	`if (msgCount < MAX_MESSAGE_COUNT)`
`@@ -1089,10 +1090,10 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)`
`1089`	`1090`	`wrappedWriteThreadCount++;`
`1090`	`1091`	`}`
`1091`	`1092`	`// printf("thread: %zx\n", tsl->threadId);`
`1092`		`- StressMsg* msg = StressLog::TranslateMemoryMappedPointer(tsl->curPtr);`
	`1093`	`+ void* msg = StressLog::TranslateMemoryMappedPointer(tsl->curPtr);`
`1093`	`1094`	`StressLogChunk* slc = StressLog::TranslateMemoryMappedPointer(tsl->curWriteChunk);`
`1094`	`1095`	`int chunkCount = 0;`
`1095`		`- StressMsg* prevMsg = nullptr;`
	`1096`	`+ void* prevMsg = nullptr;`
`1096`	`1097`	`while (true)`
`1097`	`1098`	`{`
`1098`	`1099`	`// printf("stress log chunk %zx\n", (size_t)slc);`
`@@ -1135,14 +1136,15 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)`
`1135`	`1136`	`{`
`1136`	`1137`	`while (p < end && *p == 0)`
`1137`	`1138`	`p++;`
`1138`		`- msg = (StressMsg*)p;`
	`1139`	`+ msg = (void*)p;`
`1139`	`1140`	`}`
`1140`		`- StressMsg* endMsg = (StressMsg*)end;`
	`1141`	`+ void* endMsg = (void*)end;`
`1141`	`1142`	`while (msg < endMsg)`
`1142`	`1143`	`{`
	`1144`	`+ StressMsgReader msgReader(msg);`
`1143`	`1145`	`totalMsgCount++;`
`1144`		`- char* format = (char*)(hdr->moduleImage + msg->GetFormatOffset());`
`1145`		`- double deltaTime = ((double)(msg->GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;`
	`1146`	`+ char* format = (char*)(hdr->moduleImage + msgReader.GetFormatOffset());`
	`1147`	`+ double deltaTime = ((double)(msgReader.GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;`
`1146`	`1148`	`bool fIgnoreMessage = false;`
`1147`	`1149`	`if (fTimeFilter)`
`1148`	`1150`	`{`
`@@ -1156,17 +1158,17 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)`
`1156`	`1158`	`fIgnoreMessage = true;`
`1157`	`1159`	`}`
`1158`	`1160`	`}`
`1159`		`- int numberOfArgs = msg->GetNumberOfArgs();`
	`1161`	`+ int numberOfArgs = msgReader.GetNumberOfArgs();`
`1160`	`1162`	`if (!fIgnoreMessage)`
`1161`	`1163`	`{`
`1162`		`- bool fIncludeMessage = s_showAllMessages \|\| FilterMessage(hdr, tsl, msg->GetFacility(), format, deltaTime, numberOfArgs, msg->args);`
	`1164`	`+ bool fIncludeMessage = s_showAllMessages \|\| FilterMessage(hdr, tsl, msgReader.GetFacility(), format, deltaTime, numberOfArgs, msgReader.GetArgs());`
`1163`	`1165`	`if (!fIncludeMessage && s_valueFilterCount > 0)`
`1164`	`1166`	`{`
`1165`	`1167`	`for (int i = 0; i < numberOfArgs; i++)`
`1166`	`1168`	`{`
`1167`	`1169`	`for (int j = 0; j < s_valueFilterCount; j++)`
`1168`	`1170`	`{`
`1169`		`- if (s_valueFilter[j].start <= (size_t)msg->args[i] && (size_t)msg->args[i] <= s_valueFilter[j].end)`
	`1171`	`+ if (s_valueFilter[j].start <= (size_t)msgReader.GetArgs()[i] && (size_t)msgReader.GetArgs()[i] <= s_valueFilter[j].end)`
`1170`	`1172`	`{`
`1171`	`1173`	`fIncludeMessage = true;`
`1172`	`1174`	`break;`
`@@ -1182,7 +1184,7 @@ DWORD WINAPI ProcessStresslogWorker(LPVOID)`
`1182`	`1184`	`}`
`1183`	`1185`	`}`
`1184`	`1186`	`prevMsg = msg;`
`1185`		`- msg = (StressMsg*)&msg->args[numberOfArgs];`
	`1187`	`+ msg = (StressMsg*)&msgReader.GetArgs()[numberOfArgs];`
`1186`	`1188`	`}`
`1187`	`1189`	`if (slc == StressLog::TranslateMemoryMappedPointer(tsl->chunkListTail) && !tsl->writeHasWrapped)`
`1188`	`1190`	`break;`
`@@ -1233,16 +1235,16 @@ static void PrintFriendlyNumber(LONGLONG n)`
`1233`	`1235`	`printf("%11.9f billion", n / 1000000000.0);`
`1234`	`1236`	`}`
`1235`	`1237`
`1236`		`-static void PrintMessage(CorClrData& corClrData, FILE outputFile, uint64_t threadId, StressMsg msg)`
	`1238`	`+static void PrintMessage(CorClrData& corClrData, FILE *outputFile, uint64_t threadId, StressMsgReader msg)`
`1237`	`1239`	`{`
`1238`	`1240`	`void* argBuffer[StressMsg::maxArgCnt];`
`1239`		`- char* format = (char*)(s_hdr->moduleImage + msg->GetFormatOffset());`
`1240`		`- int numberOfArgs = msg->GetNumberOfArgs();`
	`1241`	`+ char* format = (char*)(s_hdr->moduleImage + msg.GetFormatOffset());`
	`1242`	`+ int numberOfArgs = msg.GetNumberOfArgs();`
`1241`	`1243`	`for (int i = 0; i < numberOfArgs; i++)`
`1242`	`1244`	`{`
`1243`		`- argBuffer[i] = msg->args[i];`
	`1245`	`+ argBuffer[i] = msg.GetArgs()[i];`
`1244`	`1246`	`}`
`1245`		`- double deltaTime = ((double)(msg->GetTimeStamp() - s_hdr->startTimeStamp)) / s_hdr->tickFrequency;`
	`1247`	`+ double deltaTime = ((double)(msg.GetTimeStamp() - s_hdr->startTimeStamp)) / s_hdr->tickFrequency;`
`1246`	`1248`	`if (!s_printHexTidForGcThreads)`
`1247`	`1249`	`{`
`1248`	`1250`	`GcThread gcThread;`
`@@ -1255,7 +1257,7 @@ static void PrintMessage(CorClrData& corClrData, FILE *outputFile, uint64_t thre`
`1255`	`1257`	`threadId \|= 0x4000000000000000;`
`1256`	`1258`	`}`
`1257`	`1259`	`}`
`1258`		`- formatOutput(&corClrData, outputFile, format, threadId, deltaTime, msg->GetFacility(), argBuffer, s_fPrintFormatStrings);`
	`1260`	`+ formatOutput(&corClrData, outputFile, format, threadId, deltaTime, msg.GetFacility(), argBuffer, s_fPrintFormatStrings);`
`1259`	`1261`	`}`
`1260`	`1262`
`1261`	`1263`	`int ProcessStressLog(void* baseAddress, int argc, char* argv[])`
`@@ -1301,7 +1303,8 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])`
`1301`	`1303`	`StressLog::StressLogHeader* hdr = (StressLog::StressLogHeader*)baseAddress;`
`1302`	`1304`	`if (hdr->headerSize != sizeof(*hdr) \|\|`
`1303`	`1305`	`hdr->magic != (uint32_t)"LRTS" \|\|`
`1304`		`- hdr->version != 0x00010001)`
	`1306`	`+ (hdr->version != 0x00010001 &&`
	`1307`	`+ hdr->version != 0x00010002))`
`1305`	`1308`	`{`
`1306`	`1309`	`printf("Unrecognized file format\n");`
`1307`	`1310`	`return 1;`
`@@ -1383,8 +1386,8 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])`
`1383`	`1386`	`int remMsgCount = 0;`
`1384`	`1387`	`for (int msgIndex = 0; msgIndex < s_msgCount; msgIndex++)`
`1385`	`1388`	`{`
`1386`		`- StressMsg* msg = s_threadMsgBuf[msgIndex].msg;`
`1387`		`- double deltaTime = ((double)(msg->GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;`
	`1389`	`+ StressMsgReader msg = s_threadMsgBuf[msgIndex].msg;`
	`1390`	`+ double deltaTime = ((double)(msg.GetTimeStamp() - hdr->startTimeStamp)) / hdr->tickFrequency;`
`1388`	`1391`	`if (startTime <= deltaTime && deltaTime <= endTime)`
`1389`	`1392`	`{`
`1390`	`1393`	`s_threadMsgBuf[remMsgCount] = s_threadMsgBuf[msgIndex];`
`@@ -1463,7 +1466,7 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])`
`1463`	`1466`	`for (LONGLONG i = 0; i < s_msgCount; i++)`
`1464`	`1467`	`{`
`1465`	`1468`	`uint64_t threadId = (unsigned)s_threadMsgBuf[i].threadId;`
`1466`		`- StressMsg* msg = s_threadMsgBuf[i].msg;`
	`1469`	`+ StressMsgReader msg = s_threadMsgBuf[i].msg;`
`1467`	`1470`	`PrintMessage(corClrData, outputFile, threadId, msg);`
`1468`	`1471`	`}`
`1469`	`1472`
`@@ -1500,7 +1503,7 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])`
`1500`	`1503`	`LONGLONG earliestStartCount = s_msgCount;`
`1501`	`1504`	`for (int threadStressLogIndex = 0; threadStressLogIndex < s_threadStressLogCount; threadStressLogIndex++)`
`1502`	`1505`	`{`
`1503`		`- StressMsg* msg = s_threadStressLogDesc[threadStressLogIndex].earliestMessage;`
	`1506`	`+ StressMsgReader msg = s_threadStressLogDesc[threadStressLogIndex].earliestMessage;`
`1504`	`1507`	`if (msg == nullptr)`
`1505`	`1508`	`continue;`
`1506`	`1509`	`bool fIncludeMessage = s_printEarliestMessages;`
`@@ -1525,7 +1528,7 @@ int ProcessStressLog(void* baseAddress, int argc, char* argv[])`
`1525`	`1528`	`for (LONGLONG i = earliestStartCount; i < s_msgCount; i++)`
`1526`	`1529`	`{`
`1527`	`1530`	`uint64_t threadId = (unsigned)s_threadMsgBuf[i].threadId;`
`1528`		`- StressMsg* msg = s_threadMsgBuf[i].msg;`
	`1531`	`+ StressMsgReader msg = s_threadMsgBuf[i].msg;`
`1529`	`1532`	`PrintMessage(corClrData, outputFile, threadId, msg);`
`1530`	`1533`	`}`
`1531`	`1534`	`}`