Move running tasks for fixed time to the scheduler.

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
@@ skipping 959 matching lines @@
     _drivers.remove(driver);
     _statusSupport.transitionToAnalyzing();
     _hasWork.notify();
   }
 
   /**
    * Run infinitely analysis cycle, selecting the drivers with the highest
    * priority first.
    */
   Future<Null> _run() async {
+    Stopwatch timer = new Stopwatch()..start();
     PerformanceLogSection analysisSection;
     while (true) {
       // Pump the event queue to allow IO and other asynchronous data
       // processing while analysis is active. For example Analysis Server
       // needs to be able to process `updateContent` or `setPriorityFiles`
       // requests while background analysis is in progress.
       //
       // The number of pumpings is arbitrary, might be changed if we see that
       // analysis or other data processing tasks are starving. Ideally we
       // would need to be able to set priority of (continuous) asynchronous
       // tasks.
-      await _pumpEventQueue(128);
+      //
+      // Relinquishing execution flow and running event loop after every task
+      // has too much overhead. Instead we use a fixed length of time, so we
+      // can spend less time overall and still respond quick enough.
+      if (timer.elapsedMilliseconds > 2) {

[Brian Wilkerson, 2016/12/01 14:36:38]

I think it would be a good thing to define some constants for the values used to
control this code, moving the comments above into the comments for the
constants, so that we could more easily find where to change the code in order
to experiment with optimizing these values.

[scheglov, 2016/12/01 16:55:06]

Done.

+        await _pumpEventQueue(128);
+        timer.reset();
+      }
 
       await _hasWork.signal;
 
       if (analysisSection == null) {
         analysisSection = _logger.enter('Analyzing');
       }
 
       // Find the driver with the highest priority.
       AnalysisDriver bestDriver;
       AnalysisDriverPriority bestPriority = AnalysisDriverPriority.nothing;
@@ skipping 257 matching lines @@
   final String name;
   final Completer<List<String>> completer = new Completer<List<String>>();
 
   final List<String> referencingFiles = <String>[];
   final Set<String> checkedFiles = new Set<String>();
   final List<String> filesToCheck = <String>[];
 
   _FilesReferencingNameTask(this.driver, this.name);
 
   /**
-   * Perform work for a fixed length of time, and either complete the
-   * [completer] and return `true` to indicate that the task is done, return
-   * `false` to indicate that the task should continue to be run.
-   *
-   * Relinquishing execution flow and running event loop after every file
-   * works, but has too much overhead. Instead we use a fixed length of time,
-   * so we can spend less time overall and keep quick enough response time.
+   * Perform a single piece of work, and either complete the [completer] and
+   * return `true` to indicate that the task is done, return `false` to indicate
+   * that the task should continue to be run.
    */
   Future<bool> perform() async {
-    Stopwatch timer = new Stopwatch()..start();
-    while (timer.elapsedMilliseconds < 5) {
-      // Prepare files to check.
-      if (filesToCheck.isEmpty) {
-        Set<String> newFiles = driver.addedFiles.difference(checkedFiles);
-        filesToCheck.addAll(newFiles);
-      }
+    // Prepare files to check.
+    if (filesToCheck.isEmpty) {
+      Set<String> newFiles = driver.addedFiles.difference(checkedFiles);
+      filesToCheck.addAll(newFiles);
+    }
 
-      // If no more files to check, complete and done.
-      if (filesToCheck.isEmpty) {
-        completer.complete(referencingFiles);
-        return true;
-      }
+    // If no more files to check, complete and done.
+    if (filesToCheck.isEmpty) {
+      completer.complete(referencingFiles);
+      return true;
+    }
 
-      // Check the next file.
-      String path = filesToCheck.removeLast();
-      FileState file = driver._fsState.getFileForPath(path);
-      if (file.referencedNames.contains(name)) {
-        referencingFiles.add(path);
-      }
-      checkedFiles.add(path);
+    // Check the next file.
+    String path = filesToCheck.removeLast();
+    FileState file = driver._fsState.getFileForPath(path);
+    if (file.referencedNames.contains(name)) {
+      referencingFiles.add(path);
     }
+    checkedFiles.add(path);
 
     // We're not done yet.
     return false;
   }
 }
 
 /**
  * TODO(scheglov) document
  */
 class _LibraryContext {
   final FileState file;
   final SummaryDataStore store;
   _LibraryContext(this.file, this.store);
 }