- Avoid using a streamed receive port for single messages.

runtime/bin/builtin.dart

 // Copyright (c) 2012, 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.
 
 library builtin;
 // NOTE: Do not import 'dart:io' in builtin.
+import 'dart:collection';
 import 'dart:isolate';
 import 'dart:typed_data';
 
 // The root library (aka the script) is imported into this library. The
 // standalone embedder uses this to lookup the main entrypoint in the
 // root library's namespace.
 Function _getMainClosure() => main;
 
 
 // 'print' implementation.
@@ skipping 35 matching lines @@
 const Dart_kImportTag = 0;
 const Dart_kSourceTag = 1;
 const Dart_kCanonicalizeUrl = 2;
 
 // Embedder sets this to true if the --trace-loading flag was passed on the
 // command line.
 bool _traceLoading = false;
 
 // A port for communicating with the service isolate for I/O.
 SendPort _loadPort;
-// Maintain a number of outstanding load requests. Current loading request is
-// finished once there are no outstanding requests.
-int _numOutstandingLoadRequests = 0;
+// The receive port for a load request. Multiple sources can be fetched in
+// a single load request.
+RawReceivePort _receivePort;
+SendPort _sendPort;
+// A request id valid only for the current load cycle (while the number of
+// outstanding load requests is greater than 0). Can be reset when loading is
+// completed.
+int _reqId = 0;
+// An unordered hash map mapping from request id to a particular load request.
+// Once there are not outstanding load requests the current load has finished.

[siva, 2015/05/27 23:08:28]

no outstanding load

[Ivan Posva, 2015/05/27 23:41:31]

Done.

+HashMap _reqMap = new HashMap();
 
 // The current working directory when the embedder was launched.
 Uri _workingDirectory;
 // The URI that the root script was loaded from. Remembered so that
 // package imports can be resolved relative to it. The root script is the basis
 // for the root library in the VM.
 Uri _rootScript;
 // The directory to look in to resolve "package:" scheme URIs. By detault it is
 // the 'packages' directory right next to the script.
 Uri _packageRoot = _rootScript.resolve('packages/');
 
 // Special handling for Windows paths so that they are compatible with URI
 // handling.
 // Embedder sets this to true if we are running on Windows.
 bool _isWindows = false;
 
 
 // A class wrapping the load error message in an Error object.
