public void Run(AnalysisSession analysisSession, string[] arguments)
{
foreach (var runtimeThread in analysisSession.Context.Runtime.Threads)
{
analysisSession.Reporter.Write(new ThreadStacks(runtimeThread));
}
}
protected override async Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace)
{
if (args.Length < 1)
{
console.Error.WriteLine("Usage: eventstack <eventIndex>");
return;
}
if (!int.TryParse(args[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var eventIndex))
{
console.Error.WriteLine("Usage: eventstack <eventIndex>");
return;
}
var evt = trace.Events.ElementAt(eventIndex);
var stack = evt.CallStack();
if (stack != null)
{
WriteStack(stack, console);
}
else
{
console.Error.WriteLine($"Unable to find any call stacks for event {eventIndex:X4}!");
}
}
protected async Task SaveChanges(AnalysisSession analysisSession, CancellationToken cancellationToken)
{
await DbContext.SaveChangesAsync(cancellationToken);
analysisSession.DeletedDocumentsCount = await DbContext.DocumentRepository
.Where(d => d.Folder.NavigationProviderId == Id &&
d.LatestAnalysisSessionId != analysisSession.Id)
.CountAsync(cancellationToken);
await DbContext.VerseRelationRepository.DeleteAsync(
v => v.DocumentParagraph.Document.Folder.NavigationProviderId == Id &&
v.DocumentParagraph.Document.LatestAnalysisSessionId != analysisSession.Id,
cancellationToken);
await DbContext.VerseEntryRepository.DeleteAsync(
v => v.DocumentParagraph.Document.Folder.NavigationProviderId == Id &&
v.DocumentParagraph.Document.LatestAnalysisSessionId != analysisSession.Id,
cancellationToken);
await DbContext.DocumentParagraphRepository.DeleteAsync(
p => p.Document.Folder.NavigationProviderId == Id &&
p.Document.LatestAnalysisSessionId != analysisSession.Id,
cancellationToken);
await DbContext.DocumentRepository.DeleteAsync(
d => d.Folder.NavigationProviderId == Id &&
d.LatestAnalysisSessionId != analysisSession.Id,
cancellationToken);
await DbContext.DocumentFolderRepository.DeleteAsync(
f => f.NavigationProviderId == Id &&
f.LatestAnalysisSessionId != analysisSession.Id,
cancellationToken);
}
protected override Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace)
{
var prefix = string.Empty;
if (args.Length > 0)
{
prefix = args[0];
}
console.WriteLine("Scanning log events...");
var events = trace.Events
.Where(t =>
string.Equals(t.ProviderName, "Microsoft-Extensions-Logging") &&
string.Equals(t.EventName, "MessageJson") &&
((string)t.PayloadByName("LoggerName")).StartsWith(prefix))
.Select(e => e.Clone())
.ToList();
console.WriteLine("Logs:");
foreach (var evt in events)
{
var log = LogMessage.Load(evt);
console.WriteLine($"* ({((int)evt.EventIndex).ToString("X4")}) [{log.Timestamp:O}] [{log.Level}] {log.LoggerName}({log.EventId}): {log.Message}");
foreach (var(key, value) in log.Arguments)
{
console.WriteLine($" {key} = {value}");
}
}
return(Task.CompletedTask);
}
private List <DocumentFolder> GetDocumentFolders(AnalysisSession analysisSession, IEnumerable <string> folderPaths, DocumentFolder parentFolder)
{
var result = new List <DocumentFolder>();
foreach (var folder in folderPaths)
{
var documentFolder = DbContext.DocumentFolderRepository.SingleOrDefault(f => f.Path == folder);
if (documentFolder == null)
{
documentFolder = new DocumentFolder()
{
Name = Path.GetFileName(folder),
ParentFolder = parentFolder,
Path = folder,
NavigationProviderId = Id
};
DbContext.DocumentFolderRepository.Add(documentFolder);
}
documentFolder.LatestAnalysisSession = analysisSession;
result.Add(documentFolder);
}
return(result);
}
public void Build([DisallowNull] AnalysisSession session, [DisallowNull] ObservableCollection <GraphMethodRoot> methodRoots)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
if (methodRoots == null)
{
throw new ArgumentNullException(nameof(methodRoots));
}
foreach (var value in session.Files)
{
if (!value.LoadParsedSource())
{
Log.Error("Failed to load & parse {File}", value.SourceFile);
continue;
}
foreach (var parsedClass in value.ParsedClasses)
{
BuildGraphForClass(parsedClass, methodRoots);
}
}
}
private Dictionary <DocumentFolder, ContainerInfo> GetDocumentFolders(
AnalysisSession analysisSession,
IEnumerable <ContainerInfo> containerInfos,
DocumentFolder parentFolder)
{
var result = new Dictionary <DocumentFolder, ContainerInfo>();
foreach (var container in containerInfos)
{
var documentFolder = DbContext.DocumentFolderRepository.SingleOrDefault(f => f.Path == container.Id);
if (documentFolder == null)
{
documentFolder = new DocumentFolder()
{
Name = container.Name,
ParentFolder = parentFolder,
Path = container.Id,
NavigationProviderId = Id
};
DbContext.DocumentFolderRepository.Add(documentFolder);
}
documentFolder.LatestAnalysisSession = analysisSession;
result.Add(documentFolder, container);
}
return(result);
}
public override Task <IEnumerable <WebDocumentId> > LoadDocuments(
AnalysisSession analysisSession,
bool newOnly,
bool updateDb = true,
CancellationToken cancellationToken = default)
{
throw new NotImplementedException(); // todo
}
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session)
{
foreach (var thread in session.Runtime.Threads)
{
var isActive = session.ActiveThreadId == thread.ManagedThreadId ? "." : " ";
await console.Out.WriteLineAsync($"{isActive}{thread.ManagedThreadId.ToString().PadLeft(2)} Id: {Utils.FormatAddress(thread.OSThreadId)} Teb: {Utils.FormatAddress(thread.Teb)}");
}
}
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session)
{
foreach (var frame in session.ActiveThread.EnumerateStackTrace())
{
var methodInfo = frame.Method == null ? "<Unknown Method>" : GenerateMethodInfo(frame.Method);
await console.Out.WriteLineAsync($"{frame.StackPointer:x16} {frame.InstructionPointer:x16} {methodInfo}");
}
}
public IActionResult Index(string command, string arguments)
{
var analyzer = _analyzerFactory.CreateAnalyzer(command);
var reporter = new AggregateReporter();
var session = new AnalysisSession(_context, reporter);
analyzer.Run(session, (arguments ?? string.Empty).Split(" "));
return(View("Result", new Result(command + " " + arguments, reporter.Results)));
}
public IActionResult Index(string name)
{
var analyzer = _analyzerFactory.CreateAnalyzer(name);
var reporter = new AggregateReporter();
var session = new AnalysisSession(_context, reporter);
analyzer.Run(session);
return(View("Result", reporter.Results));
}
private IEnumerable <Document> GetFolderDocuments(AnalysisSession analysisSession, IEnumerable <string> folderPaths, DocumentFolder parentFolder, bool newOnly)
{
if (newOnly)
{
throw new NotSupportedException($"{nameof(newOnly)} is for WebNavigationProvider only");
}
var result = new List <Document>();
var documentFolders = GetDocumentFolders(analysisSession, folderPaths, parentFolder);
foreach (var dFolder in documentFolders)
{
var files = Directory
.GetFiles(dFolder.Path, "*", SearchOption.TopDirectoryOnly)
.Where(f => FileTypeHelper.SupportedFileExtensions.Contains(Path.GetExtension(f)));
foreach (var filePath in files)
{
var lastModifiedTime = File.GetLastWriteTime(filePath);
var document = DbContext.DocumentRepository.SingleOrDefault(d => d.Path == filePath);
if (document == null)
{
document = new Document()
{
Folder = dFolder,
Name = Path.GetFileName(filePath),
Path = filePath,
LastModifiedTime = lastModifiedTime
};
DbContext.DocumentRepository.Add(document);
analysisSession.CreatedDocumentsCount++;
}
else
{
if (document.LastModifiedTime != lastModifiedTime)
{
document.LastModifiedTime = lastModifiedTime;
analysisSession.UpdatedDocumentsCount++;
}
}
document.LatestAnalysisSession = analysisSession;
if (!newOnly || document.Id <= 0) // По непонятным причинам EF Core для нового файла выставляет Id = -2147482647
{
result.Add(document);
}
}
var subFolderPaths = Directory.GetDirectories(dFolder.Path, "*", SearchOption.TopDirectoryOnly);
result.AddRange(GetFolderDocuments(analysisSession, subFolderPaths, dFolder, newOnly));
}
return(result);
}
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session)
{
if (session.Dump == null)
{
await console.Error.WriteLineAsync("This command requires a memory dump!");
}
else
{
await RunAsyncCoreAsync(console, args, session, session.Dump);
}
}
private MNCDContext InitCtx(string dbName)
{
var options = new DbContextOptionsBuilder <MNCDContext>()
.UseInMemoryDatabase(databaseName: dbName)
.Options;
var ctx = new MNCDContext(options);
var datasets = new List <NetworkDataSet>
{
DataSetHelper.Florentine,
DataSetHelper.LouvainTest,
};
ctx.DataSets.AddRange(datasets);
ctx.SaveChanges();
var requests = new List <AnalysisRequest>
{
new AnalysisRequest
{
CreateDate = new DateTime(2020, 12, 01),
DataSet = DataSetHelper.Florentine,
SelectedLayer = 0,
Approach = AnalysisApproach.SingleLayerFlattening,
AnalysisAlgorithm = AnalysisAlgorithm.Louvain,
AnalysisAlgorithmParameters = new Dictionary <string, string>(),
FlatteningAlgorithm = FlatteningAlgorithm.BasicFlattening,
FlatteningAlgorithmParameters = new Dictionary <string, string>(),
}
};
var analyses = new List <Analysis>
{
new Analysis
{
Request = requests[0]
}
};
ctx.Analyses.AddRange(analyses);
ctx.SaveChanges();
var session = new AnalysisSession
{
Name = "AnalysisSession",
Analyses = analyses,
};
ctx.AnalysisSessions.Add(session);
ctx.SaveChanges();
return(new MNCDContext(options));
}
public async Task RunAsync(IConsole console, string[] args, AnalysisSession session)
{
if (session.Trace == null)
{
await console.Error.WriteLineAsync("This command requires an event trace!");
}
else
{
await RunAsyncCore(console, args, session, session.Trace);
}
}
private IEnumerable <Document> GetHierarchyDocuments(
AnalysisSession analysisSession,
IEnumerable <ContainerInfo> containerInfos,
DocumentFolder parentFolder,
bool newOnly)
{
if (newOnly)
{
throw new NotSupportedException($"{nameof(newOnly)} is for WebNavigationProvider only");
}
var result = new List <Document>();
var documentFolders = GetDocumentFolders(analysisSession, containerInfos, parentFolder);
foreach (var dFolderKVP in documentFolders)
{
foreach (var pageInfo in dFolderKVP.Value.Pages)
{
var document = DbContext.DocumentRepository.SingleOrDefault(d => d.Path == pageInfo.Id);
if (document == null)
{
document = new Document()
{
Folder = dFolderKVP.Key,
Name = pageInfo.Name,
Path = pageInfo.Id,
LastModifiedTime = pageInfo.LastModifiedTime,
};
DbContext.DocumentRepository.Add(document);
analysisSession.CreatedDocumentsCount++;
}
else
{
if (document.LastModifiedTime != pageInfo.LastModifiedTime)
{
document.LastModifiedTime = pageInfo.LastModifiedTime;
analysisSession.UpdatedDocumentsCount++;
}
}
document.LatestAnalysisSession = analysisSession;
if (!newOnly || document.Id <= 0) // По непонятным причинам EF Core для нового файла выставляет Id = -2147482647
{
result.Add(document);
}
}
result.AddRange(GetHierarchyDocuments(analysisSession, dFolderKVP.Value.ChildrenContainers, dFolderKVP.Key, newOnly));
}
return(result);
}
protected override Task RunAsyncCoreAsync(IConsole console, string[] args, AnalysisSession session, MemoryDump dump)
{
var stats = dump.ComputeHeapStatistics().OrderBy(s => s.TotalSize);
console.WriteLine(" MT Count TotalSize Class Name");
foreach (var heapStats in stats)
{
console.WriteLine($"{heapStats.Type.MethodTable:X16} {heapStats.Count.ToString().PadLeft(8)} {heapStats.TotalSize.ToString().PadLeft(12)} {heapStats.Type.Name}");
}
return(Task.CompletedTask);
}
protected override Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace)
{
console.WriteLine("Scanning request events...");
var requests = trace.Events
.Where(t => string.Equals(t.ProviderName, "Microsoft-AspNetCore-Hosting") && string.Equals(t.EventName, "RequestStart/Start"))
.Select(e => e.Clone())
.ToList();
console.WriteLine("HTTP requests:");
foreach (var request in requests)
{
console.WriteLine($"* ({((int)request.EventIndex).ToString("X4")}) [{request.TimeStamp:O}] {request.PayloadString(0)} {request.PayloadString(1)}");
}
return(Task.CompletedTask);
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.CreateLogger();
var analysisSession = new AnalysisSession();
foreach (var s in args)
{
var file = new FileInfo(s);
if (!file.Exists)
{
continue;
}
if (file.Extension != ".cs")
{
continue;
}
analysisSession.Add(file);
}
if (analysisSession.Files.Count == 0)
{
return;
}
var stopwatch = new Stopwatch();
stopwatch.Start();
analysisSession.BuildGraph();
stopwatch.Stop();
Log.Information("DFG: {Time}", stopwatch.Elapsed);
foreach (var methodRoot in analysisSession.CurrentMethodRoots)
{
Print(methodRoot);
}
}
public async Task <AnalysisSession> AddAnalysisSession(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Name cannot be empty.", nameof(name));
}
var session = new AnalysisSession
{
Name = name,
CreateDate = DateTime.Now
};
await _ctx.AnalysisSessions.AddAsync(session);
await _ctx.SaveChangesAsync();
return(session);
}
public void Run(AnalysisSession analysisSession, string[] arguments)
{
var groups = analysisSession.Context.Runtime.Heap.EnumerateObjects().GroupBy(o => o.Type.Name).ToList();
var heapStats = new HeapStatistics()
{
TotalUniqueObjects = groups.Count,
Types = groups.Select(g =>
{
var objs = g.ToList();
return(new HeapTypeStatistics()
{
TypeName = new TypeRef(g.Key),
Count = objs.Count,
TotalSize = objs.Aggregate(0ul, (l, o) => l + o.Size)
});
}).OrderByDescending(t => t.TotalSize)
};
analysisSession.Reporter.Write(heapStats);
}
public override async Task <IEnumerable <FileDocumentId> > LoadDocuments(
AnalysisSession analysisSession,
bool newOnly,
bool updateDb = true,
CancellationToken cancellationToken = default)
{
var documents = new List <Document>();
foreach (var folder in Parameters.FolderPaths)
{
var folderDocuments = GetFolderDocuments(analysisSession, new[] { folder }, null, newOnly);
documents.AddRange(folderDocuments);
}
if (updateDb)
{
await SaveChanges(analysisSession, cancellationToken);
}
return(documents.Select(d => new FileDocumentId(d.Id, d.Path, IsReadonly)));
}
public async Task <AnalysisSession> GetActualSession(int navigationProviderId, CancellationToken cancellationToken = default)
{
var analysisSession = await this.dbContext.AnalysisSessions
.Where(s => s.NavigationProviderId == navigationProviderId)
.Where(s => s.Status == AnalysisSessionStatus.NotStarted)
.OrderByDescending(s => s.GetDocumentsInfoTime)
.FirstOrDefaultAsync(cancellationToken);
if (analysisSession == null)
{
analysisSession = new AnalysisSession()
{
NavigationProviderId = navigationProviderId,
Status = AnalysisSessionStatus.NotStarted
};
this.dbContext.AnalysisSessions.Add(analysisSession);
await dbContext.SaveChangesAsync(cancellationToken);
}
return(analysisSession);
}
public override async Task <IEnumerable <OneNoteDocumentId> > LoadDocuments(
AnalysisSession analysisSession,
bool newOnly = false,
bool updateDb = true,
CancellationToken cancellationToken = default)
{
var documents = new List <Document>();
foreach (var item in Parameters.HierarchyItems)
{
var hierarchyInfo = await this.notebookIterator.GetHierarchyPagesAsync(item.Id, item.Type);
var hierarchyDocuments = GetHierarchyDocuments(analysisSession, new[] { hierarchyInfo }, null, newOnly);
documents.AddRange(hierarchyDocuments);
}
await DbContext.DoInTransactionAsync(async (cancellationToken) =>
{
await SaveChanges(analysisSession, cancellationToken);
return(updateDb);
}, cancellationToken);
return(documents.Select(d => new OneNoteDocumentId(d.Id, d.Path)));
}
public void Run(AnalysisSession analysisSession)
{
var pool = analysisSession.Context.Runtime.ThreadPool;
analysisSession.Reporter.Write(new Table("ThreadPool status",
new[]
{
new [] { nameof(pool.TotalThreads), pool.TotalThreads.ToString() },
new [] { nameof(pool.RunningThreads), pool.RunningThreads.ToString() },
new [] { nameof(pool.IdleThreads), pool.IdleThreads.ToString() },
new [] { nameof(pool.CpuUtilization), pool.CpuUtilization.ToString() },
new [] { nameof(pool.FreeCompletionPortCount), pool.FreeCompletionPortCount.ToString() }
}));
analysisSession.Reporter.Write(new Table("ThreadPool limits",
new[]
{
new [] { nameof(pool.MinThreads), pool.MinThreads.ToString() },
new [] { nameof(pool.MaxThreads), pool.MaxThreads.ToString() },
new [] { nameof(pool.MinCompletionPorts), pool.MinCompletionPorts.ToString() },
new [] { nameof(pool.MaxCompletionPorts), pool.MaxCompletionPorts.ToString() },
new [] { nameof(pool.MaxFreeCompletionPorts), pool.MaxFreeCompletionPorts.ToString() },
}));
}
public Task RunAsync(IConsole console, string[] args, AnalysisSession session)
{
if (session.Dump != null)
{
console.WriteLine("Memory Dump:");
console.WriteLine($" CLR Version: {session.Dump.Runtime.ClrInfo.Version}");
console.WriteLine($" CLR Flavor: {session.Dump.Runtime.ClrInfo.Flavor}");
}
else
{
console.WriteLine("No Memory Dump Loaded.");
}
if (session.Trace != null)
{
console.WriteLine("Trace:");
console.WriteLine($" OS: {session.Trace.OSName} {session.Trace.OSVersion}");
}
else
{
console.WriteLine("No Trace Loaded.");
}
return(Task.CompletedTask);
}
protected abstract Task RunAsyncCore(IConsole console, string[] args, AnalysisSession session, TraceLog trace);
public abstract Task <IEnumerable <T> > LoadDocuments(
AnalysisSession analysisSession,
bool newOnly = false,
bool updateDb = true,
CancellationToken cancellationToken = default);
protected abstract Task RunAsyncCoreAsync(IConsole console, string[] args, AnalysisSession session, MemoryDump dump);
