trace-viewer/trace_viewer/core/analysis/memory_dump_vm_regions_details_pane.html - platform/external/chromium-trace - Git at Google

 <!DOCTYPE html>
 <!--
 Copyright (c) 2015 The Chromium Authors. All rights reserved.
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 -->

 <link rel="import" href="/core/analysis/memory_dump_sub_view_util.html">
 <link rel="import" href="/base/ui/table.html">
 <link rel="import" href="/model/attribute.html">

 <polymer-element name="tr-c-a-memory-dump-vm-regions-details-pane">
   <template>
     <style>
       :host {
         display: flex;
         flex-direction: column;
       }

       #label {
         flex: 0 0 auto;
         padding: 8px;

         background-color: #eee;
         border-bottom: 1px solid #8e8e8e;
         border-top: 1px solid white;

         font-size:  15px;
         font-weight: bold;
       }

       #contents {
         flex: 1 0 auto;
         align-self: stretch;
         font-size: 12px;
       }

       #contents .info-text {
         padding: 8px;
         color: #666;
         font-style: italic;
         text-align: center;
       }
     </style>
     <div id="label">Memory maps</div>
     <div id="contents"></div>
   </template>
   <script>
   'use strict';

   (function() {
     /**
      * Rules for classifying memory maps.
      *
      * These rules are derived from core/jni/android_os_Debug.cpp in Android.
      */
     var CLASSIFICATION_RULES = {
       name: 'Total',
       children: [
         {
           name: 'Android',
           file: /^\/dev\/ashmem/,
           children: [
             {
               name: 'Java runtime',
               file: /^\/dev\/ashmem\/dalvik-.*$/,
               children: [
                 {
                   name: 'Spaces',
                   file: /\bspace/,
                   children: [
                     {
                       name: 'Normal',
                       file: /(alloc)|(main)/
                     },
                     {
                       name: 'Large',
                       file: /large.object/
                     },
                     {
                       name: 'Zygote',
                       file: /zygote/
                     },
                     {
                       name: 'Non-moving',
                       file: /non.moving/
                     }
                   ]
                 },
                 {
                   name: 'Linear Alloc',
                   file: /LinearAlloc/
                 },
                 {
                   name: 'Indirect Reference Table',
                   file: /indirect.ref/
                 },
                 {
                   name: 'Cache',
                   file: /jit-code-cache/
                 },
                 {
                   name: 'Accounting'
                 }
               ]
             },
             {
               name: 'Cursor',
               file: /CursorWindow/
             },
             {
               name: 'Ashmem'
             }
           ]
         },
         {
           name: 'Native heap',
           file: /^((\[heap\])|(\[anon:)|(\/dev\/ashmem\/libc malloc)|$)/
         },
         {
           name: 'Stack',
           file: /^\[stack/
         },
         {
           name: 'Files',
           file: /\.((((so)|(jar)|(apk)|(ttf)|(odex)|(oat)|(arg))$)|(dex))/,
           children: [
             {
               name: 'so',
               file: /\.so$/
             },
             {
               name: 'jar',
               file: /\.jar$/
             },
             {
               name: 'apk',
               file: /\.apk$/
             },
             {
               name: 'ttf',
               file: /\.ttf$/
             },
             {
               name: 'dex',
               file: /\.((dex)|(odex$))/
             },
             {
               name: 'oat',
               file: /\.oat$/
             },
             {
               name: 'art',
               file: /\.art$/
             }
           ]
         },
         {
           name: 'Devices',
           file: /(^\/dev\/)|(anon_inode:dmabuf)/,
           children: [
             {
               name: 'GPU',
               file: /\/((nv)|(mali)|(kgsl))/
             },
             {
               name: 'DMA',
               file: /anon_inode:dmabuf/
             }
           ]
         },
         {
           // Add a separate category for the discounted tracing overhead to
           // avoid negative 'Total/Other' sizes.
           name: 'Discounted tracing overhead',
           file: /\[discounted tracing overhead\]/
         }
       ]
     };

     /**
      * Create a tree of nested rows (containing no mmaps) corresponding to a
      * tree of classification rules.
      */
     function createEmptyRow(rule) {
       var row = {
         title: rule.name,
         rule: rule,
         cells: {},
         subRows: []
       };
       if (rule.children !== undefined)
         row.subRows = rule.children.map(createEmptyRow);
       return row;
     }

     function hexString(address, is64BitAddress) {
       var hexPadding = is64BitAddress ? '0000000000000000' : '00000000';
       if (address === undefined)
         return undefined;
       return (hexPadding + address.toString(16)).substr(-hexPadding.length);
     }

     /**
      * Classify a memory map and add it as a leaf row to a tree of nested rows.
      */
     function classifyVMRegion(row, vmRegion, is64BitAddress) {
       var rule = row.rule;
       if (rule === undefined ||
           rule.children === undefined ||
           rule.children.length === 0) {
         // Leaf rule (create a sub-row for the mmap).
         var mappedFile = vmRegion.mappedFile || '';

         var cells = {};
         function addCellIfValueDefined(columnName, attrClass, units, value) {
           if (value === undefined)
             return;
           var attr = new attrClass(units, value);
           var cell = new tr.c.analysis.MemoryCell(attr);
           cells[columnName] = cell;
         }
         function addBytesCellIfValueDefined(columnName, value) {
           addCellIfValueDefined(columnName,
               tr.model.ScalarAttribute, 'bytes', value);
         }
         addCellIfValueDefined('Start address',
             tr.model.StringAttribute, '',
             hexString(vmRegion.startAddress, is64BitAddress));
         addBytesCellIfValueDefined('Virtual size', vmRegion.sizeInBytes);
         addCellIfValueDefined('Protection flags',
             tr.model.StringAttribute, '',
             vmRegion.protectionFlagsToString);
         addBytesCellIfValueDefined('PSS',
             vmRegion.byteStats.proportionalResident);
         addBytesCellIfValueDefined('Private dirty',
             vmRegion.byteStats.privateDirtyResident);
         addBytesCellIfValueDefined('Private clean',
             vmRegion.byteStats.privateCleanResident);
         addBytesCellIfValueDefined('Shared dirty',
             vmRegion.byteStats.sharedDirtyResident);
         addBytesCellIfValueDefined('Shared clean',
             vmRegion.byteStats.sharedCleanResident);
         addBytesCellIfValueDefined('Swapped',
             vmRegion.byteStats.swapped);

         row.subRows.push({title: mappedFile, cells: cells});
         return;
       }

       // Non-leaf rule (classify mmap further down the tree).
       function vmRegionMatchesChildRule(childRule) {
         var fileRegExp = childRule.file;
         if (fileRegExp === undefined)
           return true;
         return fileRegExp.test(vmRegion.mappedFile);
       }

       var matchedChildRuleIndex = tr.b.findFirstIndexInArray(
           rule.children, vmRegionMatchesChildRule);
       if (matchedChildRuleIndex === -1) {
         // Mmap belongs to the 'Other' node (created lazily).
         matchedChildRuleIndex = rule.children.length;
         if (matchedChildRuleIndex >= row.subRows.length) {
           row.subRows.push({
             title: 'Other',
             cells: {},
             subRows: []
           });
         }
       }

       classifyVMRegion(
           row.subRows[matchedChildRuleIndex], vmRegion, is64BitAddress);
     }

     /**
      * Sum mmap sizes up the classification tree.
      *
      * Note that classes containing no memory maps will have no sizes (shown
      * as empty cells) instead of zeros.
      */
     // TODO(petrcermak): This code is almost the same as
     // MemoryAllocatorDump.aggregateAttributes. Consider sharing code between
     // the two functions.
     function aggregateRowCells(row) {
       if (row.subRows === undefined)
         return;

       var cells = {};

       row.subRows.forEach(function(subRow) {
         aggregateRowCells(subRow);
         tr.b.iterItems(subRow.cells, function(columnName) {
           cells[columnName] = true;
         });
       });

       tr.b.iterItems(cells, function(name) {
         var childAttributes = row.subRows.map(function(subRow) {
           var cell = subRow.cells[name];
           if (cell === undefined)
             return undefined;
           return cell.attr;
         }, this);
         row.cells[name] = new tr.c.analysis.MemoryCell(
             tr.model.Attribute.aggregate(childAttributes));
       });
     }

     Polymer({
       // TODO(petrcermak): Consider sharing more code between
       // tr-c-a-memory-dump-allocator-details-pane and
       // tr-c-a-memory-dump-vm-regions-details-pane (e.g. by defining a common
       // base class tr-c-memory-dump-details-pane).

       created: function() {
         this.vmRegions_ = undefined;
       },

       ready: function() {
         this.updateContents_();
       },

       set vmRegions(vmRegions) {
         this.vmRegions_ = vmRegions;
         this.updateContents_();
       },

       get vmRegions() {
         return this.vmRegions_;
       },

       updateContents_: function() {
         this.$.contents.textContent = '';

         if (this.vmRegions_ === undefined) {
           var infoText = this.ownerDocument.createElement('div');
           this.$.contents.appendChild(infoText);
           infoText.classList.add('info-text');
           infoText.innerText = 'No memory maps selected';
           return;
         }

         var rows = this.createRows_();
         var columns = this.createColumns_(rows);

         var table = this.ownerDocument.createElement(
             'tr-b-ui-table');
         this.$.contents.appendChild(table);
         table.supportsSelection = true;
         table.tableRows = rows;
         table.tableColumns = columns;

         // TODO(petrcermak): This can be quite slow. Consider doing this somehow
         // asynchronously.
         table.rebuild();

         tr.c.analysis.expandTableRowsRecursively(table);
       },

       createRows_: function() {
         // TODO(petrcermak): Figure out if there's a cleaner way to do this.
         var is64BitAddress = this.vmRegions_.some(function(vmRegion) {
           if (vmRegion.startAddress === undefined)
             return;
           return vmRegion.startAddress >= 4294967296 /* 2^32 */;
         });

         // Create an empty tree structure of rows.
         var rootRow = createEmptyRow(CLASSIFICATION_RULES);

         // Classify the mmaps.
         this.vmRegions_.map(function(vmRegion) {
           classifyVMRegion(rootRow, vmRegion, is64BitAddress);
         });

         // Aggregate attributes of the mmaps.
         aggregateRowCells(rootRow);

         return [rootRow];
       },

       createColumns_: function(rows) {
         var titleColumn = {
           title: 'Mapped file',
           value: function(row) {
             return row.title;
           },
           width: '200px',
           cmp: function(rowA, rowB) {
             return rowA.title.localeCompare(rowB.title);
           }
         };

         var attributeColumns = tr.c.analysis.MemoryColumn.fromRows(
             rows, 'cells');
         tr.c.analysis.MemoryColumn.spaceEqually(attributeColumns);

         var columns = [titleColumn].concat(attributeColumns);
         return columns;
       }
     });
   })();
   </script>
 </polymer-element>
	<!DOCTYPE html>
	<!--
	Copyright (c) 2015 The Chromium Authors. All rights reserved.
	Use of this source code is governed by a BSD-style license that can be
	found in the LICENSE file.
	-->

	<link rel="import" href="/core/analysis/memory_dump_sub_view_util.html">
	<link rel="import" href="/base/ui/table.html">
	<link rel="import" href="/model/attribute.html">

	<polymer-element name="tr-c-a-memory-dump-vm-regions-details-pane">
	<template>
	<style>
	:host {
	display: flex;
	flex-direction: column;
	}

	#label {
	flex: 0 0 auto;
	padding: 8px;

	background-color: #eee;
	border-bottom: 1px solid #8e8e8e;
	border-top: 1px solid white;

	font-size: 15px;
	font-weight: bold;
	}

	#contents {
	flex: 1 0 auto;
	align-self: stretch;
	font-size: 12px;
	}

	#contents .info-text {
	padding: 8px;
	color: #666;
	font-style: italic;
	text-align: center;
	}
	</style>
	<div id="label">Memory maps</div>
	<div id="contents"></div>
	</template>
	<script>
	'use strict';

	(function() {
	/**
	* Rules for classifying memory maps.
	*
	* These rules are derived from core/jni/android_os_Debug.cpp in Android.
	*/
	var CLASSIFICATION_RULES = {
	name: 'Total',
	children: [
	{
	name: 'Android',
	file: /^\/dev\/ashmem/,
	children: [
	{
	name: 'Java runtime',
	file: /^\/dev\/ashmem\/dalvik-.*$/,
	children: [
	{
	name: 'Spaces',
	file: /\bspace/,
	children: [
	{
	name: 'Normal',
	file: /(alloc)\|(main)/
	},
	{
	name: 'Large',
	file: /large.object/
	},
	{
	name: 'Zygote',
	file: /zygote/
	},
	{
	name: 'Non-moving',
	file: /non.moving/
	}
	]
	},
	{
	name: 'Linear Alloc',
	file: /LinearAlloc/
	},
	{
	name: 'Indirect Reference Table',
	file: /indirect.ref/
	},
	{
	name: 'Cache',
	file: /jit-code-cache/
	},
	{
	name: 'Accounting'
	}
	]
	},
	{
	name: 'Cursor',
	file: /CursorWindow/
	},
	{
	name: 'Ashmem'
	}
	]
	},
	{
	name: 'Native heap',
	file: /^((\[heap\])\|(\[anon:)\|(\/dev\/ashmem\/libc malloc)\|$)/
	},
	{
	name: 'Stack',
	file: /^\[stack/
	},
	{
	name: 'Files',
	file: /\.((((so)\|(jar)\|(apk)\|(ttf)\|(odex)\|(oat)\|(arg))$)\|(dex))/,
	children: [
	{
	name: 'so',
	file: /\.so$/
	},
	{
	name: 'jar',
	file: /\.jar$/
	},
	{
	name: 'apk',
	file: /\.apk$/
	},
	{
	name: 'ttf',
	file: /\.ttf$/
	},
	{
	name: 'dex',
	file: /\.((dex)\|(odex$))/
	},
	{
	name: 'oat',
	file: /\.oat$/
	},
	{
	name: 'art',
	file: /\.art$/
	}
	]
	},
	{
	name: 'Devices',
	file: /(^\/dev\/)\|(anon_inode:dmabuf)/,
	children: [
	{
	name: 'GPU',
	file: /\/((nv)\|(mali)\|(kgsl))/
	},
	{
	name: 'DMA',
	file: /anon_inode:dmabuf/
	}
	]
	},
	{
	// Add a separate category for the discounted tracing overhead to
	// avoid negative 'Total/Other' sizes.
	name: 'Discounted tracing overhead',
	file: /\[discounted tracing overhead\]/
	}
	]
	};

	/**
	* Create a tree of nested rows (containing no mmaps) corresponding to a
	* tree of classification rules.
	*/
	function createEmptyRow(rule) {
	var row = {
	title: rule.name,
	rule: rule,
	cells: {},
	subRows: []
	};
	if (rule.children !== undefined)
	row.subRows = rule.children.map(createEmptyRow);
	return row;
	}

	function hexString(address, is64BitAddress) {
	var hexPadding = is64BitAddress ? '0000000000000000' : '00000000';
	if (address === undefined)
	return undefined;
	return (hexPadding + address.toString(16)).substr(-hexPadding.length);
	}

	/**
	* Classify a memory map and add it as a leaf row to a tree of nested rows.
	*/
	function classifyVMRegion(row, vmRegion, is64BitAddress) {
	var rule = row.rule;
	if (rule === undefined \|\|
	rule.children === undefined \|\|
	rule.children.length === 0) {
	// Leaf rule (create a sub-row for the mmap).
	var mappedFile = vmRegion.mappedFile \|\| '';

	var cells = {};
	function addCellIfValueDefined(columnName, attrClass, units, value) {
	if (value === undefined)
	return;
	var attr = new attrClass(units, value);
	var cell = new tr.c.analysis.MemoryCell(attr);
	cells[columnName] = cell;
	}
	function addBytesCellIfValueDefined(columnName, value) {
	addCellIfValueDefined(columnName,
	tr.model.ScalarAttribute, 'bytes', value);
	}
	addCellIfValueDefined('Start address',
	tr.model.StringAttribute, '',
	hexString(vmRegion.startAddress, is64BitAddress));
	addBytesCellIfValueDefined('Virtual size', vmRegion.sizeInBytes);
	addCellIfValueDefined('Protection flags',
	tr.model.StringAttribute, '',
	vmRegion.protectionFlagsToString);
	addBytesCellIfValueDefined('PSS',
	vmRegion.byteStats.proportionalResident);
	addBytesCellIfValueDefined('Private dirty',
	vmRegion.byteStats.privateDirtyResident);
	addBytesCellIfValueDefined('Private clean',
	vmRegion.byteStats.privateCleanResident);
	addBytesCellIfValueDefined('Shared dirty',
	vmRegion.byteStats.sharedDirtyResident);
	addBytesCellIfValueDefined('Shared clean',
	vmRegion.byteStats.sharedCleanResident);
	addBytesCellIfValueDefined('Swapped',
	vmRegion.byteStats.swapped);

	row.subRows.push({title: mappedFile, cells: cells});
	return;
	}

	// Non-leaf rule (classify mmap further down the tree).
	function vmRegionMatchesChildRule(childRule) {
	var fileRegExp = childRule.file;
	if (fileRegExp === undefined)
	return true;
	return fileRegExp.test(vmRegion.mappedFile);
	}

	var matchedChildRuleIndex = tr.b.findFirstIndexInArray(
	rule.children, vmRegionMatchesChildRule);
	if (matchedChildRuleIndex === -1) {
	// Mmap belongs to the 'Other' node (created lazily).
	matchedChildRuleIndex = rule.children.length;
	if (matchedChildRuleIndex >= row.subRows.length) {
	row.subRows.push({
	title: 'Other',
	cells: {},
	subRows: []
	});
	}
	}

	classifyVMRegion(
	row.subRows[matchedChildRuleIndex], vmRegion, is64BitAddress);
	}

	/**
	* Sum mmap sizes up the classification tree.
	*
	* Note that classes containing no memory maps will have no sizes (shown
	* as empty cells) instead of zeros.
	*/
	// TODO(petrcermak): This code is almost the same as
	// MemoryAllocatorDump.aggregateAttributes. Consider sharing code between
	// the two functions.
	function aggregateRowCells(row) {
	if (row.subRows === undefined)
	return;

	var cells = {};

	row.subRows.forEach(function(subRow) {
	aggregateRowCells(subRow);
	tr.b.iterItems(subRow.cells, function(columnName) {
	cells[columnName] = true;
	});
	});

	tr.b.iterItems(cells, function(name) {
	var childAttributes = row.subRows.map(function(subRow) {
	var cell = subRow.cells[name];
	if (cell === undefined)
	return undefined;
	return cell.attr;
	}, this);
	row.cells[name] = new tr.c.analysis.MemoryCell(
	tr.model.Attribute.aggregate(childAttributes));
	});
	}

	Polymer({
	// TODO(petrcermak): Consider sharing more code between
	// tr-c-a-memory-dump-allocator-details-pane and
	// tr-c-a-memory-dump-vm-regions-details-pane (e.g. by defining a common
	// base class tr-c-memory-dump-details-pane).

	created: function() {
	this.vmRegions_ = undefined;
	},

	ready: function() {
	this.updateContents_();
	},

	set vmRegions(vmRegions) {
	this.vmRegions_ = vmRegions;
	this.updateContents_();
	},

	get vmRegions() {
	return this.vmRegions_;
	},

	updateContents_: function() {
	this.$.contents.textContent = '';

	if (this.vmRegions_ === undefined) {
	var infoText = this.ownerDocument.createElement('div');
	this.$.contents.appendChild(infoText);
	infoText.classList.add('info-text');
	infoText.innerText = 'No memory maps selected';
	return;
	}

	var rows = this.createRows_();
	var columns = this.createColumns_(rows);

	var table = this.ownerDocument.createElement(
	'tr-b-ui-table');
	this.$.contents.appendChild(table);
	table.supportsSelection = true;
	table.tableRows = rows;
	table.tableColumns = columns;

	// TODO(petrcermak): This can be quite slow. Consider doing this somehow
	// asynchronously.
	table.rebuild();

	tr.c.analysis.expandTableRowsRecursively(table);
	},

	createRows_: function() {
	// TODO(petrcermak): Figure out if there's a cleaner way to do this.
	var is64BitAddress = this.vmRegions_.some(function(vmRegion) {
	if (vmRegion.startAddress === undefined)
	return;
	return vmRegion.startAddress >= 4294967296 /* 2^32 */;
	});

	// Create an empty tree structure of rows.
	var rootRow = createEmptyRow(CLASSIFICATION_RULES);

	// Classify the mmaps.
	this.vmRegions_.map(function(vmRegion) {
	classifyVMRegion(rootRow, vmRegion, is64BitAddress);
	});

	// Aggregate attributes of the mmaps.
	aggregateRowCells(rootRow);

	return [rootRow];
	},

	createColumns_: function(rows) {
	var titleColumn = {
	title: 'Mapped file',
	value: function(row) {
	return row.title;
	},
	width: '200px',
	cmp: function(rowA, rowB) {
	return rowA.title.localeCompare(rowB.title);
	}
	};

	var attributeColumns = tr.c.analysis.MemoryColumn.fromRows(
	rows, 'cells');
	tr.c.analysis.MemoryColumn.spaceEqually(attributeColumns);

	var columns = [titleColumn].concat(attributeColumns);
	return columns;
	}
	});
	})();
	</script>
	</polymer-element>