public ClrmdSegment(ClrmdHeap heap, IHeapHelpers helpers, ISegmentData data)
{
if (helpers is null)
{
throw new ArgumentNullException(nameof(helpers));
}
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
_helpers = helpers;
_clrmdHeap = heap;
LogicalHeap = data.LogicalHeap;
Start = data.Start;
End = data.End;
IsLargeObjectSegment = data.IsLargeObjectSegment;
IsEphemeralSegment = data.IsEphemeralSegment;
ReservedEnd = data.ReservedEnd;
CommittedEnd = data.CommittedEnd;
Gen0Start = data.Gen0Start;
Gen0Length = data.Gen0Length;
Gen1Start = data.Gen1Start;
Gen1Length = data.Gen1Length;
Gen2Start = data.Gen2Start;
Gen2Length = data.Gen2Length;
_markers = new ulong[MarkerCount];
}
public ClrmdSegment(ClrmdHeap heap, IHeapHelpers helpers, ISegmentData data)
{
if (helpers is null)
{
throw new ArgumentNullException(nameof(helpers));
}
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
_helpers = helpers;
_clrmdHeap = heap;
LogicalHeap = data.LogicalHeap;
IsLargeObjectSegment = data.IsLargeObjectSegment;
IsPinnedObjectSegment = data.IsPinnedObjectSegment;
IsEphemeralSegment = data.IsEphemeralSegment;
ObjectRange = new MemoryRange(data.Start, data.End);
ReservedMemory = new MemoryRange(data.CommittedEnd, data.ReservedEnd);
CommittedMemory = new MemoryRange(data.BaseAddress, data.CommittedEnd);
Generation0 = MemoryRange.CreateFromLength(data.Gen0Start, data.Gen0Length);
Generation1 = MemoryRange.CreateFromLength(data.Gen1Start, data.Gen1Length);
Generation2 = MemoryRange.CreateFromLength(data.Gen2Start, data.Gen2Length);
_markers = new ulong[MarkerCount];
}
internal HeapSegment(RuntimeBase clr, ISegmentData segment, SubHeap subHeap, bool large, HeapBase heap)
{
_clr = clr;
_large = large;
_segment = segment;
_heap = heap;
_subHeap = subHeap;
}
internal override ISegmentData GetSegmentData(ulong segmentAddr)
{
if (CLRVersion == DesktopVersion.v2)
{
return(Request <ISegmentData, V2SegmentData>(DacRequests.HEAPSEGMENT_DATA, segmentAddr));
}
ISegmentData result = Request <ISegmentData, SegmentData>(DacRequests.HEAPSEGMENT_DATA, segmentAddr);
if (IntPtr.Size == 4 && result != null)
{
// fixup pointers
SegmentData s = (SegmentData)result;
result = new SegmentData(ref s);
}
return(result);
}
protected void InitSegments(RuntimeBase runtime)
{
// Populate segments
SubHeap[] heaps;
if (runtime.GetHeaps(out heaps))
{
var segments = new List <HeapSegment>();
foreach (var heap in heaps)
{
if (heap != null)
{
ISegmentData seg = runtime.GetSegmentData(heap.FirstLargeSegment);
while (seg != null)
{
var segment = new HeapSegment(runtime, seg, heap, true, this);
segments.Add(segment);
UpdateSegmentData(segment);
seg = runtime.GetSegmentData(seg.Next);
}
seg = runtime.GetSegmentData(heap.FirstSegment);
while (seg != null)
{
var segment = new HeapSegment(runtime, seg, heap, false, this);
segments.Add(segment);
UpdateSegmentData(segment);
seg = runtime.GetSegmentData(seg.Next);
}
}
}
UpdateSegments(segments.ToArray());
}
else
{
_segments = new ClrSegment[0];
}
}
/// <summary>
/// Enumerates regions of memory which CLR has allocated with a description of what data
/// resides at that location. Note that this does not return every chunk of address space
/// that CLR allocates.
/// </summary>
/// <returns>An enumeration of memory regions in the process.</returns>
public override IEnumerable <ClrMemoryRegion> EnumerateMemoryRegions()
{
// Enumerate GC Segment regions.
IHeapDetails[] heaps;
if (ServerGC)
{
heaps = new IHeapDetails[HeapCount];
int i = 0;
ulong[] heapList = GetServerHeapList();
if (heapList != null)
{
foreach (ulong addr in heapList)
{
heaps[i++] = GetSvrHeapDetails(addr);
if (i == heaps.Length)
{
break;
}
}
}
else
{
heaps = new IHeapDetails[0];
}
}
else
{
Debug.Assert(HeapCount == 1);
heaps = new IHeapDetails[1];
heaps[0] = GetWksHeapDetails();
}
HashSet <ulong> addresses = new HashSet <ulong>();
for (int i = 0; i < heaps.Length; ++i)
{
// Small heap
ISegmentData segment = GetSegmentData(heaps[i].FirstHeapSegment);
while (segment != null)
{
Debug.Assert(segment.Start < segment.Committed);
GCSegmentType type = segment.Address == heaps[i].EphemeralSegment ? GCSegmentType.Ephemeral : GCSegmentType.Regular;
yield return(new MemoryRegion(this, segment.Start, segment.Committed - segment.Start, ClrMemoryRegionType.GCSegment, (uint)i, type));
if (segment.Committed <= segment.Reserved)
{
yield return(new MemoryRegion(this, segment.Committed, segment.Reserved - segment.Committed, ClrMemoryRegionType.ReservedGCSegment, (uint)i, type));
}
if (segment.Address == segment.Next || segment.Address == 0)
{
break;
}
if (!addresses.Add(segment.Next))
{
break;
}
segment = GetSegmentData(segment.Next);
}
segment = GetSegmentData(heaps[i].FirstLargeHeapSegment);
while (segment != null)
{
Debug.Assert(segment.Start < segment.Committed);
yield return(new MemoryRegion(this, segment.Start, segment.Committed - segment.Start, ClrMemoryRegionType.GCSegment, (uint)i, GCSegmentType.LargeObject));
if (segment.Committed <= segment.Reserved)
{
yield return(new MemoryRegion(
this,
segment.Committed,
segment.Reserved - segment.Committed,
ClrMemoryRegionType.ReservedGCSegment,
(uint)i,
GCSegmentType.LargeObject));
}
if (segment.Address == segment.Next || segment.Address == 0)
{
break;
}
if (!addresses.Add(segment.Next))
{
break;
}
segment = GetSegmentData(segment.Next);
}
}
// Enumerate handle table regions.
HashSet <ulong> regions = new HashSet <ulong>();
foreach (ClrHandle handle in EnumerateHandles())
{
if (!_dataReader.VirtualQuery(handle.Address, out VirtualQueryData vq))
{
continue;
}
if (regions.Contains(vq.BaseAddress))
{
continue;
}
regions.Add(vq.BaseAddress);
yield return(new MemoryRegion(this, vq.BaseAddress, vq.Size, ClrMemoryRegionType.HandleTableChunk, handle.AppDomain));
}
// Enumerate each AppDomain and Module specific heap.
AppDomainHeapWalker adhw = new AppDomainHeapWalker(this);
IAppDomainData ad = GetAppDomainData(SystemDomainAddress);
foreach (MemoryRegion region in adhw.EnumerateHeaps(ad))
{
yield return(region);
}
foreach (ulong module in EnumerateModules(ad))
{
foreach (MemoryRegion region in adhw.EnumerateModuleHeaps(ad, module))
{
yield return(region);
}
}
ad = GetAppDomainData(SharedDomainAddress);
foreach (MemoryRegion region in adhw.EnumerateHeaps(ad))
{
yield return(region);
}
foreach (ulong module in EnumerateModules(ad))
{
foreach (MemoryRegion region in adhw.EnumerateModuleHeaps(ad, module))
{
yield return(region);
}
}
IAppDomainStoreData ads = GetAppDomainStoreData();
if (ads != null)
{
ulong[] appDomains = GetAppDomainList(ads.Count);
if (appDomains != null)
{
foreach (ulong addr in appDomains)
{
ad = GetAppDomainData(addr);
foreach (MemoryRegion region in adhw.EnumerateHeaps(ad))
{
yield return(region);
}
foreach (ulong module in EnumerateModules(ad))
{
foreach (MemoryRegion region in adhw.EnumerateModuleHeaps(ad, module))
{
yield return(region);
}
}
}
}
}
// Enumerate each JIT code heap.
regions.Clear();
foreach (ICodeHeap jitHeap in EnumerateJitHeaps())
{
if (jitHeap.Type == CodeHeapType.Host)
{
if (_dataReader.VirtualQuery(jitHeap.Address, out VirtualQueryData vq))
{
yield return(new MemoryRegion(this, vq.BaseAddress, vq.Size, ClrMemoryRegionType.JitHostCodeHeap));
}
else
{
yield return(new MemoryRegion(this, jitHeap.Address, 0, ClrMemoryRegionType.JitHostCodeHeap));
}
}
else if (jitHeap.Type == CodeHeapType.Loader)
{
foreach (MemoryRegion region in adhw.EnumerateJitHeap(jitHeap.Address))
{
yield return(region);
}
}
}
}
public ISegmentExperimental SetSegmentData(ISegmentData segmentData)
{
return(this);
}
internal HeapSegment(RuntimeBase clr, ISegmentData segment, SubHeap subHeap, bool large, HeapBase heap)
{
_clr = clr;
_large = large;
_segment = segment;
_heap = heap;
_subHeap = subHeap;
}
public ISegmentExperimental SetSegmentData(ISegmentData segmentData)
{
Data = (AbstractSegmentData)segmentData;
Data.AttachSegmentDataState(this);
return(this);
}
