trace-viewer/trace_viewer/core/trace_model/process_memory_dump_test.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/test_utils.html">
 <link rel="import" href="/core/trace_model/attribute.html">
 <link rel="import" href="/core/trace_model/trace_model.html">
 <link rel="import" href="/core/trace_model/global_memory_dump.html">
 <link rel="import" href="/core/trace_model/process_memory_dump.html">

 <script>
 'use strict';

 tv.b.unittest.testSuite(function() {
   var TraceModel = tv.c.TraceModel;
   var GlobalMemoryDump = tv.c.trace_model.GlobalMemoryDump;
   var ProcessMemoryDump = tv.c.trace_model.ProcessMemoryDump;
   var MemoryAllocatorDump = tv.c.trace_model.MemoryAllocatorDump;
   var VMRegion = tv.c.trace_model.VMRegion;
   var ScalarAttribute = tv.c.trace_model.ScalarAttribute;

   var createProcessMemoryDump = function(timestamp, model) {
     var gmd = new GlobalMemoryDump(model, timestamp);
     model.globalMemoryDumps.push(gmd);
     var p = model.getOrCreateProcess(123);
     var pmd = new ProcessMemoryDump(gmd, p, timestamp + 1);
     p.memoryDumps.push(pmd);
     return pmd;
   }

   var createFinalizedProcessMemoryDump = function(timestamp, createdCallback) {
     var model = tv.c.test_utils.newModel(function(model) {
       createdCallback(createProcessMemoryDump(timestamp, model));
     });
     var pmds = model.getProcess(123).memoryDumps;
     assert.lengthOf(pmds, 1);
     return pmds[0];
   }

   function checkProtectionFlagsToString(protectionFlags, expectedString) {
     var vmRegion = VMRegion.fromDict({
       startAddress: 256,
       sizeInBytes: 336,
       protectionFlags: protectionFlags,
       mappedFile: '[stack:20310]',
       byteStats: {
         privateResident: 96,
         sharedResident: 144,
         proportionalResident: 158
       }
     });
     assert.strictEqual(vmRegion.protectionFlagsToString, expectedString);
   }

   test('totalResidentSizeInBytes_undefinedVmRegions', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {});
     assert.isUndefined(pmd.mostRecentTotalProportionalResidentSizeInBytes);
     assert.isUndefined(pmd.mostRecentTotalPrivateResidentSizeInBytes);
     assert.isUndefined(pmd.mostRecentTotalSharedResidentSizeInBytes);
   });

   test('totalResidentSizeInBytes_zeroVmRegions', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = [];
     });
     assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 0);
     assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 0);
     assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 0);
   });

   test('totalResidentSizeInBytes_oneVmRegion', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = [
         VMRegion.fromDict({
           startAddress: 256,
           sizeInBytes: 336,
           protectionFlags: VMRegion.PROTECTION_FLAG_READ |
               VMRegion.PROTECTION_FLAG_WRITE,
           mappedFile: '[stack:20310]',
           byteStats: {
             privateResident: 96,
             sharedResident: 144,
             proportionalResident: 158
           }
         })
       ];
     });
     assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 158);
     assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 96);
     assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 144);
   });

   test('totalResidentSizeInBytes_twoVmRegions', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = [
         VMRegion.fromDict({
           startAddress: 256,
           sizeInBytes: 336,
           protectionFlags: VMRegion.PROTECTION_FLAG_READ |
               VMRegion.PROTECTION_FLAG_WRITE,
           mappedFile: '[stack:20310]',
           byteStats: {
             privateResident: 96,
             sharedResident: 144,
             proportionalResident: 158
           }
         }),
         VMRegion.fromDict({
           startAddress: 848,
           sizeInBytes: 592,
           protectionFlags: VMRegion.PROTECTION_FLAG_READ |
               VMRegion.PROTECTION_FLAG_EXECUTE,
           mappedFile: '/dev/ashmem/dalvik',
           byteStats: {
             privateResident: 205,
             sharedResident: 0,
             proportionalResident: 205
           }
         })
       ];
     });
     assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 363);
     assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 301);
     assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 144);
   });

   test('hookUpMostRecentVmRegionsLinks_emptyArray', function() {
     var dumps = [];
     ProcessMemoryDump.hookUpMostRecentVmRegionsLinks(dumps);
     assert.lengthOf(dumps, 0);
   });

   test('hookUpMostRecentVmRegionsLinks_nonEmptyArray', function() {
     var m = new TraceModel();

     // A dump with no VM regions or allocator dumps.
     var dump1 = createProcessMemoryDump(1, m);

     // A dump with VM regions and malloc and Oilpan allocator dumps.
     var dump2 = createProcessMemoryDump(2, m);
     dump2.vmRegions = [];
     dump2.memoryAllocatorDumps = (function() {
       var oilpanDump = new MemoryAllocatorDump('oilpan');
       oilpanDump.addAttribute('outer_size', new ScalarAttribute('bytes', 1024));
       oilpanDump.addAttribute('objects_count',
           new ScalarAttribute('objects', 7));
       oilpanDump.addAttribute('inner_size', new ScalarAttribute('bytes', 768));

       var v8Dump = new MemoryAllocatorDump('v8');
       v8Dump.addAttribute('outer_size', new ScalarAttribute('bytes', 2048));
       v8Dump.addAttribute('objects_count', new ScalarAttribute('objects', 15));
       v8Dump.addAttribute('inner_size', new ScalarAttribute('bytes', 1999));

       return [oilpanDump. v8Dump];
     })();

     // A dump with malloc and V8 allocator dumps.
     var dump3 = createProcessMemoryDump(3, m);
     dump3.memoryAllocatorDumps = (function() {
       var mallocDump = new MemoryAllocatorDump('malloc');
       mallocDump.addAttribute('outer_size', new ScalarAttribute('bytes', 1024));
       mallocDump.addAttribute('objects_count',
           new ScalarAttribute('objects', 7));
       mallocDump.addAttribute('inner_size', new ScalarAttribute('bytes', 768));

       var v8Dump = new MemoryAllocatorDump('v8');
       v8Dump.addAttribute('outer_size', new ScalarAttribute('bytes', 2048));
       v8Dump.addAttribute('objects_count', new ScalarAttribute('objects', 15));
       v8Dump.addAttribute('inner_size', new ScalarAttribute('bytes', 1999));

       return [mallocDump. v8Dump];
     })();

     // A dump with VM regions.
     var dump4 = createProcessMemoryDump(4, m);
     dump4.vmRegions = [
       VMRegion.fromDict({
         startAddress: 256,
         sizeInBytes: 336,
         protectionFlags: VMRegion.PROTECTION_FLAG_READ |
             VMRegion.PROTECTION_FLAG_WRITE,
         mappedFile: '[stack:20310]',
         byteStats: {
           privateResident: 96,
           sharedResident: 144,
           proportionalResident: 158
         }
       })
     ];

     var dumps = [dump1, dump2, dump3, dump4];
     ProcessMemoryDump.hookUpMostRecentVmRegionsLinks(dumps);

     assert.lengthOf(dumps, 4);

     assert.equal(dumps[0], dump1);
     assert.isUndefined(dump1.mostRecentVmRegions);

     assert.equal(dumps[1], dump2);
     assert.equal(dump2.mostRecentVmRegions, dump2.vmRegions_);

     assert.equal(dumps[2], dump3);
     assert.equal(dump3.mostRecentVmRegions, dump2.vmRegions_);

     assert.equal(dumps[3], dump4);
     assert.equal(dump4.mostRecentVmRegions, dump4.vmRegions_);
   });

   test('vmRegion_protectionFlagsToString', function() {
     checkProtectionFlagsToString(undefined, undefined);
     checkProtectionFlagsToString(0, '---');
     checkProtectionFlagsToString(VMRegion.PROTECTION_FLAG_READ, 'r--');
     checkProtectionFlagsToString(
         VMRegion.PROTECTION_FLAG_READ | VMRegion.PROTECTION_FLAG_EXECUTE,
         'r-x');
     checkProtectionFlagsToString(
         VMRegion.PROTECTION_FLAG_READ | VMRegion.PROTECTION_FLAG_WRITE,
         'rw-');
   });
 });
 </script>
	<!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/test_utils.html">
	<link rel="import" href="/core/trace_model/attribute.html">
	<link rel="import" href="/core/trace_model/trace_model.html">
	<link rel="import" href="/core/trace_model/global_memory_dump.html">
	<link rel="import" href="/core/trace_model/process_memory_dump.html">

	<script>
	'use strict';

	tv.b.unittest.testSuite(function() {
	var TraceModel = tv.c.TraceModel;
	var GlobalMemoryDump = tv.c.trace_model.GlobalMemoryDump;
	var ProcessMemoryDump = tv.c.trace_model.ProcessMemoryDump;
	var MemoryAllocatorDump = tv.c.trace_model.MemoryAllocatorDump;
	var VMRegion = tv.c.trace_model.VMRegion;
	var ScalarAttribute = tv.c.trace_model.ScalarAttribute;

	var createProcessMemoryDump = function(timestamp, model) {
	var gmd = new GlobalMemoryDump(model, timestamp);
	model.globalMemoryDumps.push(gmd);
	var p = model.getOrCreateProcess(123);
	var pmd = new ProcessMemoryDump(gmd, p, timestamp + 1);
	p.memoryDumps.push(pmd);
	return pmd;
	}

	var createFinalizedProcessMemoryDump = function(timestamp, createdCallback) {
	var model = tv.c.test_utils.newModel(function(model) {
	createdCallback(createProcessMemoryDump(timestamp, model));
	});
	var pmds = model.getProcess(123).memoryDumps;
	assert.lengthOf(pmds, 1);
	return pmds[0];
	}

	function checkProtectionFlagsToString(protectionFlags, expectedString) {
	var vmRegion = VMRegion.fromDict({
	startAddress: 256,
	sizeInBytes: 336,
	protectionFlags: protectionFlags,
	mappedFile: '[stack:20310]',
	byteStats: {
	privateResident: 96,
	sharedResident: 144,
	proportionalResident: 158
	}
	});
	assert.strictEqual(vmRegion.protectionFlagsToString, expectedString);
	}

	test('totalResidentSizeInBytes_undefinedVmRegions', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {});
	assert.isUndefined(pmd.mostRecentTotalProportionalResidentSizeInBytes);
	assert.isUndefined(pmd.mostRecentTotalPrivateResidentSizeInBytes);
	assert.isUndefined(pmd.mostRecentTotalSharedResidentSizeInBytes);
	});

	test('totalResidentSizeInBytes_zeroVmRegions', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = [];
	});
	assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 0);
	assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 0);
	assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 0);
	});

	test('totalResidentSizeInBytes_oneVmRegion', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = [
	VMRegion.fromDict({
	startAddress: 256,
	sizeInBytes: 336,
	protectionFlags: VMRegion.PROTECTION_FLAG_READ \|
	VMRegion.PROTECTION_FLAG_WRITE,
	mappedFile: '[stack:20310]',
	byteStats: {
	privateResident: 96,
	sharedResident: 144,
	proportionalResident: 158
	}
	})
	];
	});
	assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 158);
	assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 96);
	assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 144);
	});

	test('totalResidentSizeInBytes_twoVmRegions', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = [
	VMRegion.fromDict({
	startAddress: 256,
	sizeInBytes: 336,
	protectionFlags: VMRegion.PROTECTION_FLAG_READ \|
	VMRegion.PROTECTION_FLAG_WRITE,
	mappedFile: '[stack:20310]',
	byteStats: {
	privateResident: 96,
	sharedResident: 144,
	proportionalResident: 158
	}
	}),
	VMRegion.fromDict({
	startAddress: 848,
	sizeInBytes: 592,
	protectionFlags: VMRegion.PROTECTION_FLAG_READ \|
	VMRegion.PROTECTION_FLAG_EXECUTE,
	mappedFile: '/dev/ashmem/dalvik',
	byteStats: {
	privateResident: 205,
	sharedResident: 0,
	proportionalResident: 205
	}
	})
	];
	});
	assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 363);
	assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 301);
	assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 144);
	});

	test('hookUpMostRecentVmRegionsLinks_emptyArray', function() {
	var dumps = [];
	ProcessMemoryDump.hookUpMostRecentVmRegionsLinks(dumps);
	assert.lengthOf(dumps, 0);
	});

	test('hookUpMostRecentVmRegionsLinks_nonEmptyArray', function() {
	var m = new TraceModel();

	// A dump with no VM regions or allocator dumps.
	var dump1 = createProcessMemoryDump(1, m);

	// A dump with VM regions and malloc and Oilpan allocator dumps.
	var dump2 = createProcessMemoryDump(2, m);
	dump2.vmRegions = [];
	dump2.memoryAllocatorDumps = (function() {
	var oilpanDump = new MemoryAllocatorDump('oilpan');
	oilpanDump.addAttribute('outer_size', new ScalarAttribute('bytes', 1024));
	oilpanDump.addAttribute('objects_count',
	new ScalarAttribute('objects', 7));
	oilpanDump.addAttribute('inner_size', new ScalarAttribute('bytes', 768));

	var v8Dump = new MemoryAllocatorDump('v8');
	v8Dump.addAttribute('outer_size', new ScalarAttribute('bytes', 2048));
	v8Dump.addAttribute('objects_count', new ScalarAttribute('objects', 15));
	v8Dump.addAttribute('inner_size', new ScalarAttribute('bytes', 1999));

	return [oilpanDump. v8Dump];
	})();

	// A dump with malloc and V8 allocator dumps.
	var dump3 = createProcessMemoryDump(3, m);
	dump3.memoryAllocatorDumps = (function() {
	var mallocDump = new MemoryAllocatorDump('malloc');
	mallocDump.addAttribute('outer_size', new ScalarAttribute('bytes', 1024));
	mallocDump.addAttribute('objects_count',
	new ScalarAttribute('objects', 7));
	mallocDump.addAttribute('inner_size', new ScalarAttribute('bytes', 768));

	var v8Dump = new MemoryAllocatorDump('v8');
	v8Dump.addAttribute('outer_size', new ScalarAttribute('bytes', 2048));
	v8Dump.addAttribute('objects_count', new ScalarAttribute('objects', 15));
	v8Dump.addAttribute('inner_size', new ScalarAttribute('bytes', 1999));

	return [mallocDump. v8Dump];
	})();

	// A dump with VM regions.
	var dump4 = createProcessMemoryDump(4, m);
	dump4.vmRegions = [
	VMRegion.fromDict({
	startAddress: 256,
	sizeInBytes: 336,
	protectionFlags: VMRegion.PROTECTION_FLAG_READ \|
	VMRegion.PROTECTION_FLAG_WRITE,
	mappedFile: '[stack:20310]',
	byteStats: {
	privateResident: 96,
	sharedResident: 144,
	proportionalResident: 158
	}
	})
	];

	var dumps = [dump1, dump2, dump3, dump4];
	ProcessMemoryDump.hookUpMostRecentVmRegionsLinks(dumps);

	assert.lengthOf(dumps, 4);

	assert.equal(dumps[0], dump1);
	assert.isUndefined(dump1.mostRecentVmRegions);

	assert.equal(dumps[1], dump2);
	assert.equal(dump2.mostRecentVmRegions, dump2.vmRegions_);

	assert.equal(dumps[2], dump3);
	assert.equal(dump3.mostRecentVmRegions, dump2.vmRegions_);

	assert.equal(dumps[3], dump4);
	assert.equal(dump4.mostRecentVmRegions, dump4.vmRegions_);
	});

	test('vmRegion_protectionFlagsToString', function() {
	checkProtectionFlagsToString(undefined, undefined);
	checkProtectionFlagsToString(0, '---');
	checkProtectionFlagsToString(VMRegion.PROTECTION_FLAG_READ, 'r--');
	checkProtectionFlagsToString(
	VMRegion.PROTECTION_FLAG_READ \| VMRegion.PROTECTION_FLAG_EXECUTE,
	'r-x');
	checkProtectionFlagsToString(
	VMRegion.PROTECTION_FLAG_READ \| VMRegion.PROTECTION_FLAG_WRITE,
	'rw-');
	});
	});
	</script>