blob: 48ea0ec43fded5ca15d67dd7c4b0fff536043976 [file] [log] [blame]
// Copyright (c) 2019, 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.
// VMOptions=--enable-isolate-groups --experimental-enable-isolate-groups-jit
// VMOptions=--no-enable-isolate-groups
// Test that validates that transferables are faster than regular typed data.
import 'dart:async';
import 'dart:isolate';
import 'dart:typed_data';
import "package:expect/expect.dart";
const int toIsolateSize = 100 * 1024 * 1024;
const int fromIsolateSize = 100 * 1024 * 1024;
const int nIterations = 5;
int iteration;
bool keepTimerRunning;
main() async {
keepTimerRunning = true;
print('--- standard');
iteration = nIterations;
final stopwatch = new Stopwatch()..start();
await runBatch(useTransferable: false);
final standard = stopwatch.elapsedMilliseconds;
print('--- transferable');
iteration = nIterations;
stopwatch.reset();
await runBatch(useTransferable: true);
final transferable = stopwatch.elapsedMilliseconds;
print(
'standard($standard ms)/transferable($transferable ms): ${standard / transferable}x');
keepTimerRunning = false;
}
packageList(Uint8List data, bool useTransferable) {
return useTransferable
? TransferableTypedData.fromList(<Uint8List>[data])
: data;
}
class StartMessage {
final SendPort sendPort;
final bool useTransferable;
StartMessage(this.sendPort, this.useTransferable);
}
runBatch({bool useTransferable}) async {
Timer.run(idleTimer);
final port = ReceivePort();
final inbox = StreamIterator<dynamic>(port);
final worker = await Isolate.spawn(
isolateMain, StartMessage(port.sendPort, useTransferable),
paused: true);
final workerCompleted = Completer<bool>();
final workerExitedPort = ReceivePort()
..listen((_) => workerCompleted.complete(true));
worker.addOnExitListener(workerExitedPort.sendPort);
worker.resume(worker.pauseCapability);
await inbox.moveNext();
final outbox = inbox.current;
final workWatch = new Stopwatch();
final data = new Uint8List(toIsolateSize);
while (iteration-- > 0) {
final packagedData = packageList(data, useTransferable);
workWatch.start();
outbox.send(packagedData);
await inbox.moveNext();
final received = inbox.current;
final receivedData = received is TransferableTypedData
? received.materialize().asUint8List()
: received;
int time = workWatch.elapsedMilliseconds;
print('${time}ms for round-trip');
workWatch.reset();
Expect.equals(data.length, receivedData.length);
}
outbox.send(null);
await workerCompleted.future;
workerExitedPort.close();
port.close();
}
Future<Null> isolateMain(StartMessage startMessage) async {
final port = new ReceivePort();
final inbox = new StreamIterator<dynamic>(port);
startMessage.sendPort.send(port.sendPort);
final data = Uint8List.view(new Uint8List(fromIsolateSize).buffer);
while (true) {
await inbox.moveNext();
final received = inbox.current;
if (received == null) {
break;
}
final receivedData =
received is TransferableTypedData ? received.materialize() : received;
final packagedData = packageList(data, startMessage.useTransferable);
startMessage.sendPort.send(packagedData);
}
port.close();
}
final Stopwatch idleWatch = new Stopwatch();
void idleTimer() {
idleWatch.stop();
final time = idleWatch.elapsedMilliseconds;
if (time > 5) print('${time}ms since last checkin');
idleWatch.reset();
idleWatch.start();
if (keepTimerRunning) {
Timer.run(idleTimer);
}
}