public static bool InstanceReferenceFilesAvailable(int runtmNdx, DumpFileMoniker moniker, out string error)
{
error = null;
try
{
string[] fileList = new string[(int)RefFile.Count];
fileList[0] = moniker.GetFilePath(runtmNdx, Constants.MapRefFwdOffsetsFilePostfix);
fileList[1] = moniker.GetFilePath(runtmNdx, Constants.MapFwdRefsFilePostfix);
fileList[2] = moniker.GetFilePath(runtmNdx, Constants.MapRefBwdOffsetsFilePostfix);
fileList[3] = moniker.GetFilePath(runtmNdx, Constants.MapBwdRefsFilePostfix);
for (int i = 0, icnt = fileList.Length; i < icnt; ++i)
{
if (!File.Exists(fileList[i]))
{
return(false);
}
}
return(true);
}
catch (Exception ex)
{
error = Utils.GetExceptionErrorString(ex);
return(false);
}
}
public InstanceReferences(ulong[] instances, int runtmNdx, DumpFileMoniker moniker)
{
_instances = instances;
_fileList = new string[(int)RefFile.Count];
_fileList[0] = moniker.GetFilePath(runtmNdx, Constants.MapRefFwdOffsetsFilePostfix);
_fileList[1] = moniker.GetFilePath(runtmNdx, Constants.MapFwdRefsFilePostfix);
_fileList[2] = moniker.GetFilePath(runtmNdx, Constants.MapRefBwdOffsetsFilePostfix);
_fileList[3] = moniker.GetFilePath(runtmNdx, Constants.MapBwdRefsFilePostfix);
_maps = new MemoryMappedFile[(int)RefFile.Count];
_views = new MemoryMappedViewAccessor[(int)RefFile.Count];
_readers = new BinaryReader[(int)RefFile.Count];
_readers = new BinaryReader[(int)RefFile.Count];
}
public static ClrtRootInfo Load(int rtm, DumpFileMoniker fileMoniker, out string error)
{
error = null;
BinaryReader bw = null;
try
{
var path = fileMoniker.GetFilePath(rtm, Constants.MapRootsInfoFilePostfix);
bw = new BinaryReader(File.Open(path, FileMode.Open));
// root details
//
int count = bw.ReadInt32();
ClrtRoot[][] roots = new ClrtRoot[count][];
for (int i = 0; i < count; ++i)
{
int kindCount = bw.ReadInt32();
roots[i] = new ClrtRoot[kindCount];
for (int j = 0; j < kindCount; ++j)
{
roots[i][j] = ClrtRoot.Load(bw);
}
}
return(new ClrtRootInfo(roots));
}
catch (Exception ex)
{
error = Utils.GetExceptionErrorString(ex);
return(null);
}
finally
{
bw?.Close();
}
}
public static bool FinalyzerAddressFixup(int rtm, ulong[] finalyzerAddresses, DumpFileMoniker fileMoniker, out string error)
{
error = null;
FileWriter fw = null;
try
{
var path = fileMoniker.GetFilePath(rtm, Constants.MapRootsInfoFilePostfix);
fw = new FileWriter(path, FileMode.Open, FileAccess.Write, FileShare.None);
fw.Seek(sizeof(int), SeekOrigin.Begin);
for (int i = 0, icnt = finalyzerAddresses.Length; i < icnt; ++i)
{
fw.Write(finalyzerAddresses[i]);
}
return(true);
}
catch (Exception ex)
{
error = Utils.GetExceptionErrorString(ex);
return(false);
}
finally
{
fw?.Dispose();
}
}
public static bool Save(int rtm, List <ClrtRoot>[] ourRoots, DumpFileMoniker fileMoniker, out string error)
{
error = null;
BinaryWriter bw = null;
try
{
var path = fileMoniker.GetFilePath(rtm, Constants.MapRootsInfoFilePostfix);
bw = new BinaryWriter(File.Open(path, FileMode.Create));
// root details by kind
//
bw.Write(ourRoots.Length);
for (int i = 0, icnt = ourRoots.Length; i < icnt; ++i)
{
var kindRoots = ourRoots[i];
bw.Write(kindRoots.Count);
for (int j = 0, jcnt = kindRoots.Count; j < jcnt; ++j)
{
kindRoots[j].Dump(bw);
}
}
return(true);
}
catch (Exception ex)
{
error = Utils.GetExceptionErrorString(ex);
return(false);
}
finally
{
bw?.Close();
}
}
/// <summary>
///
/// </summary>
/// <param name="rtmNdx"></param>
/// <param name="segments"></param>
/// <param name="instances"></param>
/// <param name="sizes"></param>
/// <param name="fileMoniker"></param>
/// <param name="hasUnrootedInfo"></param>
/// <returns></returns>
public static Tuple <int[], ulong[], int[], ulong[], int[], ulong[]> GetTotalGenerationDistributions(int rtmNdx, ClrtSegment[] segments, ulong[] instances, uint[] sizes, DumpFileMoniker fileMoniker, bool hasUnrootedInfo)
{
var genTotalCount = new int[4];
var genTotalSize = new ulong[4];
var genTotalUnrootedCount = new int[4];
var genTotalUnrootedSize = new ulong[4];
var freeTotalGenCount = new int[4];
var freeTotalGenSize = new ulong[4];
// check unrooted
// if (!hasUnrootedInfo)
{
for (int i = 0, icnt = instances.Length; i < icnt; ++i)
{
if (!Utils.IsRooted(instances[i]))
{
var addr = instances[i];
var seg = ClrtSegment.FindSegment(segments, addr);
if (seg == null)
{
continue;
}
var gen = seg.GetGeneration(addr);
if (gen == Generation.Uknown)
{
continue;
}
seg.IncUnrooted(gen, sizes[i]);
}
}
string error;
ClrtSegment.DumpSegments(fileMoniker.GetFilePath(rtmNdx, Constants.MapSegmentInfoFilePostfix), segments,
out error, true);
}
for (int i = 0, icnt = segments.Length; i < icnt; ++i)
{
var seg = segments[i];
if (seg.Large)
{
genTotalCount[(int)Generation.Large] += seg.Gen0Count;
genTotalSize[(int)Generation.Large] += seg.Gen0Size;
freeTotalGenCount[(int)Generation.Large] += seg.Gen0FreeCount;
freeTotalGenSize[(int)Generation.Large] += seg.Gen0FreeSize;
genTotalUnrootedCount[(int)Generation.Large] += seg.Gen0UnrootedCount;
genTotalSize[(int)Generation.Large] += seg.Gen0UnrootedSize;
continue;
}
genTotalCount[(int)Generation.Gen0] += seg.Gen0Count;
genTotalSize[(int)Generation.Gen0] += seg.Gen0Size;
genTotalUnrootedCount[(int)Generation.Gen0] += seg.Gen0UnrootedCount;
genTotalUnrootedSize[(int)Generation.Gen0] += seg.Gen0UnrootedSize;
freeTotalGenCount[(int)Generation.Gen0] += seg.Gen0FreeCount;
freeTotalGenSize[(int)Generation.Gen0] += seg.Gen0FreeSize;
genTotalCount[(int)Generation.Gen1] += seg.Gen1Count;
genTotalSize[(int)Generation.Gen1] += seg.Gen1Size;
genTotalUnrootedCount[(int)Generation.Gen1] += seg.Gen1UnrootedCount;
genTotalUnrootedSize[(int)Generation.Gen1] += seg.Gen1UnrootedSize;
freeTotalGenCount[(int)Generation.Gen1] += seg.Gen1FreeCount;
freeTotalGenSize[(int)Generation.Gen1] += seg.Gen1FreeSize;
genTotalCount[(int)Generation.Gen2] += seg.Gen2Count;
genTotalSize[(int)Generation.Gen2] += seg.Gen2Size;
genTotalUnrootedCount[(int)Generation.Gen2] += seg.Gen2UnrootedCount;
genTotalUnrootedSize[(int)Generation.Gen2] += seg.Gen2UnrootedSize;
freeTotalGenCount[(int)Generation.Gen2] += seg.Gen2FreeCount;
freeTotalGenSize[(int)Generation.Gen2] += seg.Gen2FreeSize;
}
return(Tuple.Create(genTotalCount, genTotalSize, freeTotalGenCount, freeTotalGenSize, genTotalUnrootedCount, genTotalUnrootedSize));
}
