Add callers and callees to profiler output

runtime/bin/vmservice/client/lib/src/observatory/model.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 observatory;
 
 class CodeInstruction extends Observable {
   @observable final int address;
   @observable final String machine;
   @observable final String human;
@@ skipping 37 matching lines @@
     }
     throw new FallThroughError();
   }
   static const Native = const CodeKind._internal('Native');
   static const Dart = const CodeKind._internal('Dart');
   static const Collected = const CodeKind._internal('Collected');
 }
 
 class CodeTick {
   final int address;
-  final int ticks;
-  CodeTick(this.address, this.ticks);
+  final int exclusive_ticks;
+  final int inclusive_ticks;
+  CodeTick(this.address, this.exclusive_ticks, this.inclusive_ticks);
+}
+
+class CodeCaller {

[turnidge, 2014/02/24 20:13:00]

This isn't necessarily a caller, right?  It can be a caller or a callee?  How
would you feel about the name CallInfo or CallCountInfo?

[Cutch, 2014/02/25 16:44:47]

Done.

+  var code_or_index;
+  int count;
 }
 
 class Code extends Observable {
   final CodeKind kind;
   final int startAddress;
   final int endAddress;
   final List<CodeTick> ticks = [];
+  final List<CodeCaller> callers = [];
+  final List<CodeCaller> callees = [];
   int inclusiveTicks = 0;
   int exclusiveTicks = 0;
   @observable final List<CodeInstruction> instructions = toObservable([]);
   @observable Map functionRef = toObservable({});
   @observable Map codeRef = toObservable({});
   @observable String name;
   @observable String user_name;
 
   Code(this.kind, this.name, this.startAddress, this.endAddress);
 
+  int sumCallersCount() => _sumCallCount(callers);
+  int callersCount(Code code) => _individualCallCount(callers, code);
+  int sumCalleesCount() => _sumCallCount(callees);
+  int calleesCount(Code code) => _individualCallCount(callees, code);

[turnidge, 2014/02/24 20:13:00]

Maybe add simple comments.

[Cutch, 2014/02/25 16:44:47]

Done.

+
+  int _sumCallCount(List<CodeCaller> calls) {
+    var sum = 0;
+    for (CodeCaller caller in calls) {
+      sum += caller.count;
+    }
+    return sum;
+  }
+
+  int _individualCallCount(List<CodeCaller> calls, Code code) {

[turnidge, 2014/02/24 20:13:00]

Maybe just _callCount?

[Cutch, 2014/02/25 16:44:47]

Done.

+    for (CodeCaller caller in calls) {
+      if (caller.code_or_index == code) {
+        return caller.count;
+      }
+    }
+    return 0;
+  }
+
   Code.fromMap(Map m) :
     kind = CodeKind.Dart,
     startAddress = int.parse(m['start'], radix:16),
     endAddress = int.parse(m['end'], radix:16) {
     functionRef = toObservable(m['function']);
     codeRef = {
       'type': '@Code',
       'id': m['id'],
       'name': m['name'],
       'user_name': m['user_name']
     };
     name = m['name'];
     user_name = m['user_name'];
-    _loadInstructions(m['disassembly']);
+    if (m['disassembly'] != null) {
+      _loadInstructions(m['disassembly']);
+    }
   }
 
   /// Resets all tick counts to 0.
   void resetTicks() {
     inclusiveTicks = 0;
     exclusiveTicks = 0;
     ticks.clear();
     for (var instruction in instructions) {
       instruction.ticks = 0;
     }
@@ skipping 28 matching lines @@
   }
 
   /// returns true if [address] is inside the address range.
   bool contains(int address) {
     return (address >= startAddress) && (address < endAddress);
   }
 }
 
 class Profile {
   final Isolate isolate;
+  final List<Code> _codeObjectsInImportOrder = new List<Code>();
   Profile.fromMap(this.isolate, Map m) {
     var codes = m['codes'];
     totalSamples = m['samples'];
     Logger.root.info('Creating profile from ${totalSamples} samples '
                      'and ${codes.length} code objects.');
     isolate.resetCodeTicks();
+    _codeObjectsInImportOrder.clear();
     codes.forEach((code) {
       try {
         _processCode(code);
       } catch (e, st) {
         Logger.root.warning('Error processing code object. $e $st', e, st);
       }
     });
+    assert(_codeObjectsInImportOrder.length == codes.length);

[turnidge, 2014/02/24 20:13:00]

Maybe a comment here, along the lines of:

"Once all code objects have been processed, visit each code object and resolve
its callers and callees."

[Cutch, 2014/02/25 16:44:47]

Done.

+    for (var i = 0; i < codes.length; i++) {
+      Code codeModel = _codeObjectsInImportOrder[i];
+      Map codeService = codes[i];

[turnidge, 2014/02/24 20:13:00]

codeService sounds like a service that returns codes.  Would be clearer with
just codes[i].

+      _loadCallData(codeModel.callers, codeService['callers']);

[turnidge, 2014/02/24 20:13:00]

Would this work as an assignment?

codeModel.callers = _loadCallData(codes[i].callers);

+      _loadCallData(codeModel.callees, codeService['callees']);
+    }
   }
   int totalSamples = 0;
 
+  void _loadCallData(List<CodeCaller> calls, List data) {

[turnidge, 2014/02/24 20:13:00]

How about a different name?  Maybe "_resolveCalls" or something.

[Cutch, 2014/02/25 16:44:47]

Done.

+    calls.clear();
+    // Do the initial load of the data.
+    for (var i = 0; i < data.length; i += 2) {
+      var codeCaller = new CodeCaller();
+      codeCaller.code_or_index = int.parse(data[i]);
+      codeCaller.count = int.parse(data[i + 1]);
+      calls.add(codeCaller);
+    }
+    // Replace indexes with actual code objects.
+    for (var codeCaller in calls) {
+      var index = codeCaller.code_or_index;
+      assert(index >= 0);
+      assert(index < _codeObjectsInImportOrder.length);
+      codeCaller.code_or_index = _codeObjectsInImportOrder[index];

[turnidge, 2014/02/24 20:13:00]

Do you need this second loop?  Why not resolve the index in the first loop like
this:

var codeCaller = new CodeCaller();
var index = int.parse(data[i]);
assert(index >= 0);
assert(index < _codeObjectsInImportOrder.length);
codeCaller.code = _codeObjectsInImportOrder[index];
calls.add(codeCaller);

This would also mean that code_or_index could become code.

[Cutch, 2014/02/25 16:44:47]

Done.

+    }
+    // Sort.
+    calls.sort((a, b) => b.count - a.count);
+  }
+
   Code _processDartCode(Map dartCode) {
     var codeObject = dartCode['code'];
     if ((codeObject == null)) {
       // Detached code objects are handled like 'other' code.
       return _processOtherCode(CodeKind.Dart, dartCode);
     }
     var code = new Code.fromMap(codeObject);
     return code;
   }
 
@@ skipping 24 matching lines @@
     var code = isolate.findCodeByAddress(address);
     if (code == null) {
       if (kind == CodeKind.Dart) {
         code = _processDartCode(profileCode);
       } else {
         code = _processOtherCode(kind, profileCode);
       }
       assert(code != null);
       isolate.codes.add(code);
     }
+    _codeObjectsInImportOrder.add(code);
     // Load code object tick counts and set them.
     var inclusive = int.parse(profileCode['inclusive_ticks']);
     var exclusive = int.parse(profileCode['exclusive_ticks']);
     code.inclusiveTicks = inclusive;
     code.exclusiveTicks = exclusive;
     // Load address specific ticks.
     List ticksList = profileCode['ticks'];
     if (ticksList != null && (ticksList.length > 0)) {
-      for (var i = 0; i < ticksList.length; i += 2) {
+      assert((ticksList.length % 3) == 0);
+      for (var i = 0; i < ticksList.length; i += 3) {
         var address = int.parse(ticksList[i], radix:16);
-        var ticks = int.parse(ticksList[i + 1]);
-        var codeTick = new CodeTick(address, ticks);
+        var inclusive_ticks = int.parse(ticksList[i + 1]);
+        var exclusive_ticks = int.parse(ticksList[i + 2]);
+        var codeTick = new CodeTick(address, exclusive_ticks, inclusive_ticks);
         code.ticks.add(codeTick);
       }
     }
     if ((code.ticks.length > 0) && (code.instructions.length > 0)) {
       // Apply address ticks to instruction stream.
       code.ticks.forEach((CodeTick tick) {
-        code.tick(tick.address, tick.ticks);
+        code.tick(tick.address, tick.inclusive_ticks);
       });
       code.instructions.forEach((i) {
         i.updateTickString(code);
       });
     }
   }
 
   List<Code> topExclusive(int count) {
     List<Code> exclusive = isolate.codes;
     exclusive.sort((Code a, Code b) {
       return b.exclusiveTicks - a.exclusiveTicks;
     });
     if ((exclusive.length < count) || (count == 0)) {
       return exclusive;
     }
     return exclusive.sublist(0, count);
   }
-
-  List<Code> topInclusive(int count) {
-    List<Code> inclusive = isolate.codes;
-    inclusive.sort((Code a, Code b) {
-      return b.inclusiveTicks - a.inclusiveTicks;
-    });
-    if ((inclusive.length < count) || (count == 0)) {
-      return inclusive;
-    }
-    return inclusive.sublist(0, count);
-  }
 }
 
 class ScriptLine extends Observable {
   @observable final int line;
   @observable int hits = -1;
   @observable String text = '';
   /// Is this a line of executable code?
   bool get executable => hits >= 0;
   /// Has this line executed before?
   bool get covered => hits > 0;
@@ skipping 82 matching lines @@
     if (executableLines == 0) {
       return 0.0;
     }
     return (coveredLines / executableLines) * 100.0;
   }
 
   @observable String coveredPercentageFormatted() {
     return '(' + coveredPercentage().toStringAsFixed(1) + '% covered)';
   }
 }