Add Function based profile tree

runtime/observatory/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;
 
 /// A [ServiceObject] represents a persistent object within the vm.
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
     return o1.name.compareTo(o2.name);
@@ skipping 366 matching lines @@
             // TODO(koda): Do we care about GC events in VM isolate?
             Logger.root.severe(
                 'Ignoring event with unknown isolate id: $owningIsolateId');
           } else {
             var event = new ServiceObject._fromMap(owningIsolate, map);
             events.add(event);
           }
       });
   }
 
-  static final RegExp _currentIsolateMatcher = new RegExp(r'isolates/\d+');
-  static final RegExp _currentObjectMatcher = new RegExp(r'isolates/\d+/');
-  static final String _isolatesPrefix = 'isolates/';
-
-  String _parseObjectId(String id) {
-    Match m = _currentObjectMatcher.matchAsPrefix(id);
-    if (m == null) {
-      return null;
-    }
-    return m.input.substring(m.end);
-  }
-
-  String _parseIsolateId(String id) {
-    Match m = _currentIsolateMatcher.matchAsPrefix(id);
-    if (m == null) {
-      return '';
-    }
-    return id.substring(0, m.end);
-  }
-
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
   Map<String,Isolate> _isolateCache = new Map<String,Isolate>();
 
   ServiceObject getFromMap(ObservableMap map) {
     throw new UnimplementedError();
   }
 
   // Note that this function does not reload the isolate if it found
   // in the cache.
   Future<ServiceObject> getIsolate(String isolateId) {
@@ skipping 80 matching lines @@
     }, test: (e) => e is ServiceError).catchError((exception) {
 
       // ServiceException, forward to VM's ServiceException stream.
       exceptions.add(exception);
       return new Future.error(exception);
     }, test: (e) => e is ServiceException);
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
     return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
-        var obj = new ServiceObject._fromMap(this, response);
-        if (obj.canCache) {
-          _cache.putIfAbsent(id, () => obj);
-        }
-        return obj;
+      var obj = new ServiceObject._fromMap(this, response);
+      if ((obj != null) && obj.canCache) {
+        String objId = obj.id;
+        _cache.putIfAbsent(objId, () => obj);
+      }
+      return obj;
     });
   }
 
   Future<ObservableMap> _fetchDirect() {
     return invokeRpcNoUpgrade('getVM', {});
   }
 
   Future<ServiceObject> getFlagList() {
     return invokeRpc('getFlagList', {});
   }
@@ skipping 185 matching lines @@
   @observable bool loading = true;
   @observable bool ioEnabled = false;
 
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
   final TagProfile tagProfile = new TagProfile(20);
 
   Isolate._empty(ServiceObjectOwner owner) : super._empty(owner) {
     assert(owner is VM);
   }
 
-  static const TAG_ROOT_ID = 'code/tag-0';
-
-  /// Returns the Code object for the root tag.
-  Code tagRoot() {
-    // TODO(turnidge): Use get() here instead?
-    return _cache[TAG_ROOT_ID];
-  }
-
-  void processProfile(ServiceMap profile) {
-    assert(profile.type == 'CpuProfile');
-    var codeTable = new List<Code>();
-    var codeRegions = profile['codes'];
-    for (var codeRegion in codeRegions) {
-      Code code = codeRegion['code'];
-      assert(code != null);
-      codeTable.add(code);
-    }
-    _resetProfileData();
-    _updateProfileData(profile, codeTable);
-    var exclusiveTrie = profile['exclusive_trie'];
-    if (exclusiveTrie != null) {
-      profileTrieRoot = _processProfileTrie(exclusiveTrie, codeTable);
-    }
-  }
-
-  void _resetProfileData() {
+  void resetCachedProfileData() {
     _cache.values.forEach((value) {
-        if (value is Code) {
-          Code code = value;
-          code.resetProfileData();
-        }
-      });
-  }
-
-  void _updateProfileData(ServiceMap profile, List<Code> codeTable) {
-    var codeRegions = profile['codes'];
-    var sampleCount = profile['samples'];
-    for (var codeRegion in codeRegions) {
-      Code code = codeRegion['code'];
-      code.updateProfileData(codeRegion, codeTable, sampleCount);
-    }
+      if (value is Code) {
+        Code code = value;
+        code.profile = null;
+      } else if (value is ServiceFunction) {
+        ServiceFunction function = value;
+        function.profile = null;
+      }
+    });
   }
 
   /// Fetches and builds the class hierarchy for this isolate. Returns the
   /// Object class object.
   Future<Class> getClassHierarchy() {
     return invokeRpc('getClassList', {})
         .then(_loadClasses)
         .then(_buildClassHierarchy);
   }
 
