public void Upgrade(ILogger logger, IDeploymentComponentFactory deploymentComponentFactory, NugetPackage installedPackage)
{
PerformanceLogger performanceLogger = new PerformanceLogger(logger);
performanceLogger.Restart("Opening, Calculating and planing deployment component");
using (ParallelReadableZipArchive upgradeZipArchive = Open(packagePathAndFileName))
{
if (upgradeZipArchive == null)
{
throw new InvalidOperationException($"Source archive {packagePathAndFileName} not found.");
}
using (ParallelReadableZipArchive installedzipArchive = installedPackage?.Open())
{
IReadOnlyCollection <ParallelReadableZipArchiveEntry> installedEntries = installedzipArchive?.Entries;
IReadOnlyCollection <ParallelReadableZipArchiveEntry> newEntries = upgradeZipArchive.Entries;
IReadOnlyCollection <IDeploymentComponent> deploymentComponents = deploymentComponentFactory.CreateDeploymentComponents(this, installedPackage, installedEntries, newEntries);
performanceLogger.Stop();
performanceLogger.Restart("Execution of deployment activities");
UpgradeDeploymentComponents(deploymentComponents, newEntries);
performanceLogger.Stop();
}
}
}
protected override void OnUpdated(SceneData newNodes)
{
using (var t = new PerformanceLogger(nameof(OnUpdated)))
{
// Note this excludes scenes already processed so that visiting the previous world with a cached grid maintains its nodes states.
// e.g. going to town and coming back to dungeon -> scene updates should remember its visited/explored state.
foreach (var scene in newNodes.Scenes.Where(s => !_processedSceneHashes.Contains(s.SceneHash)))
{
s_logger.Debug(
$"[{nameof(OnUpdated)}] Updating grid for scene '{scene.SceneHash}' with {scene.ExplorationNodes.Count} new nodes");
UpdateInnerGrid(scene.ExplorationNodes);
foreach (var node in scene.ExplorationNodes)
{
if (node == null)
{
continue;
}
node.AStarValue = (byte)(node.HasEnoughNavigableCells ? 1 : 2);
if (!node.IsIgnored && node.HasEnoughNavigableCells)
{
WalkableNodes.Add(node);
}
}
_processedSceneHashes.Add(scene.SceneHash);
}
s_logger.Debug($"[{nameof(OnUpdated)}] Updated WalkableNodes={WalkableNodes.Count} Time={t.Elapsed}");
}
}
public void EfficientFrontierPerformanceTest()
{
// Create new portfolio
var portf = new Portfolio("TestPortfolio");
// Create instruments from data
var instruments = from k in cov.Keys
select new Instrument(k, mean[k], cov[k]);
portf.AddRange(instruments);
// Add portfolio constraints
portf.AddAllInvestedConstraint();
portf.AddLongOnlyConstraint();
double rf = 0.05;
int runs = 100;
for (int c = 0; c < runs; c++)
{
PerformanceLogger.Start("EfficientFrontierTests", "EfficientFrontierPerformanceTest", "Optimization.CalcEfficientFrontier");
var res = PortfolioOptimizer.CalcEfficientFrontier(portf, rf, 50);
Console.WriteLine(c);
PerformanceLogger.Stop("EfficientFrontierTests", "EfficientFrontierPerformanceTest", "Optimization.CalcEfficientFrontier");
}
PerformanceLogger.WriteToCSV("performancedata.csv");
}
private void PrintEventSummary(int repeatCount)
{
List <List <PerformanceLogger.EventTime> > events;
lock (_events) {
events = _events;
_events = new List <List <PerformanceLogger.EventTime> >();
events.Add(PerformanceLogger.Take().ToList());
}
Console.WriteLine("{0,-20}{1,8}{2,8}{3,8}{4,8}",
"Event", "25%", "50%", "75%", "Count"
);
var categories = events.SelectMany(i => i).GroupBy(e => e.Name).ToList();
foreach (var category in categories.OrderBy(g => g.Key))
{
var times = category.Select(e => e.Duration).ToList();
times.Sort();
Console.WriteLine("{0,-20}{1,8}{2,8}{3,8}{4,8}",
category.Key,
times[times.Count / 4],
times[times.Count / 2],
times[times.Count / 4 * 3],
times.Count / repeatCount
);
}
}
public void CalculateMetricsTest()
{
var count = 100;
var logger = new PerformanceLogger();
logger.Start();
for (int i = 0; i < count; ++i)
{
logger.Start("Fast");
logger.Stop("Fast");
logger.Start("Slow");
System.Threading.Thread.Sleep(1);
logger.Stop("Slow");
}
logger.Stop();
var metrics = logger.CalculateMetrics();
Assert.AreEqual(2, metrics.Count);
foreach (var m in metrics)
{
Assert.AreEqual(count, m.Value.Count);
Assert.IsTrue(m.Value.PercentTotal >= 0);
Assert.IsTrue(m.Value.PercentTotal <= 100);
}
}
public NeatCentralizedQTableBase(RLClientBase client, int numTeammates, int myUnum)
{
m_client = client;
m_rows = client.EnvRows;
m_cols = client.EnvCols;
m_numTeammates = numTeammates;
m_myUnum = myUnum;
m_numActions = SoccerAction.GetActionCount(Params.MoveKings, m_numTeammates);
this.PerformanceNetworkToEvaluate = new NeatPlayerPerformanceStats();
if (NeatExpParams.SaveFitnessGrowth)
{
m_eaLogger = new PerformanceLogger(String.Format("EALogs/{0}-{1}-{2}",
m_client.MyTeamName, m_myUnum, m_client.PerformanceLoggerMethodName), false);
m_eaLogger.WriteLine("% Generation BestFitness MeanFitness AvgComplexity");
}
Thread evoThread = new Thread(EvolutionaryThread);
evoThread.Start();
m_eventNewNetReady.WaitOne();
}
public PlcPerformanceLogBuilder(string identifier)
{
_identifier = identifier;
_logger = new PerformanceLogger <PlcPerformanceData>("PlcPerformance");
_logs = new List <long>(Buffer);
}
void PerformanceLogger_DumpEvents(object sender, EventArgs e)
{
var events = PerformanceLogger.Take().ToList();
lock (_events) {
_events.Add(events);
}
}
static void RunAllExamples(bool isPerformance = false)
{
if (isPerformance)
{
PerformanceLogger.GetInstance().Enable(true);
AppLogger.Enable(false);
}
RunAllRestExamples();
}
/// <summary>
/// 依據執行時間是否超過容忍上限記錄log
/// </summary>
/// <param name="timeCost">執行時間</param>
/// <param name="logInfo">log訊息</param>
private static void LogPerformance(TimeSpan timeCost, string logInfo)
{
if (timeCost < bound)
{
PerformanceLogger.Info(string.Format("{0} [{1} ms]", logInfo, timeCost.TotalMilliseconds));
}
else
{
PerformanceLogger.Warn(string.Format("{0} [{1} ms]", logInfo, timeCost.TotalMilliseconds));
}
}
public void CompressionTest()
{
string originalString = "qwerty1234567890";
byte[] bytes = Encoding.UTF8.GetBytes(originalString);
byte[] compressed = PerformanceLogger.Zip(originalString);
byte[] decompressed = Encoding.UTF8.GetBytes(PerformanceLogger.Unzip(compressed));
//Console.WriteLine(Encoding.UTF8.GetString(bytes));
//Console.WriteLine(Encoding.UTF8.GetString(decompressed));
CollectionAssert.AreEqual(bytes, decompressed);
}
public void ExampleButtonDown()
{
if (PerformanceLogger.CurrentState == PerformanceLogger.LoggerState.Logging)
{
LoggerText.text = "Dumping logfile...";
PerformanceLogger.EndLogger(Application.persistentDataPath + "/PerformanceLogs/" + SystemInfo.deviceName + " - Example.log", null, true, () => LoggerText.gameObject.SetActive(false));
}
else if (PerformanceLogger.CurrentState == PerformanceLogger.LoggerState.None)
{
LoggerText.text = "Logging...";
LoggerText.gameObject.SetActive(true);
PerformanceLogger.StartLogger();
}
}
private List <LineSpanChunk> GetLineSpans(IList <LineInfo[]> chunkInfo, CancellationToken cancel)
{
#if PERFORMANCE
object cookie = null;
try {
PerformanceLogger.Start(ref cookie);
return(GetLineSpans_Performance(chunkInfo, cancel));
} catch (OperationCanceledException) {
PerformanceLogger.Mark("Cancel");
throw;
} finally {
PerformanceLogger.End(cookie);
}
}
private static HashSet <LineSpan> LinkedLinesInternal(LineSpan line, CancellationToken cancel)
{
#if PERFORMANCE
object cookie = null;
try {
PerformanceLogger.Start(ref cookie);
return(LinkedLinesInternal_Performance(line, cancel));
} catch (OperationCanceledException) {
PerformanceLogger.Mark("Cancel");
throw;
} finally {
PerformanceLogger.End(cookie);
}
}
private async Task MessageReceivedAsync(QueueMessage <TMessage> message, CancellationToken cancellationToken)
{
using (var performanceLogger = new PerformanceLogger(performanceLoggingMethodName))
{
try
{
if (Behaviour == AcknowledgeBehaviour.BeforeProcess)
{
_queueConsumer.AcknowledgeMessage(message.DeliveryTag);
}
await ProcessMessageAsync(message.Message, message.DeliveryTag, cancellationToken, message.RoutingKey);
if (Behaviour == AcknowledgeBehaviour.AfterProcess)
{
_queueConsumer.AcknowledgeMessage(message.DeliveryTag);
}
if (Behaviour != AcknowledgeBehaviour.Never && Behaviour != AcknowledgeBehaviour.Deferred)
{
_logger.InfoFormat(Resources.MessageProcessedLogEntry, message.DeliveryTag);
}
}
catch (AlreadyClosedException ex)
{
_logger.Warn($"The connection to Rabbit was closed while processing message with deliveryTag '{message.DeliveryTag}', error details - '{ex.Message}'.");
}
catch (FatalErrorException e)
{
if (Behaviour == AcknowledgeBehaviour.AfterProcess ||
Behaviour == AcknowledgeBehaviour.Async)
{
_queueConsumer.NegativelyAcknowledgeAndRequeue(message.DeliveryTag);
}
_logger.Fatal(Resources.FatalErrorLogEntry, e);
}
catch (Exception e)
{
_logger.ErrorFormat(Resources.ProcessingErrorLogEntry, message.DeliveryTag, e);
if (Behaviour == AcknowledgeBehaviour.AfterProcess ||
Behaviour == AcknowledgeBehaviour.Async)
{
_queueConsumer.NegativelyAcknowledge(message.DeliveryTag);
}
}
}
}
public void Test()
{
var logger = new PerformanceLogger <PerformanceData>("unittests");
var rnd = new Random();
var dataValue = new [] { "Action 1", "Action 2", "Action 3" };
foreach (var i in Enumerable.Range(0, 10))
{
var performanceData = new PerformanceData(dataValue[i % 3], (float)rnd.NextDouble());
logger.Log(performanceData);
Thread.Sleep(rnd.Next(0, 10));
}
Thread.Sleep(100);
}
public void EncryptionTest()
{
// dlugosc stringa nie moze byc zbyt duza
string originalString = "qwerty1234567890";
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
string pubkey = rsa.ToXmlString(false);
string prikey = rsa.ToXmlString(true);
byte[] encrypted = PerformanceLogger.RSAEncrypt(Encoding.Unicode.GetBytes(originalString), pubkey);
byte[] decrypted = PerformanceLogger.RSADecrypt(encrypted, prikey);
string processedString = Encoding.Unicode.GetString(decrypted);
Assert.AreEqual(originalString, processedString);
}
/*
* In case of error during uprading return a modified nuget package
* assume that that everything that should be removed is still there
* in case of upgrade it might be harder because we can not be sure what happend before.
* but the deployment action must handle this!
*/
public void Upgrade(string packageId, Version packageVersion, string packageDownloadUri)
{
var loggerstate = new LoggerState
{
{ nameof(packageId), packageId },
{ nameof(packageVersion), packageVersion },
{ nameof(packageDownloadUri), packageDownloadUri },
};
logger.LogInformation("Upgrading package '{0}' to version '{1}'", packageId, packageVersion);
using (logger.BeginScope(loggerstate))
{
PerformanceLogger performanceLogger = new PerformanceLogger(logger);
logger.LogInformation("Starting action on package xml list.");
performanceLogger.Restart("Starting action on package xml list.");
packageListRepository.StartActionOnPackage(packageId, packageVersion);
performanceLogger.Stop();
logger.LogInformation("Installing new package.");
performanceLogger.Restart("Installing new package.");
NugetPackage upgradePackage = nugetPackageRepository.InstallPackage(packageId, packageVersion, packageDownloadUri);
performanceLogger.Stop();
logger.LogInformation("Reading installed package.");
performanceLogger.Restart("Reading installed package.");
NugetPackage installedPackage = nugetPackageRepository.ReadInstalledPackage(packageId);
logger.LogInformation("Installed Package: {0}", installedPackage?.PackageIdentifier);
performanceLogger.Stop();
logger.LogInformation("Upgrading package.");
performanceLogger.Restart("Upgrading package.");
upgradePackage.Upgrade(logger, deploymentComponentFactory, installedPackage);
performanceLogger.Stop();
logger.LogInformation("Archiving package.");
performanceLogger.Restart("Archiving package.");
nugetPackageRepository.ArchivePackage(packageId);
performanceLogger.Stop();
logger.LogInformation("Ending action on package xml list.");
performanceLogger.Restart("Ending action on package xml list.");
packageListRepository.EndActionOnPackage(packageId, packageVersion);
performanceLogger.Stop();
}
}
private void FindLongestLine(
ITextSnapshot snapshot,
CancellationToken cancel
)
{
#if PERFORMANCE
object cookie = null;
try {
PerformanceLogger.Start(ref cookie);
FindLongestLine_Performance(snapshot, cancel);
} catch (OperationCanceledException) {
PerformanceLogger.Mark("Cancel");
throw;
} finally {
PerformanceLogger.End(cookie);
}
}
private Func <Task> RunSequentialProcessor(ProcessingQueue <TMessage> processingQueue, CancellationToken cancellationToken)
{
return(async() =>
{
QueueMessage <TMessage> dequeuedMessage;
while (!cancellationToken.IsCancellationRequested && processingQueue.Queue.TryPeek(out dequeuedMessage))
{
using (var performanceLogger = new PerformanceLogger(performanceLoggingMethodName))
{
_logger.DebugFormat(Resources.MessageReceivedLogEntry, dequeuedMessage.DeliveryTag);
try
{
await ProcessMessageAsync(
dequeuedMessage.Message,
dequeuedMessage.DeliveryTag,
cancellationToken,
dequeuedMessage.RoutingKey);
if (Behaviour != AcknowledgeBehaviour.Async)
{
_queueConsumer.AcknowledgeMessage(dequeuedMessage.DeliveryTag);
}
_logger.InfoFormat(Resources.MessageProcessedLogEntry, dequeuedMessage.DeliveryTag);
}
catch (FatalErrorException e)
{
_logger.Fatal(Resources.FatalErrorLogEntry, e);
_queueConsumer.NegativelyAcknowledgeAndRequeue(dequeuedMessage.DeliveryTag);
throw;
}
catch (Exception e)
{
_logger.ErrorFormat(Resources.ProcessingErrorLogEntry, dequeuedMessage.DeliveryTag, e);
_queueConsumer.NegativelyAcknowledge(dequeuedMessage.DeliveryTag);
}
}
// we have finished processing - remove the message from the queue and wait for the next one.
processingQueue.Queue.TryDequeue(out dequeuedMessage);
await processingQueue.AutoResetEvent.WaitOneAsync();
}
});
}
private void SetLineInfo(
LineInfo[] lineInfo,
ITextSnapshot snapshot,
int firstLine,
int lastLine,
CancellationToken cancel
)
{
#if PERFORMANCE
object cookie = null;
try {
PerformanceLogger.Start(ref cookie);
SetLineInfo_Performance(lineInfo, snapshot, firstLine, lastLine, cancel);
} catch (OperationCanceledException) {
PerformanceLogger.Mark("Cancel");
throw;
} finally {
PerformanceLogger.End(cookie);
}
}
public void CanLoadTileDynamically()
{
// ARRANGE
var logger = new PerformanceLogger();
logger.Start();
var componentRoot = TestHelper.GetGameRunner(_container);
// ACT
componentRoot.RunGame(TestHelper.BerlinTestFilePoint);
logger.Stop();
// ASSERT
var tileLoader = _container.Resolve <ITileController>() as TileController;
Assert.IsNotNull(tileLoader);
Assert.AreEqual(1, GetSceneTileCount(tileLoader));
Assert.Less(logger.Seconds, 3, "Loading took too long");
// NOTE Actual value should be close to expected consumption for test data
Assert.Less(logger.Memory, 100, "Memory consumption is too high!");
}
protected override void OnUpdated(SceneData newNodes)
{
using (var t = new PerformanceLogger(nameof(OnUpdated)))
{
IsUpdatingNodes = true;
var sw = Stopwatch.StartNew();
var nodeCount = 0;
foreach (var scene in newNodes.Scenes)
{
var nodes = scene.ExplorationNodes.SelectMany(n => n.Nodes, (p, c) => new AvoidanceNode(c))
.ToList();
s_logger.Debug(
$"[{nameof(OnUpdated)}] Updating grid for scene '{scene.SceneHash}' with {scene.ExplorationNodes.Count} new nodes");
UpdateInnerGrid(nodes);
foreach (var node in nodes)
{
nodeCount++;
if (GetNeighbors(node).Any(n => (n.NodeFlags & NodeFlags.AllowWalk) == 0))
{
node.NodeFlags |= NodeFlags.NearWall;
}
}
}
IsUpdatingNodes = false;
IsPopulated = true;
sw.Stop();
s_logger.Debug($"[{nameof(OnUpdated)}] Avoidance Grid updated NewNodes={nodeCount} NearestNodeFound={NearestNode != null} Time={t.Elapsed}");
}
}
private void CalculateShadowChunk(Vector2Int origin)
{
PerformanceLogger.Push("Shadow Map");
// Clear
var texture = new int[DataSize * DataSize];
for (var i = 0; i < DataSize; i++)
{
for (var j = 0; j < DataSize; j++)
{
var index = i * DataSize + j;
var v = CalcShadow(new Vector3Int(i + origin.x, 0, j + origin.y));
texture[index] = v;
}
}
if (!_buffers.ContainsKey(origin))
{
_buffers[origin] = new ComputeBuffer(DataSize * DataSize, sizeof(int));
}
_buffers[origin].SetData(texture);
PerformanceLogger.Pop();
}
public HyperNEATQTable(RLClientBase client, int numTeammates, int myUnum)
{
m_client = client;
m_rows = client.EnvRows;
m_cols = client.EnvCols;
m_numTeammates = numTeammates;
m_myUnum = myUnum;
m_numActions = SoccerAction.GetActionCount(Params.MoveKings, m_numTeammates);
if (NeatExpParams.SaveFitnessGrowth)
{
m_eaLogger = new PerformanceLogger(String.Format("EALogs/{0}-{1}",
m_client.MyTeamName, m_myUnum), false);
m_eaLogger.WriteLine("% generation bestfitness");
}
Thread evoThread = new Thread(EvolutionaryThread);
evoThread.Start();
m_eventNewNetReady.WaitOne();
}
void UpdateAdornments_Performance(
ITextSnapshot snapshot,
ITextViewModel viewModel,
ITextViewLine firstVisibleLine,
IEnumerable <LineSpan> analysisLines
)
{
#endif
double spaceWidth = firstVisibleLine.VirtualSpaceWidth;
if (spaceWidth <= 0.0)
{
return;
}
double horizontalOffset = firstVisibleLine.TextLeft;
var unusedLines = new HashSet <LineSpan>(Lines.Keys);
var caret = CaretHandlerBase.FromName(Theme.CaretHandler, View.Caret.Position.VirtualBufferPosition, Analysis.TabSize);
object perfCookie = null;
PerformanceLogger.Start(ref perfCookie);
#if DEBUG
var initialCount = Lines.Count;
#endif
foreach (var line in analysisLines.Concat(GetPageWidthLines()))
{
double top = View.ViewportTop;
double bottom = View.ViewportBottom;
double left = line.Indent * spaceWidth + horizontalOffset;
Line adornment;
unusedLines.Remove(line);
if (line.Type == LineSpanType.PageWidthMarker)
{
line.Highlight = (Analysis.LongestLine > line.Indent);
if (!Lines.TryGetValue(line, out adornment))
{
Lines[line] = adornment = CreateGuide(Canvas);
}
UpdateGuide(line, adornment, left, top, bottom);
continue;
}
if (Lines.TryGetValue(line, out adornment))
{
adornment.Visibility = Visibility.Hidden;
}
caret.AddLine(line, willUpdateImmediately: true);
if (line.FirstLine >= 0 && line.LastLine < int.MaxValue)
{
var firstLineNumber = line.FirstLine;
var lastLineNumber = line.LastLine;
ITextSnapshotLine firstLine, lastLine;
try
{
firstLine = snapshot.GetLineFromLineNumber(firstLineNumber);
lastLine = snapshot.GetLineFromLineNumber(lastLineNumber);
}
catch (Exception ex)
{
Trace.TraceError("In GetLineFromLineNumber:\n{0}", ex);
continue;
}
if (firstLine.Start > View.TextViewLines.LastVisibleLine.Start ||
lastLine.Start < View.TextViewLines.FirstVisibleLine.Start)
{
continue;
}
while (
!viewModel.IsPointInVisualBuffer(firstLine.Start, PositionAffinity.Successor) &&
++firstLineNumber < lastLineNumber
)
{
try
{
firstLine = snapshot.GetLineFromLineNumber(firstLineNumber);
}
catch (Exception ex)
{
Trace.TraceError("In GetLineFromLineNumber:\n{0}", ex);
firstLine = null;
break;
}
}
while (
!viewModel.IsPointInVisualBuffer(lastLine.Start, PositionAffinity.Predecessor) &&
--lastLineNumber > firstLineNumber
)
{
try
{
lastLine = snapshot.GetLineFromLineNumber(lastLineNumber);
}
catch (Exception ex)
{
Trace.TraceError("In GetLineFromLineNumber:\n{0}", ex);
lastLine = null;
break;
}
}
if (firstLine == null || lastLine == null || firstLineNumber > lastLineNumber)
{
continue;
}
IWpfTextViewLine firstView, lastView;
try
{
firstView = View.GetTextViewLineContainingBufferPosition(firstLine.Start);
lastView = View.GetTextViewLineContainingBufferPosition(lastLine.End);
}
catch (Exception ex)
{
Trace.TraceError("UpdateAdornments GetTextViewLineContainingBufferPosition failed\n{0}", ex);
continue;
}
string extentText;
if (!string.IsNullOrWhiteSpace((extentText = firstView.Extent.GetText())) &&
line.Indent > extentText.LeadingWhitespace(Analysis.TabSize)
)
{
continue;
}
if (firstView.VisibilityState != VisibilityState.Unattached)
{
top = firstView.Top;
}
if (lastView.VisibilityState != VisibilityState.Unattached)
{
bottom = lastView.Bottom;
}
}
if (!Lines.TryGetValue(line, out adornment))
{
Lines[line] = adornment = CreateGuide(Canvas);
}
UpdateGuide(line, adornment, left, top, bottom);
}
PerformanceLogger.End(perfCookie);
#if DEBUG
Debug.WriteLine("Added {0} guides", Lines.Count - initialCount);
Debug.WriteLine("Removed {0} guides", unusedLines.Count);
Debug.WriteLine("{0} guides active", Lines.Count - unusedLines.Count);
Debug.WriteLine("");
#endif
foreach (var line in unusedLines)
{
Line adornment;
if (Lines.TryGetValue(line, out adornment))
{
Canvas.Children.Remove(adornment);
Lines.Remove(line);
}
}
foreach (var line in caret.GetModified())
{
Line adornment;
if (Lines.TryGetValue(line, out adornment))
{
UpdateGuide(line, adornment);
}
}
}
void UpdateAdornmentsWorker()
{
//var analysisLines = Analysis.Lines;
//if (Analysis.Snapshot != View.TextSnapshot) {
// var task = Analysis.Update();
// if (task != null) {
// UpdateAdornments(task);
// }
// return;
//} else if (analysisLines == null) {
// UpdateAdornments(Analysis.Reset());
// return;
//}
if (!GlobalVisible)
{
Canvas.Visibility = Visibility.Collapsed;
return;
}
Canvas.Visibility = Visibility.Visible;
var snapshot = View.TextSnapshot;
var viewModel = View.TextViewModel;
if (snapshot == null || viewModel == null)
{
return;
}
var firstVisibleLine = View.TextViewLines.FirstOrDefault(line => line.IsFirstTextViewLineForSnapshotLine);
if (firstVisibleLine == null)
{
return;
}
var lastVisibleLine = View.TextViewLines.LastOrDefault(line => line.IsLastTextViewLineForSnapshotLine);
if (lastVisibleLine == null)
{
return;
}
var analysisLines = Analysis.GetLines(
firstVisibleLine.Start.GetContainingLine().LineNumber,
lastVisibleLine.Start.GetContainingLine().LineNumber
);
if (!analysisLines.Any())
{
return;
}
#if PERFORMANCE
object cookie = null;
try {
PerformanceLogger.Start(ref cookie);
UpdateAdornments_Performance(
snapshot,
viewModel,
firstVisibleLine,
analysisLines
);
} catch (OperationCanceledException) {
PerformanceLogger.Mark("Cancel");
throw;
} finally {
PerformanceLogger.End(cookie);
}
}
static void RunPerformanceTest()
{
PerformanceLogger.GetInstance().Enable(true);
RunAllRestExamples();
}
private static void Main()
{
//Starts monitoring
PerformanceLogger.Start();
}
private void Start()
{
_logger = GetComponent <PerformanceLogger>();
_logger.NewFrame += onNewFrame;
}
