| // 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 sample_profiler; |
| |
| abstract class CallTreeNode<NodeT extends M.CallTreeNode> |
| implements M.CallTreeNode { |
| final List<NodeT> children; |
| int get count => _count; |
| int _count = 0; |
| int inclusiveNativeAllocations = 0; |
| int exclusiveNativeAllocations = 0; |
| double get percentage => _percentage; |
| double _percentage = 0.0; |
| final attributes = <String>{}; |
| |
| // Used for building timeline |
| int frameId = null; |
| int parentId = null; |
| |
| // Either a ProfileCode or a ProfileFunction. |
| Object get profileData; |
| String get name; |
| |
| CallTreeNode(this.children, |
| [this._count = 0, |
| this.inclusiveNativeAllocations = 0, |
| this.exclusiveNativeAllocations = 0]) {} |
| |
| NodeT getChild(int index); |
| |
| void sortChildren() { |
| children.sort((a, b) => b.count - a.count); |
| children.forEach((NodeT child) => child.sortChildren()); |
| } |
| |
| void tick(Map sample, {bool exclusive = false}) { |
| ++_count; |
| if (SampleProfile._isNativeAllocationSample(sample)) { |
| final allocationSize = sample[SampleProfile._kNativeAllocationSizeBytes]; |
| if (exclusive) { |
| exclusiveNativeAllocations += allocationSize; |
| } |
| inclusiveNativeAllocations += allocationSize; |
| } |
| } |
| } |
| |
| class CodeCallTreeNode extends CallTreeNode<CodeCallTreeNode> |
| implements M.CodeCallTreeNode { |
| final ProfileCode profileCode; |
| final SampleProfile profile; |
| |
| Object get profileData => profileCode; |
| |
| String get name => profileCode.code.name; |
| |
| final attributes = <String>{}; |
| CodeCallTreeNode(this.profileCode, int count, int inclusiveNativeAllocations, |
| int exclusiveNativeAllocations) |
| : profile = profileCode.profile, |
| super(<CodeCallTreeNode>[], count, inclusiveNativeAllocations, |
| exclusiveNativeAllocations) { |
| attributes.addAll(profileCode.attributes); |
| } |
| |
| CodeCallTreeNode.fromIndex(this.profile, int tableIndex) |
| : profileCode = profile.codes[tableIndex], |
| super(<CodeCallTreeNode>[]); |
| |
| CodeCallTreeNode getChild(int codeTableIndex) { |
| final length = children.length; |
| int i = 0; |
| while (i < length) { |
| final child = children[i]; |
| final childTableIndex = child.profileCode.tableIndex; |
| if (childTableIndex == codeTableIndex) { |
| return child; |
| } |
| if (childTableIndex > codeTableIndex) { |
| break; |
| } |
| ++i; |
| } |
| final child = CodeCallTreeNode.fromIndex(profile, codeTableIndex); |
| if (i < length) { |
| children.insert(i, child); |
| } else { |
| children.add(child); |
| } |
| return child; |
| } |
| } |
| |
| 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) { |
| if ((root.inclusiveNativeAllocations != null) && |
| (root.inclusiveNativeAllocations != 0)) { |
| _setCodeMemoryPercentage(null, root); |
| } else { |
| _setCodePercentage(null, root); |
| } |
| } |
| |
| CodeCallTree filtered(CallTreeNodeFilter filter) { |
| final treeFilter = _FilteredCodeCallTreeBuilder(filter, this); |
| treeFilter.build(); |
| if ((treeFilter.filtered.root.inclusiveNativeAllocations != null) && |
| (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); |
| } |
| for (var child in node.children) { |
| _setCodeMemoryPercentage(node, child); |
| } |
| node.children.sort((a, b) { |
| return b.inclusiveNativeAllocations - a.inclusiveNativeAllocations; |
| }); |
| } |
| |
| _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); |
| } |
| } |
| |
| _recordCallerAndCallees() { |
| for (var child in root.children) { |
| _recordCallerAndCalleesInner(null, child); |
| } |
| } |
| } |
| |
| class FunctionCallTreeNodeCode { |
| final ProfileCode code; |
| final int ticks; |
| FunctionCallTreeNodeCode(this.code, this.ticks); |
| } |
| |
| class FunctionCallTreeNode extends CallTreeNode<FunctionCallTreeNode> |
| implements M.FunctionCallTreeNode { |
| final ProfileFunction profileFunction; |
| final SampleProfile profile; |
| final codes = <FunctionCallTreeNodeCode>[]; |
| int _totalCodeTicks = 0; |
| int get totalCodesTicks => _totalCodeTicks; |
| |
| String get name => M.getFunctionFullName(profileFunction.function); |
| Object get profileData => profileFunction; |
| |
| FunctionCallTreeNode(this.profileFunction, int count, |
| inclusiveNativeAllocations, exclusiveNativeAllocations) |
| : profile = profileFunction.profile, |
| super(<FunctionCallTreeNode>[], count, inclusiveNativeAllocations, |
| exclusiveNativeAllocations) { |
| profileFunction._addKindBasedAttributes(attributes); |
| } |
| |
| FunctionCallTreeNode.fromIndex(this.profile, int tableIndex) |
| : profileFunction = profile.functions[tableIndex], |
| super(<FunctionCallTreeNode>[]); |
| |
| FunctionCallTreeNode getChild(int functionTableIndex) { |
| final length = children.length; |
| int i = 0; |
| while (i < length) { |
| final child = children[i]; |
| final childTableIndex = child.profileFunction.tableIndex; |
| if (childTableIndex == functionTableIndex) { |
| return child; |
| } |
| if (childTableIndex > functionTableIndex) { |
| break; |
| } |
| ++i; |
| } |
| final child = FunctionCallTreeNode.fromIndex(profile, functionTableIndex); |
| if (i < length) { |
| children.insert(i, child); |
| } else { |
| children.add(child); |
| } |
| return child; |
| } |
| } |
| |
| /// Predicate filter function. Returns true if path from root to [node] and all |
| /// of [node]'s children should be added to the filtered tree. |
| typedef CallTreeNodeFilter = bool Function(CallTreeNode node); |
| |
| /// Build a filter version of a FunctionCallTree. |
| abstract class _FilteredCallTreeBuilder<NodeT extends CallTreeNode> { |
| /// The filter. |
| final CallTreeNodeFilter filter; |
| |
| /// The unfiltered tree. |
| final CallTree _unfilteredTree; |
| |
| /// The filtered tree (construct by [build]). |
| final CallTree filtered; |
| final List _currentPath = []; |
| |
| /// Construct a filtered tree builder using [filter] and [tree]. |
| _FilteredCallTreeBuilder(this.filter, CallTree tree, this.filtered) |
| : _unfilteredTree = tree; |
| |
| /// Build the filtered tree. |
| build() { |
| assert(filtered != null); |
| assert(filter != null); |
| assert(_unfilteredTree != null); |
| _descend(_unfilteredTree.root); |
| } |
| |
| CallTreeNode _findInChildren(CallTreeNode current, CallTreeNode needle) { |
| for (var child in current.children) { |
| if ((child as CallTreeNode).profileData == needle.profileData) { |
| return child; |
| } |
| } |
| return null; |
| } |
| |
| NodeT _copyNode(NodeT node); |
| |
| /// Add all nodes in [_currentPath]. |
| FunctionCallTreeNode _addCurrentPath() { |
| FunctionCallTreeNode current = filtered.root; |
| // Tree root is always the first element of the current path. |
| assert(_unfilteredTree.root == _currentPath[0]); |
| // Assert that unfiltered tree's root and filtered tree's root are different. |
| assert(_unfilteredTree.root != current); |
| for (var i = 1; i < _currentPath.length; i++) { |
| // toAdd is from the unfiltered tree. |
| var toAdd = _currentPath[i]; |
| // See if we already have a node for toAdd in the filtered tree. |
| var child = _findInChildren(current, toAdd); |
| if (child == null) { |
| // New node. |
| child = _copyNode(toAdd); |
| current.children.add(child); |
| } |
| current = child; |
| } |
| return current; |
| } |
| |
| /// Starting at [current] append [next] and all of [next]'s sub-trees |
| _appendTree(CallTreeNode current, CallTreeNode next) { |
| if (next == null) { |
| return; |
| } |
| var child = _findInChildren(current, next); |
| if (child == null) { |
| child = _copyNode(next); |
| current.children.add(child); |
| } |
| current = child; |
| for (var nextChild in next.children) { |
| _appendTree(current, nextChild); |
| } |
| } |
| |
| /// Add path from root to [child], [child], and all of [child]'s sub-trees |
| /// to filtered tree. |
| _addTree(CallTreeNode child) { |
| var current = _addCurrentPath(); |
| _appendTree(current, child); |
| } |
| |
| /// Descend further into the tree. [current] is from the unfiltered tree. |
| _descend(CallTreeNode current) { |
| if (current == null) { |
| return; |
| } |
| _currentPath.add(current); |
| |
| if (filter(current)) { |
| // Filter matched. |
| if (current.children.length == 0) { |
| // Have no children. Add this path. |
| _addTree(null); |
| } else { |
| // Add all child trees. |
| for (var child in current.children) { |
| _addTree(child); |
| } |
| } |
| } else { |
| // Did not match, descend to each child. |
| for (var child in current.children) { |
| _descend(child); |
| } |
| } |
| |
| var last = _currentPath.removeLast(); |
| assert(current == last); |
| } |
| } |
| |
| class _FilteredFunctionCallTreeBuilder |
| extends _FilteredCallTreeBuilder<FunctionCallTreeNode> { |
| _FilteredFunctionCallTreeBuilder( |
| CallTreeNodeFilter filter, FunctionCallTree tree) |
| : super( |
| filter, |
| tree, |
| FunctionCallTree( |
| tree.inclusive, |
| FunctionCallTreeNode( |
| tree.root.profileData, |
| tree.root.count, |
| tree.root.inclusiveNativeAllocations, |
| tree.root.exclusiveNativeAllocations))); |
| |
| _copyNode(FunctionCallTreeNode node) { |
| return FunctionCallTreeNode(node.profileData, node.count, |
| node.inclusiveNativeAllocations, node.exclusiveNativeAllocations); |
| } |
| } |
| |
| class _FilteredCodeCallTreeBuilder |
| extends _FilteredCallTreeBuilder<CodeCallTreeNode> { |
| _FilteredCodeCallTreeBuilder(CallTreeNodeFilter filter, CodeCallTree tree) |
| : super( |
| filter, |
| tree, |
| CodeCallTree( |
| tree.inclusive, |
| CodeCallTreeNode( |
| tree.root.profileData, |
| tree.root.count, |
| tree.root.inclusiveNativeAllocations, |
| tree.root.exclusiveNativeAllocations))); |
| |
| _copyNode(CodeCallTreeNode node) { |
| return CodeCallTreeNode(node.profileData, node.count, |
| node.inclusiveNativeAllocations, node.exclusiveNativeAllocations); |
| } |
| } |
| |
| class FunctionCallTree extends CallTree<FunctionCallTreeNode> |
| implements M.FunctionCallTree { |
| FunctionCallTree(bool inclusive, FunctionCallTreeNode root) |
| : super(inclusive, root) { |
| if ((root.inclusiveNativeAllocations != null) && |
| (root.inclusiveNativeAllocations != 0)) { |
| _setFunctionMemoryPercentage(null, root); |
| } else { |
| _setFunctionPercentage(null, root); |
| } |
| } |
| |
| FunctionCallTree filtered(CallTreeNodeFilter filter) { |
| final treeFilter = _FilteredFunctionCallTreeBuilder(filter, this); |
| treeFilter.build(); |
| if ((treeFilter.filtered.root.inclusiveNativeAllocations != null) && |
| (treeFilter.filtered.root.inclusiveNativeAllocations != 0)) { |
| _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); |
| } |
| for (var child in node.children) { |
| _setFunctionMemoryPercentage(node, child); |
| } |
| node.children.sort((a, b) { |
| return b.inclusiveNativeAllocations - a.inclusiveNativeAllocations; |
| }); |
| } |
| |
| _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); |
| } |
| } |
| |
| _markFunctionCalls() { |
| for (var child in root.children) { |
| _markFunctionCallsInner(null, child); |
| } |
| } |
| } |
| |
| class CodeTick { |
| final int exclusiveTicks; |
| final int inclusiveTicks; |
| CodeTick(this.exclusiveTicks, this.inclusiveTicks); |
| } |
| |
| class InlineIntervalTick { |
| final int startAddress; |
| int _inclusiveTicks = 0; |
| int get inclusiveTicks => _inclusiveTicks; |
| int _exclusiveTicks = 0; |
| int get exclusiveTicks => _exclusiveTicks; |
| InlineIntervalTick(this.startAddress); |
| } |
| |
| class ProfileCode implements M.ProfileCode { |
| final int tableIndex; |
| final SampleProfile profile; |
| final Code code; |
| int exclusiveTicks; |
| int inclusiveTicks; |
| double normalizedExclusiveTicks = 0.0; |
| double normalizedInclusiveTicks = 0.0; |
| final addressTicks = <int, CodeTick>{}; |
| final intervalTicks = <int, InlineIntervalTick>{}; |
| String formattedInclusiveTicks = ''; |
| String formattedExclusiveTicks = ''; |
| String formattedExclusivePercent = ''; |
| final Set<String> attributes = <String>{}; |
| final callers = <ProfileCode, int>{}; |
| final callees = <ProfileCode, int>{}; |
| |
| void _processTicks(List<dynamic> profileTicks) { |
| assert(profileTicks != null); |
| assert((profileTicks.length % 3) == 0); |
| for (var i = 0; i < profileTicks.length; i += 3) { |
| // TODO(observatory): Address is not necessarily representable as a JS |
| // integer. |
| var address = int.parse(profileTicks[i] as String, radix: 16); |
| var exclusive = profileTicks[i + 1] as int; |
| var inclusive = profileTicks[i + 2] as int; |
| var tick = CodeTick(exclusive, inclusive); |
| addressTicks[address] = tick; |
| |
| var interval = code.findInterval(address); |
| if (interval != null) { |
| var intervalTick = intervalTicks[interval.start]; |
| if (intervalTick == null) { |
| // Insert into map. |
| intervalTick = InlineIntervalTick(interval.start); |
| intervalTicks[interval.start] = intervalTick; |
| } |
| intervalTick._inclusiveTicks += inclusive; |
| intervalTick._exclusiveTicks += exclusive; |
| } |
| } |
| } |
| |
| void clearTicks() { |
| exclusiveTicks = 0; |
| inclusiveTicks = 0; |
| normalizedExclusiveTicks = 0; |
| normalizedInclusiveTicks = 0; |
| formattedInclusiveTicks = ''; |
| formattedExclusiveTicks = ''; |
| formattedExclusivePercent = ''; |
| } |
| |
| ProfileCode.fromMap(this.tableIndex, this.profile, this.code, Map data) { |
| assert(profile != null); |
| assert(code != null); |
| |
| code.profile = this; |
| |
| if (code.kind == M.CodeKind.stub) { |
| attributes.add('stub'); |
| } else if (code.kind == M.CodeKind.dart) { |
| if (code.isNative) { |
| attributes.add('ffi'); // Not to be confused with a C function. |
| } else { |
| attributes.add('dart'); |
| } |
| if (code.hasIntrinsic) { |
| attributes.add('intrinsic'); |
| } |
| if (code.isOptimized) { |
| attributes.add('optimized'); |
| } else { |
| attributes.add('unoptimized'); |
| } |
| } else if (code.kind == M.CodeKind.tag) { |
| attributes.add('tag'); |
| } else if (code.kind == M.CodeKind.native) { |
| attributes.add('native'); |
| } |
| inclusiveTicks = data['inclusiveTicks']; |
| exclusiveTicks = data['exclusiveTicks']; |
| |
| normalizedExclusiveTicks = exclusiveTicks / profile.sampleCount; |
| |
| normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount; |
| |
| var ticks = data['ticks']; |
| if (ticks != null) { |
| _processTicks(ticks); |
| } |
| |
| formattedExclusivePercent = |
| Utils.formatPercent(exclusiveTicks, profile.sampleCount); |
| |
| formattedInclusiveTicks = |
| '${Utils.formatPercent(inclusiveTicks, profile.sampleCount)} ' |
| '($inclusiveTicks)'; |
| |
| formattedExclusiveTicks = |
| '${Utils.formatPercent(exclusiveTicks, profile.sampleCount)} ' |
| '($exclusiveTicks)'; |
| } |
| |
| _recordCaller(ProfileCode caller, int count) { |
| var r = callers[caller]; |
| if (r == null) { |
| r = 0; |
| } |
| callers[caller] = r + count; |
| } |
| |
| _recordCallee(ProfileCode callee, int count) { |
| var r = callees[callee]; |
| if (r == null) { |
| r = 0; |
| } |
| callees[callee] = r + count; |
| } |
| |
| void _normalizeTicks() { |
| normalizedExclusiveTicks = exclusiveTicks / profile.sampleCount; |
| normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount; |
| |
| formattedExclusivePercent = |
| Utils.formatPercent(exclusiveTicks, profile.sampleCount); |
| |
| formattedInclusiveTicks = |
| '${Utils.formatPercent(inclusiveTicks, profile.sampleCount)} ' |
| '($inclusiveTicks)'; |
| |
| formattedExclusiveTicks = |
| '${Utils.formatPercent(exclusiveTicks, profile.sampleCount)} ' |
| '($exclusiveTicks)'; |
| } |
| |
| void tickTag() { |
| // All functions *except* those for tags are ticked in the VM while |
| // generating the CpuSamples response. |
| if (code.kind != M.CodeKind.tag) { |
| throw StateError('Only tags should be ticked. ' |
| 'Attempted to tick: ${code.name}'); |
| } |
| ++exclusiveTicks; |
| ++inclusiveTicks; |
| _normalizeTicks(); |
| } |
| } |
| |
| class ProfileFunction implements M.ProfileFunction { |
| final int tableIndex; |
| final SampleProfile profile; |
| final ServiceFunction function; |
| final String resolvedUrl; |
| final callers = <ProfileFunction, int>{}; |
| final callees = <ProfileFunction, int>{}; |
| |
| // Absolute ticks: |
| int exclusiveTicks = 0; |
| int inclusiveTicks = 0; |
| |
| // Global percentages: |
| double normalizedExclusiveTicks = 0.0; |
| double normalizedInclusiveTicks = 0.0; |
| |
| String formattedInclusiveTicks = ''; |
| String formattedExclusiveTicks = ''; |
| String formattedExclusivePercent = ''; |
| final attributes = <String>{}; |
| |
| void clearTicks() { |
| exclusiveTicks = 0; |
| inclusiveTicks = 0; |
| normalizedExclusiveTicks = 0; |
| normalizedInclusiveTicks = 0; |
| formattedInclusiveTicks = ''; |
| formattedExclusiveTicks = ''; |
| formattedExclusivePercent = ''; |
| } |
| |
| void _addKindBasedAttributes(Set<String> attribs) { |
| if (function.kind == M.FunctionKind.tag) { |
| attribs.add('tag'); |
| } else if (function.kind == M.FunctionKind.stub) { |
| attribs.add('stub'); |
| } else if (function.kind == M.FunctionKind.native) { |
| attribs.add('native'); |
| } else if (M.isSyntheticFunction(function.kind)) { |
| attribs.add('synthetic'); |
| } else if (function.isNative) { |
| attribs.add('ffi'); // Not to be confused with a C function. |
| } else { |
| attribs.add('dart'); |
| } |
| if (function.hasIntrinsic == true) { |
| attribs.add('intrinsic'); |
| } |
| } |
| |
| ProfileFunction.fromMap( |
| this.tableIndex, this.profile, this.function, Map data) |
| : resolvedUrl = data['resolvedUrl'] { |
| function.profile = this; |
| _addKindBasedAttributes(attributes); |
| exclusiveTicks = data['exclusiveTicks']; |
| inclusiveTicks = data['inclusiveTicks']; |
| _normalizeTicks(); |
| } |
| |
| _recordCaller(ProfileFunction caller, int count) { |
| var r = callers[caller]; |
| if (r == null) { |
| r = 0; |
| } |
| callers[caller] = r + count; |
| } |
| |
| _recordCallee(ProfileFunction callee, int count) { |
| var r = callees[callee]; |
| if (r == null) { |
| r = 0; |
| } |
| callees[callee] = r + count; |
| } |
| |
| void _normalizeTicks() { |
| normalizedExclusiveTicks = exclusiveTicks / profile.sampleCount; |
| normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount; |
| |
| formattedExclusivePercent = |
| Utils.formatPercent(exclusiveTicks, profile.sampleCount); |
| |
| formattedInclusiveTicks = |
| '${Utils.formatPercent(inclusiveTicks, profile.sampleCount)} ' |
| '($inclusiveTicks)'; |
| |
| formattedExclusiveTicks = |
| '${Utils.formatPercent(exclusiveTicks, profile.sampleCount)} ' |
| '($exclusiveTicks)'; |
| } |
| |
| void tickTag() { |
| // All functions *except* those for functions are ticked in the VM while |
| // generating the CpuSamples response. |
| if (function.kind != M.FunctionKind.tag) { |
| throw StateError('Only tags should be ticked. ' |
| 'Attempted to tick: ${function.name}'); |
| } |
| ++exclusiveTicks; |
| ++inclusiveTicks; |
| _normalizeTicks(); |
| } |
| } |
| |
| class SampleProfile extends M.SampleProfile { |
| Isolate isolate; |
| |
| int sampleCount = 0; |
| int samplePeriod = 0; |
| double sampleRate = 0.0; |
| int pid = 0; |
| int maxStackDepth = 0; |
| |
| double timeSpan = 0.0; |
| |
| M.SampleProfileTag tagOrder = M.SampleProfileTag.none; |
| |
| final _functionTagMapping = <String, int>{}; |
| final _codeTagMapping = <String, int>{}; |
| |
| final List samples = []; |
| final codes = <ProfileCode>[]; |
| bool _builtCodeCalls = false; |
| final functions = <ProfileFunction>[]; |
| bool _builtFunctionCalls = false; |
| |
| static const String _kCode = 'code'; |
| static const String _kCodes = '_codes'; |
| static const String _kCodeStack = '_codeStack'; |
| static const String _kFunction = 'function'; |
| static const String _kFunctions = 'functions'; |
| static const String _kNativeAllocationSizeBytes = |
| '_nativeAllocationSizeBytes'; |
| static const String _kPid = 'pid'; |
| static const String _kSampleCount = 'sampleCount'; |
| static const String _kSamplePeriod = 'samplePeriod'; |
| static const String _kSamples = 'samples'; |
| static const String _kStack = 'stack'; |
| static const String _kMaxStackDepth = 'maxStackDepth'; |
| static const String _kTimeSpan = 'timespan'; |
| static const String _kUserTag = 'userTag'; |
| static const String _kVmTag = 'vmTag'; |
| |
| // Names of special tag types. |
| static const String kNativeTag = 'Native'; |
| static const String kRootTag = 'Root'; |
| static const String kRuntimeTag = 'Runtime'; |
| static const String kTruncatedTag = '[Truncated]'; |
| |
| // Used to stash trie information in samples for timeline processing. |
| static const String kTimelineFunctionTrie = 'timelineFunctionTrie'; |
| |
| CodeCallTree loadCodeTree(M.ProfileTreeDirection direction) { |
| switch (direction) { |
| case M.ProfileTreeDirection.inclusive: |
| return _loadCodeTree(true); |
| case M.ProfileTreeDirection.exclusive: |
| return _loadCodeTree(false); |
| } |
| throw Exception('Unknown ProfileTreeDirection'); |
| } |
| |
| FunctionCallTree loadFunctionTree(M.ProfileTreeDirection direction) { |
| switch (direction) { |
| case M.ProfileTreeDirection.inclusive: |
| return _loadFunctionTree(true); |
| case M.ProfileTreeDirection.exclusive: |
| return _loadFunctionTree(false); |
| } |
| throw Exception('Unknown ProfileTreeDirection'); |
| } |
| |
| buildCodeCallerAndCallees() { |
| if (_builtCodeCalls) { |
| return; |
| } |
| _builtCodeCalls = true; |
| var tree = loadCodeTree(M.ProfileTreeDirection.inclusive); |
| tree._recordCallerAndCallees(); |
| } |
| |
| buildFunctionCallerAndCallees() { |
| if (_builtFunctionCalls) { |
| return; |
| } |
| _builtFunctionCalls = true; |
| var tree = loadFunctionTree(M.ProfileTreeDirection.inclusive); |
| tree._markFunctionCalls(); |
| } |
| |
| clear() { |
| pid = -1; |
| sampleCount = 0; |
| samplePeriod = 0; |
| sampleRate = 0.0; |
| maxStackDepth = 0; |
| timeSpan = 0.0; |
| codes.clear(); |
| functions.clear(); |
| _builtCodeCalls = false; |
| _builtFunctionCalls = false; |
| } |
| |
| Future load(ServiceObjectOwner owner, ServiceMap profile) async { |
| await loadProgress(owner, profile).drain(); |
| } |
| |
| static Future sleep([Duration duration = const Duration(microseconds: 0)]) => |
| Future.delayed(duration); |
| |
| Future _loadCommon(ServiceObjectOwner owner, ServiceMap profile, |
| [StreamController<double> progress]) async { |
| final watch = Stopwatch(); |
| watch.start(); |
| int count = 0; |
| var needToUpdate = () { |
| if (progress == null) { |
| return false; |
| } |
| count++; |
| if (((count % 256) == 0) && (watch.elapsedMilliseconds > 16)) { |
| watch.reset(); |
| return true; |
| } |
| return false; |
| }; |
| var signal = (double p) { |
| if (progress == null) { |
| return null; |
| } |
| progress.add(p); |
| return sleep(); |
| }; |
| try { |
| clear(); |
| progress?.add(0.0); |
| if (profile == null) { |
| return; |
| } |
| |
| if ((owner != null) && (owner is Isolate)) { |
| isolate = owner; |
| isolate.resetCachedProfileData(); |
| } |
| |
| pid = profile[_kPid]; |
| sampleCount = profile[_kSampleCount]; |
| samplePeriod = profile[_kSamplePeriod]; |
| sampleRate = (Duration.microsecondsPerSecond / samplePeriod); |
| maxStackDepth = profile[_kMaxStackDepth]; |
| timeSpan = profile[_kTimeSpan]; |
| |
| num length = 0; |
| |
| if (profile.containsKey(_kCodes)) { |
| length += profile[_kCodes].length; |
| } |
| length += profile[_kFunctions].length; |
| |
| // Process code table. |
| int tableIndex = 0; |
| if (profile.containsKey(_kCodes)) { |
| for (var codeRegion in profile[_kCodes]) { |
| if (needToUpdate()) { |
| await signal(count * 100.0 / length); |
| } |
| Code code = codeRegion[_kCode]; |
| assert(code != null); |
| codes.add(ProfileCode.fromMap(tableIndex, this, code, codeRegion)); |
| ++tableIndex; |
| } |
| } |
| // Process function table. |
| tableIndex = 0; |
| for (var profileFunction in profile[_kFunctions]) { |
| if (needToUpdate()) { |
| await signal(count * 100 / length); |
| } |
| ServiceFunction function = profileFunction[_kFunction]; |
| assert(function != null); |
| functions.add(ProfileFunction.fromMap( |
| tableIndex, this, function, profileFunction)); |
| ++tableIndex; |
| } |
| if (profile.containsKey(_kCodes)) { |
| _buildCodeTagMapping(); |
| } |
| |
| _buildFunctionTagMapping(); |
| |
| samples.addAll(profile[_kSamples]); |
| } finally { |
| progress?.close(); |
| } |
| } |
| |
| Stream<double> loadProgress(ServiceObjectOwner owner, ServiceMap profile) { |
| Logger.root.info('sampling counters ${profile['_counters']}'); |
| |
| var progress = StreamController<double>.broadcast(); |
| |
| _loadCommon(owner, profile, progress); |
| return progress.stream; |
| } |
| |
| // Helpers for reading optional flags from a sample. |
| static bool _isNativeEntryTag(Map sample) => |
| sample.containsKey('nativeEntryTag'); |
| static bool _isRuntimeEntryTag(Map sample) => |
| sample.containsKey('runtimeEntryTag'); |
| static bool _isTruncated(Map sample) => sample.containsKey('truncated'); |
| static bool _isNativeAllocationSample(Map sample) => |
| sample.containsKey('_nativeAllocationSizeBytes'); |
| |
| int _getProfileFunctionTagIndex(String tag) { |
| if (_functionTagMapping.containsKey(tag)) { |
| return _functionTagMapping[tag]; |
| } |
| throw ArgumentError('$tag is not a valid tag!'); |
| } |
| |
| int _getProfileCodeTagIndex(String tag) { |
| if (_codeTagMapping.containsKey(tag)) { |
| return _codeTagMapping[tag]; |
| } |
| throw ArgumentError('$tag is not a valid tag!'); |
| } |
| |
| void _buildFunctionTagMapping() { |
| for (int i = 0; i < functions.length; ++i) { |
| final function = functions[i].function; |
| if (function.kind == M.FunctionKind.tag) { |
| _functionTagMapping[function.name] = i; |
| } |
| } |
| } |
| |
| void _buildCodeTagMapping() { |
| for (int i = 0; i < codes.length; ++i) { |
| final code = codes[i].code; |
| if (code.kind == M.CodeKind.tag) { |
| _codeTagMapping[code.name] = i; |
| } |
| } |
| } |
| |
| void _clearProfileFunctionTagTicks() => |
| _functionTagMapping.forEach((String name, int tableIndex) { |
| // Truncated tag is ticked in the VM, so don't clear it. |
| if (name != kTruncatedTag) { |
| functions[tableIndex].clearTicks(); |
| } |
| }); |
| |
| void _clearProfileCodeTagTicks() => |
| _codeTagMapping.forEach((String name, int tableIndex) { |
| // Truncated tag is ticked in the VM, so don't clear it. |
| if (name != kTruncatedTag) { |
| codes[tableIndex].clearTicks(); |
| } |
| }); |
| |
| NodeT _appendUserTag<NodeT extends CallTreeNode>( |
| String userTag, NodeT current, Map sample) { |
| bool isCode = (current is CodeCallTreeNode); |
| try { |
| final tableIndex = isCode |
| ? _getProfileCodeTagIndex(userTag) |
| : _getProfileFunctionTagIndex(userTag); |
| current = current.getChild(tableIndex); |
| current.tick(sample); |
| } catch (_) {/* invalid tag */} finally { |
| return current; |
| } |
| } |
| |
| NodeT _appendTruncatedTag<NodeT extends CallTreeNode>( |
| NodeT current, Map sample) { |
| final isCode = (current is CodeCallTreeNode); |
| try { |
| final tableIndex = isCode |
| ? _getProfileCodeTagIndex(kTruncatedTag) |
| : _getProfileFunctionTagIndex(kTruncatedTag); |
| current = current.getChild(tableIndex); |
| current.tick(sample); |
| // We don't need to tick the tag itself since this is done in the VM for |
| // the truncated tag, unlike other VM and user tags. |
| } catch (_) {/* invalid tag */} finally { |
| return current; |
| } |
| } |
| |
| FunctionCallTreeNode _getFunctionTagAndTick( |
| String tag, FunctionCallTreeNode current, Map sample) { |
| try { |
| final tableIndex = _getProfileFunctionTagIndex(tag); |
| current = current.getChild(tableIndex); |
| current.tick(sample); |
| } catch (_) {/* invalid tag */} finally { |
| return current; |
| } |
| } |
| |
| CodeCallTreeNode _getCodeTagAndTick( |
| String tag, CodeCallTreeNode current, Map sample) { |
| try { |
| final tableIndex = _getProfileCodeTagIndex(tag); |
| current = current.getChild(tableIndex); |
| current.tick(sample); |
| } catch (_) {/* invalid tag */} finally { |
| return current; |
| } |
| } |
| |
| NodeT _getTagAndTick<NodeT extends CallTreeNode>( |
| String tag, NodeT current, Map sample) { |
| if (current is FunctionCallTreeNode) { |
| return _getFunctionTagAndTick(tag, current, sample) as NodeT; |
| } else if (current is CodeCallTreeNode) { |
| return _getCodeTagAndTick(tag, current, sample) as NodeT; |
| } |
| throw ArgumentError('Unexpected tree type: $NodeT'); |
| } |
| |
| NodeT _appendVMTag<NodeT extends CallTreeNode>( |
| String vmTag, NodeT current, Map sample) { |
| if (_isNativeEntryTag(sample)) { |
| return _getTagAndTick(kNativeTag, current, sample); |
| } else if (_isRuntimeEntryTag(sample)) { |
| return _getTagAndTick(kRuntimeTag, current, sample); |
| } else { |
| return _getTagAndTick(vmTag, current, sample); |
| } |
| } |
| |
| NodeT _appendSpecificNativeRuntimeEntryVMTag<NodeT extends CallTreeNode>( |
| NodeT current, Map sample) { |
| // Only Native and Runtime entries have a second VM tag. |
| if (!_isNativeEntryTag(sample) && !_isRuntimeEntryTag(sample)) { |
| return current; |
| } |
| final vmTag = sample[_kVmTag]; |
| return _getTagAndTick(vmTag, current, sample); |
| } |
| |
| NodeT _appendVMTags<NodeT extends CallTreeNode>( |
| String vmTag, NodeT current, Map sample) { |
| current = _appendVMTag(vmTag, current, sample); |
| current = _appendSpecificNativeRuntimeEntryVMTag(current, sample); |
| return current; |
| } |
| |
| void _tickTags(String vmTag, String userTag, bool tickCode) { |
| if (tickCode) { |
| final vmTagIndex = _getProfileCodeTagIndex(vmTag); |
| codes[vmTagIndex].tickTag(); |
| |
| final userTagIndex = _getProfileCodeTagIndex(userTag); |
| codes[userTagIndex].tickTag(); |
| } else { |
| final vmTagIndex = _getProfileFunctionTagIndex(vmTag); |
| functions[vmTagIndex].tickTag(); |
| |
| final userTagIndex = _getProfileFunctionTagIndex(userTag); |
| functions[userTagIndex].tickTag(); |
| } |
| } |
| |
| NodeT _appendTags<NodeT extends CallTreeNode>( |
| String vmTag, String userTag, NodeT current, Map sample) { |
| final tickCode = (current is M.CodeCallTreeNode); |
| _tickTags(vmTag, userTag, tickCode); |
| if (tagOrder == M.SampleProfileTag.none) { |
| return current; |
| } |
| // User first. |
| if (tagOrder == M.SampleProfileTag.userVM || |
| tagOrder == M.SampleProfileTag.userOnly) { |
| current = _appendUserTag(userTag, current, sample); |
| // Only user. |
| if (tagOrder == M.SampleProfileTag.userOnly) { |
| return current; |
| } |
| return _appendVMTags(vmTag, current, sample); |
| } |
| |
| // VM first. |
| current = _appendVMTags(vmTag, current, sample); |
| // Only VM. |
| if (tagOrder == M.SampleProfileTag.vmOnly) { |
| return current; |
| } |
| return _appendUserTag(userTag, current, sample); |
| } |
| |
| NodeT _processFrame<NodeT extends CallTreeNode>(NodeT parent, int sampleIndex, |
| Map sample, List<int> stack, int frameIndex, bool inclusive) { |
| final child = parent.getChild(stack[frameIndex]); |
| child.tick(sample, exclusive: (frameIndex == 0)); |
| return child; |
| } |
| |
| FunctionCallTreeNode buildFunctionTrie(bool inclusive) { |
| final root = FunctionCallTreeNode.fromIndex( |
| this, _getProfileFunctionTagIndex(kRootTag)); |
| |
| for (int sampleIndex = 0; sampleIndex < samples.length; ++sampleIndex) { |
| final sample = samples[sampleIndex]; |
| FunctionCallTreeNode current = root; |
| // Tick the root for each sample as we always visit the root node. |
| root.tick(sample); |
| |
| // VM + User tags. |
| final vmTag = sample[_kVmTag]; |
| final userTag = sample[_kUserTag]; |
| final stack = sample[_kStack].cast<int>(); |
| current = _appendTags(vmTag, userTag, current, sample); |
| |
| if (inclusive) { |
| if (_isTruncated(sample)) { |
| current = _appendTruncatedTag(current, sample); |
| } |
| for (int frameIndex = stack.length - 1; frameIndex >= 0; --frameIndex) { |
| current = _processFrame( |
| current, sampleIndex, sample, stack, frameIndex, true); |
| } |
| |
| // Used by the timeline to find the root of each sample. |
| sample[kTimelineFunctionTrie] = current; |
| } else { |
| for (int frameIndex = 0; frameIndex < stack.length; ++frameIndex) { |
| current = _processFrame( |
| current, sampleIndex, sample, stack, frameIndex, false); |
| } |
| |
| if (_isTruncated(sample)) { |
| current = _appendTruncatedTag(current, sample); |
| } |
| } |
| } |
| return root; |
| } |
| |
| CodeCallTreeNode buildCodeTrie(bool inclusive) { |
| final root = |
| CodeCallTreeNode.fromIndex(this, _getProfileCodeTagIndex(kRootTag)); |
| |
| for (int sampleIndex = 0; sampleIndex < samples.length; ++sampleIndex) { |
| final sample = samples[sampleIndex]; |
| |
| CodeCallTreeNode current = root; |
| // Tick the root for each sample as we always visit the root node. |
| root.tick(sample); |
| |
| // VM + User tags. |
| final vmTag = sample[_kVmTag]; |
| final userTag = sample[_kUserTag]; |
| final stack = sample[_kCodeStack].cast<int>(); |
| current = _appendTags(vmTag, userTag, current, sample); |
| |
| if (inclusive) { |
| if (_isTruncated(sample)) { |
| current = _appendTruncatedTag(current, sample); |
| } |
| for (int frameIndex = stack.length - 1; frameIndex >= 0; --frameIndex) { |
| current = _processFrame( |
| current, sampleIndex, sample, stack, frameIndex, true); |
| } |
| } else { |
| for (int frameIndex = 0; frameIndex < stack.length; ++frameIndex) { |
| current = _processFrame( |
| current, sampleIndex, sample, stack, frameIndex, false); |
| } |
| |
| if (_isTruncated(sample)) { |
| current = _appendTruncatedTag(current, sample); |
| } |
| } |
| } |
| return root; |
| } |
| |
| FunctionCallTree _loadFunctionTree(bool inclusive) { |
| // Since we're only ticking tag functions when building the trie, we need |
| // to clean up ticks from previous tree builds. |
| _clearProfileFunctionTagTicks(); |
| |
| // Read the tree, returns the root node. |
| final root = buildFunctionTrie(inclusive); |
| root.sortChildren(); |
| return FunctionCallTree(inclusive, root); |
| } |
| |
| CodeCallTree _loadCodeTree(bool inclusive) { |
| // Since we're only ticking tag code when building the trie, we need |
| // to clean up ticks from previous tree builds. |
| _clearProfileCodeTagTicks(); |
| |
| // Read the tree, returns the root node. |
| final root = buildCodeTrie(inclusive); |
| root.sortChildren(); |
| return CodeCallTree(inclusive, root); |
| } |
| |
| int approximateMillisecondsForCount(count) { |
| return (count * samplePeriod) ~/ Duration.microsecondsPerMillisecond; |
| } |
| |
| double approximateSecondsForCount(count) { |
| return (count * samplePeriod) / Duration.microsecondsPerSecond; |
| } |
| } |
