Will Dart execute isolates in parallel in a multi-core environment?

Question

Question

Will isolates in Dart run in parallel utilizing all available cores on a multiple core environment, or will it multiplex on a single core?

Background

Answer 1

Warning: the code below is out of date and does not work with Dart 1.0.

Short answer

Maybe.

Long Answer

The dart:isolate library guide states: "Isolates might run in a separate process or thread, depending on the implementation. For web applications, isolates can be compiled to Web workers, if they are available." (my emphasis)

Running this code and observing your CPU load will tell you if your implementation does this or not.

#import('dart:isolate');
main() {
  for (var tmp = 0; tmp < 5; ++tmp) {
    SendPort sendPort = spawnFunction(runInIsolate);
    sendPort.call(tmp).then((reply) {
      print(reply);
    });
  }
}

runInIsolate() {
  port.receive((msg, SendPort reply) {
    var k = 0;
    var max = (5 - msg) * 100000000; 
    for (var i = 0; i < max; ++i) {
        i = ++i - 1;
        k = i;
    }
    reply.send("I received: $msg and calculated $k");
  });
}

The standalone dartvm will run isolates in parallel, utilizing all available cores. Browser implementations of Dart will likely vary depending on whether Web Workers are implemented or not.

Answer 2

I looked it up. The isolates seem to be actual threads.

The only mechanism available to communicate between isolates is to pass messages.

Very good, except

Each isolate has its own heap, which means that all values in memory, including globals, are available only to that isolate.

Not at all good, because of the messages:

it is also possible to send object instances (which would be copied in the process

Very bad.

This scheme would seem to make it impossible to communicate large amounts of data from one isolate to another without copying it, so eliminating efficient interisolate communication.

I would not use it because of this restriction that disallows the passing of large objects/buffers by address, as one would normally do with conventional threads.

It looked interesting at first, because I use almost exclusively message-passing designs, but they knackered the inter-thread comms by insisting on only private heaps.

Answer 3

Here is updated code for Dart 1.0.

import 'dart:isolate';

main() {
  int counter = 0;

  ReceivePort receivePort = new ReceivePort();

  receivePort.listen((msg) {
    if (msg is SendPort) {
      msg.send(counter++);
    } else {
      print(msg);
    }
  });

  for (var i = 0; i < 5; i++) {
    Isolate.spawn(runInIsolate, receivePort.sendPort);
  }
}

runInIsolate(SendPort sendPort) {
  ReceivePort receivePort = new ReceivePort();
  sendPort.send(receivePort.sendPort);

  receivePort.listen((msg) {
    var k = 0;
    var max = (5 - msg) * 100000000; 
    for (var i = 0; i < max; ++i) {
        i = ++i - 1;
        k = i;
    }
    sendPort.send("I received: $msg and calculated $k");
  });
}