private static IEnumerable <MemoryTracker.ChildReference> DistillChildReferencesFromObject(object current, object parent, string currentPath)
{
Type type = current.GetType();
if (type.IsClass)
{
yield return(new MemoryTracker.ChildReference
{
child = current,
path = currentPath
});
}
else if (!type.IsPrimitive)
{
if (!type.IsValueType)
{
throw new NotImplementedException();
}
string structPath = currentPath + ".";
foreach (MemoryTracker.ChildReference childReference in MemoryTracker.GetAllReferencedClassesFromClassOrStruct(current, MemoryTracker.GetFieldsFromHierarchy(type, BindingFlags.Instance), parent, structPath))
{
yield return(childReference);
}
}
}
public static void LogObjectsLoaded()
{
if (MemoryTracker.tracked.Count == 0)
{
Log.Message("No objects tracked, memory tracker markup may not be applied.");
return;
}
GC.Collect();
MemoryTracker.LockTracking();
try
{
foreach (HashSet <WeakReference> current in MemoryTracker.tracked.Values)
{
MemoryTracker.CullNulls(current);
}
StringBuilder stringBuilder = new StringBuilder();
foreach (KeyValuePair <Type, HashSet <WeakReference> > current2 in from kvp in MemoryTracker.tracked
orderby - kvp.Value.Count
select kvp)
{
stringBuilder.AppendLine(string.Format("{0,6} {1}", current2.Value.Count, current2.Key));
}
Log.Message(stringBuilder.ToString());
}
finally
{
MemoryTracker.UnlockTracking();
}
}
private static IEnumerable <MemoryTracker.ChildReference> GetAllReferencedClassesFromClassOrStruct(object current, IEnumerable <FieldInfo> fields, object parent, string currentPath)
{
foreach (FieldInfo field in fields)
{
if (!field.FieldType.IsPrimitive)
{
object referenced = null;
referenced = field.GetValue(current);
if (referenced != null)
{
foreach (MemoryTracker.ChildReference child in MemoryTracker.DistillChildReferencesFromObject(referenced, parent, currentPath + field.Name))
{
yield return(child);
}
}
}
}
if (current != null && current is ICollection)
{
MemoryTracker.foundCollections.Add(new WeakReference(current));
foreach (object entry in (current as IEnumerable))
{
if (entry != null && !entry.GetType().IsPrimitive)
{
foreach (MemoryTracker.ChildReference child2 in MemoryTracker.DistillChildReferencesFromObject(entry, parent, currentPath + "[]"))
{
yield return(child2);
}
}
}
}
}
private static void ObjectsLoaded()
{
if (MemoryTracker.tracked.Count == 0)
{
Log.Message("No objects tracked, memory tracker markup may not be applied.", false);
}
else
{
GC.Collect();
MemoryTracker.LockTracking();
try
{
foreach (HashSet <WeakReference> table in MemoryTracker.tracked.Values)
{
MemoryTracker.CullNulls(table);
}
StringBuilder stringBuilder = new StringBuilder();
foreach (KeyValuePair <Type, HashSet <WeakReference> > keyValuePair in from kvp in MemoryTracker.tracked
orderby - kvp.Value.Count
select kvp)
{
stringBuilder.AppendLine(string.Format("{0,6} {1}", keyValuePair.Value.Count, keyValuePair.Key));
}
Log.Message(stringBuilder.ToString(), false);
}
finally
{
MemoryTracker.UnlockTracking();
}
}
}
private static IEnumerable <ChildReference> GetAllReferencedClassesFromClassOrStruct(object current, IEnumerable <FieldInfo> fields, object parent, string currentPath)
{
foreach (FieldInfo field in fields)
{
if (!field.FieldType.IsPrimitive)
{
object referenced = field.GetValue(current);
if (referenced != null)
{
using (IEnumerator <ChildReference> enumerator2 = MemoryTracker.DistillChildReferencesFromObject(referenced, parent, currentPath + field.Name).GetEnumerator())
{
if (enumerator2.MoveNext())
{
ChildReference child2 = enumerator2.Current;
yield return(child2);
/*Error: Unable to find new state assignment for yield return*/;
}
}
}
}
}
if (current != null && current is ICollection)
{
MemoryTracker.foundCollections.Add(new WeakReference(current));
IEnumerator enumerator3 = (current as IEnumerable).GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
object entry = enumerator3.Current;
if (entry != null && !entry.GetType().IsPrimitive)
{
using (IEnumerator <ChildReference> enumerator4 = MemoryTracker.DistillChildReferencesFromObject(entry, parent, currentPath + "[]").GetEnumerator())
{
if (enumerator4.MoveNext())
{
ChildReference child = enumerator4.Current;
yield return(child);
/*Error: Unable to find new state assignment for yield return*/;
}
}
}
}
}
finally
{
IDisposable disposable;
IDisposable disposable2 = disposable = (enumerator3 as IDisposable);
if (disposable != null)
{
disposable2.Dispose();
}
}
}
yield break;
IL_02f3:
/*Error near IL_02f4: Unexpected return in MoveNext()*/;
}
private static IEnumerable <FieldInfo> GetFieldsFromHierarchy(Type type, BindingFlags bindingFlags)
{
while (type != null)
{
foreach (FieldInfo field in MemoryTracker.GetFields(type, bindingFlags))
{
yield return(field);
}
type = type.BaseType;
}
}
private static void CalculateReferencePaths(Dictionary <object, MemoryTracker.ReferenceData> references, IEnumerable <object> objects, int pathCost)
{
Queue <object> queue = new Queue <object>(objects);
while (queue.Count > 0)
{
object obj = queue.Dequeue();
if (references[obj].path.NullOrEmpty())
{
references[obj].path = string.Format("???.{0}", obj.GetType());
references[obj].pathCost = pathCost;
}
MemoryTracker.CalculateObjectReferencePath(obj, references, queue);
}
}
public static void Update()
{
if (MemoryTracker.tracked.Count != 0 && MemoryTracker.updatesSinceLastCull++ >= 10)
{
MemoryTracker.updatesSinceLastCull = 0;
KeyValuePair <Type, HashSet <WeakReference> > keyValuePair = MemoryTracker.tracked.ElementAtOrDefault(MemoryTracker.cullTargetIndex++);
if (keyValuePair.Value == null)
{
MemoryTracker.cullTargetIndex = 0;
}
else
{
MemoryTracker.CullNulls(keyValuePair.Value);
}
}
}
public static void LogGrownCollections()
{
if (!MemoryTracker.AnythingTracked)
{
Log.Message("No objects tracked, memory tracker markup may not be applied.");
return;
}
CollectionsTracker.collections.RemoveAll((KeyValuePair <WeakReference, int> kvp) => !kvp.Key.IsAlive || ((ICollection)kvp.Key.Target).Count <= kvp.Value);
MemoryTracker.LogObjectHoldPathsFor(from kvp in CollectionsTracker.collections
select kvp.Key, delegate(WeakReference elem)
{
ICollection collection = elem.Target as ICollection;
return(collection.Count - CollectionsTracker.collections[elem]);
});
CollectionsTracker.collections.Clear();
}
private static IEnumerable <MemoryTracker.ChildReference> GetAllReferencedClassesFromClassOrStruct(object current, IEnumerable <FieldInfo> fields, object parent, string currentPath)
{
foreach (FieldInfo field in fields)
{
if (!field.FieldType.IsPrimitive)
{
object referenced = null;
referenced = field.GetValue(current);
if (referenced != null)
{
foreach (MemoryTracker.ChildReference child in MemoryTracker.DistillChildReferencesFromObject(referenced, parent, currentPath + field.Name))
{
yield return(child);
}
}
}
}
if (current != null && current is ICollection)
{
MemoryTracker.foundCollections.Add(new WeakReference(current));
IEnumerator enumerator3 = (current as IEnumerable).GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
object entry = enumerator3.Current;
if (entry != null && !entry.GetType().IsPrimitive)
{
foreach (MemoryTracker.ChildReference child2 in MemoryTracker.DistillChildReferencesFromObject(entry, parent, currentPath + "[]"))
{
yield return(child2);
}
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator3 as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
yield break;
}
private static void ObjectHoldPaths()
{
if (MemoryTracker.tracked.Count == 0)
{
Log.Message("No objects tracked, memory tracker markup may not be applied.", false);
}
else
{
GC.Collect();
MemoryTracker.LockTracking();
try
{
foreach (HashSet <WeakReference> table in MemoryTracker.tracked.Values)
{
MemoryTracker.CullNulls(table);
}
List <Type> list = new List <Type>();
list.Add(typeof(Map));
List <FloatMenuOption> list2 = new List <FloatMenuOption>();
foreach (Type type in list.Concat(from kvp in MemoryTracker.tracked
orderby - kvp.Value.Count
select kvp.Key).Take(30))
{
Type type2 = type;
HashSet <WeakReference> trackedBatch = MemoryTracker.tracked.TryGetValue(type2, null);
if (trackedBatch == null)
{
trackedBatch = new HashSet <WeakReference>();
}
list2.Add(new FloatMenuOption(string.Format("{0} ({1})", type2, trackedBatch.Count), delegate()
{
MemoryTracker.LogObjectHoldPathsFor(trackedBatch, (WeakReference _) => 1);
}, MenuOptionPriority.Default, null, null, 0f, null, null));
if (list2.Count == 30)
{
break;
}
}
Find.WindowStack.Add(new FloatMenu(list2));
}
finally
{
MemoryTracker.UnlockTracking();
}
}
}
private static void UnlockTracking()
{
if (!MemoryTracker.trackedLocked)
{
throw new NotImplementedException();
}
MemoryTracker.trackedLocked = false;
foreach (object current in MemoryTracker.trackedQueue)
{
MemoryTracker.RegisterObject(current);
}
MemoryTracker.trackedQueue.Clear();
foreach (RuntimeTypeHandle current2 in MemoryTracker.trackedTypeQueue)
{
MemoryTracker.RegisterType(current2);
}
MemoryTracker.trackedTypeQueue.Clear();
}
public static void Update()
{
if (MemoryTracker.tracked.Count != 0)
{
if (MemoryTracker.updatesSinceLastCull++ >= 10)
{
MemoryTracker.updatesSinceLastCull = 0;
HashSet <WeakReference> value = MemoryTracker.tracked.ElementAtOrDefault(MemoryTracker.cullTargetIndex++).Value;
if (value == null)
{
MemoryTracker.cullTargetIndex = 0;
}
else
{
MemoryTracker.CullNulls(value);
}
}
}
}
private static IEnumerable <FieldInfo> GetFieldsFromHierarchy(Type type, BindingFlags bindingFlags)
{
while (type != null)
{
using (IEnumerator <FieldInfo> enumerator = MemoryTracker.GetFields(type, bindingFlags).GetEnumerator())
{
if (enumerator.MoveNext())
{
FieldInfo field = enumerator.Current;
yield return(field);
/*Error: Unable to find new state assignment for yield return*/;
}
}
type = type.BaseType;
}
yield break;
IL_00e0:
/*Error near IL_00e1: Unexpected return in MoveNext()*/;
}
private static void AccumulateReferences(object obj, Dictionary <object, ReferenceData> references, HashSet <object> seen, Queue <object> toProcess)
{
ReferenceData referenceData = null;
if (!references.TryGetValue(obj, out referenceData))
{
referenceData = (references[obj] = new ReferenceData());
}
foreach (ChildReference item in MemoryTracker.GetAllReferencedClassesFromClassOrStruct(obj, MemoryTracker.GetFieldsFromHierarchy(obj.GetType(), BindingFlags.Instance), obj, string.Empty))
{
ChildReference current = item;
if (!current.child.GetType().IsClass)
{
throw new ApplicationException();
}
ReferenceData referenceData3 = null;
if (!references.TryGetValue(current.child, out referenceData3))
{
referenceData3 = new ReferenceData();
references[current.child] = referenceData3;
}
referenceData3.referredBy.Add(new ReferenceData.Link
{
target = obj,
targetRef = referenceData,
path = current.path
});
referenceData.refers.Add(new ReferenceData.Link
{
target = current.child,
targetRef = referenceData3,
path = current.path
});
if (!seen.Contains(current.child))
{
seen.Add(current.child);
toProcess.Enqueue(current.child);
}
}
}
public static void LogObjectHoldPaths()
{
if (MemoryTracker.tracked.Count == 0)
{
Log.Message("No objects tracked, memory tracker markup may not be applied.");
}
else
{
GC.Collect();
MemoryTracker.LockTracking();
try
{
foreach (HashSet <WeakReference> value in MemoryTracker.tracked.Values)
{
MemoryTracker.CullNulls(value);
}
List <FloatMenuOption> list = new List <FloatMenuOption>();
foreach (KeyValuePair <Type, HashSet <WeakReference> > item in from kvp in MemoryTracker.tracked
orderby - kvp.Value.Count
select kvp)
{
KeyValuePair <Type, HashSet <WeakReference> > elementLocal = item;
list.Add(new FloatMenuOption(string.Format("{0} ({1})", item.Key, item.Value.Count), delegate
{
MemoryTracker.LogObjectHoldPathsFor(elementLocal.Value, (WeakReference _) => 1);
}, MenuOptionPriority.Default, null, null, 0f, null, null));
if (list.Count == 30)
{
break;
}
}
Find.WindowStack.Add(new FloatMenu(list));
}
finally
{
MemoryTracker.UnlockTracking();
}
}
}
private static void AccumulateReferences(object obj, Dictionary <object, MemoryTracker.ReferenceData> references, HashSet <object> seen, Queue <object> toProcess)
{
MemoryTracker.ReferenceData referenceData = null;
if (!references.TryGetValue(obj, out referenceData))
{
referenceData = new MemoryTracker.ReferenceData();
references[obj] = referenceData;
}
foreach (MemoryTracker.ChildReference childReference in MemoryTracker.GetAllReferencedClassesFromClassOrStruct(obj, MemoryTracker.GetFieldsFromHierarchy(obj.GetType(), BindingFlags.Instance), obj, ""))
{
if (!childReference.child.GetType().IsClass)
{
throw new ApplicationException();
}
MemoryTracker.ReferenceData referenceData2 = null;
if (!references.TryGetValue(childReference.child, out referenceData2))
{
referenceData2 = new MemoryTracker.ReferenceData();
references[childReference.child] = referenceData2;
}
referenceData2.referredBy.Add(new MemoryTracker.ReferenceData.Link
{
target = obj,
targetRef = referenceData,
path = childReference.path
});
referenceData.refers.Add(new MemoryTracker.ReferenceData.Link
{
target = childReference.child,
targetRef = referenceData2,
path = childReference.path
});
if (!seen.Contains(childReference.child))
{
seen.Add(childReference.child);
toProcess.Enqueue(childReference.child);
}
}
}
private static void AccumulateStaticMembers(Type type, Dictionary <object, MemoryTracker.ReferenceData> references, HashSet <object> seen, Queue <object> toProcess)
{
foreach (MemoryTracker.ChildReference current in MemoryTracker.GetAllReferencedClassesFromClassOrStruct(null, MemoryTracker.GetFields(type, BindingFlags.Static), null, type.ToString() + "."))
{
if (!current.child.GetType().IsClass)
{
throw new ApplicationException();
}
MemoryTracker.ReferenceData referenceData = null;
if (!references.TryGetValue(current.child, out referenceData))
{
referenceData = new MemoryTracker.ReferenceData();
referenceData.path = current.path;
referenceData.pathCost = 0;
references[current.child] = referenceData;
}
if (!seen.Contains(current.child))
{
seen.Add(current.child);
toProcess.Enqueue(current.child);
}
}
}
private static IEnumerable <ChildReference> DistillChildReferencesFromObject(object current, object parent, string currentPath)
{
Type type = current.GetType();
if (type.IsClass)
{
yield return(new ChildReference
{
child = current,
path = currentPath
});
/*Error: Unable to find new state assignment for yield return*/;
}
if (!type.IsPrimitive)
{
if (!type.IsValueType)
{
throw new NotImplementedException();
}
string structPath = currentPath + ".";
using (IEnumerator <ChildReference> enumerator = MemoryTracker.GetAllReferencedClassesFromClassOrStruct(current, MemoryTracker.GetFieldsFromHierarchy(type, BindingFlags.Instance), parent, structPath).GetEnumerator())
{
if (enumerator.MoveNext())
{
ChildReference childReference = enumerator.Current;
yield return(childReference);
/*Error: Unable to find new state assignment for yield return*/;
}
}
}
yield break;
IL_017e:
/*Error near IL_017f: Unexpected return in MoveNext()*/;
}
public static void LogObjectHoldPathsFor(IEnumerable <WeakReference> elements, Func <WeakReference, int> weight)
{
GC.Collect();
MemoryTracker.LockTracking();
try
{
Dictionary <object, MemoryTracker.ReferenceData> dictionary = new Dictionary <object, MemoryTracker.ReferenceData>();
HashSet <object> hashSet = new HashSet <object>();
MemoryTracker.foundCollections.Clear();
Queue <object> queue = new Queue <object>();
foreach (object current in from weakref in MemoryTracker.tracked.SelectMany((KeyValuePair <Type, HashSet <WeakReference> > kvp) => kvp.Value)
where weakref.IsAlive
select weakref.Target)
{
if (!hashSet.Contains(current))
{
hashSet.Add(current);
queue.Enqueue(current);
}
}
foreach (Type current2 in GenTypes.AllTypes.Union(MemoryTracker.tracked.Keys))
{
if (!current2.FullName.Contains("MemoryTracker") && !current2.FullName.Contains("CollectionsTracker"))
{
if (!current2.ContainsGenericParameters)
{
MemoryTracker.AccumulateStaticMembers(current2, dictionary, hashSet, queue);
}
}
}
int num = 0;
while (queue.Count > 0)
{
if (num % 10000 == 0)
{
UnityEngine.Debug.LogFormat("{0} / {1} (to process: {2})", new object[]
{
num,
num + queue.Count,
queue.Count
});
}
num++;
MemoryTracker.AccumulateReferences(queue.Dequeue(), dictionary, hashSet, queue);
}
if (elements != null && weight != null)
{
int num2 = 0;
MemoryTracker.CalculateReferencePaths(dictionary, from kvp in dictionary
where !kvp.Value.path.NullOrEmpty()
select kvp.Key, num2);
num2 += 1000;
MemoryTracker.CalculateReferencePaths(dictionary, from kvp in dictionary
where kvp.Value.path.NullOrEmpty() && kvp.Value.referredBy.Count == 0
select kvp.Key, num2);
foreach (object current3 in from kvp in dictionary
where kvp.Value.path.NullOrEmpty()
select kvp.Key)
{
num2 += 1000;
MemoryTracker.CalculateReferencePaths(dictionary, new object[]
{
current3
}, num2);
}
Dictionary <string, int> dictionary2 = new Dictionary <string, int>();
foreach (WeakReference current4 in elements)
{
if (current4.IsAlive)
{
string path = dictionary[current4.Target].path;
if (!dictionary2.ContainsKey(path))
{
dictionary2[path] = 0;
}
Dictionary <string, int> dictionary3;
string key;
(dictionary3 = dictionary2)[key = path] = dictionary3[key] + weight(current4);
}
}
StringBuilder stringBuilder = new StringBuilder();
foreach (KeyValuePair <string, int> current5 in from kvp in dictionary2
orderby - kvp.Value
select kvp)
{
stringBuilder.AppendLine(string.Format("{0}: {1}", current5.Value, current5.Key));
}
Log.Message(stringBuilder.ToString());
}
}
finally
{
MemoryTracker.UnlockTracking();
}
}
internal void <> m__0()
{
MemoryTracker.LogObjectHoldPathsFor(this.trackedBatch, (WeakReference _) => 1);
}