public IReadOnlyCollection <ObjectTypeStatistics> GetInstanceTypeStatistics([FromQuery(Name = "traversing-heap-mode")] TraversingHeapModes traversingMode)
{
var analyzer = new ObjectTypeStatisticsAnalyzer(_runtimeContext);
analyzer.TraversingHeapMode = traversingMode;
return(analyzer.GetObjectTypeStatistics());
}
private void LogLongestStrings(ILogger logger, TraversingHeapModes traversingMode, int count, int maxLength = 200)
{
foreach (var s in GetStrings(count, maxLength))
{
logger.LogInformation($"Length = {s.Length} symbols, Value = {s.Value}");
}
}
public IEnumerable <ClrObject> EnumerateObjects(TraversingHeapModes traversingMode)
{
return
(from obj in Heap.EnumerateObjects()
where obj.IsValid &&
FilterByWalkMode(traversingMode, obj.Address)
select obj);
}
private bool FilterByWalkMode(TraversingHeapModes traversingMode, ulong address)
{
return(traversingMode switch
{
TraversingHeapModes.Live => HeapIndex.HasRoot(address),
TraversingHeapModes.Dead => !HeapIndex.HasRoot(address),
TraversingHeapModes.All => true,
_ => throw new ArgumentOutOfRangeException(nameof(traversingMode), traversingMode, null),
});
private void WriteLog(ILogger logger, TraversingHeapModes traversingMode)
{
foreach (var timer in GetTimers(traversingMode))
{
logger.LogInformation($"{timer.Address} m_dueTime = {timer.DueTime}, m_period = {timer.Period}, m_canceled = {timer.Cancelled}");
if (timer.CancellationState != null)
{
logger.LogInformation($"CanBeCanceled: {timer.CancellationState.CanBeCanceled}");
logger.LogInformation($"IsCancellationRequested: {timer.CancellationState.IsCancellationRequested}");
logger.LogInformation($"IsCancellationCompleted: {timer.CancellationState.IsCancellationCompleted}");
}
}
}
private IEnumerable <ClrObject> GetLongestStrings(int count, TraversingHeapModes traversingMode)
{
var query =
from clrObject in Context.EnumerateObjectsByTypeName("System.String", traversingMode)
orderby clrObject.Size descending
select clrObject;
return(query.Take(count));
// var stringLength = clrObject.GetField<int>("_stringLength");
// var firstCharAddress = clrObject.Type.GetFieldByName("_firstChar").GetAddress(clrObject.Address);
//
// var bufferLength = Math.Min(stringLength * 2, 30 * 2);
// var buffer = new byte[bufferLength];
// heap.ReadMemory(firstCharAddress,buffer,0,
// bufferLength);
//
// Console.WriteLine($"Address: {clrObject.HexAddress}");
// Console.WriteLine($"Length: {stringLength}");
// Console.WriteLine($"Value: {System.Text.Encoding.Unicode.GetString(buffer)}...");
}
public IReadOnlyCollection <TimerQueueTimerInfo> GetTimers(TraversingHeapModes traversingMode)
{
var result = new List <TimerQueueTimerInfo>();
foreach (var address in Context.EnumerateObjectAddressesByTypeName("System.Threading.TimerQueueTimer", traversingMode))
{
var timerObjectType = Context.Heap.GetObjectType(address);
var state = timerObjectType.GetFieldByName("m_state").ReadObject(address, false);
var dueTime = timerObjectType.GetFieldByName("m_dueTime").Read <uint>(address, true);
var period = timerObjectType.GetFieldByName("m_period").Read <uint>(address, true);
var canceled = timerObjectType.GetFieldByName("m_canceled").Read <bool>(address, true);
// var timerCallback = timerObjectType.GetFieldByName("m_timerCallback")
// .GetValue(address);
// public delegate void TimerCallback(Object state);
//var timerCallbackObjectType = heap.GetObjectType((ulong)timerCallback);
CancellationTokenSourceInfo?cancellationTokenSourceInfo = null;
if (state.IsValid)
{
var stateObjectType = state.Type;
if (stateObjectType.Name == "System.Threading.CancellationTokenSource")
{
var cancellationTokenSourceProxy = new CancellationTokenSourceProxy(Context, state);
cancellationTokenSourceInfo = new(cancellationTokenSourceProxy.CanBeCanceled, cancellationTokenSourceProxy.IsCancellationRequested, cancellationTokenSourceProxy.IsCancellationCompleted);
}
}
var timerInfo = new TimerQueueTimerInfo(new(address), dueTime, period, canceled, cancellationTokenSourceInfo);
result.Add(timerInfo);
}
return(result);
}
private void WriteLog(ILogger logger, TraversingHeapModes traversingMode)
{
LogLongestStrings(logger, traversingMode, 10);
}
public async Task <ObjectTypeStatistics[]> GetInstanceTypeStatisticsAsync(TraversingHeapModes traversingMode)
{
return(await _httpClient.GetFromJsonAsync <ObjectTypeStatistics[]>($"dump/instance-type-statistics?traversing-heap-mode={traversingMode:G}"));
}
public IEnumerable <ClrObject> EnumerateObjectsByTypeName(string typeName, TraversingHeapModes traversingMode)
{
var clrType = Heap.GetTypeByName(typeName);
return(EnumerateObjects(traversingMode).Where(obj => obj.Type !.MethodTable == clrType.MethodTable));
}
public IEnumerable <ulong> EnumerateObjectAddressesByTypeName(string typeName, TraversingHeapModes traversingMode)
{
var clrType = Heap.GetTypeByName(typeName);
if (clrType == null)
{
throw new Exception($"Type '{typeName}' is not found");
}
return
(from clrObject in Heap.EnumerateObjects()
let type = clrObject.Type
where type != null && !type.IsFree && type.MethodTable == clrType.MethodTable &&
FilterByWalkMode(traversingMode, clrObject)
select clrObject.Address);
}
