private async Task <int> AnalyzeAffectedEntriesAsync(Stopwatch stopWatch)
{
IDependencyChainNode <PythonAnalyzerEntry> node;
var remaining = 0;
var ace = new AsyncCountdownEvent(0);
bool isCanceled;
while ((node = await _walker.GetNextAsync(_analyzerCancellationToken)) != null)
{
lock (_syncObj) {
isCanceled = _isCanceled;
}
if (isCanceled && !node.Value.NotAnalyzed)
{
remaining++;
node.MoveNext();
continue;
}
ActivityTracker.OnEnqueueModule(node.Value.Module.FilePath);
if (Interlocked.Increment(ref _runningTasks) >= _maxTaskRunning || _walker.Remaining == 1)
{
RunAnalysis(node, stopWatch);
}
else
{
ace.AddOne();
StartAnalysis(node, ace, stopWatch).DoNotWait();
}
}
await ace.WaitAsync(_analyzerCancellationToken);
lock (_syncObj) {
isCanceled = _isCanceled;
}
if (_walker.MissingKeys.Count == 0 || _walker.MissingKeys.All(k => k.IsTypeshed))
{
Interlocked.Exchange(ref _runningTasks, 0);
if (!isCanceled)
{
_analysisCompleteEvent.Set();
}
}
else if (!isCanceled && _log != null && _log.LogLevel >= TraceEventType.Verbose)
{
_log?.Log(TraceEventType.Verbose, $"Missing keys: {string.Join(", ", _walker.MissingKeys)}");
}
return(remaining);
}
private async Task <int> AnalyzeAffectedEntriesAsync(Stopwatch stopWatch)
{
IDependencyChainNode node;
var remaining = 0;
while ((node = await _walker.GetNextAsync(_analyzerCancellationToken)) != null)
{
var taskLimitReached = false;
lock (_syncObj) {
if (_isCanceled)
{
switch (node)
{
case IDependencyChainLoopNode <PythonAnalyzerEntry> loop:
// Loop analysis is not cancellable or else small
// inner loops of a larger loop will not be analyzed
// correctly as large loop may cancel inner loop pass.
break;
case IDependencyChainSingleNode <PythonAnalyzerEntry> single when !single.Value.NotAnalyzed:
remaining++;
node.MoveNext();
continue;
}
}
taskLimitReached = _ace.Count >= _maxTaskRunning || _walker.Remaining == 1;
_ace.AddOne();
}
if (taskLimitReached)
{
RunAnalysis(node, stopWatch);
}
else
{
StartAnalysis(node, stopWatch).DoNotWait();
}
}
await _ace.WaitAsync(_analyzerCancellationToken);
lock (_syncObj) {
if (_walker.MissingKeys.Count == 0 || _walker.MissingKeys.All(k => k.IsTypeshed))
{
Debug.Assert(_ace.Count == 0);
}
else if (!_isCanceled && _log != null && _log.LogLevel >= TraceEventType.Verbose)
{
_log?.Log(TraceEventType.Verbose, $"Missing keys: {string.Join(", ", _walker.MissingKeys)}");
}
}
return(remaining);
}
private async Task <int> AnalyzeAffectedEntriesAsync(Stopwatch stopWatch, CancellationToken cancellationToken)
{
IDependencyChainNode <PythonAnalyzerEntry> node;
var remaining = 0;
var ace = new AsyncCountdownEvent(0);
while ((node = await _walker.GetNextAsync(cancellationToken)) != null)
{
bool isCanceled;
lock (_syncObj) {
isCanceled = _isCanceled;
}
if (isCanceled && !node.Value.NotAnalyzed)
{
remaining++;
node.Skip();
continue;
}
if (Interlocked.Increment(ref _runningTasks) >= _maxTaskRunning || _walker.Remaining == 1)
{
Analyze(node, null, stopWatch, cancellationToken);
}
else
{
StartAnalysis(node, ace, stopWatch, cancellationToken).DoNotWait();
}
}
await ace.WaitAsync(cancellationToken);
if (_walker.MissingKeys.All(k => k.IsTypeshed))
{
Interlocked.Exchange(ref _runningTasks, 0);
bool isCanceled;
lock (_syncObj) {
isCanceled = _isCanceled;
}
if (!isCanceled)
{
_analysisCompleteEvent.Set();
}
}
return(remaining);
}
