firka/flutter
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Refactor analysis benchmark and collect more data" (#20280)

Browse Source 
* Revert "increase size of user account drawer headers to 48 by 48 (#20266)"

This reverts commit 4a7b4a4dde.

* Revert "EditableText Cursor can be set to not blink for testing (#20004)"

This reverts commit d041b319e8.

* Revert "Refactor analysis benchmark and collect more data (#20169)"

This reverts commit 5ea0a13598.
This commit is contained in:
Ian Hickson
2018-08-06 15:34:08 -07:00
committed by GitHub
parent 4a7b4a4dde
commit b81e361192
1 changed files with 55 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
dev/devicelab/lib/tasks/analysis.dart
View File

@@ -4,20 +4,20 @@
import 'dart:async';
import 'dart:io';
import 'dart:math' as math;
import 'package:path/path.dart' as path;
import '../framework/framework.dart';
import '../framework/utils.dart';
/// Run each benchmark this many times and compute average, min, max.
///
/// This must be small enough that we can do all the work in 15 minutes, the
/// devicelab deadline. Since there's four different analysis tasks, on average,
/// each can have 4 minutes. The tasks currently average a little more than a
/// minute, so that allows three runs per task.
/// Run each benchmark this many times and compute average.
const int _kRunsPerBenchmark = 3;
/// Runs a benchmark once and reports the result as a lower-is-better numeric
/// value.
typedef Future<double> _Benchmark();
/// Path to the generated "mega gallery" app.
Directory get _megaGalleryDirectory => dir(path.join(Directory.systemTemp.path, 'mega_gallery'));
@@ -28,101 +28,76 @@ Future<TaskResult> analyzerBenchmarkTask() async {
await dart(<String>['dev/tools/mega_gallery.dart', '--out=${_megaGalleryDirectory.path}']);
});
final Map<String, dynamic> data = <String, dynamic>{};
data.addAll((await _run(new _FlutterRepoBenchmark())).asMap('flutter_repo', 'batch'));
data.addAll((await _run(new _FlutterRepoBenchmark(watch: true))).asMap('flutter_repo', 'watch'));
data.addAll((await _run(new _MegaGalleryBenchmark())).asMap('mega_gallery', 'batch'));
data.addAll((await _run(new _MegaGalleryBenchmark(watch: true))).asMap('mega_gallery', 'watch'));
final Map<String, dynamic> data = <String, dynamic>{
'flutter_repo_batch': await _run(new _FlutterRepoBenchmark()),
'flutter_repo_watch': await _run(new _FlutterRepoBenchmark(watch: true)),
'mega_gallery_batch': await _run(new _MegaGalleryBenchmark()),
'mega_gallery_watch': await _run(new _MegaGalleryBenchmark(watch: true)),
};
return new TaskResult.success(data, benchmarkScoreKeys: data.keys.toList());
}
class _BenchmarkResult {
const _BenchmarkResult(this.mean, this.min, this.max);
final double mean; // seconds
final double min; // seconds
final double max; // seconds
Map<String, dynamic> asMap(String benchmark, String mode) {
return <String, dynamic>{
'${benchmark}_$mode': mean,
'${benchmark}_${mode}_minimum': min,
'${benchmark}_${mode}_maximum': max,
};
}
}
abstract class _Benchmark {
_Benchmark({ this.watch = false });
/// Times how long it takes to analyze the Flutter repository.
class _FlutterRepoBenchmark {
_FlutterRepoBenchmark({ this.watch = false });
final bool watch;
String get title;
Directory get directory;
List<String> get options {
final List<String> result = <String>[ '--benchmark' ];
if (watch)
options.add('--watch');
return result;
}
Future<double> execute(int iteration, int targetIterations) async {
section('Analyze $title ${watch ? 'with watcher' : ''} - ${iteration + 1} / $targetIterations');
Future<double> call() async {
section('Analyze Flutter repo ${watch ? 'with watcher' : ''}');
final Stopwatch stopwatch = new Stopwatch();
await inDirectory(directory, () async {
await inDirectory(flutterDirectory, () async {
final List<String> options = <String>[
'--flutter-repo',
'--benchmark',
];
if (watch)
options.add('--watch');
stopwatch.start();
await flutter('analyze', options: options);
stopwatch.stop();
});
return stopwatch.elapsedMicroseconds / (1000.0 * 1000.0);
}
}
/// Times how long it takes to analyze the Flutter repository.
class _FlutterRepoBenchmark extends _Benchmark {
_FlutterRepoBenchmark({ bool watch = false }) : super(watch: watch);
@override
String get title => 'Flutter repo';
@override
Directory get directory => flutterDirectory;
@override
List<String> get options {
return super.options
..add('--flutter-repo');
return stopwatch.elapsedMilliseconds / 1000;
}
}
/// Times how long it takes to analyze the generated "mega_gallery" app.
class _MegaGalleryBenchmark extends _Benchmark {
_MegaGalleryBenchmark({ bool watch = false }) : super(watch: watch);
class _MegaGalleryBenchmark {
_MegaGalleryBenchmark({ this.watch = false });
@override
String get title => 'mega gallery';
final bool watch;
@override
Directory get directory => _megaGalleryDirectory;
Future<double> call() async {
section('Analyze mega gallery ${watch ? 'with watcher' : ''}');
final Stopwatch stopwatch = new Stopwatch();
await inDirectory(_megaGalleryDirectory, () async {
final List<String> options = <String>[
'--benchmark',
];
if (watch)
options.add('--watch');
stopwatch.start();
await flutter('analyze', options: options);
stopwatch.stop();
});
return stopwatch.elapsedMilliseconds / 1000;
}
}
/// Runs `benchmark` several times and reports the results.
Future<_BenchmarkResult> _run(_Benchmark benchmark) async {
final List<double> results = <double>[];
for (int i = 0; i < _kRunsPerBenchmark; i += 1) {
/// Runs a [benchmark] several times and reports the average result.
Future<double> _run(_Benchmark benchmark) async {
double best;
for (int i = 0; i < _kRunsPerBenchmark; i++) {
// Delete cached analysis results.
rmTree(dir('${Platform.environment['HOME']}/.dartServer'));
results.add(await benchmark.execute(i, _kRunsPerBenchmark));
final double result = await benchmark();
best = math.min(result, best ?? result);
}
results.sort();
final double sum = results.fold<double>(
0.0,
(double previousValue, double element) => previousValue + element,
);
return new _BenchmarkResult(sum / results.length, results.first, results.last);
return best;
}