Implement GetThreadStoreData in cDAC

Author: elinor-fung

docs/design/datacontracts/Thread.md

@@ -2,15 +2,16 @@
 
 This contract is for reading and iterating the threads of the process.
 
-## Data structures defined by contract
+## APIs of contract
+
 ``` csharp
-record struct DacThreadStoreData (
+record struct ThreadStoreData (
     int ThreadCount,
     TargetPointer FirstThread,
     TargetPointer FinalizerThread,
     TargetPointer GcThread);
 
-record struct DacThreadStoreCounts (
+record struct ThreadStoreCounts (
     int UnstartedThreadCount,
     int BackgroundThreadCount,
     int PendingThreadCount,
@@ -75,7 +76,7 @@ enum ThreadState
     TS_Detached               = 0x80000000,    // Thread was detached by DllMain
 }
 
-record struct DacThreadData (
+record struct ThreadData (
     uint ThreadId;
     TargetNUint OsThreadId;
     ThreadState State;
@@ -90,11 +91,10 @@ record struct DacThreadData (
 );
 ```
 
-## Apis of contract
 ``` csharp
-DacThreadStoreData GetThreadStoreData();
-DacThreadStoreCounts GetThreadCounts();
-DacThreadData GetThreadData(TargetPointer threadPointer);
+ThreadStoreData GetThreadStoreData();
+ThreadStoreCounts GetThreadCounts();
+ThreadData GetThreadData(TargetPointer threadPointer);
 TargetPointer GetNestedExceptionInfo(TargetPointer nestedExceptionPointer, out TargetPointer nextNestedException);
 TargetPointer GetManagedThreadObject(TargetPointer threadPointer);
 ```
