Added page to Observatory to display native memory allocation information.

runtime/observatory/lib/src/cpu_profile/cpu_profile.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 cpu_profiler;
 
 abstract class CallTreeNode<NodeT extends M.CallTreeNode>
     implements M.CallTreeNode {
   final List<NodeT> children;
   final int count;
+  final int inclusiveNativeAllocations;
+  final int exclusiveNativeAllocations;
   double get percentage => _percentage;
   double _percentage = 0.0;
   final Set<String> attributes = new Set<String>();
 
   // Either a ProfileCode or a ProfileFunction.
   Object get profileData;
   String get name;
 
-  CallTreeNode(this.children, this.count);
+  CallTreeNode(this.children, this.count, this.inclusiveNativeAllocations,
+      this.exclusiveNativeAllocations);
 }
 
 class CodeCallTreeNode extends CallTreeNode<CodeCallTreeNode>
     implements M.CodeCallTreeNode {
   final ProfileCode profileCode;
 
   Object get profileData => profileCode;
 
   String get name => profileCode.code.name;
 
   final Set<String> attributes = new Set<String>();
-  CodeCallTreeNode(this.profileCode, int count)
-      : super(new List<CodeCallTreeNode>(), count) {
+  CodeCallTreeNode(this.profileCode, int count, int inclusiveNativeAllocations,
+      int exclusiveNativeAllocations)
+      : super(new List<CodeCallTreeNode>(), count, inclusiveNativeAllocations,
+            exclusiveNativeAllocations) {
     attributes.addAll(profileCode.attributes);
   }
 }
 
 class CallTree<NodeT extends CallTreeNode> {
   final bool inclusive;
   final NodeT root;
 
   CallTree(this.inclusive, this.root);
 }
 
 class CodeCallTree extends CallTree<CodeCallTreeNode>
     implements M.CodeCallTree {
   CodeCallTree(bool inclusive, CodeCallTreeNode root) : super(inclusive, root) {
-    _setCodePercentage(null, root);
+    if (root.inclusiveNativeAllocations != 0) {
+      _setCodeMemoryPercentage(null, root);
+    } else {
+      _setCodePercentage(null, root);
+    }
   }
 
   CodeCallTree filtered(CallTreeNodeFilter filter) {
     var treeFilter = new _FilteredCodeCallTreeBuilder(filter, this);
     treeFilter.build();
-    _setCodePercentage(null, treeFilter.filtered.root);
+    if (treeFilter.filtered.root.inclusiveNativeAllocations != 0) {
+      _setCodeMemoryPercentage(null, treeFilter.filtered.root);
+    } else {
+      _setCodePercentage(null, treeFilter.filtered.root);
+    }
     return treeFilter.filtered;
   }
 
   _setCodePercentage(CodeCallTreeNode parent, CodeCallTreeNode node) {
     assert(node != null);
     var parentPercentage = 1.0;
     var parentCount = node.count;
     if (parent != null) {
       parentPercentage = parent._percentage;
       parentCount = parent.count;
     }
     if (inclusive) {
       node._percentage = parentPercentage * (node.count / parentCount);
     } else {
       node._percentage = (node.count / parentCount);
     }
     for (var child in node.children) {
       _setCodePercentage(node, child);
     }
   }
 
+  _setCodeMemoryPercentage(CodeCallTreeNode parent, CodeCallTreeNode node) {
+    assert(node != null);
+    var parentPercentage = 1.0;
+    var parentMemory = node.inclusiveNativeAllocations;
+    if (parent != null) {
+      parentPercentage = parent._percentage;
+      parentMemory = parent.inclusiveNativeAllocations;
+    }
+    if (inclusive) {
+      node._percentage =
+          parentPercentage * (node.inclusiveNativeAllocations / parentMemory);
+    } else {
+      node._percentage = (node.inclusiveNativeAllocations / parentMemory);

[Cutch, 2017/03/23 23:39:44]

should this be exclusiveNativeAllocations?

[bkonyi, 2017/03/24 00:53:38]

No, since the variable "inclusive" represents the direction of the tree, keeping
consistent with the flags used in Observatory for "Top Down" and "Bottom Up" 

+    }
+    for (var child in node.children) {
+      _setCodeMemoryPercentage(node, child);
+    }
+  }
+
   _recordCallerAndCalleesInner(
       CodeCallTreeNode caller, CodeCallTreeNode callee) {
     if (caller != null) {
       caller.profileCode._recordCallee(callee.profileCode, callee.count);
       callee.profileCode._recordCaller(caller.profileCode, caller.count);
     }
 
     for (var child in callee.children) {
       _recordCallerAndCalleesInner(callee, child);
     }
@@ skipping 14 matching lines @@
 
 class FunctionCallTreeNode extends CallTreeNode {
   final ProfileFunction profileFunction;
   final codes = new List<FunctionCallTreeNodeCode>();
   int _totalCodeTicks = 0;
   int get totalCodesTicks => _totalCodeTicks;
 
   String get name => M.getFunctionFullName(profileFunction.function);
   Object get profileData => profileFunction;
 
-  FunctionCallTreeNode(this.profileFunction, int count)
-      : super(new List<FunctionCallTreeNode>(), count) {
+  FunctionCallTreeNode(this.profileFunction, int count,
+      inclusiveNativeAllocations, exclusiveNativeAllocations)
+      : super(new List<FunctionCallTreeNode>(), count,
+            inclusiveNativeAllocations, exclusiveNativeAllocations) {
     profileFunction._addKindBasedAttributes(attributes);
   }
 
   // Does this function have an optimized version of itself?
   bool hasOptimizedCode() {
     for (var nodeCode in codes) {
       var profileCode = nodeCode.code;
       if (!profileCode.code.isDartCode) {
         continue;
       }
@@ skipping 162 matching lines @@
 
 class _FilteredFunctionCallTreeBuilder extends _FilteredCallTreeBuilder {
   _FilteredFunctionCallTreeBuilder(
       CallTreeNodeFilter filter, FunctionCallTree tree)
       : super(
             filter,
             tree,
             new FunctionCallTree(
                 tree.inclusive,
                 new FunctionCallTreeNode(
-                    tree.root.profileData, tree.root.count)));
+                    tree.root.profileData,
+                    tree.root.count,
+                    tree.root.inclusiveNativeAllocations,
+                    tree.root.exclusiveNativeAllocations)));
 
   _copyNode(FunctionCallTreeNode node) {
-    return new FunctionCallTreeNode(node.profileData, node.count);
+    return new FunctionCallTreeNode(node.profileData, node.count,
+        node.inclusiveNativeAllocations, node.exclusiveNativeAllocations);
   }
 }
 
 class _FilteredCodeCallTreeBuilder extends _FilteredCallTreeBuilder {
   _FilteredCodeCallTreeBuilder(CallTreeNodeFilter filter, CodeCallTree tree)
       : super(
             filter,
             tree,
-            new CodeCallTree(tree.inclusive,
-                new CodeCallTreeNode(tree.root.profileData, tree.root.count)));
+            new CodeCallTree(
+                tree.inclusive,
+                new CodeCallTreeNode(
+                    tree.root.profileData,
+                    tree.root.count,
+                    tree.root.inclusiveNativeAllocations,
+                    tree.root.exclusiveNativeAllocations)));
 
   _copyNode(CodeCallTreeNode node) {
-    return new CodeCallTreeNode(node.profileData, node.count);
+    return new CodeCallTreeNode(node.profileData, node.count,
+        node.inclusiveNativeAllocations, node.exclusiveNativeAllocations);
   }
 }
 
 class FunctionCallTree extends CallTree implements M.FunctionCallTree {
   FunctionCallTree(bool inclusive, FunctionCallTreeNode root)
       : super(inclusive, root) {
-    _setFunctionPercentage(null, root);
+    if (root.inclusiveNativeAllocations != 0 &&
+        root.inclusiveNativeAllocations != null) {

[Cutch, 2017/03/23 23:39:44]

test for null before testing against 0.

wrap each in parens.

[bkonyi, 2017/03/24 00:53:38]

Done.

+      _setFunctionMemoryPercentage(null, root);
+    } else {
+      _setFunctionPercentage(null, root);
+    }
   }
 
   FunctionCallTree filtered(CallTreeNodeFilter filter) {
     var treeFilter = new _FilteredFunctionCallTreeBuilder(filter, this);
     treeFilter.build();
-    _setFunctionPercentage(null, treeFilter.filtered.root);
+    if (treeFilter.filtered.root.inclusiveNativeAllocations != 0 &&

[Cutch, 2017/03/23 23:39:44]

ditto

[bkonyi, 2017/03/24 00:53:38]

Done.

+        treeFilter.filtered.root.inclusiveNativeAllocations != null) {
+      _setFunctionMemoryPercentage(null, treeFilter.filtered.root);
+    } else {
+      _setFunctionPercentage(null, treeFilter.filtered.root);
+    }
     return treeFilter.filtered;
   }
 
   void _setFunctionPercentage(
       FunctionCallTreeNode parent, FunctionCallTreeNode node) {
     assert(node != null);
     var parentPercentage = 1.0;
     var parentCount = node.count;
     if (parent != null) {
       parentPercentage = parent._percentage;
       parentCount = parent.count;
     }
     if (inclusive) {
       node._percentage = parentPercentage * (node.count / parentCount);
     } else {
       node._percentage = (node.count / parentCount);
     }
     for (var child in node.children) {
       _setFunctionPercentage(node, child);
     }
   }
 
+  void _setFunctionMemoryPercentage(
+      FunctionCallTreeNode parent, FunctionCallTreeNode node) {
+    assert(node != null);
+    var parentPercentage = 1.0;
+    var parentMemory = node.inclusiveNativeAllocations;
+    if (parent != null) {
+      parentPercentage = parent._percentage;
+      parentMemory = parent.inclusiveNativeAllocations;
+    }
+    if (inclusive) {
+      node._percentage =
+          parentPercentage * (node.inclusiveNativeAllocations / parentMemory);
+    } else {
+      node._percentage = (node.inclusiveNativeAllocations / parentMemory);

[Cutch, 2017/03/23 23:39:44]

should this be exclusiveNativeAllocations?

[bkonyi, 2017/03/24 00:53:38]

See reply above.

+    }
+    for (var child in node.children) {
+      _setFunctionMemoryPercentage(node, child);
+    }
+  }
+
   _markFunctionCallsInner(
       FunctionCallTreeNode caller, FunctionCallTreeNode callee) {
     if (caller != null) {
       caller.profileFunction
           ._recordCallee(callee.profileFunction, callee.count);
       callee.profileFunction
           ._recordCaller(caller.profileFunction, caller.count);
     }
     for (var child in callee.children) {
       _markFunctionCallsInner(callee, child);
@@ skipping 20 matching lines @@
   int _exclusiveTicks = 0;
   int get exclusiveTicks => _exclusiveTicks;
   InlineIntervalTick(this.startAddress);
 }
 
 class ProfileCode implements M.ProfileCode {
   final CpuProfile profile;
   final Code code;
   int exclusiveTicks;
   int inclusiveTicks;
+  int exclusiveNativeAllocations;
+  int inclusiveNativeAllocations;
   double normalizedExclusiveTicks = 0.0;
   double normalizedInclusiveTicks = 0.0;
   final addressTicks = new Map<int, CodeTick>();
   final intervalTicks = new Map<int, InlineIntervalTick>();
   String formattedInclusiveTicks = '';
   String formattedExclusiveTicks = '';
   String formattedExclusivePercent = '';
   String formattedCpuTime = '';
   String formattedOnStackTime = '';
   final Set<String> attributes = new Set<String>();
@@ skipping 56 matching lines @@
 
     normalizedExclusiveTicks = exclusiveTicks / profile.sampleCount;
 
     normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount;
 
     var ticks = data['ticks'];
     if (ticks != null) {
       _processTicks(ticks);
     }
 
+    if (data.containsKey('exclusiveNativeAllocations') &&
+        data.containsKey('inclusiveNativeAllocations')) {
+      exclusiveNativeAllocations =
+          int.parse(data['exclusiveNativeAllocations']);
+      inclusiveNativeAllocations =
+          int.parse(data['inclusiveNativeAllocations']);
+    }
+
     formattedExclusivePercent =
         Utils.formatPercent(exclusiveTicks, profile.sampleCount);
 
     formattedCpuTime = Utils.formatTimeMilliseconds(
         profile.approximateMillisecondsForCount(exclusiveTicks));
 
     formattedOnStackTime = Utils.formatTimeMilliseconds(
         profile.approximateMillisecondsForCount(inclusiveTicks));
 
     formattedInclusiveTicks =
@@ skipping 31 matching lines @@
   final Map<ProfileFunction, int> callees = new Map<ProfileFunction, int>();
 
   // Absolute ticks:
   int exclusiveTicks = 0;
   int inclusiveTicks = 0;
 
   // Global percentages:
   double normalizedExclusiveTicks = 0.0;
   double normalizedInclusiveTicks = 0.0;
 
+  // Native allocations:
+  int exclusiveNativeAllocations = 0;
+  int inclusiveNativeAllocations = 0;
+
   String formattedInclusiveTicks = '';
   String formattedExclusiveTicks = '';
   String formattedExclusivePercent = '';
   String formattedCpuTime = '';
   String formattedOnStackTime = '';
   final Set<String> attributes = new Set<String>();
 
   int _sortCodes(ProfileCode a, ProfileCode b) {
     if (a.code.isOptimized == b.code.isOptimized) {
       return b.code.profile.exclusiveTicks - a.code.profile.exclusiveTicks;
@@ skipping 77 matching lines @@
     }
     profileCodes.sort(_sortCodes);
 
     _addKindBasedAttributes(attributes);
     exclusiveTicks = int.parse(data['exclusiveTicks']);
     inclusiveTicks = int.parse(data['inclusiveTicks']);
 
     normalizedExclusiveTicks = exclusiveTicks / profile.sampleCount;
     normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount;
 
+    if (data.containsKey('exclusiveNativeAllocations') &&
+        data.containsKey('inclusiveNativeAllocations')) {
+      exclusiveNativeAllocations =
+          int.parse(data['exclusiveNativeAllocations']);
+      inclusiveNativeAllocations =
+          int.parse(data['inclusiveNativeAllocations']);
+    }
+
     formattedExclusivePercent =
         Utils.formatPercent(exclusiveTicks, profile.sampleCount);
 
     formattedCpuTime = Utils.formatTimeMilliseconds(
         profile.approximateMillisecondsForCount(exclusiveTicks));
 
     formattedOnStackTime = Utils.formatTimeMilliseconds(
         profile.approximateMillisecondsForCount(inclusiveTicks));
 
     formattedInclusiveTicks =
@@ skipping 84 matching lines @@
     sampleRate = 0.0;
     stackDepth = 0;
     timeSpan = 0.0;
     codes.clear();
     functions.clear();
     tries.clear();
     _builtCodeCalls = false;
     _builtFunctionCalls = false;
   }
 
-  Future load(Isolate isolate, ServiceMap profile) async {
-    await loadProgress(isolate, profile).last;
+  Future load(ServiceObjectOwner owner, ServiceMap profile) async {
+    await loadProgress(owner, profile).last;
   }
 
   static Future sleep([Duration duration = const Duration(microseconds: 0)]) {
     final Completer completer = new Completer();
     new Timer(duration, () => completer.complete());
     return completer.future;
   }
 
-  Stream<double> loadProgress(Isolate isolate, ServiceMap profile) {
+  Stream<double> loadProgress(ServiceObjectOwner owner, ServiceMap profile) {
     var progress = new StreamController<double>.broadcast();
 
     (() async {
       final Stopwatch watch = new Stopwatch();
       watch.start();
       int count = 0;
       var needToUpdate = () {
         count++;
         if (((count % 256) == 0) && (watch.elapsedMilliseconds > 16)) {
           watch.reset();
           return true;
         }
         return false;
       };
       var signal = (double p) {
         progress.add(p);
         return sleep();
       };
       try {
         clear();
         progress.add(0.0);
-        if ((isolate == null) || (profile == null)) {
+        if (profile == null) {
           return;
         }
 
-        this.isolate = isolate;
-        isolate.resetCachedProfileData();
+        if (owner != null && owner is Isolate) {

[Cutch, 2017/03/23 23:39:44]

here and everywhere: wrap in parens

((owner != null) && (owner is Isolate))

[bkonyi, 2017/03/24 00:53:38]

Done.

+          isolate = owner as Isolate;
+          isolate.resetCachedProfileData();
+        }
 
         sampleCount = profile['sampleCount'];
         samplePeriod = profile['samplePeriod'];
         sampleRate = (Duration.MICROSECONDS_PER_SECOND / samplePeriod);
         stackDepth = profile['stackDepth'];
         timeSpan = profile['timeSpan'];
 
         num length = profile['codes'].length + profile['functions'].length;
 
         // Process code table.
@@ skipping 56 matching lines @@
   }
 
   CodeCallTreeNode _readCodeTrieNode(List<int> data) {
     // Lookup code object.
     var codeIndex = data[_dataCursor++];
     var code = codes[codeIndex];
     // Node tick counter.
     var count = data[_dataCursor++];
     // Child node count.
     var children = data[_dataCursor++];
+    // Inclusive native allocations.
+    var inclusiveNativeAllocations = data[_dataCursor++];
+    // Exclusive native allocations.
+    var exclusiveNativeAllocations = data[_dataCursor++];
     // Create node.
-    var node = new CodeCallTreeNode(code, count);
+    var node = new CodeCallTreeNode(
+        code, count, inclusiveNativeAllocations, exclusiveNativeAllocations);
     node.children.length = children;
     return node;
   }
 
   CodeCallTreeNode _readCodeTrie(List<int> data) {
     final nodeStack = new List<CodeCallTreeNode>();
     final childIndexStack = new List<int>();
 
     _dataCursor = 0;
     // Read root.
@@ skipping 48 matching lines @@
     return new FunctionCallTree(inclusive, root);
   }
 
   FunctionCallTreeNode _readFunctionTrieNode(List<int> data) {
     // Read index into function table.
     var index = data[_dataCursor++];
     // Lookup function object.
     var function = functions[index];
     // Counter.
     var count = data[_dataCursor++];
+    // Inclusive native allocations.
+    var inclusiveNativeAllocations = data[_dataCursor++];
+    // Exclusive native allocations.
+    var exclusiveNativeAllocations = data[_dataCursor++];
     // Create node.
-    var node = new FunctionCallTreeNode(function, count);
+    var node = new FunctionCallTreeNode(function, count,
+        inclusiveNativeAllocations, exclusiveNativeAllocations);
     // Number of code index / count pairs.
     var codeCount = data[_dataCursor++];
     node.codes.length = codeCount;
     var totalCodeTicks = 0;
     for (var i = 0; i < codeCount; i++) {
       var codeIndex = data[_dataCursor++];
       var code = codes[codeIndex];
       assert(code != null);
       var codeTicks = data[_dataCursor++];
       totalCodeTicks += codeTicks;
@@ skipping 54 matching lines @@
   }
 
   int approximateMillisecondsForCount(count) {
     return (count * samplePeriod) ~/ Duration.MICROSECONDS_PER_MILLISECOND;
   }
 
   double approximateSecondsForCount(count) {
     return (count * samplePeriod) / Duration.MICROSECONDS_PER_SECOND;
   }
 }