Fast path Dart Timeline events with no arguments to avoid calling JSON.encode

sdk/lib/developer/timeline.dart

 // Copyright (c) 2015, 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.
 
 part of dart.developer;
 
 typedef dynamic TimelineSyncFunction();
 typedef Future TimelineAsyncFunction();
 
 /// Add to the timeline.
@@ skipping 26 matching lines @@
     block.finish();
   }
 
   /// Emit an instant event.
   static void instantSync(String name, {Map arguments}) {
     if (name is! String) {
       throw new ArgumentError.value(name,
                                     'name',
                                     'Must be a String');
     }
-    Map instantArguments = {
-      'isolateNumber': '${Timeline._isolateId}'
-    };
+    Map instantArguments;
     if (arguments is Map) {
-      instantArguments.addAll(arguments);
+      instantArguments = new Map.from(arguments);
     }
-    String argumentsAsJson = JSON.encode(instantArguments);
     _reportInstantEvent(_getTraceClock(),
                         'Dart',
                         name,
-                        argumentsAsJson);
+                        _argumentsAsJson(instantArguments));
   }
 
 
   /// A utility method to time a synchronous [function]. Internally calls
   /// [function] bracketed by calls to [startSync] and [finishSync].
   static dynamic timeSync(String name,
                           TimelineSyncFunction function,
                           {Map arguments}) {
     startSync(name, arguments: arguments);
     try {
       return function();
     } finally {
       finishSync();
     }
   }
 
   static final List<_SyncBlock> _stack = new List<_SyncBlock>();
-
   static final int _isolateId = _getIsolateNum();
+  static final String _isolateIdString = _isolateId.toString();
 }
 
 /// An asynchronous task on the timeline. An asynchronous task can have many
 /// (nested) synchronous operations. Synchronous operations can live longer than
 /// the current isolate event. To pass a [TimelineTask] to another isolate,
 /// you must first call [pass] to get the task id and then construct a new
 /// [TimelineTask] in the other isolate.
 class TimelineTask {
   /// Create a task. [taskId] will be set by the system.
   TimelineTask()
@@ skipping 27 matching lines @@
     block._start();
   }
 
   /// Emit an instant event for this task.
   void instant(String name, {Map arguments}) {
     if (name is! String) {
       throw new ArgumentError.value(name,
                                     'name',
                                     'Must be a String');
     }
-    Map instantArguments = {
-      'isolateNumber': '${Timeline._isolateId}'
-    };
+    Map instantArguments;
     if (arguments is Map) {
-      instantArguments.addAll(arguments);
+      instantArguments = new Map.from(arguments);
     }
-    String argumentsAsJson = JSON.encode(instantArguments);
     _reportTaskEvent(_getTraceClock(),
                      _taskId,
                      'n',
                      'Dart',
                      name,
-                     argumentsAsJson);
+                     _argumentsAsJson(instantArguments));
   }
 
   /// Finish the last synchronous operation that was started.
   void finish() {
     if (_stack.length == 0) {
       throw new StateError(
           'Uneven calls to start and finish');
     }
     // Pop top item off of stack.
     var block = _stack.removeLast();
@@ skipping 26 matching lines @@
   /// The asynchronous task id.
   final int _taskId;
   /// An (optional) set of arguments which will be serialized to JSON and
   /// associated with this block.
   final Map arguments = {};
 
   _AsyncBlock._(this.name, this._taskId);
 
   // Emit the start event.
   void _start() {
-    arguments['isolateNumber'] = '${Timeline._isolateId}';
-    String argumentsAsJson = JSON.encode(arguments);
     _reportTaskEvent(_getTraceClock(),
                      _taskId,
                      'b',
                      category,
                      name,
-                     argumentsAsJson);
+                     _argumentsAsJson(arguments));
   }
 
   // Emit the finish event.
   void _finish() {
     _reportTaskEvent(_getTraceClock(),
                      _taskId,
                      'e',
                      category,
                      name,
-                     JSON.encode({}));
+                     _argumentsAsJson(null));
   }
 }
 
 /// A synchronous block of time on the timeline. This block should not be
 /// kept open across isolate messages.
 class _SyncBlock {
   /// The category this block belongs to.
   final String category = 'Dart';
   /// The name of this block.
   final String name;
   /// An (optional) set of arguments which will be serialized to JSON and
   /// associated with this block.
   final Map arguments = {};
   // The start time stamp.
   final int _start;
 
   _SyncBlock._(this.name,
                this._start);
 
   /// Finish this block of time. At this point, this block can no longer be
   /// used.
   void finish() {
-    var end = _getTraceClock();
-
-    arguments['isolateNumber'] = '${Timeline._isolateId}';
-
-    // Encode arguments map as JSON before reporting.
-    var argumentsAsJson = JSON.encode(arguments);
-
     // Report event to runtime.
     _reportCompleteEvent(_start,
-                         end,
+                         _getTraceClock(),
                          category,
                          name,
-                         argumentsAsJson);
+                         _argumentsAsJson(arguments));
   }
 }
 
+String _fastPathArguments;
+String _argumentsAsJson(Map arguments) {
+  if ((arguments == null) || (arguments.length == 0)) {
+    // Fast path no arguments. Avoid calling JSON.encode.
+    if (_fastPathArguments == null) {
+      _fastPathArguments = '{"isolateNumber":"${Timeline._isolateId}"}';
+    }
+    return _fastPathArguments;
+  }
+  // Add isolateNumber to arguments map.
+  arguments['isolateNumber'] = Timeline._isolateIdString;
+  return JSON.encode(arguments);
+}
+
 /// Returns the next async task id.
 external int _getNextAsyncId();
 
 /// Returns the current value from the trace clock.
 external int _getTraceClock();
 
 /// Returns the isolate's main port number.
 external int _getIsolateNum();
 
 /// Reports an event for a task.
 external void _reportTaskEvent(int start,
                                int taskId,
                                String phase,
                                String category,
                                String name,
                                String argumentsAsJson);
 
 /// Reports a complete synchronous event.
 external void _reportCompleteEvent(int start,
                                    int end,
                                    String category,
                                    String name,
                                    String argumentsAsJson);
 
 /// Reports an instant event.
 external void _reportInstantEvent(int start,
                                   String category,
                                   String name,
-                                  String argumentsAsJson);
+                                  String argumentsAsJson);