@@ skipping 23 matching lines @@
       }
     }
     assert(objectClass != null);
     return new Future.value(objectClass);
   }
 
   ServiceObject getFromMap(ObservableMap map) {
     if (map == null) {
       return null;
     }
-    String id = map['id'];
-    var obj = _cache[id];
+    String mapId = map['id'];
+    var obj = (mapId != null) ? _cache[mapId] : null;
     if (obj != null) {
       // Consider calling update when map is not a reference.
       return obj;
     }
     // Build the object from the map directly.
     obj = new ServiceObject._fromMap(this, map);
-    if (obj != null && obj.canCache) {
-      _cache[id] = obj;
+    if ((obj != null) && obj.canCache) {
+      _cache[mapId] = obj;
     }
     return obj;
   }
 
   Future<ObservableMap> invokeRpcNoUpgrade(String method, Map params) {
     params['isolateId'] = id;
     return vm.invokeRpcNoUpgrade(method, params);
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
     return invokeRpcNoUpgrade(method, params).then((ObservableMap response) {
-        var obj = new ServiceObject._fromMap(this, response);
-        if (obj.canCache) {
-          _cache.putIfAbsent(id, () => obj);
-        }
-        return obj;
+      var obj = new ServiceObject._fromMap(this, response);
+      if ((obj != null) && obj.canCache) {
+        String objId = obj.id;
+        _cache.putIfAbsent(objId, () => obj);
+      }
+      return obj;
     });
   }
 
   Future<ServiceObject> getObject(String objectId) {
     assert(objectId != null && objectId != '');
     var obj = _cache[objectId];
     if (obj != null) {
       return obj.reload();
     }
     Map params = {
@@ skipping 135 matching lines @@
 
   Future<TagProfile> updateTagProfile() {
     return isolate.invokeRpcNoUpgrade('getTagProfile', {}).then(
       (ObservableMap map) {
         var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
         tagProfile._processTagProfile(seconds, map);
         return tagProfile;
       });
   }
 
-  @reflectable CodeTrieNode profileTrieRoot;
-  // The profile trie is serialized as a list of integers. Each node
-  // is recreated by consuming some portion of the list. The format is as
-  // follows:
-  // [0] index into codeTable of code object.
-  // [1] tick count (number of times this stack frame occured).
-  // [2] child node count
-  // Reading the trie is done by recursively reading the tree depth-first
-  // pre-order.
-  CodeTrieNode _processProfileTrie(List<int> data, List<Code> codeTable) {
-    // Setup state shared across calls to _readTrieNode.
-    _trieDataCursor = 0;
-    _trieData = data;
-    if (_trieData == null) {
-      return null;
-    }
-    if (_trieData.length < 3) {
-      // Not enough integers for 1 node.
-      return null;
-    }
-    // Read the tree, returns the root node.
-    return _readTrieNode(codeTable);
-  }
-  int _trieDataCursor;
-  List<int> _trieData;
-  CodeTrieNode _readTrieNode(List<Code> codeTable) {
-    // Read index into code table.
-    var index = _trieData[_trieDataCursor++];
-    // Lookup code object.
-    var code = codeTable[index];
-    // Frame counter.
-    var count = _trieData[_trieDataCursor++];
-    // Create node.
-    var node = new CodeTrieNode(code, count);
-    // Number of children.
-    var children = _trieData[_trieDataCursor++];
-    // Recursively read child nodes.
-    for (var i = 0; i < children; i++) {
-      var child = _readTrieNode(codeTable);
-      node.children.add(child);
-      node.summedChildCount += child.count;
-    }
-    return node;
-  }
-
   ObservableList<Breakpoint> breakpoints = new ObservableList();
 
   void _removeBreakpoint(Breakpoint bpt) {
     var script = bpt.script;
     var tokenPos = bpt.tokenPos;
     assert(tokenPos != null);
     if (script.loaded) {
       var line = script.tokenToLine(tokenPos);
       assert(line != null);
       if (script.lines[line - 1] != null) {
@@ skipping 761 matching lines @@
 
   String toString() => 'Context($length)';
 }
 
 
 // TODO(koda): Sync this with VM.
 class FunctionKind {
   final String _strValue;
   FunctionKind._internal(this._strValue);
   toString() => _strValue;
-  bool isFake() => [kCollected, kNative, kTag, kReused].contains(this);
+  bool isSynthetic() => [kCollected, kNative, kTag, kReused].contains(this);
 
   static FunctionKind fromJSON(String value) {
     switch(value) {
       case 'kRegularFunction': return kRegularFunction;
       case 'kClosureFunction': return kClosureFunction;
       case 'kGetterFunction': return kGetterFunction;
       case 'kSetterFunction': return kSetterFunction;
       case 'kConstructor': return kConstructor;
       case 'kImplicitGetter': return kImplicitGetterFunction;
       case 'kImplicitSetter': return kImplicitSetterFunction;
@@ skipping 38 matching lines @@
   @observable int endTokenPos;
   @observable Code code;
   @observable Code unoptimizedCode;
   @observable bool isOptimizable;
   @observable bool isInlinable;
   @observable FunctionKind kind;
   @observable int deoptimizations;
   @observable String qualifiedName;
   @observable int usageCounter;
   @observable bool isDart;
+  @observable ProfileFunction profile;
+
+  bool get canCache => true;
+  bool get immutable => false;
 
   ServiceFunction._empty(ServiceObject owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     name = map['name'];
     vmName = (map.containsKey('vmName') ? map['vmName'] : name);
 
     _upgradeCollection(map, isolate);
 
     owningClass = map.containsKey('owningClass') ? map['owningClass'] : null;
     owningLibrary = map.containsKey('owningLibrary') ? map['owningLibrary'] : null;
     kind = FunctionKind.fromJSON(map['kind']);
-    isDart = !kind.isFake();
+    isDart = !kind.isSynthetic();
 
     if (parent == null) {
       qualifiedName = (owningClass != null) ?
           "${owningClass.name}.${name}" :
           name;
     } else {
       qualifiedName = "${parent.qualifiedName}.${name}";
     }
 
-    if (mapIsRef) { return; }
+    if (mapIsRef) {
+      return;
+    }
 
     isStatic = map['static'];
     isConst = map['const'];
     parent = map['parent'];
     script = map['script'];
     tokenPos = map['tokenPos'];
     endTokenPos = map['endTokenPos'];
     code = _convertNull(map['code']);
     unoptimizedCode = _convertNull(map['unoptimizedCode']);
     isOptimizable = map['optimizable'];
     isInlinable = map['inlinable'];
     deoptimizations = map['deoptimizations'];
     usageCounter = map['usageCounter'];
-
   }
 }
 
 
 class Field extends ServiceObject {
   @observable var /* Library or Class */ owner;
   @observable Instance declaredType;
   @observable bool isStatic;
   @observable bool isFinal;
   @observable bool isConst;
@@ skipping 222 matching lines @@
   }
 
   void _applyHitsToLines() {
     for (var line in lines) {
       var hits = _hits[line.line];
       line.hits = hits;
     }
   }
 }
 
-class CodeTick {
-  final int address;
-  final int exclusiveTicks;
-  final int inclusiveTicks;
-  CodeTick(this.address, this.exclusiveTicks, this.inclusiveTicks);
-}
-
 class PcDescriptor extends Observable {
   final int pcOffset;
   @reflectable final int deoptId;
   @reflectable final int tokenPos;
   @reflectable final int tryIndex;
   @reflectable final String kind;
   @observable Script script;
   @observable String formattedLine;
   PcDescriptor(this.pcOffset, this.deoptId, this.tokenPos, this.tryIndex,
                this.kind);
@@ skipping 123 matching lines @@
 
 class CodeInstruction extends Observable {
   @observable final int address;
   @observable final int pcOffset;
   @observable final String machine;
   @observable final String human;
   @observable CodeInstruction jumpTarget;
   @reflectable List<PcDescriptor> descriptors =
       new ObservableList<PcDescriptor>();
 
-  static String formatPercent(num a, num total) {
-    var percent = 100.0 * (a / total);
-    return '${percent.toStringAsFixed(2)}%';
-  }
-
   CodeInstruction(this.address, this.pcOffset, this.machine, this.human);
 
   @reflectable bool get isComment => address == 0;
   @reflectable bool get hasDescriptors => descriptors.length > 0;
 
-  @reflectable String formattedAddress() {
-    if (address == 0) {
-      return '';
-    }
-    return '0x${address.toRadixString(16)}';
-  }
-
-  @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})';
-  }
-
   bool _isJumpInstruction() {
     return human.startsWith('j');
   }
 
   int _getJumpAddress() {
     assert(_isJumpInstruction());
     var chunks = human.split(' ');
     if (chunks.length != 2) {
       // We expect jump instructions to be of the form 'j.. address'.
       return 0;
     }
     var address = chunks[1];
     if (address.startsWith('0x')) {
       // Chop off the 0x.
       address = address.substring(2);
     }
     try {
       return int.parse(address, radix:16);
     } catch (_) {
       return 0;
     }
   }
 
   void _resolveJumpTarget(List<CodeInstruction> instructions) {
     if (!_isJumpInstruction()) {
       return;
     }
     int address = _getJumpAddress();
     if (address == 0) {
-      // Could not determine jump address.
-      Logger.root.severe('Could not determine jump address for $human');
       return;
     }
     for (var i = 0; i < instructions.length; i++) {
       var instruction = instructions[i];
       if (instruction.address == address) {
         jumpTarget = instruction;
         return;
       }
     }
-    Logger.root.severe(
-        'Could not find instruction at ${address.toRadixString(16)}');
   }
 }
 
 class CodeKind {
   final _value;
   const CodeKind._internal(this._value);
   String toString() => '$_value';
 
   static CodeKind fromString(String s) {
     if (s == 'Native') {
@@ skipping 10 matching lines @@
     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');
   static const Tag = const CodeKind._internal('Tag');
 }
 
-class CodeCallCount {
-  final Code code;
-  final int count;
-  CodeCallCount(this.code, this.count);
-}
-
-class CodeTrieNode {
-  final Code code;
-  final int count;
-  final children = new List<CodeTrieNode>();
-  int summedChildCount = 0;
-  CodeTrieNode(this.code, this.count);
+class CodeInlineInterval {
+  final int start;
+  final int end;
+  final List<ServiceFunction> functions = new List<ServiceFunction>();
+  bool contains(int pc) => (pc >= start) && (pc < end);
+  CodeInlineInterval(this.start, this.end);
 }
 
 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 Instance objectPool;
   @observable ServiceFunction function;
   @observable Script script;
   @observable bool isOptimized = false;
-
+  @reflectable int startAddress = 0;
+  @reflectable int endAddress = 0;
+  @reflectable final instructions = new ObservableList<CodeInstruction>();
+  @observable ProfileCode profile;
+  final List<CodeInlineInterval> inlineIntervals =
+      new List<CodeInlineInterval>();
+  final ObservableList<ServiceFunction> inlinedFunctions =
+      new ObservableList<ServiceFunction>();
   bool get canCache => true;
   bool get immutable => true;
 
   Code._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  // Reset all data associated with a profile.
-  void resetProfileData() {
-    totalSamplesInProfile = 0;
-    exclusiveTicks = 0;
-    inclusiveTicks = 0;
-    formattedInclusiveTicks = '';
-    formattedExclusiveTicks = '';
-    callers.clear();
-    callees.clear();
-    addressTicks.clear();
-  }
-
   void _updateDescriptors(Script script) {
     this.script = script;
     for (var instruction in instructions) {
       for (var descriptor in instruction.descriptors) {
         descriptor.processScript(script);
       }
     }
   }
 
   void loadScript() {
@@ skipping 28 matching lines @@
   /// 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 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)} '
-        '($exclusiveTicks)';
-  }
-
   void _update(ObservableMap m, bool mapIsRef) {
     name = m['name'];
     vmName = (m.containsKey('vmName') ? m['vmName'] : name);
     isOptimized = m['optimized'] != null ? m['optimized'] : false;
     kind = CodeKind.fromString(m['kind']);
     startAddress = int.parse(m['start'], radix:16);
     endAddress = int.parse(m['end'], radix:16);
     function = isolate.getFromMap(m['function']);
+    if (mapIsRef) {
+      return;
+    }
+    _loaded = true;
     objectPool = isolate.getFromMap(m['objectPool']);
     var disassembly = m['disassembly'];
     if (disassembly != null) {
       _processDisassembly(disassembly);
     }
     var descriptors = m['descriptors'];
     if (descriptors != null) {
       descriptors = descriptors['members'];
       _processDescriptors(descriptors);
     }
-    // We are loaded if we have instructions or are not Dart code.
-    _loaded = (instructions.length != 0) || (kind != CodeKind.Dart);
     hasDisassembly = (instructions.length != 0) && (kind == CodeKind.Dart);
+    inlinedFunctions.clear();
+    var inlinedFunctionsTable = m['inlinedFunctions'];
+    var inlinedIntervals = m['inlinedIntervals'];
+    if (inlinedFunctionsTable != null) {
+      // Iterate and upgrade each ServiceFunction.
+      for (var i = 0; i < inlinedFunctionsTable.length; i++) {
+        // Upgrade each function and set it back in the list.
+        var func = isolate.getFromMap(inlinedFunctionsTable[i]);
+        inlinedFunctionsTable[i] = func;
+        if (!inlinedFunctions.contains(func)) {
+          inlinedFunctions.add(func);
+        }
+      }
+    }
+    if ((inlinedIntervals == null) || (inlinedFunctionsTable == null)) {
+      // No inline information.
+      inlineIntervals.clear();
+      return;
+    }
+    _processInline(inlinedFunctionsTable, inlinedIntervals);
+  }
+
+  CodeInlineInterval findInterval(int pc) {
+    for (var i = 0; i < inlineIntervals.length; i++) {
+      var interval = inlineIntervals[i];
+      if (interval.contains(pc)) {
+        return interval;
+      }
+    }
+    return null;
+  }
+
+  void _processInline(List<ServiceFunction> inlinedFunctionsTable,
+                      List<List<int>> inlinedIntervals) {
+    for (var i = 0; i < inlinedIntervals.length; i++) {
+      var inlinedInterval = inlinedIntervals[i];
+      var start = inlinedInterval[0] + startAddress;
+      var end = inlinedInterval[1] + startAddress;
+      var codeInlineInterval = new CodeInlineInterval(start, end);
+      for (var i = 2; i < inlinedInterval.length - 1; i++) {
+        var inline_id = inlinedInterval[i];
+        if (inline_id < 0) {
+          continue;
+        }
+        var function = inlinedFunctionsTable[inline_id];
+        codeInlineInterval.functions.add(function);
+      }
+      inlineIntervals.add(codeInlineInterval);
+    }
   }
 
   @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.
@@ skipping 33 matching lines @@
     Logger.root.warning(
         'Could not find instruction with pc descriptor address: $address');
   }
 
   void _processDescriptors(List<Map> descriptors) {
     for (Map descriptor in descriptors) {
       _processDescriptor(descriptor);
     }
   }
 
-  void _processTicks(List<String> profileTicks) {
-    assert(profileTicks != null);
-    assert((profileTicks.length % 3) == 0);
-    for (var i = 0; i < profileTicks.length; i += 3) {
-      var address = int.parse(profileTicks[i], radix:16);
-      var exclusive = int.parse(profileTicks[i + 1]);
-      var inclusive = int.parse(profileTicks[i + 2]);
-      var tick = new CodeTick(address, exclusive, inclusive);
-      addressTicks[address] = tick;
-    }
-  }
-
   /// Returns true if [address] is contained inside [this].
   bool contains(int address) {
     return (address >= startAddress) && (address < endAddress);
   }
 
-  /// Sum all caller counts.
-  int sumCallersCount() => _sumCallCount(callers);
-  /// Specific caller count.
-  int callersCount(Code code) => _callCount(callers, code);
-  /// Sum of callees count.
-  int sumCalleesCount() => _sumCallCount(callees);
-  /// Specific callee count.
-  int calleesCount(Code code) => _callCount(callees, code);
-
-  int _sumCallCount(List<CodeCallCount> calls) {
-    var sum = 0;
-    for (CodeCallCount caller in calls) {
-      sum += caller.count;
-    }
-    return sum;
-  }
-
-  int _callCount(List<CodeCallCount> calls, Code code) {
-    for (CodeCallCount caller in calls) {
-      if (caller.code == code) {
-        return caller.count;
-      }
-    }
-    return 0;
-  }
-
   @reflectable bool get isDartCode => kind == CodeKind.Dart;
 }
 
 
 class SocketKind {
   final _value;
   const SocketKind._internal(this._value);
   String toString() => '$_value';
 
   static SocketKind fromString(String s) {
@@ skipping 238 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }