private static void TestProperties(ClrRuntime runtime) { ClrThread thread = runtime.Threads.Where(t => !t.IsFinalizer).Single(); ClrException ex = thread.CurrentException; Assert.IsNotNull(ex); Assert.AreEqual("IOE Message", ex.Message); Assert.AreEqual("System.InvalidOperationException", ex.Type.Name); Assert.IsNotNull(ex.Inner); }
public static void TestProperties(ClrRuntime runtime) { ClrThread thread = runtime.Threads.Where(t => !t.IsFinalizer).Single(); ClrException ex = thread.CurrentException; Assert.IsNotNull(ex); ExceptionTestData testData = TestTargets.NestedExceptionData; Assert.AreEqual(testData.OuterExceptionMessage, ex.Message); Assert.AreEqual(testData.OuterExceptionType, ex.Type.Name); Assert.IsNotNull(ex.Inner); }
private void ShowCLRRuntimeInformation(DataTarget target) { rtxtCLRInfor.Clear(); foreach (var clr in target.ClrVersions) { AppendText($"Version:\t{clr.Version.ToString()}"); AppendText($"Module: \t{clr.ModuleInfo.ToString()}"); } AppendText(""); ClrRuntime runtime = target.ClrVersions.First().CreateRuntime(); AppendText("App Domains:"); AppendText(""); var domains = new List <ClrAppDomain> { runtime.SystemDomain, runtime.SharedDomain }; domains.AddRange(runtime.AppDomains.Select(x => x)); foreach (var domain in domains) { AppendText($" ID: {domain.Id}"); AppendText($" Name: {domain.Name}"); AppendText($" Address: {domain.Address}"); AppendText($" ApplicationBase: {domain.ApplicationBase}"); AppendText($" ConfigurationFile: {domain.ConfigurationFile}"); AppendText(""); AppendText(" Modules:" + Environment.NewLine); foreach (ClrModule module in domain.Modules) { AppendText($" Module: { module.Name}"); AppendText($" AssemblyName: { module.AssemblyName}"); AppendText(""); } } }
private static void PrintHeapSegments(ClrRuntime runtime, StreamWriter sw) { sw.WriteLine("{0,12} {1,12} {2,12} {3,12} {4,4} {5}", "Start", "End", "CommittedEnd", "ReservedEnd", "Heap", "Type"); foreach (ClrSegment segment in runtime.Heap.Segments) { string type; if (segment.IsEphemeral) { type = "Ephemeral"; } else if (segment.IsLarge) { type = "Large"; } else { type = "Gen2"; } sw.WriteLine($"{segment.Start,12:X} {segment.End,12:X} {segment.CommittedEnd,12:X} {segment.ReservedEnd,12:X} {segment.ProcessorAffinity,4} {type}"); } }
public void DumpHeapStat() { using DataTarget dt = TestTargets.Types.LoadFullDump(); using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrHeap heap = runtime.Heap; var results = heap.DumpHeapStat(0); var all = results.ToList(); Assert.Equal(167, all.Count); Assert.Equal <(ulong, int, long)>((0x00007ff9fd29e768, 1, 24), GetRowData("System.Resources.FastResourceComparer")); Assert.Equal <(ulong, int, long)>((0x00007ff9fd295e70, 24, 36152), GetRowData("System.Object[]")); Assert.Equal <(ulong, int, long)>((0x00007ff9fd2959c0, 301, 22700), GetRowData("System.String")); (ulong methodTable, int instances, long totalSize) GetRowData(string typeName) { var objectArray = all.Where(a => a.type.Name.Equals(typeName)).Single(); var size = objectArray.size; var mt = objectArray.type.MethodTable; return(mt, objectArray.objects.Count(), objectArray.size); } }
private Tuple <ulong, int, ulong, uint, uint>[] GetClrStackFrameLocals(Tuple <int, uint, int> input) { int runtimeId = input.Item1; uint threadSystemId = input.Item2; int stackFrameId = input.Item3; ClrRuntime clrRuntime = runtimesCache[runtimeId]; ClrThread clrThread = clrRuntime.Threads.First(t => t.OSThreadId == threadSystemId); ClrStackFrame clrStackFrame = clrThread.StackTrace[stackFrameId]; IList <ClrValue> clrValues = clrStackFrame.Locals; Tuple <ulong, int, ulong, uint, uint>[] variables = new Tuple <ulong, int, ulong, uint, uint> [clrValues.Count]; ulong moduleBase = clrStackFrame.Module.ImageBase; uint metadataToken = clrStackFrame.Method.MetadataToken; uint ilOffset = FindIlOffset(clrStackFrame); for (int i = 0; i < variables.Length; i++) { GetClrValueAddressAndCodeTypeId(clrValues[i], out ulong address, out int codeTypeId); variables[i] = Tuple.Create(address, codeTypeId, moduleBase, metadataToken, ilOffset); } return(variables); }
public void GCRoots() { using (DataTarget dataTarget = TestTargets.GCRoot.LoadFullDump()) { ClrRuntime runtime = dataTarget.ClrVersions.Single().CreateRuntime(); GCRoot gcroot = new GCRoot(runtime.Heap); gcroot.ClearCache(); Assert.False(gcroot.IsFullyCached); GCRootsImpl(gcroot); gcroot.BuildCache(CancellationToken.None); gcroot.AllowParallelSearch = false; Assert.True(gcroot.IsFullyCached); GCRootsImpl(gcroot); gcroot.AllowParallelSearch = true; Assert.True(gcroot.IsFullyCached); GCRootsImpl(gcroot); } }
public static ClrModule GetMscorlib(ClrRuntime clr) { foreach (ClrModule module in clr.Modules) { if (module.AssemblyName.Contains("mscorlib.dll")) { return(module); } } // Uh oh, this shouldn't have happened. Let's look more carefully (slowly). foreach (ClrModule module in clr.Modules) { if (module.AssemblyName.ToLower().Contains("mscorlib")) { return(module); } } // Ok...not sure why we couldn't find it. return(null); }
static void Main(string[] args) { int pid = 1234; DataTarget dt = DataTarget.AttachToProcess(pid, 5000, AttachFlag.Passive); using (dt) { //pick first CLR version ClrInfo runtimeInfo = dt.ClrVersions[0]; ClrRuntime runtime = runtimeInfo.CreateRuntime(); ClrType type; //enumerate objects on managed heap foreach (ulong obj in runtime.Heap.EnumerateObjectAddresses()) { type = runtime.Heap.GetObjectType(obj); if (type == null) { continue; } if (type.Name == "MyProject.MyClass") { Console.WriteLine("Address 0x{0:X}: {1}", obj, type.Name); ClrInstanceField f = type.GetFieldByName("Foo"); object val = f.GetValue(obj); if (val != null) { Console.WriteLine(val.ToString()); } } } } Console.ReadKey(); }
public void VariableRootTest() { // Test to make sure that a specific static and local variable exist. using (DataTarget dt = TestTargets.Types.LoadFullDump()) { ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrHeap heap = runtime.Heap; heap.StackwalkPolicy = ClrRootStackwalkPolicy.Exact; var fooRoots = from root in heap.EnumerateRoots() where root.Type.Name == "Foo" select root; ClrRoot staticRoot = fooRoots.Where(r => r.Kind == GCRootKind.StaticVar).Single(); Assert.IsTrue(staticRoot.Name.Contains("s_foo")); var arr = fooRoots.Where(r => r.Kind == GCRootKind.LocalVar).ToArray(); ClrRoot localVarRoot = fooRoots.Where(r => r.Kind == GCRootKind.LocalVar).Single(); ClrThread thread = runtime.GetMainThread(); ClrStackFrame main = thread.GetFrame("Main"); ClrStackFrame inner = thread.GetFrame("Inner"); ulong low = thread.StackBase; ulong high = thread.StackLimit; // Account for different platform stack direction. if (low > high) { ulong tmp = low; low = high; high = tmp; } Assert.IsTrue(low <= localVarRoot.Address && localVarRoot.Address <= high); } }
internal static Runtime GetCurrentRuntime() { //do not change the order of conditions because it may cause incorrect determination of runtime if (IsMono) { return(MonoRuntime.Default); } if (IsFullFramework) { return(ClrRuntime.GetCurrentVersion()); } if (IsNetCore) { return(CoreRuntime.GetCurrentVersion()); } if (IsCoreRT) { return(CoreRtRuntime.GetCurrentVersion()); } throw new NotSupportedException("Unknown .NET Runtime"); }
private static void OnParallelStacks(ClrRuntime runtime, string args) { var ps = ParallelStack.Build(runtime); if (ps == null) { return; } // display parallel stacks Console.WriteLine(); foreach (var stack in ps.Stacks) { Console.Write("________________________________________________"); stack.WriteToConsole(useDml: true); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); } Console.WriteLine($"==> {ps.ThreadIds.Count} threads with {ps.Stacks.Count} roots{Environment.NewLine}"); }
public void AllocationContextLocation() { // Simply test that we can enumerate the heap. using DataTarget dt = TestTargets.Types.LoadFullDump(); using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrHeap heap = runtime.Heap; // Ensure that we never find objects within allocation contexts. MemoryRange[] allocationContexts = heap.EnumerateAllocationContexts().ToArray(); Assert.NotEmpty(allocationContexts); foreach (MemoryRange ac in allocationContexts) { Assert.True(ac.Length > 0); ClrSegment seg = heap.GetSegmentByAddress(ac.Start); Assert.NotNull(seg); Assert.Same(seg, heap.GetSegmentByAddress(ac.End - 1)); Assert.True(seg.ObjectRange.Contains(ac)); } }
static void Main(string[] args) { //ClrRuntime runtime = CreateRuntime(@"C:\Users\leculver\Desktop\work\projects\rmd_test_data\dumps\v4.0.30319.239_x86.cab", // @"C:\Users\leculver\Desktop\work\projects\rmd_test_data\dacs"); //PrintDict(runtime, "0262b058"); List <string> typeNames = new List <string>(); ClrRuntime runtime = CreateRuntime(@"D:\work\03_09_ml\ml.dmp", @"D:\work\03_09_ml"); ClrHeap heap = runtime.GetHeap(); foreach (var type in heap.EnumerateTypes()) { typeNames.Add(type.Name); } typeNames.Sort(delegate(string a, string b) { return(-a.Length.CompareTo(b.Length)); }); for (int i = 0; i < 10; ++i) { Console.WriteLine("{0} {1}", typeNames[i].Length, typeNames[i]); } }
public ClrDriver(ClrRuntime runtime) { (this.runtime, heap, domain) = (runtime, runtime.Heap, runtime.AppDomains[0]); typeObject = heap.GetTypeByName("System.Object"); typeDelegate = heap.GetTypeByName("System.Delegate"); fieldDelegateTarget = typeDelegate.GetFieldByName("_target"); typeTask = heap.GetTypeByName("System.Threading.Tasks.Task"); if (typeTask.BaseType.Name == "System.Threading.Tasks.Task") { typeTask = typeTask.BaseType; } fieldTaskAction = typeTask.GetFieldByName("m_action"); fieldTaskScheduler = typeTask.GetFieldByName("m_taskScheduler"); fieldTaskContinuationObject = typeTask.GetFieldByName("m_continuationObject"); typeDelayPromise = heap.GetTypeByName("System.Threading.Tasks.Task+DelayPromise"); typeQueueUserWorkItemCallback = heap.GetTypeByName("System.Threading.QueueUserWorkItemCallback"); fieldCallback = typeQueueUserWorkItemCallback.GetFieldByName("callback"); typeWaitCallback = heap.GetTypeByName("System.Threading.WaitCallback"); }
public static void Profile(ClrRuntime runtime) { { foreach (ClrThread thread in runtime.Threads) { Console.WriteLine("Thread {0:x}:", thread.OSThreadId); foreach (ClrStackFrame frame in thread.StackTrace) { if (frame.Kind == ClrStackFrameType.Runtime) { Console.WriteLine("{0,12:x} {1,12:x} {2}", frame.InstructionPointer, frame.StackPointer, frame.DisplayString); } else { FileAndLineNumber info = frame.GetSourceLocation(); Console.WriteLine("{0,12:x} {1,12:x} {2} [{3} @ {4}]", frame.InstructionPointer, frame.StackPointer, frame.DisplayString, info.File, info.Line); } } } } }
public IEnumerable <ClrObject> EnumerateObjectsFromSource([NotNull] ClrRuntime runtime) { Type classCarryingConfig; string[] fieldNames; if (this.IsOldSitecore(runtime)) { classCarryingConfig = typeof(Configuration.Factory); fieldNames = new[] { "configuration" }; } else { classCarryingConfig = typeof(Configuration.ConfigReader); fieldNames = new[] { "config" }; } var enumartor = new StaticFieldValuesEnumerator(classCarryingConfig.FullName, fieldNames); return(enumartor.EnumerateObjectsFromSource(runtime)); }
private static void ShowConcurrentQueue(ClrRuntime runtime, ulong address, bool showItemType) { var heap = runtime.Heap; ClrType t = heap.GetObjectType(address); if (t == null) { Console.WriteLine("this is not a heap object"); return; } try { // different implementations between .NET Core and .NET Framework var helper = new ClrMDHelper(runtime); var cq = heap.GetProxy(address); int count = 0; foreach (var item in ClrMDHelper.EnumerateConcurrentQueue(cq, helper.IsNetCore())) { count++; var itemAddress = (ulong)item; var type = heap.GetObjectType(itemAddress); var typeName = (type == null) ? "?" : type.Name; if (showItemType) { Console.WriteLine($"{count,4} - <link cmd =\"!do {itemAddress:X}\">0x{itemAddress:X16}</link> | {typeName}"); } else { Console.WriteLine($"{count,4} - <link cmd =\"!do {itemAddress:X}\">0x{itemAddress:X16}</link>"); } } //Console.WriteLine("---------------------------------------------" + Environment.NewLine + $"{count} items"); } catch (NullReferenceException) { Console.WriteLine("this is not a ConcurrentQueue"); } }
public static void OnDumpConcurrentQueue(ClrRuntime runtime, string args) { // parse the command argument if (string.IsNullOrEmpty(args)) { Console.WriteLine("Missing address of a ConcurrentQueue"); return; } var arguments = args.Split(' '); var address = arguments[0]; if (address.StartsWith("0x")) { // remove "0x" for parsing address = address.Substring(2).TrimStart('0'); } // remove the leading 0000 that WinDBG often add in 64 bit address = address.TrimStart('0'); if (!ulong.TryParse(address, System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out var reference)) { Console.WriteLine("numeric address value expected"); return; } // check parameters // -t: show item type // var showItemType = false; if (arguments.Length > 1) { showItemType = arguments.Any(arg => arg == "-t"); } ShowConcurrentQueue(runtime, reference, showItemType); }
public void EETypeTest() { using DataTarget dt = TestTargets.AppDomains.LoadFullDump(); ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrHeap heap = runtime.Heap; HashSet <ulong> methodTables = (from obj in heap.EnumerateObjectAddresses() let type = heap.GetObjectType(obj) where !type.IsFree select heap.GetMethodTable(obj)).Unique(); Assert.DoesNotContain(0ul, methodTables); foreach (ulong mt in methodTables) { ClrType type = heap.GetTypeByMethodTable(mt); ulong eeclass = heap.GetEEClassByMethodTable(mt); Assert.NotEqual(0ul, eeclass); Assert.NotEqual(0ul, heap.GetMethodTableByEEClass(eeclass)); } }
public void PdbSourceLineTest() { using (DataTarget dt = TestTargets.NestedException.LoadFullDump()) { ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrThread thread = runtime.GetMainThread(); HashSet <int> sourceLines = new HashSet <int>(); using (PdbReader reader = new PdbReader(TestTargets.NestedException.Pdb)) { Assert.IsTrue(TestTargets.NestedException.Source.Equals(reader.Sources.Single().Name, StringComparison.OrdinalIgnoreCase)); var functions = from frame in thread.StackTrace where frame.Kind != ClrStackFrameType.Runtime select reader.GetFunctionFromToken(frame.Method.MetadataToken); foreach (PdbFunction function in functions) { PdbSequencePointCollection sourceFile = function.SequencePoints.Single(); foreach (int line in sourceFile.Lines.Select(l => l.LineBegin)) { sourceLines.Add(line); } } } int curr = 0; foreach (var line in File.ReadLines(TestTargets.NestedException.Source)) { curr++; if (line.Contains("/* seq */")) { Assert.IsTrue(sourceLines.Contains(curr)); } } } }
public static ClrAppDomain[] GetDomains(ClrRuntime Runtime) { ClrAppDomain system = Runtime.SystemDomain; ClrAppDomain shared = Runtime.SharedDomain; /* * ulong systemDomain = 0; * ulong sharedDomain = 0; * GetSystemAndSharedAddress(Runtime, out systemDomain, out sharedDomain); * * ClrAppDomain system = RunMethod(Runtime, "InitDomain", systemDomain) as ClrAppDomain ; * ClrAppDomain shared = RunMethod(Runtime, "InitDomain", sharedDomain) as ClrAppDomain; */ List <ClrAppDomain> domains = new List <ClrAppDomain>(); domains.Add((ClrAppDomain)system); domains.Add((ClrAppDomain)shared); domains.AddRange(Runtime.AppDomains); return(domains.ToArray()); }
private IList <BlockingObject> GetAllLocks(ClrRuntime runtime) { List <BlockingObject> locks = new List <BlockingObject>(); _logger?.LogTrace("Starting lock walk"); foreach (var thread in runtime.Threads) { var blocking = thread.BlockingObjects; if (blocking != null) { foreach (var lck in blocking) { if (lck.Taken) { locks.Add(lck); } } } } return(locks); }
public virtual HashSet <ulong> GetAliveObjects([NotNull] ClrRuntime runtime) { var pinnedRoots = this.ExtractRootsFromRuntime(runtime); var heap = runtime.GetHeap(); var uniqueObjectsToStay = HashSetHelper.GetHashSet <ulong>(10 * 1000 * 1000); foreach (var pinnedRoot in pinnedRoots) { var type = heap.GetObjectType(pinnedRoot); if (type == null) { continue; } this.EnumerateObjectReferences(pinnedRoot, uniqueObjectsToStay, heap); } uniqueObjectsToStay.TrimExcess(); return(uniqueObjectsToStay); }
private bool TryReadMethodPtr(ClrObject obj, [CanBeNull] out ClrMethod methodDescriptor) { methodDescriptor = null; ClrRuntime rn = obj.Type.Heap.Runtime; try { var _methodPtr = (ulong)(long)obj.GetSimpleFld <object>("_methodPtr"); if (_methodPtr == 0) { return(false); } byte[] commandOpCode = ReadBytes(_methodPtr, rn, 1); return((commandOpCode[0] == 0xE9) && TryProcessNearJump(_methodPtr, rn, out methodDescriptor) && (methodDescriptor != null)); } catch (Exception) { return(false); } }
public void ObjectSetAddRemove() { using DataTarget dataTarget = TestTargets.Types.LoadFullDump(); using ClrRuntime runtime = dataTarget.ClrVersions.Single().CreateRuntime(); ClrHeap heap = runtime.Heap; ObjectSet hash = new ObjectSet(heap); foreach (ulong obj in heap.EnumerateObjects()) { Assert.False(hash.Contains(obj)); hash.Add(obj); Assert.True(hash.Contains(obj)); } foreach (ulong obj in heap.EnumerateObjects()) { Assert.True(hash.Contains(obj)); hash.Remove(obj); Assert.False(hash.Contains(obj)); } }
public static ulong[] GetDomainsAddr(ClrRuntime runtime, ulong Address) { List <ulong> domains = new List <ulong>(); if (Address == 0) { return(domains.ToArray()); } foreach (var domain in AdHoc.GetDomains(runtime)) { foreach (var module in domain.Modules) { if (module.ImageBase == Address) { domains.Add(module.AssemblyId); } } } return(domains.ToArray()); }
public static ulong GetDomainFromMT(ClrRuntime Runtime, ulong MethodTable) { if (MethodTable == 0) { return(0); } object module = RunMethod(Runtime, "GetModuleForMT", MethodTable); if (module == null) { return(0); } object moduleData = RunMethod(Runtime, "GetModuleData", module); if (moduleData == null) { return(0); } object assembly = GetMember(moduleData, "Assembly"); if (assembly == null) { return(0); } object assemblyData = RunMethod(Runtime, "GetAssemblyData", 0UL, assembly); if (assemblyData == null) { return(0); } object domain = GetMember(assemblyData, "ParentDomain"); if (domain == null) { return(0); } return((ulong)domain); }
public void ComponentTypeEventuallyFilledTest() { // https://github.com/microsoft/clrmd/issues/108 // Ensure that a previously created type with a erronous null ComponentType eventually // gets its ComponentType set. using DataTarget dt = TestTargets.Types.LoadFullDump(); using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrType fooType = runtime.GetModule(ModuleName).GetTypeByName("Types"); ClrStaticField list = fooType.GetStaticFieldByName("s_list"); Assert.NotNull(list); ClrInstanceField itemsField = list.Type.GetFieldByName("_items"); ClrElementType elementType = itemsField.ElementType; ClrType componentType = itemsField.Type.ComponentType; // If this assert fails, remove the test. This value is null because currently CLR's // debugging layer doesn't tell us the component type of an array. If we eventually // fix that issue, we would return a non-null m_array.Type.ComponentType, causing // this test to fail but the underlying issue would be fixed. Assert.Null(componentType); ClrObject itemsObj = list.ReadObject().GetObjectField("_items"); // Ensure we are looking at the same ClrType if (dt.CacheOptions.CacheTypes) { Assert.Same(itemsField.Type, itemsObj.Type); } else { Assert.Equal(itemsField.Type, itemsObj.Type); } // Assert that we eventually filled in ComponentType after we got a real object for the type Assert.NotNull(itemsObj.Type.ComponentType); }
public void NoMethodCachingTest() { using DataTarget dt = TestTargets.Types.LoadFullDump(); dt.CacheOptions.CacheMethods = false; dt.CacheOptions.CacheMethodNames = StringCaching.None; using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); ClrModule module = runtime.GetModule("sharedlibrary.dll"); ClrType type = module.GetTypeByName("Foo"); ClrMethod method = type.GetMethod("Bar"); Assert.NotEqual(0ul, method.MethodDesc); // Sanity test ClrMethod method2 = type.GetMethod("Bar"); Assert.Equal(method, method2); Assert.NotSame(method, method2); string signature1 = method.Signature; string signature2 = method2.Signature; Assert.NotNull(signature1); Assert.Equal(signature1, signature2); Assert.Equal(signature1, method.Signature); Assert.NotSame(signature1, method.Signature); Assert.NotSame(method2.Signature, method.Signature); // Ensure that we can swap this at runtime and that we get interned strings dt.CacheOptions.CacheMethodNames = StringCaching.Intern; Assert.NotNull(method.Signature); Assert.Same(method2.Signature, method.Signature); Assert.Same(method.Signature, string.Intern(method.Signature)); }
public void TestTypeMapRoundTrip() { using DataTarget dt = TestTargets.Types.LoadFullDump(); using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime(); int badTypes = 0; foreach (ClrModule module in runtime.EnumerateModules()) { foreach ((ulong mt, int token) in module.EnumerateTypeDefToMethodTableMap()) { Assert.NotEqual(0, token); Assert.True((token & 0x02000000) == 0x02000000); ClrType type = runtime.GetTypeByMethodTable(mt); if (type == null) { // We really want to Assert.NotNull(type), but it turns out that one type // (System.Runtime.Remoting.Proxies.__TransparentProxy) cannot be constructed because // GetMethodTableData returns null for it. This is an issue with the dac so we'll // simply count types that are null and assert there's only one badTypes++; continue; } Assert.NotNull(type); ClrType typeFromToken = module.ResolveToken(token); Assert.NotNull(typeFromToken); Assert.Same(type, typeFromToken); } } Assert.True(badTypes <= 1); }
private static void DumpHeapRefHierachy(ClrRuntime runtime, string typeNameOrAddress, bool detailed, int depth) { HashSet <ulong> instances = GetObjectListByName(runtime, typeNameOrAddress); Console.WriteLine(typeNameOrAddress + ", # of instances: " + instances.Count); Dictionary <string, HeapObjectCounter> owners = GetObjectOwners(runtime, instances); List <ObjectHistogramItem> histogram = new List <ObjectHistogramItem>(); foreach (var owner in owners) { ObjectHistogramItem item = new ObjectHistogramItem { Key = owner.Key, Counter = owner.Value }; histogram.Add(item); } histogram.Sort(); int count = 0; foreach (var item in histogram) { Console.WriteLine($"{item.Counter.Total} {item.Key}({item.Counter.OwnerCount})"); if (detailed == true) { foreach (var instance in item.Counter) { Console.WriteLine($"\t[{instance.Key:x}, {instance.Value}]"); } } count += item.Counter.Total; } Console.WriteLine("Total: " + count); }
/// <summary> /// Parses the specified node. /// </summary> /// <param name="node">The node.</param> public override void Parse(XmlNode node) { m_Name = Helper.AttributeValue(node, "name", m_Name); m_Path = Helper.AttributeValue(node, "path", m_Path); m_FilterGroups = Helper.AttributeValue(node, "filterGroups", m_FilterGroups); m_Version = Helper.AttributeValue(node, "version", m_Version); m_AppIcon = Helper.AttributeValue(node, "icon", m_AppIcon); m_ApplicationManifest = Helper.AttributeValue(node, "appmanifest", m_ApplicationManifest); m_ConfigFile = Helper.AttributeValue(node, "configFile", m_ConfigFile); m_DesignerFolder = Helper.AttributeValue(node, "designerFolder", m_DesignerFolder); m_AssemblyName = Helper.AttributeValue(node, "assemblyName", m_AssemblyName); m_Language = Helper.AttributeValue(node, "language", m_Language); m_Type = (ProjectType)Helper.EnumAttributeValue(node, "type", typeof(ProjectType), m_Type); m_Runtime = (ClrRuntime)Helper.EnumAttributeValue(node, "runtime", typeof(ClrRuntime), m_Runtime); if(m_useFramework) m_Framework = (FrameworkVersion)Helper.EnumAttributeValue(node, "frameworkVersion", typeof(FrameworkVersion), m_Framework); m_StartupObject = Helper.AttributeValue(node, "startupObject", m_StartupObject); m_RootNamespace = Helper.AttributeValue(node, "rootNamespace", m_RootNamespace); int hash = m_Name.GetHashCode(); Guid guidByHash = new Guid(hash, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); string guid = Helper.AttributeValue(node, "guid", guidByHash.ToString()); m_Guid = new Guid(guid); m_GenerateAssemblyInfoFile = Helper.ParseBoolean(node, "generateAssemblyInfoFile", false); m_DebugStartParameters = Helper.AttributeValue(node, "debugStartParameters", string.Empty); if(string.IsNullOrEmpty(m_AssemblyName)) { m_AssemblyName = m_Name; } if(string.IsNullOrEmpty(m_RootNamespace)) { m_RootNamespace = m_Name; } m_FullPath = m_Path; try { m_FullPath = Helper.ResolvePath(m_FullPath); } catch { throw new WarningException("Could not resolve Solution path: {0}", m_Path); } Kernel.Instance.CurrentWorkingDirectory.Push(); try { Helper.SetCurrentDir(m_FullPath); if( node == null ) { throw new ArgumentNullException("node"); } foreach(XmlNode child in node.ChildNodes) { IDataNode dataNode = Kernel.Instance.ParseNode(child, this); if(dataNode is ConfigurationNode) { HandleConfiguration((ConfigurationNode)dataNode); } else if(dataNode is ReferencePathNode) { m_ReferencePaths.Add((ReferencePathNode)dataNode); } else if(dataNode is ReferenceNode) { m_References.Add((ReferenceNode)dataNode); } else if(dataNode is AuthorNode) { m_Authors.Add((AuthorNode)dataNode); } else if(dataNode is FilesNode) { m_Files = (FilesNode)dataNode; } } } finally { Kernel.Instance.CurrentWorkingDirectory.Pop(); } }
public NativeAppDomain(ClrRuntime runtime, IList<ClrModule> modules) { _runtime = runtime; _modules = modules; }
/// <summary> /// Parses the specified node. /// </summary> /// <param name="node">The node.</param> public override void Parse(XmlNode node) { m_Name = Helper.AttributeValue(node, "name", m_Name); m_Path = Helper.AttributeValue(node, "path", m_Path); m_FilterGroups = Helper.AttributeValue(node, "filterGroups", m_FilterGroups); m_AppIcon = Helper.AttributeValue(node, "icon", m_AppIcon); m_DesignerFolder = Helper.AttributeValue(node, "designerFolder", m_DesignerFolder); m_AssemblyName = Helper.AttributeValue(node, "assemblyName", m_AssemblyName); m_Language = Helper.AttributeValue(node, "language", m_Language); m_Type = (ProjectType)Helper.EnumAttributeValue(node, "type", typeof(ProjectType), m_Type); m_Runtime = (ClrRuntime)Helper.EnumAttributeValue(node, "runtime", typeof(ClrRuntime), m_Runtime); m_StartupObject = Helper.AttributeValue(node, "startupObject", m_StartupObject); m_RootNamespace = Helper.AttributeValue(node, "rootNamespace", m_RootNamespace); int hash = m_Name.GetHashCode(); m_Guid = new Guid( hash, 0, 0, 0, 0, 0, 0,0,0,0,0 ); m_GenerateAssemblyInfoFile = Helper.ParseBoolean(node, "generateAssemblyInfoFile", false); if(m_AssemblyName == null || m_AssemblyName.Length < 1) { m_AssemblyName = m_Name; } if(m_RootNamespace == null || m_RootNamespace.Length < 1) { m_RootNamespace = m_Name; } m_FullPath = m_Path; try { m_FullPath = Helper.ResolvePath(m_FullPath); } catch { throw new WarningException("Could not resolve Solution path: {0}", m_Path); } Kernel.Instance.CurrentWorkingDirectory.Push(); try { Helper.SetCurrentDir(m_FullPath); if( node == null ) { throw new ArgumentNullException("node"); } foreach(XmlNode child in node.ChildNodes) { IDataNode dataNode = Kernel.Instance.ParseNode(child, this); if(dataNode is ConfigurationNode) { HandleConfiguration((ConfigurationNode)dataNode); } else if(dataNode is ReferencePathNode) { m_ReferencePaths.Add(dataNode); } else if(dataNode is ReferenceNode) { m_References.Add(dataNode); } else if(dataNode is FilesNode) { m_Files = (FilesNode)dataNode; } } } finally { Kernel.Instance.CurrentWorkingDirectory.Pop(); } }