@@ -106,34 +106,34 @@ TargetPointer GetManagedThreadObject(TargetPointer threadPointer);
 ``` csharp
 SListReader ThreadListReader = Contracts.SList.GetReader("Thread");
 
-DacThreadStoreData GetThreadStoreData()
+ThreadStoreData GetThreadStoreData()
 {
-    TargetPointer threadStore = Target.ReadGlobalTargetPointer("s_pThreadStore");
+    TargetPointer threadStore = Target.ReadGlobalPointer("s_pThreadStore");
     var runtimeThreadStore = new ThreadStore(Target, threadStore);
 
     TargetPointer firstThread = ThreadListReader.GetHead(runtimeThreadStore.SList.Pointer);
 
-    return new DacThreadStoreData(
+    return new ThreadStoreData(
         ThreadCount : runtimeThreadStore.m_ThreadCount,
         FirstThread: firstThread,
-        FinalizerThread: Target.ReadGlobalTargetPointer("g_pFinalizerThread"),
-        GcThread: Target.ReadGlobalTargetPointer("g_pSuspensionThread"));
+        FinalizerThread: Target.ReadGlobalPointer("g_pFinalizerThread"),
+        GCThread: Target.ReadGlobalPointer("g_pSuspensionThread"));
 }
 
 DacThreadStoreCounts GetThreadCounts()
 {
-    TargetPointer threadStore = Target.ReadGlobalTargetPointer("s_pThreadStore");
+    TargetPointer threadStore = Target.ReadGlobalPointer("s_pThreadStore");
     var runtimeThreadStore = new ThreadStore(Target, threadStore);
 
-    return new DacThreadStoreCounts(
+    return new ThreadStoreCounts(
         ThreadCount : runtimeThreadStore.m_ThreadCount,
         UnstartedThreadCount : runtimeThreadStore.m_UnstartedThreadCount,
         BackgroundThreadCount : runtimeThreadStore.m_BackgroundThreadCount,
         PendingThreadCount : runtimeThreadStore.m_PendingThreadCount,
         DeadThreadCount: runtimeThreadStore.m_DeadThreadCount,
 }
 
-DacThreadData GetThreadData(TargetPointer threadPointer)
+ThreadData GetThreadData(TargetPointer threadPointer)
 {
     var runtimeThread = new Thread(Target, threadPointer);
 
@@ -150,7 +150,7 @@ DacThreadData GetThreadData(TargetPointer threadPointer)
         firstNestedException = runtimeThread.m_ExceptionState.m_currentExInfo.m_pPrevNestedInfo;
     }
 
-    return new DacThread(
+    return new ThreadData(
         ThreadId : runtimeThread.m_ThreadId,
         OsThreadId : (OsThreadId)runtimeThread.m_OSThreadId,
         State : (ThreadState)runtimeThread.m_State,

docs/design/datacontracts/contract_csharp_api_design.cs

@@ -40,7 +40,7 @@ struct TargetPointer
     struct TargetNInt
     {
         public long Value;
-        // Add a full set of operators to support arithmetic as well as casting to/from TargetPointer 
+        // Add a full set of operators to support arithmetic as well as casting to/from TargetPointer
     }
 
     struct TargetNUInt
@@ -72,109 +72,53 @@ struct FieldLayout
         public FieldType Type;
     }
 
-    interface IAlgorithmContract
-    {
-        void Init();
-    }
-
     interface IContract
     {
         string Name { get; }
         uint Version { get; }
     }
-        class Target
+
+    class Target
     {
         // Users of the data contract may adjust this number to force re-reading of all data
         public int CurrentEpoch = 0;
 
-        sbyte ReadInt8(TargetPointer pointer);
-        byte ReadUInt8(TargetPointer pointer);
-        short ReadInt16(TargetPointer pointer);
-        ushort ReadUInt16(TargetPointer pointer);
-        int ReadInt32(TargetPointer pointer);
-        uint ReadUInt32(TargetPointer pointer);
-        long ReadInt64(TargetPointer pointer);
-        ulong ReadUInt64(TargetPointer pointer);
-        TargetPointer ReadTargetPointer(TargetPointer pointer);
-        TargetNInt ReadNInt(TargetPointer pointer);
-        TargetNUInt ReadNUint(TargetPointer pointer);
+        public T Read<T>(ulong address) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>;
+        TargetPointer ReadPointer(ulong address);
+
         byte[] ReadByteArray(TargetPointer pointer, ulong size);
         void FillByteArray(TargetPointer pointer, byte[] array, ulong size);
 
-        bool TryReadInt8(TargetPointer pointer, out sbyte value);
-        bool TryReadUInt8(TargetPointer pointer, out byte value);
-        bool TryReadInt16(TargetPointer pointer, out short value);
-        bool TryReadUInt16(TargetPointer pointer, out ushort value);
-        bool TryReadInt32(TargetPointer pointer, out int value);
-        bool TryReadUInt32(TargetPointer pointer, out uint value);
-        bool TryReadInt64(TargetPointer pointer, out long value);
-        bool TryReadUInt64(TargetPointer pointer, out ulong value);
-        bool TryReadTargetPointer(TargetPointer pointer, out TargetPointer value);
-        bool TryReadNInt(TargetPointer pointer, out TargetNInt value);
-        bool TryReadNUInt(TargetPointer pointer, out TargetNUInt value);
-        bool TryReadByteArray(TargetPointer pointer, ulong size, out byte[] value);
-        bool TryFillByteArray(TargetPointer pointer, byte[] array, ulong size);
-
         // If pointer is 0, then the return value will be 0
         TargetPointer GetTargetPointerForField(TargetPointer pointer, FieldLayout fieldLayout);
 
-        sbyte ReadGlobalInt8(string globalName);
-        byte ReadGlobalUInt8(string globalName);
-        short ReadGlobalInt16(string globalName);
-        ushort ReadGlobalUInt16(string globalName);
-        int ReadGlobalInt32(string globalName);
-        uint ReadGlobalUInt32(string globalName);
-        long ReadGlobalInt64(string globalName);
-        ulong ReadGlobalUInt64(string globalName);
-        TargetPointer ReadGlobalTargetPointer(string globalName);
-
-        bool TryReadGlobalInt8(string globalName, out sbyte value);
-        bool TryReadGlobalUInt8(string globalName, out byte value);
-        bool TryReadGlobalInt16(string globalName, out short value);
-        bool TryReadGlobalUInt16(string globalName, out ushort value);
-        bool TryReadGlobalInt32(string globalName, out int value);
-        bool TryReadGlobalUInt32(string globalName, out uint value);
-        bool TryReadGlobalInt64(string globalName, out long value);
-        bool TryReadGlobalUInt64(string globalName, out ulong value);
-        bool TryReadGlobalTargetPointer(string globalName, out TargetPointer value);
-
-        Contracts Contract { get; }
-
-        partial class Contracts
-        {
-            FieldLayout GetFieldLayout(string typeName, string fieldName);
-            bool TryGetFieldLayout(string typeName, string fieldName, out FieldLayout layout);
-            int GetTypeSize(string typeName);
-            bool TryGetTypeSize(string typeName, out int size);
+        T ReadGlobal<T>(string globalName) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>;
+        TargetPointer ReadGlobalPointer(string globalName);
 
-            object GetContract(string contractName);
-            bool TryGetContract(string contractName, out object contract);
+        Contracts.Registry Contracts { get; }
+    }
 
+    // Types defined by contracts live here
+    namespace Contracts
+    {
+        class Registry
+        {
             // Every contract that is defined has a field here. As an example this document defines a MethodTableContract
             // If the contract is not supported by the runtime in use, then the implementation of the contract will be the base type which
             // is defined to throw if it is ever used.
 
             // List of contracts will be inserted here by source generator
             MethodTableContract MethodTableContract;
         }
-    }
-
-    // Types defined by contracts live here
-    namespace ContractDefinitions
-    {
-        class CompositeContract
-        {
-            List<Tuple<string, uint>> Subcontracts;
-        }
 
         class DataStructureContract
         {
             string MethodTableName {get;}
             List<Tuple<string, FieldLayout>> FieldData;
         }
 
-        // Insert Algorithmic Contract definitions here
-        class MethodTableContract
+        // Insert contract definitions here
+        interface MethodTableContract : IContract
         {
             public virtual int DynamicTypeID(TargetPointer methodTablePointer) { throw new NotImplementedException(); }
             public virtual int BaseSize(TargetPointer methodTablePointer) { throw new NotImplementedException(); }
@@ -207,7 +151,7 @@ public class FeatureFlags_2
         }
 
         [DataContractAlgorithm(1)]
-        class MethodTableContract_1 : ContractDefinitions.MethodTableContract, IAlgorithmContract
+        readonly struct MethodTableContract_1 : Contracts.MethodTableContract
         {
             DataContracts.Target Target;
             readonly uint ContractVersion;
@@ -219,7 +163,7 @@ class MethodTableContract_1 : ContractDefinitions.MethodTableContract, IAlgorith
 
         // This is used for version 2 and 3 of the contract, where the dynamic type id is no longer present, and baseSize has a new limitation in that it can only be a value up to 0x1FFFFFFF in v3
         [DataContractAlgorithm(2, 3)]
-        class MethodTableContract_2 : ContractDefinitions.MethodTableContract, IAlgorithmContract
+        readonly struct MethodTableContract_2 : Contracts.MethodTableContract
         {
             DataContracts.Target Target;
             readonly uint ContractVersion;

src/coreclr/debug/runtimeinfo/datadescriptor.h

@@ -111,8 +111,12 @@ CDAC_TYPE_END(Thread)
 
 CDAC_TYPE_BEGIN(ThreadStore)
 CDAC_TYPE_INDETERMINATE(ThreadStore)
-CDAC_TYPE_FIELD(ThreadStore, /*omit type*/, ThreadCount, cdac_offsets<ThreadStore>::ThreadCount)
-CDAC_TYPE_FIELD(ThreadStore, /*omit type*/, ThreadList, cdac_offsets<ThreadStore>::ThreadList)
+CDAC_TYPE_FIELD(ThreadStore, /*SLink*/, FirstThreadLink, cdac_offsets<ThreadStore>::FirstThreadLink)
+CDAC_TYPE_FIELD(ThreadStore, /*int32*/, ThreadCount, cdac_offsets<ThreadStore>::ThreadCount)
+CDAC_TYPE_FIELD(ThreadStore, /*int32*/, UnstartedCount, cdac_offsets<ThreadStore>::UnstartedCount)
+CDAC_TYPE_FIELD(ThreadStore, /*int32*/, BackgroundCount, cdac_offsets<ThreadStore>::BackgroundCount)
+CDAC_TYPE_FIELD(ThreadStore, /*int32*/, PendingCount, cdac_offsets<ThreadStore>::PendingCount)
+CDAC_TYPE_FIELD(ThreadStore, /*int32*/, DeadCount, cdac_offsets<ThreadStore>::DeadCount)
 CDAC_TYPE_END(ThreadStore)
 
 CDAC_TYPE_BEGIN(GCHandle)
@@ -123,6 +127,8 @@ CDAC_TYPES_END()
 
 CDAC_GLOBALS_BEGIN()
 CDAC_GLOBAL_POINTER(ThreadStore, &ThreadStore::s_pThreadStore)
+CDAC_GLOBAL_POINTER(FinalizerThread, &::g_pFinalizerThread)
+CDAC_GLOBAL_POINTER(GCThread, &::g_pSuspensionThread)
 #if FEATURE_EH_FUNCLETS
 CDAC_GLOBAL(FeatureEHFunclets, uint8, 1)
 #else

src/coreclr/inc/slist.h

@@ -26,6 +26,8 @@
 #ifndef _H_SLIST_
 #define _H_SLIST_
 
+#include "cdacoffsets.h"
+
 //------------------------------------------------------------------
 // struct SLink, to use a singly linked list
 // have a data member m_Link of type SLink in your class
@@ -118,6 +120,8 @@ class SList
     PTR_SLink m_pHead;
     PTR_SLink m_pTail;
 
+    template<typename T> friend struct ::cdac_offsets;
+
     // get the list node within the object
     static SLink* GetLink (T* pLink)
     {

src/coreclr/vm/threads.h

@@ -4307,8 +4307,12 @@ class ThreadStore
 template<>
 struct cdac_offsets<ThreadStore>
 {
-    static constexpr size_t ThreadList = offsetof(ThreadStore, m_ThreadList);
+    static constexpr size_t FirstThreadLink = offsetof(ThreadStore, m_ThreadList) + offsetof(ThreadList, m_link);
     static constexpr size_t ThreadCount = offsetof(ThreadStore, m_ThreadCount);
+    static constexpr size_t UnstartedCount = offsetof(ThreadStore, m_UnstartedThreadCount);
+    static constexpr size_t BackgroundCount = offsetof(ThreadStore, m_BackgroundThreadCount);
+    static constexpr size_t PendingCount = offsetof(ThreadStore, m_PendingThreadCount);
+    static constexpr size_t DeadCount = offsetof(ThreadStore, m_DeadThreadCount);
 };
 
 struct TSSuspendHelper {

src/native/managed/cdacreader/src/Constants.cs

@@ -9,6 +9,9 @@ internal static class Globals
     {
         // See src/coreclr/debug/runtimeinfo/datadescriptor.h
         internal const string ThreadStore = nameof(ThreadStore);
+        internal const string FinalizerThread = nameof(FinalizerThread);
+        internal const string GCThread = nameof(GCThread);
+
         internal const string SOSBreakingChangeVersion = nameof(SOSBreakingChangeVersion);
     }
 }