-class LoadError extends Error {
+class _LoadError extends Error {
   final String message;
-  LoadError(this.message);
+  _LoadError(this.message);
 
   String toString() => 'Load Error: $message';
 }
 
+// Class collecting all of the information about a particular load request.
+class _LoadRequest {
+  final int _id;
+  final int _tag;
+  final String _uri;
+  final String _libraryUri;
+
+  _LoadRequest(this._id, this._tag, this._uri, this._libraryUri);
+}
+
 
 // Native calls provided by the embedder.
 void _signalDoneLoading() native "Builtin_DoneLoading";
 void _loadScriptCallback(int tag, String uri, String libraryUri, Uint8List data)
     native "Builtin_LoadSource";
 void _asyncLoadErrorCallback(uri, libraryUri, error)
     native "Builtin_AsyncLoadError";
 
 
 _sanitizeWindowsPath(path) {
@@ skipping 122 matching lines @@
   // this location.
   _rootScript = scriptUri;
 
   if (_traceLoading) {
     _print('# Resolved entry point to: $_rootScript');
   }
   return scriptUri;
 }
 
 
-void _finishLoadRequest(String uri) {
-  assert(_numOutstandingLoadRequests > 0);
-  _numOutstandingLoadRequests--;
+void _finishLoadRequest(_LoadRequest req) {
+  // Now that we are done with loading remove the request from the map.
+  var tmp = _reqMap.remove(req._id);
+  assert(tmp == req);
   if (_traceLoading) {
-    _print("Loading of $uri finished, "
-           "${_numOutstandingLoadRequests} requests remaining");
+    _print("Loading of ${req._uri} finished, "
+    "${_reqMap.length} requests remaining");
   }
-  if (_numOutstandingLoadRequests == 0) {
+
+  if (_reqMap.isEmpty) {
+    if (_traceLoading) {
+      _print("Closing loading port.");
+    }
+    _receivePort.close();
+    _receivePort = null;
+    _sendPort = null;
+    _reqId = 0;
     _signalDoneLoading();
   }
 }
 
 
-void _startLoadRequest(String uri, Uri resourceUri) {
-  assert(_numOutstandingLoadRequests >= 0);
-  _numOutstandingLoadRequests++;
-  if (_traceLoading) {
-    _print("Loading of $resourceUri for $uri started, "
-           "${_numOutstandingLoadRequests} requests outstanding");
+void _handleLoaderReply(msg) {
+  int id = msg[0];

[siva, 2015/05/27 23:08:28]

assert((id > 0) && (id < _reqMap.length));

[Ivan Posva, 2015/05/27 23:41:31]

assert((id >= 0) && (id < _reqId));

+  var dataOrError = msg[1];
+  var req = _reqMap[id];
+  try {
+    if (dataOrError is Uint8List) {
+      _loadScript(req, dataOrError);
+    } else {
+      assert(dataOrError is String);
+      var error = new _LoadError(dataOrError.toString());
+      _asyncLoadError(req, error);
+    }
+  } catch(e, s) {
+    // Wrap inside a _LoadError unless we are already propagating a
+    // previous _LoadError.
+    var error = (e is _LoadError) ? e : new _LoadError(e.toString());
+    assert(req != null);
+    _asyncLoadError(req, error);
   }
 }
 
 
-void _loadScript(int tag, String uri, String libraryUri, Uint8List data) {
-  // TODO: Currently a compilation error while loading the script is
-  // fatal for the isolate. _loadScriptCallback() does not return and
-  // the _numOutstandingLoadRequests counter remains out of sync.
-  _loadScriptCallback(tag, uri, libraryUri, data);
-  _finishLoadRequest(uri);
+void _startLoadRequest(int tag,
+                       String uri,
+                       String libraryUri,
+                       Uri resourceUri) {
+  if (_reqMap.isEmpty) {
+    if (_traceLoading) {
+      _print("Initializing load port.");
+    }
+    assert(_receivePort == null);
+    assert(_sendPort == null);
+    _receivePort = new RawReceivePort(_handleLoaderReply);
+    _sendPort = _receivePort.sendPort;
+  }
+  // Send the load request to the VM service isolate.
+  var curId = _reqId++;
+  var msg = new List(3);
+  msg[0] = _sendPort;
+  msg[1] = curId;
+  msg[2] = resourceUri.toString();
+  _loadPort.send(msg);
+
+  assert(_reqMap[curId] == null);
+  _reqMap[curId] = new _LoadRequest(curId, tag, uri, libraryUri);

[siva, 2015/05/27 23:08:28]

I understand we are single threaded and adding the request into the map after
sending the message is fine but it would be better for data consistency to order
the code as:

var curId = _reqId++;
assert(_reqMap[curId] == null);
_reqMap[curId] = new ...
var msg = new List[3];
msg[0] = ...;
msg[1] = ...
....
_loadPort.send(msg);

[Ivan Posva, 2015/05/27 23:41:31]

Done.

+
+  if (_traceLoading) {
+    _print("Loading of $resourceUri for $uri started with id: $curId, "
+           "${_reqMap.length} requests outstanding");
+  }
 }
 
 
-void _asyncLoadError(int tag, String uri, String libraryUri, LoadError error) {
-  if (_traceLoading) {
-    _print("_asyncLoadError($uri), error: $error");
-  }
-  if (tag == Dart_kImportTag) {
-    // When importing a library, the libraryUri is the imported
-    // uri.
-    libraryUri = uri;
-  }
-  _asyncLoadErrorCallback(uri, libraryUri, error);
-  _finishLoadRequest(uri);
+void _loadScript(_LoadRequest req, Uint8List data) {
+  // TODO: Currently a compilation error while loading the script is
+  // fatal for the isolate. _loadScriptCallback() does not return and
+  // the number of requests remains out of sync.
+  _loadScriptCallback(req._tag, req._uri, req._libraryUri, data);
+  _finishLoadRequest(req);
 }
 
 
+void _asyncLoadError(_LoadRequest req, _LoadError error) {
+  if (_traceLoading) {
+    _print("_asyncLoadError(${req._uri}), error: $error");
+  }
+  if (req._tag == Dart_kImportTag) {
+    // When importing a library, the libraryUri is the imported
+    // uri.
+    req._libraryUri = req._uri;
+  }
+  _asyncLoadErrorCallback(req._uri, req._libraryUri, error);
+  _finishLoadRequest(req);
+}
+
+
 _loadDataFromLoadPort(int tag,
                       String uri,
                       String libraryUri,
                       Uri resourceUri) {
-  var receivePort = new ReceivePort();
-  receivePort.first.then((dataOrError) {
-    receivePort.close();
-    if (dataOrError is Uint8List) {
-      _loadScript(tag, uri, libraryUri, dataOrError);
-    } else {
-      assert(dataOrError is String);
-      var error = new LoadError(dataOrError.toString());
-      _asyncLoadError(tag, uri, libraryUri, error);
-    }
-  }).catchError((e) {
-    receivePort.close();
-    // Wrap inside a LoadError unless we are already propagating a previously
-    // seen LoadError.
-    var error = (e is LoadError) ? e : new LoadError(e.toString);
-    _asyncLoadError(tag, uri, libraryUri, error);
-  });
-
   try {
-    var msg = [receivePort.sendPort, resourceUri.toString()];
-    _loadPort.send(msg);
-    _startLoadRequest(uri, resourceUri);
+    _startLoadRequest(tag, uri, libraryUri, resourceUri);
   } catch (e) {
     if (_traceLoading) {
       _print("Exception when communicating with service isolate: $e");
     }
-    // Wrap inside a LoadError unless we are already propagating a previously
-    // seen LoadError.
-    var error = (e is LoadError) ? e : new LoadError(e.toString);
+    // Wrap inside a _LoadError unless we are already propagating a previously
+    // seen _LoadError.
+    var error = (e is _LoadError) ? e : new _LoadError(e.toString());
     _asyncLoadError(tag, uri, libraryUri, error);
-    receivePort.close();
   }
 }
 
 
 // Embedder Entrypoint:
 // Asynchronously loads script data through a http[s] or file uri.
 _loadDataAsync(int tag, String uri, String libraryUri) {
   var resourceUri;
   if (tag == Dart_kScriptTag) {
     resourceUri = _resolveScriptUri(uri);
@@ skipping 130 matching lines @@
   } else {
     name = userUri.substring(index + 1);
     path = userUri.substring(0, index + 1);
   }
 
   path = _filePathFromUri(path);
   var filename = _platformExtensionFileName(name);
 
   return [path, filename, name];
 }