- 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 no outstanding load requests the current load has finished.
+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];
+  var dataOrError = msg[1];
+  assert((id >= 0) && (id < _reqId));
+  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;
+  }
+  // Register the load request and send it to the VM service isolate.
+  var curId = _reqId++;
+
+  assert(_reqMap[curId] == null);
+  _reqMap[curId] = new _LoadRequest(curId, tag, uri, libraryUri);
+
+  var msg = new List(3);
+  msg[0] = _sendPort;
+  msg[1] = curId;
+  msg[2] = resourceUri.toString();
+  _loadPort.send(msg);
+
+  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];
 }