Add dead CodeRegionTable for tracking overwritten Dart code

runtime/bin/vmservice/client/lib/src/service/object.dart

 // Copyright (c) 2014, 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 service;
 
 /// State for a running isolate.
 class Isolate extends ServiceObject {
   final VM vm;
   String get link => _id;
   String get hashLink => '#/$_id';
 
   ScriptCache _scripts;
   /// Script cache.
   ScriptCache get scripts => _scripts;
   CodeCache _codes;
   /// Code cache.
   CodeCache get codes => _codes;
   /// Class cache.
   ClassCache _classes;
   ClassCache get classes => _classes;
+  /// Function cache.
+  FunctionCache _functions;
+  FunctionCache get functions => _functions;
 
   void _initOnce() {
     // Only called once.
     assert(_isolate == null);
     _isolate = this;
     _scripts = new ScriptCache(this);
     _codes = new CodeCache(this);
     _classes = new ClassCache(this);
+    _functions = new FunctionCache(this);
   }
 
   Isolate.fromId(this.vm, String id) : super(null, id, '@Isolate') {
     _initOnce();
   }
 
   Isolate.fromMap(this.vm, Map map) : super.fromMap(null, map) {
     _initOnce();
   }
 
   /// Creates a link to [id] relative to [this].
   @reflectable String relativeLink(String id) => '${this.id}/$id';
   /// Creates a relative link to [id] with a '#/' prefix.
   @reflectable String relativeHashLink(String id) => '#/${relativeLink(id)}';
 
   Future<ScriptCache> refreshCoverage() {
     return get('coverage').then(_scripts._processCoverage);
   }
 
   void processProfile(ServiceMap profile) {
     assert(profile.serviceType == 'Profile');
     var codeTable = new List<Code>();
-    var profileCodes = profile['codes'];
-    for (var profileCode in profileCodes) {
-      Code code = profileCode['code'];
+    var codeRegions = profile['codes'];
+    for (var codeRegion in codeRegions) {
+      Code code = codeRegion['code'];
+      assert(code != null);
       codeTable.add(code);
     }
     _codes._resetProfileData();
     _codes._updateProfileData(profile, codeTable);
   }
 
   /// Requests [serviceId] from [this]. Completes to a [ServiceObject].
   /// Can return pre-existing, cached, [ServiceObject]s.
   Future<ServiceObject> get(String serviceId) {
     if (_scripts.cachesId(serviceId)) {
       return _scripts.get(serviceId);
     }
     if (_codes.cachesId(serviceId)) {
       return _codes.get(serviceId);
     }
     if (_classes.cachesId(serviceId)) {
       return _classes.get(serviceId);
     }
+    if (_functions.cachesId(serviceId)) {
+      return _functions.get(serviceId);
+    }
     return vm.getAsMap(relativeLink(serviceId)).then((ObservableMap m) {
       return _upgradeToServiceObject(vm, this, m);
     });
   }
 
   @observable ServiceMap rootLib;
   @observable ObservableMap topFrame;
 
   @observable String name;
   @observable String vmName;
@@ skipping 313 matching lines @@
   }
 
   @reflectable String formattedInclusive(Code code) {
     if (code == null) {
       return '';
     }
     var tick = code.addressTicks[address];
     if (tick == null) {
       return '';
     }
+    // Don't show inclusive ticks if they are the same as exclusive ticks.
+    if (tick.inclusiveTicks == tick.exclusiveTicks) {
+      return '';
+    }
     var pcent = formatPercent(tick.inclusiveTicks, code.totalSamplesInProfile);
     return '$pcent (${tick.inclusiveTicks})';
   }
 
   @reflectable String formattedExclusive(Code code) {
     if (code == null) {
       return '';
     }
     var tick = code.addressTicks[address];
     if (tick == null) {
       return '';
     }
     var pcent = formatPercent(tick.exclusiveTicks, code.totalSamplesInProfile);
     return '$pcent (${tick.exclusiveTicks})';
   }
 }
 
 class CodeKind {
   final _value;
   const CodeKind._internal(this._value);
-  String toString() => 'CodeKind.$_value';
+  String toString() => '$_value';
 
   static CodeKind fromString(String s) {
     if (s == 'Native') {
       return Native;
     } else if (s == 'Dart') {
       return Dart;
     } else if (s == 'Collected') {
       return Collected;
+    } else if (s == 'Reused') {
+      return Reused;

[turnidge, 2014/03/13 18:09:09]

What does Reused mean?  The same exact code at the same address with diff
timestamp?

[Cutch, 2014/03/13 20:52:26]

The address is used by a newer piece of code.

     }
+    Logger.root.warning('Unknown code kind $s');
     throw new FallThroughError();
   }
   static const Native = const CodeKind._internal('Native');
   static const Dart = const CodeKind._internal('Dart');
   static const Collected = const CodeKind._internal('Collected');
+  static const Reused = const CodeKind._internal('Reused');
 }
 
 class CodeCallCount {
   final Code code;
   final int count;
   CodeCallCount(this.code, this.count);
 }
 
 class Code extends ServiceObject {
   @observable CodeKind kind;
   @observable int totalSamplesInProfile = 0;
   @reflectable int exclusiveTicks = 0;
   @reflectable int inclusiveTicks = 0;
   @reflectable int startAddress = 0;
   @reflectable int endAddress = 0;
   @reflectable final callers = new List<CodeCallCount>();
   @reflectable final callees = new List<CodeCallCount>();
   @reflectable final instructions = new ObservableList<CodeInstruction>();
   @reflectable final addressTicks = new ObservableMap<int, CodeTick>();
+  @observable String formattedInclusiveTicks = '';
+  @observable String formattedExclusiveTicks = '';
 
   @observable ServiceMap function;
   String name;
   String vmName;
 
   Code.fromMap(Isolate isolate, Map map) : super.fromMap(isolate, map);
 
   // Reset all data associated with a profile.
   void resetProfileData() {
     totalSamplesInProfile = 0;
     exclusiveTicks = 0;
     inclusiveTicks = 0;
+    formattedInclusiveTicks = '';
+    formattedExclusiveTicks = '';
     callers.clear();
     callees.clear();
     addressTicks.clear();
   }
 
+  /// Reload [this]. Returns a future which completes to [this] or
+  /// a [ServiceError].
+  Future<ServiceObject> reload() {
+    assert(kind != null);
+    if (kind == CodeKind.Dart) {
+      // We only reload Dart code.
+      return super.reload();
+    }
+    return new Future.value(this);
+  }
+
   void _resolveCalls(List<CodeCallCount> calls, List data, List<Code> codes) {
     // Assert that this has been cleared.
     assert(calls.length == 0);
     // Resolve.
     for (var i = 0; i < data.length; i += 2) {
       var index = int.parse(data[i]);
       var count = int.parse(data[i + 1]);
       assert(index >= 0);
       assert(index < codes.length);
       calls.add(new CodeCallCount(codes[index], count));
     }
     // Sort to descending count order.
     calls.sort((a, b) => b.count - a.count);
   }
 
 
+  static String formatPercent(num a, num total) {
+    var percent = 100.0 * (a / total);
+    return '${percent.toStringAsFixed(2)}%';
+  }
+
   void updateProfileData(Map profileData,
                          List<Code> codeTable,
                          int sampleCount) {
-    // Assert we have a ProfileCode entry.
-    assert(profileData['type'] == 'ProfileCode');
+    // Assert we have a CodeRegion entry.
+    assert(profileData['type'] == 'CodeRegion');
     // Assert we are handed profile data for this code object.
     assert(profileData['code'] == this);
     totalSamplesInProfile = sampleCount;
     inclusiveTicks = int.parse(profileData['inclusive_ticks']);
     exclusiveTicks = int.parse(profileData['exclusive_ticks']);
     _resolveCalls(callers, profileData['callers'], codeTable);
     _resolveCalls(callees, profileData['callees'], codeTable);
     var ticks = profileData['ticks'];
     if (ticks != null) {
       _processTicks(ticks);
     }
+    formattedInclusiveTicks =
+        '${formatPercent(inclusiveTicks, totalSamplesInProfile)} '
+        '($inclusiveTicks)';
+    formattedExclusiveTicks =
+        '${formatPercent(exclusiveTicks, totalSamplesInProfile)} '
+        '($inclusiveTicks)';
   }
 
   void _update(ObservableMap m) {
     assert(ServiceObject.isServiceMap(m));
     assert(m['id'] == _id);
     assert(ServiceObject.stripRef(m['type']) == _serviceType);
     name = m['user_name'];
     vmName = m['name'];
+    kind = CodeKind.fromString(m['kind']);
     startAddress = int.parse(m['start'], radix:16);
     endAddress = int.parse(m['end'], radix:16);
     // Upgrade the function.
     function = _upgradeToServiceObject(isolate.vm, isolate, m['function']);
     var disassembly = m['disassembly'];
     if (disassembly != null) {
       _processDisassembly(disassembly);
     }
-    // We are a reference if we don't have instructions.
-    _ref = (instructions.length == 0);
+    // We are a reference if we don't have instructions and are Dart code.
+    _ref = (instructions.length == 0) && (kind == CodeKind.Dart);
+    hasDisassembly = (instructions.length != 0) && (kind == CodeKind.Dart);
   }
 
+  @observable bool hasDisassembly = false;
+
   void _processDisassembly(List<String> disassembly){
     assert(disassembly != null);
     instructions.clear();
     assert((disassembly.length % 3) == 0);
     for (var i = 0; i < disassembly.length; i += 3) {
       var address = 0;  // Assume code comment.
       var machine = disassembly[i + 1];
       var human = disassembly[i + 2];
       if (disassembly[i] != '') {
         // Not a code comment, extract address.
@@ skipping 40 matching lines @@
 
   int _callCount(List<CodeCallCount> calls, Code code) {
     for (CodeCallCount caller in calls) {
       if (caller.code == code) {
         return caller.count;
       }
     }
     return 0;
   }
 }