/// <summary>
///
/// </summary>
/// <param name="toReplace"></param>
public static void ReplaceModelFromFile(HSD_JOBJ toReplace)
{
var f = Tools.FileIO.OpenFile(IOManager.GetModelImportFileFilter());
if (f != null)
{
var settings = new ModelImportSettings();
using (PropertyDialog d = new PropertyDialog("Model Import Options", settings))
{
if (d.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
ImportSettings ioSettings = new ImportSettings()
{
FlipUVs = settings.FlipUVs,
FlipWindingOrder = !settings.FlipFaces,
SmoothNormals = settings.SmoothNormals,
Triangulate = true,
//WeightLimit = true,
};
ModelImporter imp = new ModelImporter(f, settings, ioSettings);
using (ProgressBarDisplay pb = new ProgressBarDisplay(imp))
{
pb.DoWork();
pb.ShowDialog();
}
var newroot = imp.NewModel;
toReplace._s.SetFromStruct(newroot._s);
}
}
}
}
internal FrameSetupData(int minFrame, int maxFrame, int filterDepth, List <string> filterThreads)
{
progressBar = new ProgressBarDisplay();
firstFrame = minFrame;
lastFrame = maxFrame;
analyzer = new ProfileAnalyzer(progressBar);
profileData = analyzer.PullFromProfiler(minFrame, maxFrame);
depthFilter = filterDepth;
threadFilters = filterThreads;
}
public void SetupView(ulong rowMemorySize)
{
ProgressBarDisplay.ShowBar("Setup memory map diff view ");
m_BytesInRow = rowMemorySize;
CreateGroups();
SetupGroups();
ProgressBarDisplay.ClearBar();
}
void CreateGroups( )
{
m_Groups.Clear();
ProgressBarDisplay.UpdateProgress(0.0f, "Create groups ...");
int metaRegions = 0;
while (m_SnapshotMemoryRegion[metaRegions].AddressBegin == 0 && m_SnapshotMemoryRegion[metaRegions].AddressBegin == m_SnapshotMemoryRegion[metaRegions].AddressEnd)
{
metaRegions++;
}
int groupIdx = 0;
ulong groupAddressBegin = m_SnapshotMemoryRegion[metaRegions].AddressBegin;
ulong groupAddressEnd = groupAddressBegin;
for (int i = metaRegions; i < m_SnapshotMemoryRegion.Length; ++i)
{
if (i % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)i / (float)m_SnapshotMemoryRegion.Length);
}
if (m_SnapshotMemoryRegion[i].Type == RegionType.VirtualMemory && !GetDisplayElement(DisplayElements.VirtualMemory))
{
continue;
}
ulong addressBegin = m_SnapshotMemoryRegion[i].AddressBegin;
ulong addressEnd = m_SnapshotMemoryRegion[i].AddressEnd;
if ((addressBegin > groupAddressEnd) && (addressBegin / m_BytesInRow) > (groupAddressEnd / m_BytesInRow) + 1)
{
AddGroup(groupAddressBegin, groupAddressEnd);
groupAddressBegin = addressBegin;
groupAddressEnd = addressEnd;
groupIdx++;
}
else
{
groupAddressEnd = Math.Max(groupAddressEnd, addressEnd);
}
m_SnapshotMemoryRegion[i].Group = groupIdx;
}
AddGroup(groupAddressBegin, groupAddressEnd);
ProgressBarDisplay.UpdateProgress(1.0f);
}
public void Setup(CachedSnapshot snapshot)
{
m_Snapshot = snapshot;
ProgressBarDisplay.ShowBar("Setup memory map");
SetupSortedData();
SetupRegions();
CreateGroups();
SetupGroups();
ProgressBarDisplay.ClearBar();
}
public void Setup(CachedSnapshot snapshotA, CachedSnapshot snapshotB)
{
m_Snapshots[0] = snapshotA;
m_Snapshots[1] = snapshotB;
ProgressBarDisplay.ShowBar("Setup memory map diff");
SetupSortedData();
SetupRegions();
CreateGroups();
SetupGroups();
ProgressBarDisplay.ClearBar();
}
protected void PrepareSortedData(CachedSnapshot.ISortedEntriesCache[] caches)
{
ProgressBarDisplay.UpdateProgress(0.0f, "Sorting data ...");
long entriesCount = 0;
long entriesProcessed = 0;
for (int i = 0; i < caches.Length; ++i)
{
entriesCount += caches[i].Count;
}
for (int i = 0; i < caches.Length; ++i)
{
CachedSnapshot.ISortedEntriesCache cache = caches[i];
cache.Preload();
entriesProcessed += cache.Count;
ProgressBarDisplay.UpdateProgress((float)((100 * entriesProcessed) / entriesCount) / 100.0f);
}
}
void SetupGroups( )
{
ProgressBarDisplay.UpdateProgress(0.0f, "Setup groups ...");
for (Int32 snapshotIdx = 0; snapshotIdx < 2; ++snapshotIdx)
{
CachedSnapshot snapshot = m_Snapshots[snapshotIdx];
int managedObjectsOffset = 0;
int managedObjectsCount = snapshot.SortedManagedObjects.Count;
int nativeAllocationsOffset = 0;
int nativeAllocationsCount = snapshot.SortedNativeAllocations.Count;
int nativeObjectsOffset = 0;
int nativeObjectsCount = snapshot.SortedNativeObjects.Count;
m_GroupsMangedObj[snapshotIdx].Clear();
m_GroupsNativeAlloc[snapshotIdx].Clear();
m_GroupsNativeObj[snapshotIdx].Clear();
EntryRange range;
for (int i = 0; i < m_Groups.Count; ++i)
{
if (i % 1000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)i / (float)m_Groups.Count);
}
// Assigning Managed Objects Range
while (managedObjectsOffset < managedObjectsCount && m_Groups[i].AddressBegin > snapshot.SortedManagedObjects.Address(managedObjectsOffset))
{
managedObjectsOffset++;
}
range.Begin = managedObjectsOffset;
while (managedObjectsOffset < managedObjectsCount && snapshot.SortedManagedObjects.Address(managedObjectsOffset) < m_Groups[i].AddressEnd)
{
managedObjectsOffset++;
}
range.End = managedObjectsOffset;
m_GroupsMangedObj[snapshotIdx].Add(range);
// Assigning Native Allocation Range
while (nativeAllocationsOffset < nativeAllocationsCount && m_Groups[i].AddressBegin > snapshot.SortedNativeAllocations.Address(nativeAllocationsOffset))
{
nativeAllocationsOffset++;
}
range.Begin = nativeAllocationsOffset;
while (nativeAllocationsOffset < nativeAllocationsCount && snapshot.SortedNativeAllocations.Address(nativeAllocationsOffset) < m_Groups[i].AddressEnd)
{
nativeAllocationsOffset++;
}
range.End = nativeAllocationsOffset;
m_GroupsNativeAlloc[snapshotIdx].Add(range);
// Assigning Native Objects Range
while (nativeObjectsOffset < nativeObjectsCount && m_Groups[i].AddressBegin > snapshot.SortedNativeObjects.Address(nativeObjectsOffset))
{
nativeObjectsOffset++;
}
range.Begin = nativeObjectsOffset;
while (nativeObjectsOffset < nativeObjectsCount && snapshot.SortedNativeObjects.Address(nativeObjectsOffset) < m_Groups[i].AddressEnd)
{
nativeObjectsOffset++;
}
range.End = nativeObjectsOffset;
m_GroupsNativeObj[snapshotIdx].Add(range);
}
}
ProgressBarDisplay.UpdateProgress(1.0f);
}
void SetupRegions()
{
ProgressBarDisplay.UpdateProgress(0.0f, "Flushing regions ...");
uint regionCount = 0;
for (int snapshotIdx = 0; snapshotIdx < m_Snapshots.Length; ++snapshotIdx)
{
regionCount += m_Snapshots[snapshotIdx].nativeMemoryRegions.Count + m_Snapshots[snapshotIdx].managedHeapSections.Count + m_Snapshots[snapshotIdx].managedStacks.Count;
}
m_SnapshotMemoryRegion = new DiffMemoryRegion[regionCount];
int regionIndex = 0;
int offset = 0;
uint processed = 0;
for (int i = 0; i != m_Snapshots[0].SortedNativeRegionsEntries.Count; ++i)
{
if (processed++ % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)processed / (float)m_SnapshotMemoryRegion.Length);
}
DiffMemoryRegion region = CreateNativeRegion(regionIndex, m_Snapshots[0], i);
region.m_Snapshot = PresenceInSnapshots.First;
m_SnapshotMemoryRegion[regionIndex++] = region;
}
int offsetMax = regionIndex;
for (int i = 0; i != m_Snapshots[1].SortedNativeRegionsEntries.Count; ++i)
{
if (processed++ % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)processed / (float)m_SnapshotMemoryRegion.Length);
}
ulong addr = m_Snapshots[1].SortedNativeRegionsEntries.Address(i);
ulong size = (ulong)m_Snapshots[1].SortedNativeRegionsEntries.Size(i);
string name = m_Snapshots[1].SortedNativeRegionsEntries.Name(i);
while (offset < offsetMax && m_SnapshotMemoryRegion[offset].AddressBegin < addr)
{
offset++;
}
for (int j = offset; j < offsetMax && m_SnapshotMemoryRegion[j].AddressBegin == addr; ++j)
{
if (m_SnapshotMemoryRegion[j].Name == name && m_SnapshotMemoryRegion[j].Size == size)
{
m_SnapshotMemoryRegion[j].m_Snapshot |= PresenceInSnapshots.Second;
name = null;
break;
}
}
if (name != null)
{
DiffMemoryRegion region = CreateNativeRegion(regionIndex, m_Snapshots[1], i);
region.m_Snapshot = PresenceInSnapshots.Second;
m_SnapshotMemoryRegion[regionIndex++] = region;
}
}
offset = regionIndex;
for (int i = 0; i != m_Snapshots[0].SortedManagedHeapEntries.Count; ++i)
{
if (processed++ % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)processed / (float)m_SnapshotMemoryRegion.Length);
}
DiffMemoryRegion region = CreateManagedHeapRegion(regionIndex, m_Snapshots[0], i);
region.m_Snapshot = PresenceInSnapshots.First;
m_SnapshotMemoryRegion[regionIndex++] = region;
}
offsetMax = regionIndex;
for (int i = 0; i != m_Snapshots[1].SortedManagedHeapEntries.Count; ++i)
{
if (processed++ % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)processed / (float)m_SnapshotMemoryRegion.Length);
}
ulong addr = m_Snapshots[1].SortedManagedHeapEntries.Address(i);
ulong size = (ulong)m_Snapshots[1].SortedManagedHeapEntries.Size(i);
while (offset < offsetMax && m_SnapshotMemoryRegion[offset].AddressBegin < addr)
{
offset++;
}
for (int j = offset; j < offsetMax && m_SnapshotMemoryRegion[j].AddressBegin == addr; ++j)
{
if (m_SnapshotMemoryRegion[j].Size == size)
{
m_SnapshotMemoryRegion[j].m_Snapshot |= PresenceInSnapshots.Second;
addr = size = 0;
break;
}
}
if (addr != 0)
{
DiffMemoryRegion region = CreateManagedHeapRegion(regionIndex, m_Snapshots[1], i);
region.m_Snapshot = PresenceInSnapshots.Second;
m_SnapshotMemoryRegion[regionIndex++] = region;
}
}
offset = regionIndex;
for (int i = 0; i != m_Snapshots[0].SortedManagedStacksEntries.Count; ++i)
{
if (processed++ % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)processed / (float)m_SnapshotMemoryRegion.Length);
}
DiffMemoryRegion region = CreateManagedStackRegion(regionIndex, m_Snapshots[0], i);
region.m_Snapshot = PresenceInSnapshots.First;
m_SnapshotMemoryRegion[regionIndex++] = region;
}
offsetMax = regionIndex;
for (int i = 0; i != m_Snapshots[1].SortedManagedStacksEntries.Count; ++i)
{
if (processed++ % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)processed / (float)m_SnapshotMemoryRegion.Length);
}
ulong addr = m_Snapshots[1].SortedManagedStacksEntries.Address(i);
ulong size = (ulong)m_Snapshots[1].SortedManagedStacksEntries.Size(i);
while (offset < offsetMax && m_SnapshotMemoryRegion[offset].AddressBegin < addr)
{
offset++;
}
for (int j = offset; j < offsetMax && m_SnapshotMemoryRegion[j].AddressBegin == addr; ++j)
{
if (m_SnapshotMemoryRegion[j].Size == size)
{
m_SnapshotMemoryRegion[j].m_Snapshot |= PresenceInSnapshots.Second;
addr = size = 0;
break;
}
}
if (addr != 0)
{
DiffMemoryRegion region = CreateManagedStackRegion(regionIndex, m_Snapshots[1], i);
region.m_Snapshot = PresenceInSnapshots.Second;
m_SnapshotMemoryRegion[regionIndex++] = region;
}
}
ProgressBarDisplay.UpdateProgress(0.0f, "Sorting regions ..");
Array.Resize(ref m_SnapshotMemoryRegion, regionIndex);
Array.Sort(m_SnapshotMemoryRegion, delegate(MemoryRegion a, MemoryRegion b)
{
int result = a.AddressBegin.CompareTo(b.AddressBegin);
if (result == 0)
{
result = -a.AddressEnd.CompareTo(b.AddressEnd);
}
return(result);
}
);
}
void SetupRegions()
{
ProgressBarDisplay.UpdateProgress(0.0f, "Flushing regions ...");
int regionIndex = 0;
m_SnapshotMemoryRegion = new MemoryRegion[m_Snapshot.nativeMemoryRegions.Count + m_Snapshot.managedHeapSections.Count + m_Snapshot.managedStacks.Count];
for (int i = 0; i != m_Snapshot.nativeMemoryRegions.Count; ++i)
{
if (regionIndex % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)regionIndex / (float)m_SnapshotMemoryRegion.Length);
}
ulong start = m_Snapshot.nativeMemoryRegions.addressBase[i];
ulong size = (ulong)m_Snapshot.nativeMemoryRegions.addressSize[i];
string name = m_Snapshot.nativeMemoryRegions.memoryRegionName[i];
MemoryRegion region;
if (name.Contains("Virtual Memory"))
{
region = new MemoryRegion(RegionType.VirtualMemory, start, size, name);
region.ColorRegion = m_ColorNative[(int)EntryColors.VirtualMemory];
}
else
{
region = new MemoryRegion(RegionType.Native, start, size, name);
region.ColorRegion = m_ColorNative[(int)EntryColors.Region];
}
region.ColorRegion = new Color32(region.ColorRegion.r, region.ColorRegion.g, region.ColorRegion.b, (byte)(1 + regionIndex % 255));
m_SnapshotMemoryRegion[regionIndex++] = region;
}
for (int i = 0; i != m_Snapshot.managedHeapSections.Count; ++i)
{
if (regionIndex % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)regionIndex / (float)m_SnapshotMemoryRegion.Length);
}
ulong start = m_Snapshot.managedHeapSections.startAddress[i];
ulong size = (ulong)m_Snapshot.managedHeapSections.bytes[i].Length;
string name = string.Format("Heap Sections {0}", i);
MemoryRegion region = new MemoryRegion(RegionType.Managed, start, size, name);
region.ColorRegion = m_ColorManaged[(int)EntryColors.Region];
region.ColorRegion = new Color32(region.ColorRegion.r, region.ColorRegion.g, region.ColorRegion.b, (byte)(1 + regionIndex % 255));
m_SnapshotMemoryRegion[regionIndex++] = region;
}
ProgressBarDisplay.UpdateProgress((float)regionIndex / (float)m_SnapshotMemoryRegion.Length);
for (int i = 0; i != m_Snapshot.managedStacks.Count; ++i)
{
if (regionIndex % 10000 == 0)
{
ProgressBarDisplay.UpdateProgress((float)regionIndex / (float)m_SnapshotMemoryRegion.Length);
}
ulong start = m_Snapshot.managedStacks.startAddress[i];
ulong size = (ulong)m_Snapshot.managedStacks.bytes[i].Length;
string name = string.Format("Stack Sections {0}", i);
MemoryRegion region = new MemoryRegion(RegionType.ManagedStack, start, size, name);
region.ColorRegion = m_ColorManagedStack[(int)EntryColors.Region];
region.ColorRegion = new Color32(region.ColorRegion.r, region.ColorRegion.g, region.ColorRegion.b, (byte)(1 + regionIndex % 255));
m_SnapshotMemoryRegion[regionIndex++] = region;
}
ProgressBarDisplay.UpdateProgress((float)regionIndex / (float)m_SnapshotMemoryRegion.Length);
ProgressBarDisplay.UpdateProgress(0.0f, "Sorting regions ...");
Array.Sort(m_SnapshotMemoryRegion, delegate(MemoryRegion a, MemoryRegion b)
{
int result = a.AddressBegin.CompareTo(b.AddressBegin);
if (result == 0)
{
result = -a.AddressEnd.CompareTo(b.AddressEnd);
}
return(result);
}
);
ProgressBarDisplay.UpdateProgress(1.0f);
}
private void LoadAll()
{
m_IsReady = false;
try {
foreach (var filePath in m_List)
{
if (File.Exists(filePath))
{
try {
Debug.LogFormat("Loading \"{0}\"", filePath);
var rawSnapshot = Unity.MemoryProfilerForExtension.Editor.Format.QueriedMemorySnapshot.Load(filePath);
//var rawSnapshot = UnityEditor.Profiling.Memory.Experimental.PackedMemorySnapshot.Load(filePath);
if (null == rawSnapshot)
{
Debug.LogErrorFormat("MemoryProfiler: Unrecognized memory snapshot format '{0}'.", filePath);
}
Debug.LogFormat("Completed loading \"{0}\"", filePath);
Debug.LogFormat("Crawling \"{0}\"", filePath);
ProgressBarDisplay.ShowBar(string.Format("Opening snapshot: {0}", System.IO.Path.GetFileNameWithoutExtension(filePath)));
var cachedSnapshot = new CachedSnapshot(rawSnapshot);
using (s_CrawlManagedData.Auto()) {
var crawling = Crawler.Crawl(cachedSnapshot);
crawling.MoveNext(); //start execution
var status = crawling.Current as EnumerationStatus;
float progressPerStep = 1.0f / status.StepCount;
while (crawling.MoveNext())
{
ProgressBarDisplay.UpdateProgress(status.CurrentStep * progressPerStep, status.StepStatus);
}
}
ProgressBarDisplay.ClearBar();
var rawSchema = new RawSchema();
rawSchema.SetupSchema(cachedSnapshot, new ObjectDataFormatter());
var managedObjcts = rawSchema.GetTableByName("AllManagedObjects") as ObjectListTable;
var nativeObjects = rawSchema.GetTableByName("AllNativeObjects") as ObjectListTable;
Debug.LogFormat("Completed crawling \"{0}\"", filePath);
Debug.LogFormat("Saving \"{0}\"", filePath);
var path = Path.GetDirectoryName(filePath);
var snapName = Path.GetFileNameWithoutExtension(filePath);
string exportPath1 = Path.Combine(path, snapName + "_MANAGEDHEAP_SnapshotExport_" + CsLibrary.DateTime.Now.ToString("dd_MM_yyyy_hh_mm_ss") + ".csv");
if (!String.IsNullOrEmpty(exportPath1))
{
System.IO.StreamWriter sw = new System.IO.StreamWriter(exportPath1);
sw.WriteLine("Managed_Objects,Size,Address");
int ct = cachedSnapshot.SortedManagedHeapEntries.Count;
for (int i = 0; i < ct; i++)
{
var size = cachedSnapshot.SortedManagedHeapEntries.Size(i);
var addr = cachedSnapshot.SortedManagedHeapEntries.Address(i);
sw.WriteLine("Managed," + size + "," + addr);
ResourceProcessor.Instance.DisplayProgressBar("write managed heap ...", i, ct);
}
sw.Flush();
sw.Close();
}
string exportPath2 = Path.Combine(path, snapName + "_MANAGED_SnapshotExport_" + CsLibrary.DateTime.Now.ToString("dd_MM_yyyy_hh_mm_ss") + ".csv");
if (!String.IsNullOrEmpty(exportPath2))
{
m_ManagedGroups.Clear();
System.IO.StreamWriter sw = new System.IO.StreamWriter(exportPath2);
sw.WriteLine("Index,Type,RefCount,Size,Address");
int ct = cachedSnapshot.SortedManagedObjects.Count;
for (int i = 0; i < ct; i++)
{
var size = cachedSnapshot.SortedManagedObjects.Size(i);
var addr = cachedSnapshot.SortedManagedObjects.Address(i);
ManagedObjectInfo objInfo;
int index = -1;
int refCount = 0;
string typeName = string.Empty;
if (cachedSnapshot.CrawledData.MangedObjectIndexByAddress.TryGetValue(addr, out index))
{
objInfo = cachedSnapshot.CrawledData.ManagedObjects[index];
index = objInfo.ManagedObjectIndex;
refCount = objInfo.RefCount;
if (objInfo.ITypeDescription >= 0 && objInfo.ITypeDescription < cachedSnapshot.typeDescriptions.Count)
{
typeName = cachedSnapshot.typeDescriptions.typeDescriptionName[objInfo.ITypeDescription];
}
}
sw.WriteLine("" + index + ",\"" + typeName + "\"," + refCount + "," + size + "," + addr);
ManagedGroupInfo info;
if (m_ManagedGroups.TryGetValue(typeName, out info))
{
++info.Count;
info.Size += size;
}
else
{
string g = string.Empty;
int si = typeName.IndexOf('.');
if (si > 0)
{
g = typeName.Substring(0, si);
if (!s_ManagedGroupNames.Contains(g))
{
g = string.Empty;
}
}
info = new ManagedGroupInfo {
Group = g, Type = typeName, Count = 1, Size = size
};
m_ManagedGroups.Add(typeName, info);
}
if (i % 1000 == 0)
{
ResourceProcessor.Instance.DisplayProgressBar("write managed objects ...", i, ct);
}
}
sw.Flush();
sw.Close();
string dir = Path.GetDirectoryName(exportPath2);
string fn = Path.GetFileNameWithoutExtension(exportPath2);
string gpath = Path.Combine(dir, fn + "_groups.csv");
var lastGroup = "A000000";
using (var outsw = new StreamWriter(gpath)) {
outsw.WriteLine("group,type,count,size");
int curCt = 0;
int totalCt = m_ManagedGroups.Count;
foreach (var pair in m_ManagedGroups)
{
var info = pair.Value;
var g = info.Group;
if (!string.IsNullOrEmpty(lastGroup) && string.IsNullOrEmpty(info.Group))
{
g = lastGroup + "__";
}
if (!string.IsNullOrEmpty(info.Group))
{
lastGroup = info.Group;
}
outsw.WriteLine("\"{0}\",\"{1}\",{2},{3}", g, info.Type, info.Count, info.Size);
if (curCt % 100 == 0)
{
ResourceProcessor.Instance.DisplayProgressBar("write managed object group ...", curCt, totalCt);
}
++curCt;
}
}
string gpath2 = Path.Combine(dir, fn + "_groups_forcmp.csv");
using (var outsw = new StreamWriter(gpath2)) {
outsw.WriteLine("type,count,size");
int curCt = 0;
int totalCt = m_ManagedGroups.Count;
foreach (var pair in m_ManagedGroups)
{
var info = pair.Value;
outsw.WriteLine("\"{0}\",{1},{2}", info.Type, info.Count, info.Size);
if (curCt % 100 == 0)
{
ResourceProcessor.Instance.DisplayProgressBar("write managed object group for cmp ...", curCt, totalCt);
}
++curCt;
}
}
}
string exportPath = Path.Combine(path, snapName + "_NATIVE_SnapshotExport_" + CsLibrary.DateTime.Now.ToString("dd_MM_yyyy_hh_mm_ss") + ".csv");
if (!String.IsNullOrEmpty(exportPath))
{
m_NativeGroups.Clear();
System.IO.StreamWriter sw = new System.IO.StreamWriter(exportPath);
sw.WriteLine("Index,Name,Type,RefCount,InstanceID,Size,Address");
int ct = cachedSnapshot.SortedNativeObjects.Count;
for (int i = 0; i < ct; i++)
{
var size = cachedSnapshot.SortedNativeObjects.Size(i);
var addr = cachedSnapshot.SortedNativeObjects.Address(i);
var name = cachedSnapshot.SortedNativeObjects.Name(i);
var refCount = cachedSnapshot.SortedNativeObjects.Refcount(i);
var instanceId = cachedSnapshot.SortedNativeObjects.InstanceId(i);
int index;
if (!cachedSnapshot.nativeObjects.instanceId2Index.TryGetValue(instanceId, out index))
{
index = -1;
}
var nativeTypeIndex = cachedSnapshot.SortedNativeObjects.NativeTypeArrayIndex(i);
string typeName = string.Empty;
if (nativeTypeIndex >= 0 && nativeTypeIndex < cachedSnapshot.nativeTypes.Count)
{
typeName = cachedSnapshot.nativeTypes.typeName[nativeTypeIndex];
}
sw.WriteLine("" + index + ",\"" + name + "\",\"" + typeName + "\"," + refCount + "," + instanceId + "," + size + "," + addr);
NativeGroupInfo info;
if (m_NativeGroups.TryGetValue(typeName, out info))
{
++info.Count;
info.Size += size;
}
else
{
info = new NativeGroupInfo {
Type = typeName, Count = 1, Size = size
};
m_NativeGroups.Add(typeName, info);
}
if (i % 100 == 0)
{
ResourceProcessor.Instance.DisplayProgressBar("write native objects ...", i, ct);
}
}
sw.Flush();
sw.Close();
string dir = Path.GetDirectoryName(exportPath);
string fn = Path.GetFileNameWithoutExtension(exportPath);
string gpath = Path.Combine(dir, fn + "_groups.csv");
using (var outsw = new StreamWriter(gpath)) {
outsw.WriteLine("type,count,size");
int curCt = 0;
int totalCt = m_NativeGroups.Count;
foreach (var pair in m_NativeGroups)
{
var info = pair.Value;
outsw.WriteLine("\"{0}\",{1},{2}", info.Type, info.Count, info.Size);
ResourceProcessor.Instance.DisplayProgressBar("write native object group ...", curCt, totalCt);
++curCt;
}
}
}
Debug.LogFormat("Completed saving \"{0}\"", filePath);
}
catch (Exception ex) {
UnityEngine.Debug.LogErrorFormat("file {0} exception {1}\n{2}", filePath, ex.Message, ex.StackTrace);
}
}
}
EditorUtility.ClearProgressBar();
}
finally {
m_IsReady = true;
}
}
