public WorkItem( DocumentId documentId, string language, InvocationReasons invocationReasons, bool isLowPriority, SyntaxPath activeMember, IAsyncToken asyncToken) : this(documentId, documentId.ProjectId, language, invocationReasons, isLowPriority, activeMember, ImmutableHashSet.Create<IIncrementalAnalyzer>(), false, asyncToken) { }
public void RegisterNotification(Func<bool> action, int delay, IAsyncToken asyncToken, CancellationToken cancellationToken = default(CancellationToken)) { Contract.Requires(delay >= 0); var current = Environment.TickCount; _workQueue.Enqueue(new PendingWork(current + delay, action, asyncToken, cancellationToken)); }
public static Task CompletesAsyncOperation(this Task task, IAsyncToken asyncToken) { var diagnosticToken = asyncToken as AsynchronousOperationListener.DiagnosticAsyncToken; if (diagnosticToken != null) { diagnosticToken.AssociateWithTask(task); } return task.CompletesTrackingOperation(asyncToken); }
public void RegisterNotification(Func<bool> action, int delayInMS, IAsyncToken asyncToken, CancellationToken cancellationToken = default(CancellationToken)) { Task task; lock (_gate) { task = _queue.ScheduleTask(() => Execute_NoLock(action, asyncToken, cancellationToken), cancellationToken); _tasks.Add(task); } task.Wait(cancellationToken); }
private void Execute_NoLock(Func<bool> action, IAsyncToken asyncToken, CancellationToken cancellationToken) { if (action()) { asyncToken.Dispose(); } else { _tasks.Add(_queue.ScheduleTask(() => Execute_NoLock(action, asyncToken, cancellationToken), cancellationToken)); } }
protected override async Task ExecuteAsync() { lock (_gate) { _lastToken?.Dispose(); _lastToken = null; } // wait for global operation to finish await GlobalOperationTask.ConfigureAwait(false); // update primary solution in remote host await SynchronizePrimaryWorkspaceAsync(_globalOperationCancellationSource.Token).ConfigureAwait(false); }
public void RegisterNotification(Action action, int delayInMS, IAsyncToken asyncToken, CancellationToken cancellationToken = default(CancellationToken)) { Task task; lock (_gate) { task = _queue.ScheduleTask(() => { action(); asyncToken.Dispose(); }, cancellationToken); _tasks.Add(task); } task.Wait(cancellationToken); }
private void Search(IDisposable navigateToSearch, IAsyncToken asyncToken) { var searchTasks = _solution.Projects.Select(SearchAsync).ToArray(); var whenAllTask = Task.WhenAll(searchTasks); // NOTE(cyrusn) This SafeContinueWith is *not* cancellable. We must dispose of the notifier // in order for tests to work property. Also, if we don't notify the callback that we're // done then the UI will never stop displaying the progress bar. whenAllTask.SafeContinueWith(_ => { _callback.Done(); navigateToSearch.Dispose(); asyncToken.Dispose(); }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); }
protected override async Task ExecuteAsync() { lock (_gate) { _lastToken?.Dispose(); _lastToken = null; } // wait for global operation to finish await GlobalOperationTask.ConfigureAwait(false); // cancel updating solution checksum if a global operation (such as loading solution, building solution and etc) has started await UpdateSolutionChecksumAsync(_globalOperationCancellationSource.Token).ConfigureAwait(false); // check whether we had bulk change that require asset synchronization if (_synchronize) { await SynchronizeAssets().ConfigureAwait(false); } }
private WorkItem( DocumentId documentId, ProjectId projectId, string language, InvocationReasons invocationReasons, bool isLowPriority, SyntaxPath activeMember, ImmutableHashSet<IIncrementalAnalyzer> analyzers, bool retry, IAsyncToken asyncToken) { this.DocumentId = documentId; this.ProjectId = projectId; this.Language = language; this.InvocationReasons = invocationReasons; this.IsLowPriority = isLowPriority; this.ActiveMember = activeMember; this.Analyzers = analyzers; this.IsRetry = retry; this.AsyncToken = asyncToken; }
private PendingWork(int minimumRunPointInMS, Action action, Func<bool> func, IAsyncToken asyncToken, CancellationToken cancellationToken) { this.MinimumRunPointInMS = minimumRunPointInMS; this.DoWorkAction = action; this.DoWorkFunc = func; this.AsyncToken = asyncToken; this.CancellationToken = cancellationToken; }
private void EnqueueEvent(Solution solution, DocumentId documentId, InvocationReasons invocationReasons, IAsyncToken asyncToken) { _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemForDocumentAsync(solution, documentId, invocationReasons), _shutdownToken).CompletesAsyncOperation(asyncToken); }
private void ProcessSolutionEvent(WorkspaceChangeEventArgs e, IAsyncToken asyncToken) { switch (e.Kind) { case WorkspaceChangeKind.SolutionAdded: OnSolutionAdded(e.NewSolution); EnqueueEvent(e.NewSolution, InvocationReasons.DocumentAdded, asyncToken); break; case WorkspaceChangeKind.SolutionRemoved: EnqueueEvent(e.OldSolution, InvocationReasons.SolutionRemoved, asyncToken); break; case WorkspaceChangeKind.SolutionCleared: EnqueueEvent(e.OldSolution, InvocationReasons.DocumentRemoved, asyncToken); break; case WorkspaceChangeKind.SolutionChanged: case WorkspaceChangeKind.SolutionReloaded: EnqueueEvent(e.OldSolution, e.NewSolution, asyncToken); break; default: throw ExceptionUtilities.Unreachable; } }
private void ProcessEvents(WorkspaceChangeEventArgs args, IAsyncToken asyncToken) { SolutionCrawlerLogger.LogWorkspaceEvent(_logAggregator, (int)args.Kind); // TODO: add telemetry that record how much it takes to process an event (max, min, average and etc) switch (args.Kind) { case WorkspaceChangeKind.SolutionAdded: case WorkspaceChangeKind.SolutionChanged: case WorkspaceChangeKind.SolutionReloaded: case WorkspaceChangeKind.SolutionRemoved: case WorkspaceChangeKind.SolutionCleared: ProcessSolutionEvent(args, asyncToken); break; case WorkspaceChangeKind.ProjectAdded: case WorkspaceChangeKind.ProjectChanged: case WorkspaceChangeKind.ProjectReloaded: case WorkspaceChangeKind.ProjectRemoved: ProcessProjectEvent(args, asyncToken); break; case WorkspaceChangeKind.DocumentAdded: case WorkspaceChangeKind.DocumentReloaded: case WorkspaceChangeKind.DocumentChanged: case WorkspaceChangeKind.DocumentRemoved: case WorkspaceChangeKind.AdditionalDocumentAdded: case WorkspaceChangeKind.AdditionalDocumentRemoved: case WorkspaceChangeKind.AdditionalDocumentChanged: case WorkspaceChangeKind.AdditionalDocumentReloaded: ProcessDocumentEvent(args, asyncToken); break; default: throw ExceptionUtilities.Unreachable; } }
public WorkItem( DocumentId documentId, string language, InvocationReasons invocationReasons, bool isLowPriority, IIncrementalAnalyzer analyzer, IAsyncToken asyncToken) : this(documentId, documentId.ProjectId, language, invocationReasons, isLowPriority, null, analyzer == null ? ImmutableHashSet.Create<IIncrementalAnalyzer>() : ImmutableHashSet.Create<IIncrementalAnalyzer>(analyzer), false, asyncToken) { }
public Data(ProjectId projectId, bool needDependencyTracking, IAsyncToken asyncToken) { this.AsyncToken = asyncToken; this.ProjectId = projectId; this.NeedDependencyTracking = needDependencyTracking; }
public void RegisterNotification(Func <bool> action, IAsyncToken asyncToken, CancellationToken cancellationToken = default) { RegisterNotification(action, DefaultTimeSliceInMS, asyncToken, cancellationToken); }
public PendingWork(int minimumRunPointInMS, Func <bool> work, IAsyncToken asyncToken, CancellationToken cancellationToken) : this(minimumRunPointInMS, null, work, asyncToken, cancellationToken) { }
public PendingWork(int minimumRunPointInMS, Action work, IAsyncToken asyncToken, CancellationToken cancellationToken) : this(minimumRunPointInMS, work, null, asyncToken, cancellationToken) { }
private PendingWork(int minimumRunPointInMS, Action action, Func <bool> func, IAsyncToken asyncToken, CancellationToken cancellationToken) { this.MinimumRunPointInMS = minimumRunPointInMS; this.DoWorkAction = action; this.DoWorkFunc = func; this.AsyncToken = asyncToken; this.CancellationToken = cancellationToken; }
private void EnqueueEvent(Solution oldSolution, Solution newSolution, DocumentId documentId, IAsyncToken asyncToken) { // document changed event is the special one. _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemAfterDiffAsync(oldSolution, newSolution, documentId), _shutdownToken).CompletesAsyncOperation(asyncToken); }
private void EnqueueEvent(Solution solution, DocumentId documentId, InvocationReasons invocationReasons, IAsyncToken asyncToken) { _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemForDocumentAsync(solution, documentId, invocationReasons), _shutdownToken).CompletesAsyncOperation(asyncToken); }
private void EnqueueEvent(Solution oldSolution, Solution newSolution, ProjectId projectId, IAsyncToken asyncToken) { _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemAfterDiffAsync(oldSolution, newSolution, projectId), _shutdownToken).CompletesAsyncOperation(asyncToken); }
public PendingWork(int minimumRunPointInMS, Func<bool> work, IAsyncToken asyncToken, CancellationToken cancellationToken) : this(minimumRunPointInMS, null, work, asyncToken, cancellationToken) { }
public WorkItem(DocumentId documentId, string language, InvocationReasons invocationReasons, bool isLowPriority, IAsyncToken asyncToken) : this(documentId, documentId.ProjectId, language, invocationReasons, isLowPriority, null, ImmutableHashSet.Create <IIncrementalAnalyzer>(), false, asyncToken) { }
public Data(ProjectId projectId, bool needDependencyTracking, IAsyncToken asyncToken) { AsyncToken = asyncToken; ProjectId = projectId; NeedDependencyTracking = needDependencyTracking; }
public WorkItem With(DocumentId documentId, ProjectId projectId, IAsyncToken asyncToken) { // create new work item return new WorkItem( documentId, projectId, this.Language, this.InvocationReasons, this.IsLowPriority, this.ActiveMember, this.Analyzers, this.IsRetry, asyncToken); }
public Data(Document document, SyntaxPath changedMember, IAsyncToken asyncToken) { AsyncToken = asyncToken; Document = document; ChangedMember = changedMember; }
public void RegisterNotification(Action action, IAsyncToken asyncToken, CancellationToken cancellationToken = default) => RegisterNotification(action, DefaultTimeSliceInMS, asyncToken, cancellationToken);
public void RegisterNotification(Action action, IAsyncToken asyncToken, CancellationToken cancellationToken = default(CancellationToken)) { RegisterNotification(action, 0, asyncToken, cancellationToken); }
private void EnqueueEvent(Solution solution, InvocationReasons invocationReasons, IAsyncToken asyncToken) { var task = _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemForSolution(solution, invocationReasons), _shutdownToken).CompletesAsyncOperation(asyncToken); }
public void RegisterNotification(Action action, IAsyncToken asyncToken, CancellationToken cancellationToken = default(CancellationToken)) { RegisterNotification(action, 0, asyncToken, cancellationToken); }
private void ProcessDocumentEvent(WorkspaceChangeEventArgs e, IAsyncToken asyncToken) { switch (e.Kind) { case WorkspaceChangeKind.DocumentAdded: EnqueueEvent(e.NewSolution, e.DocumentId, InvocationReasons.DocumentAdded, asyncToken); break; case WorkspaceChangeKind.DocumentRemoved: EnqueueEvent(e.OldSolution, e.DocumentId, InvocationReasons.DocumentRemoved, asyncToken); break; case WorkspaceChangeKind.DocumentReloaded: case WorkspaceChangeKind.DocumentChanged: EnqueueEvent(e.OldSolution, e.NewSolution, e.DocumentId, asyncToken); break; case WorkspaceChangeKind.AdditionalDocumentAdded: case WorkspaceChangeKind.AdditionalDocumentRemoved: case WorkspaceChangeKind.AdditionalDocumentChanged: case WorkspaceChangeKind.AdditionalDocumentReloaded: // If an additional file has changed we need to reanalyze the entire project. EnqueueEvent(e.NewSolution, e.ProjectId, InvocationReasons.AdditionalDocumentChanged, asyncToken); break; default: throw ExceptionUtilities.Unreachable; } }
public Data(Project project, DocumentId documentId, Document?document, SyntaxPath?changedMember, IAsyncToken asyncToken) { _documentId = documentId; _document = document; Project = project; ChangedMember = changedMember; AsyncToken = asyncToken; }
private void EnqueueEvent(Solution oldSolution, Solution newSolution, ProjectId projectId, IAsyncToken asyncToken) { _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemAfterDiffAsync(oldSolution, newSolution, projectId), _shutdownToken).CompletesAsyncOperation(asyncToken); }
public WorkItem With(IAsyncToken asyncToken) { return(new WorkItem( this.DocumentId, this.ProjectId, this.Language, this.InvocationReasons, this.IsLowPriority, this.ActiveMember, this.Analyzers, retry: false, asyncToken: asyncToken)); }
private void EnqueueEvent(Solution oldSolution, Solution newSolution, DocumentId documentId, IAsyncToken asyncToken) { // document changed event is the special one. _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemAfterDiffAsync(oldSolution, newSolution, documentId), _shutdownToken).CompletesAsyncOperation(asyncToken); }
private void EnqueueChecksumUpdate() { // event will raised sequencially. no concurrency on this handler if (_event.CurrentCount > 0) { return; } lock (_gate) { _lastToken = _lastToken ?? Listener.BeginAsyncOperation(nameof(SolutionChecksumUpdater)); } _event.Release(); }
public PendingWork(int minimumRunPointInMS, Action work, IAsyncToken asyncToken, CancellationToken cancellationToken) : this(minimumRunPointInMS, work, null, asyncToken, cancellationToken) { }
public WorkItem With( InvocationReasons invocationReasons, SyntaxPath currentMember, ImmutableHashSet<IIncrementalAnalyzer> analyzers, bool retry, IAsyncToken asyncToken) { // dispose old one this.AsyncToken.Dispose(); // create new work item return new WorkItem( this.DocumentId, this.ProjectId, this.Language, InvocationReasons.With(invocationReasons), IsLowPriority, this.ActiveMember == currentMember ? currentMember : null, Union(analyzers), this.IsRetry || retry, asyncToken); }
public void RegisterNotification(Func<bool> action, IAsyncToken asyncToken, CancellationToken cancellationToken = default(CancellationToken)) { RegisterNotification(action, DefaultTimeSliceInMS, asyncToken, cancellationToken); }
public WorkItem With(IAsyncToken asyncToken) { return new WorkItem( this.DocumentId, this.ProjectId, this.Language, this.InvocationReasons, this.IsLowPriority, this.ActiveMember, this.Analyzers, retry: false, asyncToken: asyncToken); }
private void EnqueueEvent(Solution solution, InvocationReasons invocationReasons, IAsyncToken asyncToken) { var task = _eventProcessingQueue.ScheduleTask( () => EnqueueWorkItemForSolution(solution, invocationReasons), _shutdownToken).CompletesAsyncOperation(asyncToken); }
public Data(Document document, SyntaxPath changedMember, IAsyncToken asyncToken) { this.AsyncToken = asyncToken; this.Document = document; this.ChangedMember = changedMember; }