catapult/tracing/tracing/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="/tracing/core/test_utils.html">
 <link rel="import" href="/tracing/model/global_memory_dump.html">
 <link rel="import" href="/tracing/model/memory_dump_test_utils.html">
 <link rel="import" href="/tracing/model/model.html">
 <link rel="import" href="/tracing/model/process_memory_dump.html">
 <link rel="import" href="/tracing/model/vm_region.html">
 <link rel="import" href="/tracing/value/numeric.html">
 <link rel="import" href="/tracing/value/unit.html">

 <script>
 'use strict';

 tr.b.unittest.testSuite(function() {
   var GlobalMemoryDump = tr.model.GlobalMemoryDump;
   var ProcessMemoryDump = tr.model.ProcessMemoryDump;
   var VMRegion = tr.model.VMRegion;
   var VMRegionClassificationNode = tr.model.VMRegionClassificationNode;
   var ScalarNumeric = tr.v.ScalarNumeric;
   var unitlessNumber_smallerIsBetter =
       tr.v.Unit.byName.unitlessNumber_smallerIsBetter;
   var newAllocatorDump = tr.model.MemoryDumpTestUtils.newAllocatorDump;
   var newChildDump = tr.model.MemoryDumpTestUtils.newChildDump;
   var addOwnershipLink = tr.model.MemoryDumpTestUtils.addOwnershipLink;
   var checkDumpNumericsAndDiagnostics =
       tr.model.MemoryDumpTestUtils.checkDumpNumericsAndDiagnostics;
   var checkVMRegions = tr.model.MemoryDumpTestUtils.checkVMRegions;

   function createClassificationNode(opt_sizeInBytes, opt_byteStats) {
     var node = new VMRegionClassificationNode();
     if (opt_sizeInBytes !== undefined || opt_byteStats !== undefined) {
       node.addRegion(VMRegion.fromDict({
         mappedFile: 'mock.so',
         sizeInBytes: opt_sizeInBytes,
         byteStats: opt_byteStats
       }));
     }
     return node;
   }

   function createProcessMemoryDump(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);
     gmd.processMemoryDumps[123] = pmd;
     p.memoryDumps.push(pmd);
     return pmd;
   }

   function createFinalizedProcessMemoryDump(timestamp, opt_createdCallback) {
     return createFinalizedProcessMemoryDumps([timestamp], function(pmds) {
       if (opt_createdCallback !== undefined)
         opt_createdCallback(pmds[0]);
     })[0];
   }

   function createFinalizedProcessMemoryDumps(timestamps, createdCallback) {
     var model = tr.c.TestUtils.newModel(function(model) {
       var pmds = timestamps.map(function(timestamp) {
         return createProcessMemoryDump(timestamp, model);
       });
       createdCallback(pmds);
     });
     var pmds = model.getProcess(123).memoryDumps;
     assert.lengthOf(pmds, timestamps.length);
     return pmds;
   }

   test('processMemoryDumps', function() {
     var pmd = createFinalizedProcessMemoryDump(42);
     var pmds = pmd.processMemoryDumps;
     assert.lengthOf(Object.keys(pmds), 1);
     assert.strictEqual(pmds[123], pmd);
   });

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

   test('hookUpMostRecentVmRegionsLinks_nonEmptyArray', function() {
     var m = new tr.Model();

     // 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 = createClassificationNode();
     dump2.memoryAllocatorDumps = [
       newAllocatorDump(dump2, 'oilpan', {
         size: 1024,
         objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 7),
         inner_size: 768
       }),
       newAllocatorDump(dump2, 'v8', {
         size: 2048,
         objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 15),
         inner_size: 1999
       })
     ];

     // A dump with malloc and V8 allocator dumps.
     var dump3 = createProcessMemoryDump(3, m);
     dump3.memoryAllocatorDumps = [
       newAllocatorDump(dump3, 'malloc', {
         size: 1024,
         objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 7),
         inner_size: 768
       }),
       newAllocatorDump(dump3, 'v8', {
         size: 2048,
         objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 15),
         inner_size: 1999
       })
     ];

     // A dump with VM regions.
     var dump4 = createProcessMemoryDump(4, m);
     dump4.vmRegions = createClassificationNode();

     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('checkDiscountTracingOverhead_undefinedFields', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.memoryAllocatorDumps = [
         newAllocatorDump(pmd, 'v8', { size: 2048 }),
         newAllocatorDump(pmd, 'tracing', { size: 1024 })
       ];
     });

     assert.isUndefined(pmd.totals);
     assert.isUndefined(pmd.vmRegions);

     var v8Dump = pmd.getMemoryAllocatorDumpByFullName('v8');
     checkDumpNumericsAndDiagnostics(v8Dump, {
       'size': 2048,
       'effective_size': 2048
     }, {});

     var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
     checkDumpNumericsAndDiagnostics(tracingDump, {
       'size': 1024,
       'effective_size': 1024
     }, {});
   });

   test('checkDiscountTracingOverhead_definedFields', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.totals = { residentBytes: 10240 };
       pmd.vmRegions = createClassificationNode(6000, {
         privateDirtyResident: 4096,
         proportionalResident: 5120,
         swapped: 1536
       });

       var mallocDump = newAllocatorDump(pmd, 'malloc', { size: 3072 });
       newChildDump(mallocDump, 'allocated_objects', { size: 2560 });

       var tracingDump = newAllocatorDump(
           pmd, 'tracing', { size: 1024, resident_size: 1000 });

       pmd.memoryAllocatorDumps = [mallocDump, tracingDump];
     });

     assert.equal(pmd.totals.residentBytes, 9240);
     assert.isUndefined(pmd.totals.peakResidentBytes);

     var vmRegions = pmd.vmRegions;
     assert.strictEqual(vmRegions.sizeInBytes, 4976);
     assert.deepEqual(vmRegions.byteStats, {
       privateDirtyResident: 3096,
       proportionalResident: 4120,
       swapped: 1536
     });

     checkVMRegions(vmRegions, [
       {
         mappedFile: 'mock.so',
         sizeInBytes: 6000,
         byteStats: {
           privateDirtyResident: 4096,
           proportionalResident: 5120,
           swapped: 1536
         }
       },
       {
         mappedFile: '[discounted tracing overhead]',
         sizeInBytes: -1024,
         byteStats: {
           privateDirtyResident: -1000,
           proportionalResident: -1000
         }
       }
     ]);

     var mallocDump = pmd.getMemoryAllocatorDumpByFullName('malloc');
     checkDumpNumericsAndDiagnostics(mallocDump, {
       'size': 3072,
       'effective_size': 2048
     }, {});
     assert.lengthOf(
         mallocDump.children, 2 /* 'allocated_objects' and '<unspecified>' */);

     var allocatedObjectsDump = pmd.getMemoryAllocatorDumpByFullName(
         'malloc/allocated_objects');
     checkDumpNumericsAndDiagnostics(allocatedObjectsDump, {
       'size': 2560,
       'effective_size': 1536
     }, {});
     assert.lengthOf(
         allocatedObjectsDump.children,
         2 /* 'tracing_overhead' and '<unspecified>' */);

     var discountDump = pmd.getMemoryAllocatorDumpByFullName(
         'malloc/allocated_objects/tracing_overhead');
     assert.strictEqual(discountDump.parent, allocatedObjectsDump);
     assert.include(allocatedObjectsDump.children, discountDump);
     checkDumpNumericsAndDiagnostics(discountDump, {
       'size': 1024,
       'effective_size': 0
     }, {});

     var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
     checkDumpNumericsAndDiagnostics(tracingDump, {
       'size': 1024,
       'effective_size': 1024,
       'resident_size': 1000
     }, {});
     assert.strictEqual(tracingDump.owns.target, discountDump);
   });

   test('checkDiscountTracingOverhead_winheap', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.memoryAllocatorDumps = [
         newAllocatorDump(pmd, 'tracing', { size: 2048 }),
         newAllocatorDump(pmd, 'winheap', { size: 5120 })
       ];
     });

     assert.isUndefined(pmd.totals);
     assert.isUndefined(pmd.vmRegions);

     var winheapDump = pmd.getMemoryAllocatorDumpByFullName('winheap');
     checkDumpNumericsAndDiagnostics(winheapDump, {
       'size': 5120,
       'effective_size': 3072
     }, {});
     assert.lengthOf(winheapDump.children,
         2 /* 'allocated_objects' and '<unspecified>' */);

     var allocatedObjectsDump = pmd.getMemoryAllocatorDumpByFullName(
         'winheap/allocated_objects');
     checkDumpNumericsAndDiagnostics(allocatedObjectsDump, {
       'size': 2048,
       'effective_size': 0
     }, {});
     assert.lengthOf(
         allocatedObjectsDump.children, 1 /* 'tracing_overhead' */);

     var discountDump = pmd.getMemoryAllocatorDumpByFullName(
         'winheap/allocated_objects/tracing_overhead');
     assert.strictEqual(discountDump.parent, allocatedObjectsDump);
     assert.include(allocatedObjectsDump.children, discountDump);
     checkDumpNumericsAndDiagnostics(discountDump, {
       'size': 2048,
       'effective_size': 0
     }, {});

     var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
     checkDumpNumericsAndDiagnostics(tracingDump, {
       'size': 2048,
       'effective_size': 2048
     }, {});
     assert.strictEqual(tracingDump.owns.target, discountDump);
   });

   test('checkDiscountTracingOverhead_withMostRecentVmRegionsLinks', function() {
     var pmds = createFinalizedProcessMemoryDumps([42, 90], function(pmds) {
       pmds[0].totals = { residentBytes: 1000, peakResidentBytes: 2000 };
       pmds[0].vmRegions = createClassificationNode(6000, {
         privateDirtyResident: 4096
       });
       pmds[0].memoryAllocatorDumps = [
         newAllocatorDump(pmds[0], 'tracing', { size: 300, resident_size: 100 })
       ];

       pmds[1].totals = { peakResidentBytes: 3000 };
       pmds[1].memoryAllocatorDumps = [
         newAllocatorDump(pmds[0], 'tracing', { resident_size: 200 })
       ];
     });

     // First PMD: Both total resident and private dirty resident size should be
     // reduced by 100. Virtual size should be reduced by 300.
     assert.strictEqual(pmds[0].totals.residentBytes, 900);
     assert.strictEqual(pmds[0].totals.peakResidentBytes, 1900);
     assert.strictEqual(pmds[0].vmRegions.sizeInBytes, 5700);
     assert.deepEqual(pmds[0].vmRegions.byteStats, {
       privateDirtyResident: 3996
     });
     checkVMRegions(pmds[0].vmRegions, [
       {
         mappedFile: 'mock.so',
         sizeInBytes: 6000,
         byteStats: {
           privateDirtyResident: 4096,
         }
       },
       {
         mappedFile: '[discounted tracing overhead]',
         sizeInBytes: -300,
         byteStats: {
           privateDirtyResident: -100
         }
       }
     ]);
     assert.strictEqual(pmds[0].mostRecentVmRegions, pmds[0].vmRegions);

     // Second PMD: Total resident size should be reduced by 200, whereas private
     // dirty resident size should be reduced by 100 (because it comes from
     // the VM regions in the first dump). Similarly, virtual size should be
     // reduced by 300.
     assert.isUndefined(pmds[1].totals.residentBytes);
     assert.equal(pmds[1].totals.peakResidentBytes, 2800);
     assert.isUndefined(pmds[1].vmRegions);
     assert.strictEqual(pmds[1].mostRecentVmRegions, pmds[0].vmRegions);
   });

   test('checkDiscountTracingOverhead_allDiscountedVmRegionFields', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = createClassificationNode(10000, {
         privateDirtyResident: 4096,
         proportionalResident: 8192,
         swapped: 1536
       });
       pmd.memoryAllocatorDumps = [
         newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
       ];
     });

     var vmRegions = pmd.vmRegions;
     assert.strictEqual(vmRegions.sizeInBytes, 9000);
     assert.deepEqual(vmRegions.byteStats, {
       privateDirtyResident: 3072,
       proportionalResident: 7168,
       swapped: 1536
     });
     checkVMRegions(vmRegions, [
       {
         mappedFile: 'mock.so',
         sizeInBytes: 10000,
         byteStats: {
           privateDirtyResident: 4096,
           proportionalResident: 8192,
           swapped: 1536
         }
       },
       {
         mappedFile: '[discounted tracing overhead]',
         sizeInBytes: -1000,
         byteStats: {
           privateDirtyResident: -1024,
           proportionalResident: -1024
         }
       }
     ]);
   });

   test('checkDiscountTracingOverhead_twoDiscountedVmRegionField', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = createClassificationNode(10000, {
         privateDirtyResident: 4096,
         swapped: 1536
       });
       pmd.memoryAllocatorDumps = [
         newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
       ];
     });

     var vmRegions = pmd.vmRegions;
     assert.strictEqual(vmRegions.sizeInBytes, 9000);
     assert.deepEqual(vmRegions.byteStats, {
       privateDirtyResident: 3072,
       swapped: 1536
     });
     checkVMRegions(vmRegions, [
       {
         mappedFile: 'mock.so',
         sizeInBytes: 10000,
         byteStats: {
           privateDirtyResident: 4096,
           swapped: 1536
         }
       },
       {
         mappedFile: '[discounted tracing overhead]',
         sizeInBytes: -1000,
         byteStats: {
           privateDirtyResident: -1024
         }
       }
     ]);
   });

   test('checkDiscountTracingOverhead_oneDiscountedVmRegionField', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = createClassificationNode(10000);
       pmd.memoryAllocatorDumps = [
         newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
       ];
     });

     var vmRegions = pmd.vmRegions;
     assert.strictEqual(vmRegions.sizeInBytes, 9000);
     assert.deepEqual(vmRegions.byteStats, {});
     checkVMRegions(vmRegions, [
       {
         mappedFile: 'mock.so',
         sizeInBytes: 10000
       },
       {
         mappedFile: '[discounted tracing overhead]',
         sizeInBytes: -1000
       }
     ]);
   });

   test('checkDiscountTracingOverhead_noDiscountedVmRegionFields', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.vmRegions = createClassificationNode(undefined, {
         swapped: 1536
       });
       pmd.memoryAllocatorDumps = [
         newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
       ];
     });

     var vmRegions = pmd.vmRegions;
     assert.isUndefined(vmRegions.sizeInBytes);
     assert.deepEqual(vmRegions.byteStats, {
       swapped: 1536
     });
     checkVMRegions(vmRegions, [
       {
         mappedFile: 'mock.so',
         byteStats: {
           swapped: 1536
         }
       }
     ]);
   });

   test('checkDiscountTracingOverhead_existingLink', function() {
     var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
       pmd.totals = { residentBytes: 10240 };

       pmd.vmRegions = createClassificationNode(6000, {
         privateDirtyResident: 4096,
         swapped: 1536,
         proportionalResident: 5120
       });

       var mallocDump = newAllocatorDump(pmd, 'malloc', { size: 3072 });
       var tracingDump = newAllocatorDump(pmd, 'tracing',
           { size: 1024, resident_size: 1000 });
       var ownedDump = newAllocatorDump(pmd, 'owned');

       // The code for discounting tracing overhead should *not* override an
       // existing ownership.
       addOwnershipLink(tracingDump, ownedDump);

       pmd.memoryAllocatorDumps = [mallocDump, tracingDump, ownedDump];
     });

     assert.strictEqual(pmd.totals.residentBytes, 9240);
     assert.isUndefined(pmd.totals.peakResidentBytes);

     var vmRegions = pmd.vmRegions;
     assert.strictEqual(vmRegions.sizeInBytes, 4976);
     assert.deepEqual(vmRegions.byteStats, {
       privateDirtyResident: 3096,
       proportionalResident: 4120,
       swapped: 1536
     });
     checkVMRegions(vmRegions, [
       {
         mappedFile: 'mock.so',
         sizeInBytes: 6000,
         byteStats: {
           privateDirtyResident: 4096,
           proportionalResident: 5120,
           swapped: 1536
         }
       },
       {
         mappedFile: '[discounted tracing overhead]',
         sizeInBytes: -1024,
         byteStats: {
           privateDirtyResident: -1000,
           proportionalResident: -1000
         }
       }
     ]);

     var mallocDump = pmd.getMemoryAllocatorDumpByFullName('malloc');
     checkDumpNumericsAndDiagnostics(mallocDump, {
       'size': 3072,
       'effective_size': 3072
     }, {});
     assert.lengthOf(mallocDump.children, 0);

     var ownedDump = pmd.getMemoryAllocatorDumpByFullName('owned');
     checkDumpNumericsAndDiagnostics(ownedDump, {
       'size': 1024,
       'effective_size': 0
     }, {});
     assert.lengthOf(ownedDump.children, 0);

     var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
     checkDumpNumericsAndDiagnostics(tracingDump, {
       'size': 1024,
       'effective_size': 1024,
       'resident_size': 1000
     }, {});
     assert.strictEqual(tracingDump.owns.target, ownedDump);
   });
 });
 </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="/tracing/core/test_utils.html">
	<link rel="import" href="/tracing/model/global_memory_dump.html">
	<link rel="import" href="/tracing/model/memory_dump_test_utils.html">
	<link rel="import" href="/tracing/model/model.html">
	<link rel="import" href="/tracing/model/process_memory_dump.html">
	<link rel="import" href="/tracing/model/vm_region.html">
	<link rel="import" href="/tracing/value/numeric.html">
	<link rel="import" href="/tracing/value/unit.html">

	<script>
	'use strict';

	tr.b.unittest.testSuite(function() {
	var GlobalMemoryDump = tr.model.GlobalMemoryDump;
	var ProcessMemoryDump = tr.model.ProcessMemoryDump;
	var VMRegion = tr.model.VMRegion;
	var VMRegionClassificationNode = tr.model.VMRegionClassificationNode;
	var ScalarNumeric = tr.v.ScalarNumeric;
	var unitlessNumber_smallerIsBetter =
	tr.v.Unit.byName.unitlessNumber_smallerIsBetter;
	var newAllocatorDump = tr.model.MemoryDumpTestUtils.newAllocatorDump;
	var newChildDump = tr.model.MemoryDumpTestUtils.newChildDump;
	var addOwnershipLink = tr.model.MemoryDumpTestUtils.addOwnershipLink;
	var checkDumpNumericsAndDiagnostics =
	tr.model.MemoryDumpTestUtils.checkDumpNumericsAndDiagnostics;
	var checkVMRegions = tr.model.MemoryDumpTestUtils.checkVMRegions;

	function createClassificationNode(opt_sizeInBytes, opt_byteStats) {
	var node = new VMRegionClassificationNode();
	if (opt_sizeInBytes !== undefined \|\| opt_byteStats !== undefined) {
	node.addRegion(VMRegion.fromDict({
	mappedFile: 'mock.so',
	sizeInBytes: opt_sizeInBytes,
	byteStats: opt_byteStats
	}));
	}
	return node;
	}

	function createProcessMemoryDump(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);
	gmd.processMemoryDumps[123] = pmd;
	p.memoryDumps.push(pmd);
	return pmd;
	}

	function createFinalizedProcessMemoryDump(timestamp, opt_createdCallback) {
	return createFinalizedProcessMemoryDumps([timestamp], function(pmds) {
	if (opt_createdCallback !== undefined)
	opt_createdCallback(pmds[0]);
	})[0];
	}

	function createFinalizedProcessMemoryDumps(timestamps, createdCallback) {
	var model = tr.c.TestUtils.newModel(function(model) {
	var pmds = timestamps.map(function(timestamp) {
	return createProcessMemoryDump(timestamp, model);
	});
	createdCallback(pmds);
	});
	var pmds = model.getProcess(123).memoryDumps;
	assert.lengthOf(pmds, timestamps.length);
	return pmds;
	}

	test('processMemoryDumps', function() {
	var pmd = createFinalizedProcessMemoryDump(42);
	var pmds = pmd.processMemoryDumps;
	assert.lengthOf(Object.keys(pmds), 1);
	assert.strictEqual(pmds[123], pmd);
	});

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

	test('hookUpMostRecentVmRegionsLinks_nonEmptyArray', function() {
	var m = new tr.Model();

	// 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 = createClassificationNode();
	dump2.memoryAllocatorDumps = [
	newAllocatorDump(dump2, 'oilpan', {
	size: 1024,
	objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 7),
	inner_size: 768
	}),
	newAllocatorDump(dump2, 'v8', {
	size: 2048,
	objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 15),
	inner_size: 1999
	})
	];

	// A dump with malloc and V8 allocator dumps.
	var dump3 = createProcessMemoryDump(3, m);
	dump3.memoryAllocatorDumps = [
	newAllocatorDump(dump3, 'malloc', {
	size: 1024,
	objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 7),
	inner_size: 768
	}),
	newAllocatorDump(dump3, 'v8', {
	size: 2048,
	objects_count: new ScalarNumeric(unitlessNumber_smallerIsBetter, 15),
	inner_size: 1999
	})
	];

	// A dump with VM regions.
	var dump4 = createProcessMemoryDump(4, m);
	dump4.vmRegions = createClassificationNode();

	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('checkDiscountTracingOverhead_undefinedFields', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.memoryAllocatorDumps = [
	newAllocatorDump(pmd, 'v8', { size: 2048 }),
	newAllocatorDump(pmd, 'tracing', { size: 1024 })
	];
	});

	assert.isUndefined(pmd.totals);
	assert.isUndefined(pmd.vmRegions);

	var v8Dump = pmd.getMemoryAllocatorDumpByFullName('v8');
	checkDumpNumericsAndDiagnostics(v8Dump, {
	'size': 2048,
	'effective_size': 2048
	}, {});

	var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
	checkDumpNumericsAndDiagnostics(tracingDump, {
	'size': 1024,
	'effective_size': 1024
	}, {});
	});

	test('checkDiscountTracingOverhead_definedFields', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.totals = { residentBytes: 10240 };
	pmd.vmRegions = createClassificationNode(6000, {
	privateDirtyResident: 4096,
	proportionalResident: 5120,
	swapped: 1536
	});

	var mallocDump = newAllocatorDump(pmd, 'malloc', { size: 3072 });
	newChildDump(mallocDump, 'allocated_objects', { size: 2560 });

	var tracingDump = newAllocatorDump(
	pmd, 'tracing', { size: 1024, resident_size: 1000 });

	pmd.memoryAllocatorDumps = [mallocDump, tracingDump];
	});

	assert.equal(pmd.totals.residentBytes, 9240);
	assert.isUndefined(pmd.totals.peakResidentBytes);

	var vmRegions = pmd.vmRegions;
	assert.strictEqual(vmRegions.sizeInBytes, 4976);
	assert.deepEqual(vmRegions.byteStats, {
	privateDirtyResident: 3096,
	proportionalResident: 4120,
	swapped: 1536
	});

	checkVMRegions(vmRegions, [
	{
	mappedFile: 'mock.so',
	sizeInBytes: 6000,
	byteStats: {
	privateDirtyResident: 4096,
	proportionalResident: 5120,
	swapped: 1536
	}
	},
	{
	mappedFile: '[discounted tracing overhead]',
	sizeInBytes: -1024,
	byteStats: {
	privateDirtyResident: -1000,
	proportionalResident: -1000
	}
	}
	]);

	var mallocDump = pmd.getMemoryAllocatorDumpByFullName('malloc');
	checkDumpNumericsAndDiagnostics(mallocDump, {
	'size': 3072,
	'effective_size': 2048
	}, {});
	assert.lengthOf(
	mallocDump.children, 2 /* 'allocated_objects' and '<unspecified>' */);

	var allocatedObjectsDump = pmd.getMemoryAllocatorDumpByFullName(
	'malloc/allocated_objects');
	checkDumpNumericsAndDiagnostics(allocatedObjectsDump, {
	'size': 2560,
	'effective_size': 1536
	}, {});
	assert.lengthOf(
	allocatedObjectsDump.children,
	2 /* 'tracing_overhead' and '<unspecified>' */);

	var discountDump = pmd.getMemoryAllocatorDumpByFullName(
	'malloc/allocated_objects/tracing_overhead');
	assert.strictEqual(discountDump.parent, allocatedObjectsDump);
	assert.include(allocatedObjectsDump.children, discountDump);
	checkDumpNumericsAndDiagnostics(discountDump, {
	'size': 1024,
	'effective_size': 0
	}, {});

	var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
	checkDumpNumericsAndDiagnostics(tracingDump, {
	'size': 1024,
	'effective_size': 1024,
	'resident_size': 1000
	}, {});
	assert.strictEqual(tracingDump.owns.target, discountDump);
	});

	test('checkDiscountTracingOverhead_winheap', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.memoryAllocatorDumps = [
	newAllocatorDump(pmd, 'tracing', { size: 2048 }),
	newAllocatorDump(pmd, 'winheap', { size: 5120 })
	];
	});

	assert.isUndefined(pmd.totals);
	assert.isUndefined(pmd.vmRegions);

	var winheapDump = pmd.getMemoryAllocatorDumpByFullName('winheap');
	checkDumpNumericsAndDiagnostics(winheapDump, {
	'size': 5120,
	'effective_size': 3072
	}, {});
	assert.lengthOf(winheapDump.children,
	2 /* 'allocated_objects' and '<unspecified>' */);

	var allocatedObjectsDump = pmd.getMemoryAllocatorDumpByFullName(
	'winheap/allocated_objects');
	checkDumpNumericsAndDiagnostics(allocatedObjectsDump, {
	'size': 2048,
	'effective_size': 0
	}, {});
	assert.lengthOf(
	allocatedObjectsDump.children, 1 /* 'tracing_overhead' */);

	var discountDump = pmd.getMemoryAllocatorDumpByFullName(
	'winheap/allocated_objects/tracing_overhead');
	assert.strictEqual(discountDump.parent, allocatedObjectsDump);
	assert.include(allocatedObjectsDump.children, discountDump);
	checkDumpNumericsAndDiagnostics(discountDump, {
	'size': 2048,
	'effective_size': 0
	}, {});

	var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
	checkDumpNumericsAndDiagnostics(tracingDump, {
	'size': 2048,
	'effective_size': 2048
	}, {});
	assert.strictEqual(tracingDump.owns.target, discountDump);
	});

	test('checkDiscountTracingOverhead_withMostRecentVmRegionsLinks', function() {
	var pmds = createFinalizedProcessMemoryDumps([42, 90], function(pmds) {
	pmds[0].totals = { residentBytes: 1000, peakResidentBytes: 2000 };
	pmds[0].vmRegions = createClassificationNode(6000, {
	privateDirtyResident: 4096
	});
	pmds[0].memoryAllocatorDumps = [
	newAllocatorDump(pmds[0], 'tracing', { size: 300, resident_size: 100 })
	];

	pmds[1].totals = { peakResidentBytes: 3000 };
	pmds[1].memoryAllocatorDumps = [
	newAllocatorDump(pmds[0], 'tracing', { resident_size: 200 })
	];
	});

	// First PMD: Both total resident and private dirty resident size should be
	// reduced by 100. Virtual size should be reduced by 300.
	assert.strictEqual(pmds[0].totals.residentBytes, 900);
	assert.strictEqual(pmds[0].totals.peakResidentBytes, 1900);
	assert.strictEqual(pmds[0].vmRegions.sizeInBytes, 5700);
	assert.deepEqual(pmds[0].vmRegions.byteStats, {
	privateDirtyResident: 3996
	});
	checkVMRegions(pmds[0].vmRegions, [
	{
	mappedFile: 'mock.so',
	sizeInBytes: 6000,
	byteStats: {
	privateDirtyResident: 4096,
	}
	},
	{
	mappedFile: '[discounted tracing overhead]',
	sizeInBytes: -300,
	byteStats: {
	privateDirtyResident: -100
	}
	}
	]);
	assert.strictEqual(pmds[0].mostRecentVmRegions, pmds[0].vmRegions);

	// Second PMD: Total resident size should be reduced by 200, whereas private
	// dirty resident size should be reduced by 100 (because it comes from
	// the VM regions in the first dump). Similarly, virtual size should be
	// reduced by 300.
	assert.isUndefined(pmds[1].totals.residentBytes);
	assert.equal(pmds[1].totals.peakResidentBytes, 2800);
	assert.isUndefined(pmds[1].vmRegions);
	assert.strictEqual(pmds[1].mostRecentVmRegions, pmds[0].vmRegions);
	});

	test('checkDiscountTracingOverhead_allDiscountedVmRegionFields', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = createClassificationNode(10000, {
	privateDirtyResident: 4096,
	proportionalResident: 8192,
	swapped: 1536
	});
	pmd.memoryAllocatorDumps = [
	newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
	];
	});

	var vmRegions = pmd.vmRegions;
	assert.strictEqual(vmRegions.sizeInBytes, 9000);
	assert.deepEqual(vmRegions.byteStats, {
	privateDirtyResident: 3072,
	proportionalResident: 7168,
	swapped: 1536
	});
	checkVMRegions(vmRegions, [
	{
	mappedFile: 'mock.so',
	sizeInBytes: 10000,
	byteStats: {
	privateDirtyResident: 4096,
	proportionalResident: 8192,
	swapped: 1536
	}
	},
	{
	mappedFile: '[discounted tracing overhead]',
	sizeInBytes: -1000,
	byteStats: {
	privateDirtyResident: -1024,
	proportionalResident: -1024
	}
	}
	]);
	});

	test('checkDiscountTracingOverhead_twoDiscountedVmRegionField', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = createClassificationNode(10000, {
	privateDirtyResident: 4096,
	swapped: 1536
	});
	pmd.memoryAllocatorDumps = [
	newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
	];
	});

	var vmRegions = pmd.vmRegions;
	assert.strictEqual(vmRegions.sizeInBytes, 9000);
	assert.deepEqual(vmRegions.byteStats, {
	privateDirtyResident: 3072,
	swapped: 1536
	});
	checkVMRegions(vmRegions, [
	{
	mappedFile: 'mock.so',
	sizeInBytes: 10000,
	byteStats: {
	privateDirtyResident: 4096,
	swapped: 1536
	}
	},
	{
	mappedFile: '[discounted tracing overhead]',
	sizeInBytes: -1000,
	byteStats: {
	privateDirtyResident: -1024
	}
	}
	]);
	});

	test('checkDiscountTracingOverhead_oneDiscountedVmRegionField', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = createClassificationNode(10000);
	pmd.memoryAllocatorDumps = [
	newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
	];
	});

	var vmRegions = pmd.vmRegions;
	assert.strictEqual(vmRegions.sizeInBytes, 9000);
	assert.deepEqual(vmRegions.byteStats, {});
	checkVMRegions(vmRegions, [
	{
	mappedFile: 'mock.so',
	sizeInBytes: 10000
	},
	{
	mappedFile: '[discounted tracing overhead]',
	sizeInBytes: -1000
	}
	]);
	});

	test('checkDiscountTracingOverhead_noDiscountedVmRegionFields', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.vmRegions = createClassificationNode(undefined, {
	swapped: 1536
	});
	pmd.memoryAllocatorDumps = [
	newAllocatorDump(pmd, 'tracing', { size: 1000, resident_size: 1024 })
	];
	});

	var vmRegions = pmd.vmRegions;
	assert.isUndefined(vmRegions.sizeInBytes);
	assert.deepEqual(vmRegions.byteStats, {
	swapped: 1536
	});
	checkVMRegions(vmRegions, [
	{
	mappedFile: 'mock.so',
	byteStats: {
	swapped: 1536
	}
	}
	]);
	});

	test('checkDiscountTracingOverhead_existingLink', function() {
	var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
	pmd.totals = { residentBytes: 10240 };

	pmd.vmRegions = createClassificationNode(6000, {
	privateDirtyResident: 4096,
	swapped: 1536,
	proportionalResident: 5120
	});

	var mallocDump = newAllocatorDump(pmd, 'malloc', { size: 3072 });
	var tracingDump = newAllocatorDump(pmd, 'tracing',
	{ size: 1024, resident_size: 1000 });
	var ownedDump = newAllocatorDump(pmd, 'owned');

	// The code for discounting tracing overhead should not override an
	// existing ownership.
	addOwnershipLink(tracingDump, ownedDump);

	pmd.memoryAllocatorDumps = [mallocDump, tracingDump, ownedDump];
	});

	assert.strictEqual(pmd.totals.residentBytes, 9240);
	assert.isUndefined(pmd.totals.peakResidentBytes);

	var vmRegions = pmd.vmRegions;
	assert.strictEqual(vmRegions.sizeInBytes, 4976);
	assert.deepEqual(vmRegions.byteStats, {
	privateDirtyResident: 3096,
	proportionalResident: 4120,
	swapped: 1536
	});
	checkVMRegions(vmRegions, [
	{
	mappedFile: 'mock.so',
	sizeInBytes: 6000,
	byteStats: {
	privateDirtyResident: 4096,
	proportionalResident: 5120,
	swapped: 1536
	}
	},
	{
	mappedFile: '[discounted tracing overhead]',
	sizeInBytes: -1024,
	byteStats: {
	privateDirtyResident: -1000,
	proportionalResident: -1000
	}
	}
	]);

	var mallocDump = pmd.getMemoryAllocatorDumpByFullName('malloc');
	checkDumpNumericsAndDiagnostics(mallocDump, {
	'size': 3072,
	'effective_size': 3072
	}, {});
	assert.lengthOf(mallocDump.children, 0);

	var ownedDump = pmd.getMemoryAllocatorDumpByFullName('owned');
	checkDumpNumericsAndDiagnostics(ownedDump, {
	'size': 1024,
	'effective_size': 0
	}, {});
	assert.lengthOf(ownedDump.children, 0);

	var tracingDump = pmd.getMemoryAllocatorDumpByFullName('tracing');
	checkDumpNumericsAndDiagnostics(tracingDump, {
	'size': 1024,
	'effective_size': 1024,
	'resident_size': 1000
	}, {});
	assert.strictEqual(tracingDump.owns.target, ownedDump);
	});
	});
	</script>