| OLD | NEW |
|---|
| 1 <!DOCTYPE html> | 1 <!DOCTYPE html> |
| 2 <!-- | 2 <!-- |
| 3 Copyright 2016 The Chromium Authors. All rights reserved. | 3 Copyright 2016 The Chromium Authors. All rights reserved. |
| 4 Use of this source code is governed by a BSD-style license that can be | 4 Use of this source code is governed by a BSD-style license that can be |
| 5 found in the LICENSE file. | 5 found in the LICENSE file. |
| 6 --> | 6 --> |
| 7 | 7 |
| 8 <link rel="import" href="/tracing/base/iteration_helpers.html"> |
| 9 <link rel="import" href="/tracing/base/range.html"> |
| 8 <link rel="import" href="/tracing/core/test_utils.html"> | 10 <link rel="import" href="/tracing/core/test_utils.html"> |
| 9 <link rel="import" href="/tracing/metrics/system_health/memory_metric.html"> | 11 <link rel="import" href="/tracing/metrics/system_health/memory_metric.html"> |
| 10 <link rel="import" href="/tracing/model/container_memory_dump.html"> | 12 <link rel="import" href="/tracing/model/container_memory_dump.html"> |
| 11 <link rel="import" href="/tracing/model/memory_dump_test_utils.html"> | 13 <link rel="import" href="/tracing/model/memory_dump_test_utils.html"> |
| 12 <link rel="import" href="/tracing/model/vm_region.html"> | 14 <link rel="import" href="/tracing/model/vm_region.html"> |
| 13 <link rel="import" href="/tracing/value/value.html"> | 15 <link rel="import" href="/tracing/value/value.html"> |
| 14 <link rel="import" href="/tracing/value/value_set.html"> | 16 <link rel="import" href="/tracing/value/value_set.html"> |
| 15 | 17 |
| 16 <script> | 18 <script> |
| 17 'use strict'; | 19 'use strict'; |
| 18 | 20 |
| 19 tr.b.unittest.testSuite(function() { | 21 tr.b.unittest.testSuite(function() { |
| 20 var VMRegion = tr.model.VMRegion; | 22 var VMRegion = tr.model.VMRegion; |
| 21 var VMRegionClassificationNode = tr.model.VMRegionClassificationNode; | 23 var VMRegionClassificationNode = tr.model.VMRegionClassificationNode; |
| 22 var LIGHT = tr.model.ContainerMemoryDump.LevelOfDetail.LIGHT; | 24 var LIGHT = tr.model.ContainerMemoryDump.LevelOfDetail.LIGHT; |
| 23 var DETAILED = tr.model.ContainerMemoryDump.LevelOfDetail.DETAILED; | 25 var DETAILED = tr.model.ContainerMemoryDump.LevelOfDetail.DETAILED; |
| 24 var SIZE_DELTA = tr.model.MemoryDumpTestUtils.SIZE_DELTA; | 26 var SIZE_DELTA = tr.model.MemoryDumpTestUtils.SIZE_DELTA; |
| 25 var addProcessMemoryDump = tr.model.MemoryDumpTestUtils.addProcessMemoryDump; | 27 var addProcessMemoryDump = tr.model.MemoryDumpTestUtils.addProcessMemoryDump; |
| 26 var addGlobalMemoryDump = tr.model.MemoryDumpTestUtils.addGlobalMemoryDump; | 28 var addGlobalMemoryDump = tr.model.MemoryDumpTestUtils.addGlobalMemoryDump; |
| 27 var newAllocatorDump = tr.model.MemoryDumpTestUtils.newAllocatorDump; | 29 var newAllocatorDump = tr.model.MemoryDumpTestUtils.newAllocatorDump; |
| 28 var addChildDump = tr.model.MemoryDumpTestUtils.addChildDump; | 30 var addChildDump = tr.model.MemoryDumpTestUtils.addChildDump; |
| 29 var addOwnershipLink = tr.model.MemoryDumpTestUtils.addOwnershipLink; | 31 var addOwnershipLink = tr.model.MemoryDumpTestUtils.addOwnershipLink; |
| 30 var unitlessNumber_smallerIsBetter = | 32 var unitlessNumber_smallerIsBetter = |
| 31 tr.v.Unit.byName.unitlessNumber_smallerIsBetter; | 33 tr.v.Unit.byName.unitlessNumber_smallerIsBetter; |
| 32 var sizeInBytes_smallerIsBetter = | 34 var sizeInBytes_smallerIsBetter = |
| 33 tr.v.Unit.byName.sizeInBytes_smallerIsBetter; | 35 tr.v.Unit.byName.sizeInBytes_smallerIsBetter; |
| 34 | 36 |
| 35 function memoryMetricTest(name, modelCallback, expectedNumerics) { | 37 function memoryMetricTest( |
| 38 name, modelCallback, opt_options, expectedNumerics) { |
| 36 test(name, function() { | 39 test(name, function() { |
| 37 // Create a model and a fake value list. | 40 // Create a model and a fake value list. |
| 38 var model = tr.c.TestUtils.newModel(modelCallback); | 41 var model = tr.c.TestUtils.newModel(modelCallback); |
| 39 var valueNameToValues = {}; | 42 var valueNameToValues = {}; |
| 40 var fakeValueList = { | 43 var fakeValueList = { |
| 41 addValue: function(value) { | 44 addValue: function(value) { |
| 42 var values = valueNameToValues[value.name]; | 45 var values = valueNameToValues[value.name]; |
| 43 if (values === undefined) | 46 if (values === undefined) |
| 44 valueNameToValues[value.name] = values = []; | 47 valueNameToValues[value.name] = values = []; |
| 45 values.push(value); | 48 values.push(value); |
| 46 } | 49 } |
| 47 }; | 50 }; |
| 48 | 51 |
| 49 // Run the memory metric on the model. | 52 // Run the memory metric on the model. |
| 50 tr.metrics.sh.memoryMetric(fakeValueList, model); | 53 tr.metrics.sh.memoryMetric(fakeValueList, model, opt_options); |
| 51 | 54 |
| 52 // Check that the names of the added values match expectations. | 55 // Check that the names of the added values match expectations. |
| 53 var actualValueNames = Object.keys(valueNameToValues).sort(); | 56 var actualValueNames = Object.keys(valueNameToValues).sort(); |
| 54 var expectedValueNames = Object.keys(expectedNumerics).sort(); | 57 var expectedValueNames = Object.keys(expectedNumerics).sort(); |
| 55 assert.deepEqual(actualValueNames, expectedValueNames, { | 58 assert.deepEqual(actualValueNames, expectedValueNames, { |
| 56 // Build the long error message lazily. | 59 // Build the long error message lazily. |
| 57 toString: function() { | 60 toString: function() { |
| 58 var errorMessageParts = []; | 61 var errorMessageParts = []; |
| 59 function addValueNamesToError(type, valueNames, otherValueNames) { | 62 function addValueNamesToError(type, valueNames, otherValueNames) { |
| 60 var otherValueNamesSet = new Set(otherValueNames); | 63 var otherValueNamesSet = new Set(otherValueNames); |
| (...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 151 } | 154 } |
| 152 | 155 |
| 153 function createWebViewProcess(model) { | 156 function createWebViewProcess(model) { |
| 154 var process = createChromeBrowserProcess(model); | 157 var process = createChromeBrowserProcess(model); |
| 155 process.getOrCreateThread(2).name = 'Chrome_InProcRendererThread'; | 158 process.getOrCreateThread(2).name = 'Chrome_InProcRendererThread'; |
| 156 return process; | 159 return process; |
| 157 } | 160 } |
| 158 | 161 |
| 159 memoryMetricTest('noDumps_noBrowser', function(model) { | 162 memoryMetricTest('noDumps_noBrowser', function(model) { |
| 160 createProcessWithName(model, 'Non-browser'); | 163 createProcessWithName(model, 'Non-browser'); |
| 161 }, { | 164 }, undefined /* opt_options */, { |
| 162 /* no values */ | 165 /* no values */ |
| 163 }); | 166 }); |
| 164 | 167 |
| 165 memoryMetricTest('noDumps_chrome', function(model) { | 168 memoryMetricTest('noDumps_chrome', function(model) { |
| 166 createChromeBrowserProcess(model); | 169 createChromeBrowserProcess(model); |
| 167 }, { | 170 }, undefined /* opt_options */, { |
| 168 'memory:chrome:all_processes:dump_count:detailed': { | 171 'memory:chrome:all_processes:dump_count:detailed': { |
| 169 value: 0, | 172 value: 0, |
| 170 unit: unitlessNumber_smallerIsBetter, | 173 unit: unitlessNumber_smallerIsBetter, |
| 171 description: 'total number of detailed memory dumps added by Chrome to ' + | 174 description: 'total number of detailed memory dumps added by Chrome to ' + |
| 172 'the trace' | 175 'the trace' |
| 173 }, | 176 }, |
| 174 'memory:chrome:all_processes:dump_count:light': { | 177 'memory:chrome:all_processes:dump_count:light': { |
| 175 value: 0, | 178 value: 0, |
| 176 unit: unitlessNumber_smallerIsBetter, | 179 unit: unitlessNumber_smallerIsBetter, |
| 177 description: 'total number of light memory dumps added by Chrome to ' + | 180 description: 'total number of light memory dumps added by Chrome to ' + |
| 178 'the trace' | 181 'the trace' |
| 179 }, | 182 }, |
| 180 'memory:chrome:all_processes:dump_count': { | 183 'memory:chrome:all_processes:dump_count': { |
| 181 value: 0, | 184 value: 0, |
| 182 unit: unitlessNumber_smallerIsBetter, | 185 unit: unitlessNumber_smallerIsBetter, |
| 183 description: 'total number of all memory dumps added by Chrome to the ' + | 186 description: 'total number of all memory dumps added by Chrome to the ' + |
| 184 'trace' | 187 'trace' |
| 185 } | 188 } |
| 186 }); | 189 }); |
| 187 | 190 |
| 188 memoryMetricTest('noDumps_multipleBrowsers', function(model) { | 191 memoryMetricTest('noDumps_multipleBrowsers', function(model) { |
| 189 createChromeBrowserProcess(model); | 192 createChromeBrowserProcess(model); |
| 190 createWebViewProcess(model); | 193 createWebViewProcess(model); |
| 191 createProcessWithName(model, 'Non-browser'); | 194 createProcessWithName(model, 'Non-browser'); |
| 192 createChromeBrowserProcess(model); | 195 createChromeBrowserProcess(model); |
| 193 }, { | 196 }, undefined /* opt_options */, { |
| 194 'memory:chrome2:all_processes:dump_count:detailed': { | 197 'memory:chrome2:all_processes:dump_count:detailed': { |
| 195 value: 0, | 198 value: 0, |
| 196 unit: unitlessNumber_smallerIsBetter, | 199 unit: unitlessNumber_smallerIsBetter, |
| 197 description: 'total number of detailed memory dumps added by Chrome(2) ' + | 200 description: 'total number of detailed memory dumps added by Chrome(2) ' + |
| 198 'to the trace' | 201 'to the trace' |
| 199 }, | 202 }, |
| 200 'memory:chrome2:all_processes:dump_count:light': { | 203 'memory:chrome2:all_processes:dump_count:light': { |
| 201 value: 0, | 204 value: 0, |
| 202 unit: unitlessNumber_smallerIsBetter, | 205 unit: unitlessNumber_smallerIsBetter, |
| 203 description: 'total number of light memory dumps added by Chrome(2) to ' + | 206 description: 'total number of light memory dumps added by Chrome(2) to ' + |
| (...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 241 }, | 244 }, |
| 242 'memory:webview:all_processes:dump_count': { | 245 'memory:webview:all_processes:dump_count': { |
| 243 value: 0, | 246 value: 0, |
| 244 unit: unitlessNumber_smallerIsBetter, | 247 unit: unitlessNumber_smallerIsBetter, |
| 245 description: 'total number of all memory dumps added by WebView to the ' + | 248 description: 'total number of all memory dumps added by WebView to the ' + |
| 246 'trace' | 249 'trace' |
| 247 } | 250 } |
| 248 }); | 251 }); |
| 249 | 252 |
| 250 memoryMetricTest('dumpCountsOnly_unknownBrowser', function(model) { | 253 memoryMetricTest('dumpCountsOnly_unknownBrowser', function(model) { |
| 251 addGlobalMemoryDump(model, 45, DETAILED); | 254 addGlobalMemoryDump(model, {ts: 45, levelOfDetail: DETAILED}); |
| 252 addGlobalMemoryDump(model, 68, LIGHT); | 255 addGlobalMemoryDump(model, {ts: 68, levelOfDetail: LIGHT}); |
| 253 addGlobalMemoryDump(model, 89, DETAILED); | 256 addGlobalMemoryDump(model, {ts: 89, levelOfDetail: DETAILED}); |
| 254 }, { | 257 }, undefined /* opt_options */, { |
| 255 'memory:unknown_browser:all_processes:dump_count:detailed': { | 258 'memory:unknown_browser:all_processes:dump_count:detailed': { |
| 256 value: 2, | 259 value: 2, |
| 257 unit: unitlessNumber_smallerIsBetter, | 260 unit: unitlessNumber_smallerIsBetter, |
| 258 description: 'total number of detailed memory dumps added by an ' + | 261 description: 'total number of detailed memory dumps added by an ' + |
| 259 'unknown browser to the trace' | 262 'unknown browser to the trace' |
| 260 }, | 263 }, |
| 261 'memory:unknown_browser:all_processes:dump_count:light': { | 264 'memory:unknown_browser:all_processes:dump_count:light': { |
| 262 value: 1, | 265 value: 1, |
| 263 unit: unitlessNumber_smallerIsBetter, | 266 unit: unitlessNumber_smallerIsBetter, |
| 264 description: 'total number of light memory dumps added by an unknown ' + | 267 description: 'total number of light memory dumps added by an unknown ' + |
| 265 'browser to the trace' | 268 'browser to the trace' |
| 266 }, | 269 }, |
| 267 'memory:unknown_browser:all_processes:dump_count': { | 270 'memory:unknown_browser:all_processes:dump_count': { |
| 268 value: 3, | 271 value: 3, |
| 269 unit: unitlessNumber_smallerIsBetter, | 272 unit: unitlessNumber_smallerIsBetter, |
| 270 description: 'total number of all memory dumps added by an unknown ' + | 273 description: 'total number of all memory dumps added by an unknown ' + |
| 271 'browser to the trace' | 274 'browser to the trace' |
| 272 } | 275 } |
| 273 }); | 276 }); |
| 274 | 277 |
| 275 memoryMetricTest('dumpCountsOnly_webview', function(model) { | 278 memoryMetricTest('dumpCountsOnly_webview', function(model) { |
| 276 var p = createWebViewProcess(model); | 279 var p = createWebViewProcess(model); |
| 277 addProcessMemoryDump(addGlobalMemoryDump(model, 45, LIGHT), p, 45); | 280 addProcessMemoryDump(addGlobalMemoryDump( |
| 278 addProcessMemoryDump(addGlobalMemoryDump(model, 68, LIGHT), p, 68); | 281 model, {ts: 45, levelOfDetail: LIGHT}), p, {ts: 45}); |
| 279 }, { | 282 addProcessMemoryDump(addGlobalMemoryDump( |
| 283 model, {ts: 68, levelOfDetail: LIGHT}), p, {ts: 68}); |
| 284 }, undefined /* opt_options */, { |
| 280 'memory:webview:all_processes:dump_count:detailed': { | 285 'memory:webview:all_processes:dump_count:detailed': { |
| 281 value: 0, | 286 value: 0, |
| 282 unit: unitlessNumber_smallerIsBetter, | 287 unit: unitlessNumber_smallerIsBetter, |
| 283 description: 'total number of detailed memory dumps added by WebView ' + | 288 description: 'total number of detailed memory dumps added by WebView ' + |
| 284 'to the trace' | 289 'to the trace' |
| 285 }, | 290 }, |
| 286 'memory:webview:all_processes:dump_count:light': { | 291 'memory:webview:all_processes:dump_count:light': { |
| 287 value: 2, | 292 value: 2, |
| 288 unit: unitlessNumber_smallerIsBetter, | 293 unit: unitlessNumber_smallerIsBetter, |
| 289 description: 'total number of light memory dumps added by WebView to ' + | 294 description: 'total number of light memory dumps added by WebView to ' + |
| (...skipping 18 matching lines...) Expand all Loading... |
| 308 }); | 313 }); |
| 309 | 314 |
| 310 memoryMetricTest('generalValues_chrome', function(model) { | 315 memoryMetricTest('generalValues_chrome', function(model) { |
| 311 var pBrowser = createChromeBrowserProcess(model); | 316 var pBrowser = createChromeBrowserProcess(model); |
| 312 var pRendererA = createProcessWithName(model, 'Renderer'); | 317 var pRendererA = createProcessWithName(model, 'Renderer'); |
| 313 var pRendererB = createProcessWithName(model, 'Renderer'); | 318 var pRendererB = createProcessWithName(model, 'Renderer'); |
| 314 var pPpapi = createProcessWithName(model, 'PPAPI Process'); | 319 var pPpapi = createProcessWithName(model, 'PPAPI Process'); |
| 315 var pUnknown = createProcessWithName(model, undefined); | 320 var pUnknown = createProcessWithName(model, undefined); |
| 316 | 321 |
| 317 // Timestamp 1. | 322 // Timestamp 1. |
| 318 var gmd1 = addGlobalMemoryDump(model, 20); | 323 var gmd1 = addGlobalMemoryDump(model, {ts: 20}); |
| 319 var pmdBrowser1 = addProcessMemoryDump(gmd1, pBrowser, 19); | 324 var pmdBrowser1 = addProcessMemoryDump(gmd1, pBrowser, {ts: 19}); |
| 320 pmdBrowser1.memoryAllocatorDumps = [ | 325 pmdBrowser1.memoryAllocatorDumps = [ |
| 321 newAllocatorDump(pmdBrowser1, 'malloc', { | 326 newAllocatorDump(pmdBrowser1, 'malloc', {numerics: { |
| 322 'size': 8, | 327 size: 8, |
| 323 'allocated_objects_size': 4 | 328 allocated_objects_size: 4 |
| 324 }) | 329 }}) |
| 325 ]; | 330 ]; |
| 326 var pmdRendererA1 = addProcessMemoryDump(gmd1, pRendererA, 20); | 331 var pmdRendererA1 = addProcessMemoryDump(gmd1, pRendererA, {ts: 20}); |
| 327 pmdRendererA1.memoryAllocatorDumps = (function() { | 332 pmdRendererA1.memoryAllocatorDumps = (function() { |
| 328 var mallocDump = | 333 var mallocDump = |
| 329 newAllocatorDump(pmdRendererA1, 'malloc', { 'size': 16 }); | 334 newAllocatorDump(pmdRendererA1, 'malloc', {numerics: {size: 16}}); |
| 330 var partitionAllocDump = | 335 var partitionAllocDump = |
| 331 newAllocatorDump(pmdRendererA1, 'partition_alloc'); | 336 newAllocatorDump(pmdRendererA1, 'partition_alloc'); |
| 332 addOwnershipLink( | 337 addOwnershipLink( |
| 333 addChildDump(partitionAllocDump, 'allocated_objects', { 'size': 32 }), | 338 addChildDump(partitionAllocDump, 'allocated_objects', |
| 334 addChildDump(partitionAllocDump, 'partitions', { 'size': 24 })); | 339 {numerics: {size: 32}}), |
| 340 addChildDump(partitionAllocDump, 'partitions', |
| 341 {numerics: {size: 24}})); |
| 335 return [mallocDump, partitionAllocDump]; | 342 return [mallocDump, partitionAllocDump]; |
| 336 })(); | 343 })(); |
| 337 var pmdGpu1 = addProcessMemoryDump(gmd1, pPpapi, 21); | 344 var pmdGpu1 = addProcessMemoryDump(gmd1, pPpapi, {ts: 21}); |
| 338 pmdGpu1.memoryAllocatorDumps = [ | 345 pmdGpu1.memoryAllocatorDumps = [ |
| 339 newAllocatorDump(pmdGpu1, 'gpu', { | 346 newAllocatorDump(pmdGpu1, 'gpu', {numerics: { |
| 340 'size': 30, | 347 size: 30, |
| 341 'allocated_objects_size': 25 | 348 allocated_objects_size: 25 |
| 342 }) | 349 }}) |
| 343 ]; | 350 ]; |
| 344 | 351 |
| 345 // Timestamp 2. | 352 // Timestamp 2. |
| 346 var gmd2 = addGlobalMemoryDump(model, 40); | 353 var gmd2 = addGlobalMemoryDump(model, {ts: 40}); |
| 347 var pmdBrowser2 = addProcessMemoryDump(gmd2, pBrowser, 41); | 354 var pmdBrowser2 = addProcessMemoryDump(gmd2, pBrowser, {ts: 41}); |
| 348 pmdBrowser2.memoryAllocatorDumps = (function() { | 355 pmdBrowser2.memoryAllocatorDumps = (function() { |
| 349 var mallocDump = newAllocatorDump(pmdBrowser2, 'malloc', { 'size': 120 }); | 356 var mallocDump = newAllocatorDump(pmdBrowser2, 'malloc', |
| 357 {numerics: {size: 120}}); |
| 350 var tracingDump = | 358 var tracingDump = |
| 351 newAllocatorDump(pmdBrowser2, 'tracing', { 'size': 40 }); | 359 newAllocatorDump(pmdBrowser2, 'tracing', {numerics: {size: 40}}); |
| 352 return [mallocDump, tracingDump]; | 360 return [mallocDump, tracingDump]; |
| 353 })(); | 361 })(); |
| 354 var pmdRendererA2 = addProcessMemoryDump(gmd2, pRendererA, 39); | 362 var pmdRendererA2 = addProcessMemoryDump(gmd2, pRendererA, {ts: 39}); |
| 355 pmdRendererA2.memoryAllocatorDumps = (function() { | 363 pmdRendererA2.memoryAllocatorDumps = (function() { |
| 356 var partitionAllocDump = | 364 var partitionAllocDump = |
| 357 newAllocatorDump(pmdRendererA2, 'partition_alloc'); | 365 newAllocatorDump(pmdRendererA2, 'partition_alloc'); |
| 358 addOwnershipLink( | 366 addOwnershipLink( |
| 359 addChildDump(partitionAllocDump, 'allocated_objects', | 367 addChildDump(partitionAllocDump, 'allocated_objects', |
| 360 { 'size': 320 }), | 368 {numerics: {size: 320}}), |
| 361 addChildDump(partitionAllocDump, 'partitions', { 'size': 240 })); | 369 addChildDump(partitionAllocDump, 'partitions', |
| 362 var v8Dump = newAllocatorDump(pmdRendererA2, 'v8', { 'size': 650 }); | 370 {numerics: {size: 240}})); |
| 371 var v8Dump = newAllocatorDump(pmdRendererA2, 'v8', |
| 372 {numerics: {size: 650}}); |
| 373 var isolateDumpA = addChildDump(v8Dump, 'isolate_A'); |
| 374 addChildDump(isolateDumpA, 'malloc', {numerics: {size: 1 }}); |
| 375 var isolateDumpB = addChildDump(v8Dump, 'isolate_B'); |
| 376 addChildDump(isolateDumpB, 'malloc', {numerics: {size: 10 }}); |
| 363 return [partitionAllocDump, v8Dump]; | 377 return [partitionAllocDump, v8Dump]; |
| 364 })(); | 378 })(); |
| 365 var pmdRendererB2 = addProcessMemoryDump(gmd2, pRendererB, 40); | 379 var pmdRendererB2 = addProcessMemoryDump(gmd2, pRendererB, {ts: 40}); |
| 366 pmdRendererB2.memoryAllocatorDumps = [ | 380 pmdRendererB2.memoryAllocatorDumps = [ |
| 367 newAllocatorDump(pmdRendererB2, 'v8', { | 381 newAllocatorDump(pmdRendererB2, 'v8', {numerics: { |
| 368 'size': 970, | 382 size: 970, |
| 369 'allocated_objects_size': 860 | 383 allocated_objects_size: 860 |
| 370 }), | 384 }}), |
| 371 newAllocatorDump(pmdRendererB2, 'malloc', { | 385 newAllocatorDump(pmdRendererB2, 'malloc', |
| 372 'allocated_objects_size': 750 | 386 {numerics: {allocated_objects_size: 750}}) |
| 373 }) | |
| 374 ]; | 387 ]; |
| 375 var pmdUnknown = addProcessMemoryDump(gmd2, pUnknown, 42); | 388 var pmdUnknown = addProcessMemoryDump(gmd2, pUnknown, {ts: 42}); |
| 376 pmdUnknown.memoryAllocatorDumps = [ | 389 pmdUnknown.memoryAllocatorDumps = [ |
| 377 newAllocatorDump(pmdRendererB2, 'v8', { | 390 newAllocatorDump(pmdRendererB2, 'v8', {numerics: {size: 111}}) |
| 378 'size': 111 | |
| 379 }) | |
| 380 ]; | 391 ]; |
| 381 | 392 |
| 382 // Timestamp 3. | 393 // Timestamp 3. |
| 383 var gmd3 = addGlobalMemoryDump(model, 60); | 394 var gmd3 = addGlobalMemoryDump(model, {ts: 60}); |
| 384 var pmdBrowser3 = addProcessMemoryDump(gmd3, pBrowser, 60); | 395 var pmdBrowser3 = addProcessMemoryDump(gmd3, pBrowser, {ts: 60}); |
| 385 pmdBrowser3.memoryAllocatorDumps = [ | 396 pmdBrowser3.memoryAllocatorDumps = [ |
| 386 newAllocatorDump(pmdBrowser3, 'malloc', { | 397 newAllocatorDump(pmdBrowser3, 'malloc', {numerics: { |
| 387 'size': 8000, | 398 size: 8000, |
| 388 'allocated_objects_size': 4000 | 399 allocated_objects_size: 4000 |
| 389 }) | 400 }}) |
| 390 ]; | 401 ]; |
| 391 var pmdRendererB3 = addProcessMemoryDump(gmd3, pRendererB, 61); | 402 var pmdRendererB3 = addProcessMemoryDump(gmd3, pRendererB, {ts: 61}); |
| 392 // Intentionally pmdRendererB3.memoryAllocatorDumps undefined. | 403 // Intentionally pmdRendererB3.memoryAllocatorDumps undefined. |
| 393 var pmdGpu3 = addProcessMemoryDump(gmd3, pPpapi, 59); | 404 var pmdGpu3 = addProcessMemoryDump(gmd3, pPpapi, {ts: 59}); |
| 394 pmdGpu3.memoryAllocatorDumps = [ | 405 pmdGpu3.memoryAllocatorDumps = [ |
| 395 newAllocatorDump(pmdGpu3, 'gpu', { 'size': 300 }) | 406 newAllocatorDump(pmdGpu3, 'gpu', {numerics: {size: 300}}) |
| 396 ]; | 407 ]; |
| 397 | 408 |
| 398 // Timestamp 4. | 409 // Timestamp 4. |
| 399 var gmd4 = addGlobalMemoryDump(model, 80); | 410 var gmd4 = addGlobalMemoryDump(model, {ts: 80}); |
| 400 var pmdBrowser4 = addProcessMemoryDump(gmd4, pBrowser, 81); | 411 var pmdBrowser4 = addProcessMemoryDump(gmd4, pBrowser, {ts: 81}); |
| 401 pmdBrowser4.memoryAllocatorDumps = [ | 412 pmdBrowser4.memoryAllocatorDumps = [ |
| 402 newAllocatorDump(pmdBrowser4, 'malloc', { 'size': 80000 }) | 413 newAllocatorDump(pmdBrowser4, 'malloc', {numerics: {size: 80000}}) |
| 403 ]; | 414 ]; |
| 404 var pmdRendererB4 = addProcessMemoryDump(gmd4, pRendererB, 79); | 415 var pmdRendererB4 = addProcessMemoryDump(gmd4, pRendererB, {ts: 79}); |
| 405 pmdRendererB4.memoryAllocatorDumps = (function() { | 416 pmdRendererB4.memoryAllocatorDumps = (function() { |
| 406 var v8Dump = newAllocatorDump(pmdRendererB4, 'v8', { 'size': 9e5 }); | 417 var v8Dump = newAllocatorDump(pmdRendererB4, 'v8', |
| 418 {numerics: {size: 9e5}}); |
| 407 var partitionAllocDump = newAllocatorDump(pmdRendererB4, | 419 var partitionAllocDump = newAllocatorDump(pmdRendererB4, |
| 408 'partition_alloc', { 'size': 5e5 }); | 420 'partition_alloc', {numerics: {size: 5e5}}); |
| 409 addOwnershipLink(partitionAllocDump, v8Dump); | 421 addOwnershipLink(partitionAllocDump, v8Dump); |
| 410 return [v8Dump, partitionAllocDump]; | 422 return [v8Dump, partitionAllocDump]; |
| 411 })(); | 423 })(); |
| 412 var pmdGpu4 = addProcessMemoryDump(gmd4, pPpapi, 80); | 424 var pmdGpu4 = addProcessMemoryDump(gmd4, pPpapi, {ts: 80}); |
| 413 pmdGpu4.memoryAllocatorDumps = [ | 425 pmdGpu4.memoryAllocatorDumps = [ |
| 414 newAllocatorDump(pmdGpu4, 'gpu', { 'memtrack_pss': 666 /* ignored */ }) | 426 newAllocatorDump(pmdGpu4, 'gpu', |
| 427 {numerics: {memtrack_pss: 666 /* ignored */}}) |
| 415 ]; | 428 ]; |
| 416 }, { | 429 }, undefined /* opt_options */, { |
| 417 'memory:chrome:all_processes:dump_count:detailed': { | 430 'memory:chrome:all_processes:dump_count:detailed': { |
| 418 value: 0, | 431 value: 0, |
| 419 unit: unitlessNumber_smallerIsBetter, | 432 unit: unitlessNumber_smallerIsBetter, |
| 420 description: 'total number of detailed memory dumps added by Chrome to ' + | 433 description: 'total number of detailed memory dumps added by Chrome to ' + |
| 421 'the trace' | 434 'the trace' |
| 422 }, | 435 }, |
| 423 'memory:chrome:all_processes:dump_count:light': { | 436 'memory:chrome:all_processes:dump_count:light': { |
| 424 value: 4, | 437 value: 4, |
| 425 unit: unitlessNumber_smallerIsBetter, | 438 unit: unitlessNumber_smallerIsBetter, |
| 426 description: 'total number of light memory dumps added by Chrome to ' + | 439 description: 'total number of light memory dumps added by Chrome to ' + |
| (...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 479 value: [32, 320, 0, 5e5], | 492 value: [32, 320, 0, 5e5], |
| 480 unit: sizeInBytes_smallerIsBetter, | 493 unit: sizeInBytes_smallerIsBetter, |
| 481 description: 'effective size of partition_alloc in all processes ' + | 494 description: 'effective size of partition_alloc in all processes ' + |
| 482 'in Chrome' | 495 'in Chrome' |
| 483 }, | 496 }, |
| 484 'memory:chrome:all_processes:reported_by_chrome:tracing:effective_size': { | 497 'memory:chrome:all_processes:reported_by_chrome:tracing:effective_size': { |
| 485 value: [0, 40, 0, 0], | 498 value: [0, 40, 0, 0], |
| 486 unit: sizeInBytes_smallerIsBetter, | 499 unit: sizeInBytes_smallerIsBetter, |
| 487 description: 'effective size of tracing in all processes in Chrome' | 500 description: 'effective size of tracing in all processes in Chrome' |
| 488 }, | 501 }, |
| 502 'memory:chrome:all_processes:reported_by_chrome:v8:allocated_by_malloc:effec
tive_size': |
| 503 { |
| 504 value: [0, 1 + 10, 0, 0], |
| 505 unit: sizeInBytes_smallerIsBetter, |
| 506 description: 'effective size of objects allocated by malloc for v8 ' + |
| 507 'in all processes in Chrome' |
| 508 }, |
| 489 'memory:chrome:all_processes:reported_by_chrome:v8:effective_size': { | 509 'memory:chrome:all_processes:reported_by_chrome:v8:effective_size': { |
| 490 value: [0, 650 + 970 + 111, 0, 4e5], | 510 value: [0, 650 + 970 + 111, 0, 4e5], |
| 491 unit: sizeInBytes_smallerIsBetter, | 511 unit: sizeInBytes_smallerIsBetter, |
| 492 description: 'effective size of v8 in all processes in Chrome' | 512 description: 'effective size of v8 in all processes in Chrome' |
| 493 }, | 513 }, |
| 494 'memory:chrome:all_processes:reported_by_chrome:v8:allocated_objects_size': | 514 'memory:chrome:all_processes:reported_by_chrome:v8:allocated_objects_size': |
| 495 { | 515 { |
| 496 value: [0, 860, 0, 0], | 516 value: [0, 860, 0, 0], |
| 497 unit: sizeInBytes_smallerIsBetter, | 517 unit: sizeInBytes_smallerIsBetter, |
| 498 description: 'size of all objects allocated by v8 in all processes ' + | 518 description: 'size of all objects allocated by v8 in all processes ' + |
| (...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 593 description: 'size of all objects allocated by malloc in renderer ' + | 613 description: 'size of all objects allocated by malloc in renderer ' + |
| 594 'processes in Chrome' | 614 'processes in Chrome' |
| 595 }, | 615 }, |
| 596 'memory:chrome:renderer_processes:reported_by_chrome:partition_alloc:effecti
ve_size': | 616 'memory:chrome:renderer_processes:reported_by_chrome:partition_alloc:effecti
ve_size': |
| 597 { | 617 { |
| 598 value: [32, 320, 0, 5e5], | 618 value: [32, 320, 0, 5e5], |
| 599 unit: sizeInBytes_smallerIsBetter, | 619 unit: sizeInBytes_smallerIsBetter, |
| 600 description: 'effective size of partition_alloc in renderer ' + | 620 description: 'effective size of partition_alloc in renderer ' + |
| 601 'processes in Chrome' | 621 'processes in Chrome' |
| 602 }, | 622 }, |
| 623 'memory:chrome:renderer_processes:reported_by_chrome:v8:allocated_by_malloc:
effective_size': |
| 624 { |
| 625 value: [0, 1 + 10, 0, 0], |
| 626 unit: sizeInBytes_smallerIsBetter, |
| 627 description: 'effective size of objects allocated by malloc for v8 ' + |
| 628 'in renderer processes in Chrome' |
| 629 }, |
| 603 'memory:chrome:renderer_processes:reported_by_chrome:v8:effective_size': { | 630 'memory:chrome:renderer_processes:reported_by_chrome:v8:effective_size': { |
| 604 value: [0, 650 + 970, 0, 4e5], | 631 value: [0, 650 + 970, 0, 4e5], |
| 605 unit: sizeInBytes_smallerIsBetter, | 632 unit: sizeInBytes_smallerIsBetter, |
| 606 description: 'effective size of v8 in renderer processes in Chrome' | 633 description: 'effective size of v8 in renderer processes in Chrome' |
| 607 }, | 634 }, |
| 608 'memory:chrome:renderer_processes:reported_by_chrome:v8:allocated_objects_si
ze': | 635 'memory:chrome:renderer_processes:reported_by_chrome:v8:allocated_objects_si
ze': |
| 609 { | 636 { |
| 610 value: [0, 860, 0, 0], | 637 value: [0, 860, 0, 0], |
| 611 unit: sizeInBytes_smallerIsBetter, | 638 unit: sizeInBytes_smallerIsBetter, |
| 612 description: 'size of all objects allocated by v8 in renderer ' + | 639 description: 'size of all objects allocated by v8 in renderer ' + |
| (...skipping 18 matching lines...) Expand all Loading... |
| 631 }); | 658 }); |
| 632 | 659 |
| 633 memoryMetricTest('detailedValues_unknownBrowser', function(model) { | 660 memoryMetricTest('detailedValues_unknownBrowser', function(model) { |
| 634 var pBrowser = createProcessWithName(model, 'Browser'); | 661 var pBrowser = createProcessWithName(model, 'Browser'); |
| 635 var pRendererA = createProcessWithName(model, 'Renderer'); | 662 var pRendererA = createProcessWithName(model, 'Renderer'); |
| 636 var pRendererB = createProcessWithName(model, 'Renderer'); | 663 var pRendererB = createProcessWithName(model, 'Renderer'); |
| 637 var pRendererC = createProcessWithName(model, 'Renderer'); | 664 var pRendererC = createProcessWithName(model, 'Renderer'); |
| 638 var pGpu = createProcessWithName(model, 'GPU Process'); | 665 var pGpu = createProcessWithName(model, 'GPU Process'); |
| 639 | 666 |
| 640 // Timestamp 1. | 667 // Timestamp 1. |
| 641 var gmd1 = addGlobalMemoryDump(model, 10, DETAILED); | 668 var gmd1 = addGlobalMemoryDump(model, {ts: 10, levelOfDetail: DETAILED}); |
| 642 var pmdBrowser1 = addProcessMemoryDump(gmd1, pBrowser, 9); | 669 var pmdBrowser1 = addProcessMemoryDump(gmd1, pBrowser, {ts: 9}); |
| 643 pmdBrowser1.vmRegions = VMRegionClassificationNode.fromRegions([ | 670 pmdBrowser1.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 644 new VMRegion(0xABCD, 128, 0, '/dev/ashmem/dalvik-non moving space', | 671 new VMRegion(0xABCD, 128, 0, '/dev/ashmem/dalvik-non moving space', |
| 645 { 'privateDirtyResident': 8 }) | 672 {privateDirtyResident: 8}) |
| 646 ]); | 673 ]); |
| 647 var pmdRendererA1 = addProcessMemoryDump(gmd1, pRendererA, 10); | 674 var pmdRendererA1 = addProcessMemoryDump(gmd1, pRendererA, {ts: 10}); |
| 648 pmdRendererA1.vmRegions = VMRegionClassificationNode.fromRegions([ | 675 pmdRendererA1.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 649 new VMRegion(0xEF01, 256, 0, '[anon:libc_malloc]', | 676 new VMRegion(0xEF01, 256, 0, '[anon:libc_malloc]', |
| 650 { 'privateDirtyResident': 17 }) | 677 {privateDirtyResident: 17}) |
| 651 ]); | 678 ]); |
| 652 var pmdRendererB1 = addProcessMemoryDump(gmd1, pRendererB, 11); | 679 var pmdRendererB1 = addProcessMemoryDump(gmd1, pRendererB, {ts: 11}); |
| 653 pmdRendererB1.vmRegions = VMRegionClassificationNode.fromRegions([ | 680 pmdRendererB1.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 654 new VMRegion(0x2345, 512, 0, '[heap]', | 681 new VMRegion(0x2345, 512, 0, '[heap]', |
| 655 { 'proportionalResident': 67, 'privateDirtyResident': 34 }) | 682 {proportionalResident: 67, privateDirtyResident: 34}) |
| 656 ]); | 683 ]); |
| 657 pmdRendererB1.memoryAllocatorDumps = [ | 684 pmdRendererB1.memoryAllocatorDumps = [ |
| 658 newAllocatorDump(pmdRendererA4, 'v8', { 'code_and_metadata_size': 16 }) | 685 newAllocatorDump(pmdRendererA4, 'v8', |
| 686 {numerics: {code_and_metadata_size: 16}}) |
| 659 ]; | 687 ]; |
| 660 var pmdGpu1 = addProcessMemoryDump(gmd1, pGpu, 10); | 688 var pmdGpu1 = addProcessMemoryDump(gmd1, pGpu, {ts: 10}); |
| 661 pmdGpu1.memoryAllocatorDumps = (function() { | 689 pmdGpu1.memoryAllocatorDumps = (function() { |
| 662 var gpuDump = newAllocatorDump(pmdGpu1, 'gpu'); | 690 var gpuDump = newAllocatorDump(pmdGpu1, 'gpu'); |
| 663 var memtrackDump = addChildDump(gpuDump, 'android_memtrack'); | 691 var memtrackDump = addChildDump(gpuDump, 'android_memtrack'); |
| 664 addChildDump(memtrackDump, 'gl', { 'memtrack_pss': 100 }); | 692 addChildDump(memtrackDump, 'gl', {numerics: {memtrack_pss: 100}}); |
| 665 addChildDump(memtrackDump, 'graphics', { 'memtrack_pss': 200 }); | 693 addChildDump(memtrackDump, 'graphics', {numerics: {memtrack_pss: 200}}); |
| 666 return [gpuDump]; | 694 return [gpuDump]; |
| 667 })(); | 695 })(); |
| 668 | 696 |
| 669 // Timestamp 2 (light global memory dump, so it should be skipped for | 697 // Timestamp 2 (light global memory dump, so it should be skipped for |
| 670 // mmaps_* values). | 698 // mmaps_* values). |
| 671 var gmd2 = addGlobalMemoryDump(model, 20, LIGHT); | 699 var gmd2 = addGlobalMemoryDump(model, {ts: 20, levelOfDetail: LIGHT}); |
| 672 var pmdBrowser2 = addProcessMemoryDump(gmd2, pBrowser, 18); | 700 var pmdBrowser2 = addProcessMemoryDump(gmd2, pBrowser, {ts: 18}); |
| 673 pmdBrowser2.vmRegions = VMRegionClassificationNode.fromRegions([ | 701 pmdBrowser2.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 674 new VMRegion(0x999, 999, 999, '/dev/ashmem/dalvik-main space', | 702 new VMRegion(0x999, 999, 999, '/dev/ashmem/dalvik-main space', |
| 675 { 'proportionalResident': 999 }) | 703 {proportionalResident: 999}) |
| 676 ]); | 704 ]); |
| 677 var pmdRendererA2 = addProcessMemoryDump(gmd2, pRendererA, 19); | 705 var pmdRendererA2 = addProcessMemoryDump(gmd2, pRendererA, {ts: 19}); |
| 678 pmdRendererA2.memoryAllocatorDumps = [ | 706 pmdRendererA2.memoryAllocatorDumps = [ |
| 679 newAllocatorDump(pmdRendererA4, 'v8', { | 707 newAllocatorDump(pmdRendererA4, 'v8', |
| 680 'bytecode_and_metadata_size': 678 | 708 {numerics: {bytecode_and_metadata_size: 678}}) |
| 681 }) | |
| 682 ]; | 709 ]; |
| 683 var pmdRendererB2 = addProcessMemoryDump(gmd2, pRendererB, 21); | 710 var pmdRendererB2 = addProcessMemoryDump(gmd2, pRendererB, {ts: 21}); |
| 684 var pmdRendererC2 = addProcessMemoryDump(gmd2, pRendererC, 22); | 711 var pmdRendererC2 = addProcessMemoryDump(gmd2, pRendererC, {ts: 22}); |
| 685 var pmdGpu2 = addProcessMemoryDump(gmd2, pGpu, 20); | 712 var pmdGpu2 = addProcessMemoryDump(gmd2, pGpu, {ts: 20}); |
| 686 pmdGpu2.memoryAllocatorDumps = (function() { | 713 pmdGpu2.memoryAllocatorDumps = (function() { |
| 687 var gpuDump = newAllocatorDump(pmdGpu2, 'gpu'); | 714 var gpuDump = newAllocatorDump(pmdGpu2, 'gpu'); |
| 688 var memtrackDump = addChildDump(gpuDump, 'android_memtrack'); | 715 var memtrackDump = addChildDump(gpuDump, 'android_memtrack'); |
| 689 addChildDump(memtrackDump, 'gl', { 'memtrack_pss': 12345 }); | 716 addChildDump(memtrackDump, 'gl', {numerics: {memtrack_pss: 12345}}); |
| 690 return [gpuDump]; | 717 return [gpuDump]; |
| 691 })(); | 718 })(); |
| 692 | 719 |
| 693 // Timestamp 3. | 720 // Timestamp 3. |
| 694 var gmd3 = addGlobalMemoryDump(model, 30, DETAILED); | 721 var gmd3 = addGlobalMemoryDump(model, {ts: 30, levelOfDetail: DETAILED}); |
| 695 var pmdBrowser3 = addProcessMemoryDump(gmd3, pBrowser, 30); | 722 var pmdBrowser3 = addProcessMemoryDump(gmd3, pBrowser, {ts: 30}); |
| 696 pmdBrowser3.vmRegions = VMRegionClassificationNode.fromRegions([ | 723 pmdBrowser3.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 697 new VMRegion(0xABCD, 1024, 0, '/dev/ashmem/dalvik-non moving space', | 724 new VMRegion(0xABCD, 1024, 0, '/dev/ashmem/dalvik-non moving space', |
| 698 { 'proportionalResident': 3, 'privateDirtyResident': 80 }) | 725 {proportionalResident: 3, privateDirtyResident: 80}) |
| 699 ]); | 726 ]); |
| 700 var pmdRendererA3 = addProcessMemoryDump(gmd3, pRendererA, 29); | 727 var pmdRendererA3 = addProcessMemoryDump(gmd3, pRendererA, {ts: 29}); |
| 701 // Intentionally pmdRendererA3.vmRegions undefined. | 728 // Intentionally pmdRendererA3.vmRegions undefined. |
| 702 var pmdRendererC3 = addProcessMemoryDump(gmd3, pRendererC, 31); | 729 var pmdRendererC3 = addProcessMemoryDump(gmd3, pRendererC, {ts: 31}); |
| 703 pmdRendererC3.vmRegions = VMRegionClassificationNode.fromRegions([ | 730 pmdRendererC3.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 704 new VMRegion(0x2345, 2048, 0, '/no/matching/category', | 731 new VMRegion(0x2345, 2048, 0, '/no/matching/category', |
| 705 { 'proportionalResident': 200 }), | 732 {proportionalResident: 200}), |
| 706 new VMRegion(0x2345, 2048, 0, '/dev/ashmem', | 733 new VMRegion(0x2345, 2048, 0, '/dev/ashmem', {proportionalResident: 500}), |
| 707 { 'proportionalResident': 500 }), | |
| 708 ]); | 734 ]); |
| 709 var pmdGpu3 = addProcessMemoryDump(gmd3, pGpu, 30); | 735 var pmdGpu3 = addProcessMemoryDump(gmd3, pGpu, {ts: 30}); |
| 710 pmdGpu3.memoryAllocatorDumps = (function() { | 736 pmdGpu3.memoryAllocatorDumps = (function() { |
| 711 var gpuDump = newAllocatorDump(pmdGpu3, 'gpu', | 737 var gpuDump = newAllocatorDump(pmdGpu3, 'gpu', |
| 712 { 'memtrack_pss': 6000 /* ignored */ }); | 738 {numerics: {memtrack_pss: 6000 /* ignored */}}); |
| 713 var memtrackDump = addChildDump(gpuDump, 'android_memtrack', | 739 var memtrackDump = addChildDump(gpuDump, 'android_memtrack', |
| 714 { 'memtrack_pss': 5000 /* ignored */ }); | 740 {numerics: {memtrack_pss: 5000 /* ignored */}}); |
| 715 addChildDump(memtrackDump, 'gl', { 'memtrack_pss': 3000 }); | 741 addChildDump(memtrackDump, 'gl', {numerics: {memtrack_pss: 3000}}); |
| 716 addChildDump(memtrackDump, 'graphics', { 'ignored': 2000 }); | 742 addChildDump(memtrackDump, 'graphics', {numerics: {ignored: 2000}}); |
| 717 addChildDump(memtrackDump, 'gfx', { 'memtrack_pss': 1000 }); | 743 addChildDump(memtrackDump, 'gfx', {numerics: {memtrack_pss: 1000}}); |
| 718 return [gpuDump]; | 744 return [gpuDump]; |
| 719 })(); | 745 })(); |
| 720 pmdGpu3.vmRegions = VMRegionClassificationNode.fromRegions([ | 746 pmdGpu3.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 721 new VMRegion(0xCDCD, 4096, 0, '/dev/ashmem/dalvik-zygote space', | 747 new VMRegion(0xCDCD, 4096, 0, '/dev/ashmem/dalvik-zygote space', |
| 722 { 'proportionalResident': 150, 'privateDirtyResident': 90 }) | 748 {proportionalResident: 150, privateDirtyResident: 90}) |
| 723 ]); | 749 ]); |
| 724 | 750 |
| 725 // Timestamp 4. | 751 // Timestamp 4. |
| 726 var gmd4 = addGlobalMemoryDump(model, 40, DETAILED); | 752 var gmd4 = addGlobalMemoryDump(model, {ts: 40, levelOfDetail: DETAILED}); |
| 727 var pmdBrowser4 = addProcessMemoryDump(gmd4, pBrowser, 40); | 753 var pmdBrowser4 = addProcessMemoryDump(gmd4, pBrowser, {ts: 40}); |
| 728 var pmdRendererA4 = addProcessMemoryDump(gmd4, pRendererA, 40); | 754 var pmdRendererA4 = addProcessMemoryDump(gmd4, pRendererA, {ts: 40}); |
| 729 pmdRendererA4.memoryAllocatorDumps = [ | 755 pmdRendererA4.memoryAllocatorDumps = [ |
| 730 newAllocatorDump(pmdRendererA4, 'v8', { | 756 newAllocatorDump(pmdRendererA4, 'v8', {numerics: { |
| 731 'code_and_metadata_size': 21, | 757 code_and_metadata_size: 21, |
| 732 'bytecode_and_metadata_size': 35 | 758 bytecode_and_metadata_size: 35 |
| 733 }) | 759 }}) |
| 734 ]; | 760 ]; |
| 735 }, { | 761 }, undefined /* opt_options */, { |
| 736 'memory:unknown_browser:all_processes:dump_count:detailed': { | 762 'memory:unknown_browser:all_processes:dump_count:detailed': { |
| 737 value: 3, | 763 value: 3, |
| 738 unit: unitlessNumber_smallerIsBetter, | 764 unit: unitlessNumber_smallerIsBetter, |
| 739 description: 'total number of detailed memory dumps added by an ' + | 765 description: 'total number of detailed memory dumps added by an ' + |
| 740 'unknown browser to the trace' | 766 'unknown browser to the trace' |
| 741 }, | 767 }, |
| 742 'memory:unknown_browser:all_processes:dump_count:light': { | 768 'memory:unknown_browser:all_processes:dump_count:light': { |
| 743 value: 1, | 769 value: 1, |
| 744 unit: unitlessNumber_smallerIsBetter, | 770 unit: unitlessNumber_smallerIsBetter, |
| 745 description: 'total number of light memory dumps added by an unknown ' + | 771 description: 'total number of light memory dumps added by an unknown ' + |
| (...skipping 388 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1134 unit: sizeInBytes_smallerIsBetter, | 1160 unit: sizeInBytes_smallerIsBetter, |
| 1135 description: 'proportional resident size (PSS) of the native heap ' + | 1161 description: 'proportional resident size (PSS) of the native heap ' + |
| 1136 'in renderer processes in an unknown browser' | 1162 'in renderer processes in an unknown browser' |
| 1137 } | 1163 } |
| 1138 }); | 1164 }); |
| 1139 | 1165 |
| 1140 memoryMetricTest('combined_chrome', function(model) { | 1166 memoryMetricTest('combined_chrome', function(model) { |
| 1141 var pBrowser = createChromeBrowserProcess(model); | 1167 var pBrowser = createChromeBrowserProcess(model); |
| 1142 | 1168 |
| 1143 // Timestamp 1. | 1169 // Timestamp 1. |
| 1144 var gmd1 = addGlobalMemoryDump(model, 10, DETAILED); | 1170 var gmd1 = addGlobalMemoryDump(model, {ts: 10, levelOfDetail: DETAILED}); |
| 1145 var pmdBrowser1 = addProcessMemoryDump(gmd1, pBrowser, 10); | 1171 var pmdBrowser1 = addProcessMemoryDump(gmd1, pBrowser, {ts: 10}); |
| 1146 pmdBrowser1.vmRegions = VMRegionClassificationNode.fromRegions([ | 1172 pmdBrowser1.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1147 new VMRegion(0xABCD, 128, 0, '/dev/ashmem/dalvik-non moving space', | 1173 new VMRegion(0xABCD, 128, 0, '/dev/ashmem/dalvik-non moving space', |
| 1148 { 'privateDirtyResident': 100 }) | 1174 {privateDirtyResident: 100}) |
| 1149 ]); | 1175 ]); |
| 1150 | 1176 |
| 1151 // Timestamp 2 (light global memory dump, so it should be skipped for | 1177 // Timestamp 2 (light global memory dump, so it should be skipped for |
| 1152 // mmaps_* values). | 1178 // mmaps_* values). |
| 1153 var gmd2 = addGlobalMemoryDump(model, 20, LIGHT); | 1179 var gmd2 = addGlobalMemoryDump(model, {ts: 20, levelOfDetail: LIGHT}); |
| 1154 var pmdBrowser2 = addProcessMemoryDump(gmd2, pBrowser, 20); | 1180 var pmdBrowser2 = addProcessMemoryDump(gmd2, pBrowser, {ts: 20}); |
| 1155 pmdBrowser2.memoryAllocatorDumps = [ | 1181 pmdBrowser2.memoryAllocatorDumps = [ |
| 1156 newAllocatorDump(pmdBrowser2, 'malloc', { size: 32 }) | 1182 newAllocatorDump(pmdBrowser2, 'malloc', {numerics: {size: 32}}) |
| 1157 ]; | 1183 ]; |
| 1158 | 1184 |
| 1159 // Timestamp 3. | 1185 // Timestamp 3. |
| 1160 var gmd3 = addGlobalMemoryDump(model, 30, DETAILED); | 1186 var gmd3 = addGlobalMemoryDump(model, {ts: 30, levelOfDetail: DETAILED}); |
| 1161 var pmdBrowser3 = addProcessMemoryDump(gmd3, pBrowser, 30); | 1187 var pmdBrowser3 = addProcessMemoryDump(gmd3, pBrowser, {ts: 30}); |
| 1162 pmdBrowser3.memoryAllocatorDumps = [ | 1188 pmdBrowser3.memoryAllocatorDumps = [ |
| 1163 newAllocatorDump(pmdBrowser3, 'malloc', { size: 48 }) | 1189 newAllocatorDump(pmdBrowser3, 'malloc', {numerics: {size: 48}}) |
| 1164 ]; | 1190 ]; |
| 1165 pmdBrowser3.vmRegions = VMRegionClassificationNode.fromRegions([ | 1191 pmdBrowser3.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1166 new VMRegion(0xABCD, 1024, 0, '/dev/ashmem/dalvik-non moving space', | 1192 new VMRegion(0xABCD, 1024, 0, '/dev/ashmem/dalvik-non moving space', |
| 1167 { 'privateDirtyResident': 150 }) | 1193 {privateDirtyResident: 150}) |
| 1168 ]); | 1194 ]); |
| 1169 }, { | 1195 }, {} /* opt_options */, { |
| 1170 'memory:chrome:all_processes:dump_count:detailed': { | 1196 'memory:chrome:all_processes:dump_count:detailed': { |
| 1171 value: 2, | 1197 value: 2, |
| 1172 unit: unitlessNumber_smallerIsBetter, | 1198 unit: unitlessNumber_smallerIsBetter, |
| 1173 description: 'total number of detailed memory dumps added by Chrome to ' + | 1199 description: 'total number of detailed memory dumps added by Chrome to ' + |
| 1174 'the trace' | 1200 'the trace' |
| 1175 }, | 1201 }, |
| 1176 'memory:chrome:all_processes:dump_count:light': { | 1202 'memory:chrome:all_processes:dump_count:light': { |
| 1177 value: 1, | 1203 value: 1, |
| 1178 unit: unitlessNumber_smallerIsBetter, | 1204 unit: unitlessNumber_smallerIsBetter, |
| 1179 description: 'total number of light memory dumps added by Chrome to ' + | 1205 description: 'total number of light memory dumps added by Chrome to ' + |
| (...skipping 177 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1357 memoryMetricTest('combined_multipleBrowsers', function(model) { | 1383 memoryMetricTest('combined_multipleBrowsers', function(model) { |
| 1358 var pWebView = createWebViewProcess(model); | 1384 var pWebView = createWebViewProcess(model); |
| 1359 var pChrome1 = createChromeBrowserProcess(model); | 1385 var pChrome1 = createChromeBrowserProcess(model); |
| 1360 var pRenderer1 = createProcessWithName(model, 'Renderer'); | 1386 var pRenderer1 = createProcessWithName(model, 'Renderer'); |
| 1361 var pGpu1 = createProcessWithName(model, 'GPU Process'); | 1387 var pGpu1 = createProcessWithName(model, 'GPU Process'); |
| 1362 var pUnknownBrowser = createProcessWithName(model, 'Browser'); | 1388 var pUnknownBrowser = createProcessWithName(model, 'Browser'); |
| 1363 var pChrome2 = createChromeBrowserProcess(model); | 1389 var pChrome2 = createChromeBrowserProcess(model); |
| 1364 var pRenderer2 = createProcessWithName(model, 'Renderer'); | 1390 var pRenderer2 = createProcessWithName(model, 'Renderer'); |
| 1365 | 1391 |
| 1366 // Timestamp 1 (WebView). | 1392 // Timestamp 1 (WebView). |
| 1367 var gmd1 = addGlobalMemoryDump(model, 0, LIGHT); | 1393 var gmd1 = addGlobalMemoryDump(model, {ts: 0, levelOfDetail: LIGHT}); |
| 1368 var pmdBrowser1 = addProcessMemoryDump(gmd1, pWebView, 0); | 1394 var pmdBrowser1 = addProcessMemoryDump(gmd1, pWebView, {ts: 0}); |
| 1369 pmdBrowser1.memoryAllocatorDumps = [ | 1395 pmdBrowser1.memoryAllocatorDumps = [ |
| 1370 newAllocatorDump(pmdBrowser1, 'malloc', { size: 2 }), | 1396 newAllocatorDump(pmdBrowser1, 'malloc', {numerics: {size: 2}}), |
| 1371 newAllocatorDump(pmdBrowser1, 'v8', { size: 4 }) | 1397 newAllocatorDump(pmdBrowser1, 'v8', {numerics: {size: 4}}) |
| 1372 ]; | 1398 ]; |
| 1373 | 1399 |
| 1374 // Timestamp 2 (Chrome 1 + Renderer + GPU Process). | 1400 // Timestamp 2 (Chrome 1 + Renderer + GPU Process). |
| 1375 var gmd2 = addGlobalMemoryDump(model, 10, DETAILED); | 1401 var gmd2 = addGlobalMemoryDump(model, {ts: 10, levelOfDetail: DETAILED}); |
| 1376 var pmdBrowser2 = addProcessMemoryDump(gmd2, pChrome1, 12); | 1402 var pmdBrowser2 = addProcessMemoryDump(gmd2, pChrome1, {ts: 12}); |
| 1377 pmdBrowser2.vmRegions = VMRegionClassificationNode.fromRegions([ | 1403 pmdBrowser2.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1378 new VMRegion(0xABCD, 9999, 0, '/dev/ashmem/dalvik-non moving space', | 1404 new VMRegion(0xABCD, 9999, 0, '/dev/ashmem/dalvik-non moving space', |
| 1379 { 'privateDirtyResident': 8 }) | 1405 {privateDirtyResident: 8}) |
| 1380 ]); | 1406 ]); |
| 1381 var pmdGpu2 = addProcessMemoryDump(gmd2, pGpu1, 8); | 1407 var pmdGpu2 = addProcessMemoryDump(gmd2, pGpu1, {ts: 8}); |
| 1382 pmdGpu2.vmRegions = VMRegionClassificationNode.fromRegions([ | 1408 pmdGpu2.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1383 new VMRegion(0xABCD, 9999, 0, '/dev/ashmem/dalvik-non moving space', | 1409 new VMRegion(0xABCD, 9999, 0, '/dev/ashmem/dalvik-non moving space', |
| 1384 { 'privateDirtyResident': 16 }) | 1410 {privateDirtyResident: 16}) |
| 1385 ]); | 1411 ]); |
| 1386 var pmdRenderer2 = addProcessMemoryDump(gmd2, pRenderer1, 8); | 1412 var pmdRenderer2 = addProcessMemoryDump(gmd2, pRenderer1, {ts: 8}); |
| 1387 pmdRenderer2.memoryAllocatorDumps = [ | 1413 pmdRenderer2.memoryAllocatorDumps = [ |
| 1388 newAllocatorDump(pmdBrowser2, 'malloc', { size: 32 }) | 1414 newAllocatorDump(pmdBrowser2, 'malloc', {numerics: {size: 32}}) |
| 1389 ]; | 1415 ]; |
| 1390 | 1416 |
| 1391 // Timestamp 3 (Chrome 2). | 1417 // Timestamp 3 (Chrome 2). |
| 1392 var gmd3 = addGlobalMemoryDump(model, 20, DETAILED); | 1418 var gmd3 = addGlobalMemoryDump(model, {ts: 20, levelOfDetail: DETAILED}); |
| 1393 var pmdBrowser3 = addProcessMemoryDump(gmd3, pChrome2, 20); | 1419 var pmdBrowser3 = addProcessMemoryDump(gmd3, pChrome2, {ts: 20}); |
| 1394 pmdBrowser3.memoryAllocatorDumps = [ | 1420 pmdBrowser3.memoryAllocatorDumps = [ |
| 1395 newAllocatorDump(pmdBrowser3, 'malloc', { size: 64 }), | 1421 newAllocatorDump(pmdBrowser3, 'malloc', {numerics: {size: 64}}), |
| 1396 newAllocatorDump(pmdBrowser3, 'sqlite', { size: 128 }), | 1422 newAllocatorDump(pmdBrowser3, 'sqlite', {numerics: {size: 128}}), |
| 1397 newAllocatorDump(pmdBrowser3, 'discardable', { | 1423 newAllocatorDump(pmdBrowser3, 'discardable', {numerics: { |
| 1398 size: 8388608, | 1424 size: 8388608, |
| 1399 locked_size: 4194304 | 1425 locked_size: 4194304 |
| 1400 }) | 1426 }}) |
| 1401 ]; | 1427 ]; |
| 1402 pmdBrowser3.vmRegions = VMRegionClassificationNode.fromRegions([ | 1428 pmdBrowser3.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1403 new VMRegion(0xABCD, 99, 0, '/dev/ashmem/dalvik-non moving space', | 1429 new VMRegion(0xABCD, 99, 0, '/dev/ashmem/dalvik-non moving space', |
| 1404 { 'privateDirtyResident': 256 }) | 1430 {privateDirtyResident: 256}) |
| 1405 ]); | 1431 ]); |
| 1406 | 1432 |
| 1407 // Timestamp 4 (Chrome 2 + Renderer). | 1433 // Timestamp 4 (Chrome 2 + Renderer). |
| 1408 var gmd4 = addGlobalMemoryDump(model, 30, LIGHT); | 1434 var gmd4 = addGlobalMemoryDump(model, {ts: 30, levelOfDetail: LIGHT}); |
| 1409 var pmdBrowser4 = addProcessMemoryDump(gmd4, pChrome2, 28); | 1435 var pmdBrowser4 = addProcessMemoryDump(gmd4, pChrome2, {ts: 28}); |
| 1410 pmdBrowser4.memoryAllocatorDumps = [ | 1436 pmdBrowser4.memoryAllocatorDumps = [ |
| 1411 newAllocatorDump(pmdBrowser4, 'malloc', { size: 512 }), | 1437 newAllocatorDump(pmdBrowser4, 'malloc', {numerics: {size: 512}}), |
| 1412 newAllocatorDump(pmdBrowser3, 'discardable', { size: 16777216 }) | 1438 newAllocatorDump(pmdBrowser3, 'discardable', {numerics: {size: 16777216}}) |
| 1413 ]; | 1439 ]; |
| 1414 var pmdRenderer4 = addProcessMemoryDump(gmd4, pRenderer2, 32); | 1440 var pmdRenderer4 = addProcessMemoryDump(gmd4, pRenderer2, {ts: 32}); |
| 1415 pmdRenderer4.memoryAllocatorDumps = [ | 1441 pmdRenderer4.memoryAllocatorDumps = [ |
| 1416 newAllocatorDump(pmdRenderer4, 'malloc', { size: 1024 }), | 1442 newAllocatorDump(pmdRenderer4, 'malloc', {numerics: {size: 1024}}), |
| 1417 newAllocatorDump(pmdRenderer4, 'v8', { size: 2048 }) | 1443 newAllocatorDump(pmdRenderer4, 'v8', {numerics: {size: 2048}}) |
| 1418 ]; | 1444 ]; |
| 1419 | 1445 |
| 1420 // Timestamp 5 (Unknown browser). | 1446 // Timestamp 5 (Unknown browser). |
| 1421 var gmd5 = addGlobalMemoryDump(model, 40, LIGHT); | 1447 var gmd5 = addGlobalMemoryDump(model, {ts: 40, levelOfDetail: LIGHT}); |
| 1422 var pmdBrowser5 = addProcessMemoryDump(gmd5, pUnknownBrowser, 40); | 1448 var pmdBrowser5 = addProcessMemoryDump(gmd5, pUnknownBrowser, {ts: 40}); |
| 1423 pmdBrowser5.memoryAllocatorDumps = [ | 1449 pmdBrowser5.memoryAllocatorDumps = [ |
| 1424 newAllocatorDump(pmdBrowser5, 'malloc', { size: 4096 }), | 1450 newAllocatorDump(pmdBrowser5, 'malloc', {numerics: {size: 4096}}), |
| 1425 newAllocatorDump(pmdBrowser5, 'sqlite', { size: 8192 }), | 1451 newAllocatorDump(pmdBrowser5, 'sqlite', {numerics: {size: 8192}}), |
| 1426 ]; | 1452 ]; |
| 1427 | 1453 |
| 1428 // Timestamp 6 (WebView). | 1454 // Timestamp 6 (WebView). |
| 1429 var gmd6 = addGlobalMemoryDump(model, 50, DETAILED); | 1455 var gmd6 = addGlobalMemoryDump(model, {ts: 50, levelOfDetail: DETAILED}); |
| 1430 var pmdBrowser6 = addProcessMemoryDump(gmd6, pWebView, 50); | 1456 var pmdBrowser6 = addProcessMemoryDump(gmd6, pWebView, {ts: 50}); |
| 1431 pmdBrowser6.memoryAllocatorDumps = [ | 1457 pmdBrowser6.memoryAllocatorDumps = (function() { |
| 1432 newAllocatorDump(pmdBrowser6, 'malloc', { size: 16384 }), | 1458 var mallocDump = newAllocatorDump(pmdBrowser6, 'malloc', |
| 1433 newAllocatorDump(pmdBrowser6, 'v8', { | 1459 {numerics: {size: 16384}}); |
| 1434 'allocated_objects_size': 32768, | 1460 var v8Dump = newAllocatorDump(pmdBrowser6, 'v8', {numerics: { |
| 1435 'code_and_metadata_size': 33554432, | 1461 allocated_objects_size: 32768, |
| 1436 'size': 67108864 | 1462 code_and_metadata_size: 33554432, |
| 1437 }) | 1463 size: 67108864 |
| 1438 ]; | 1464 }}); |
| 1465 var isolateDump = addChildDump(v8Dump, 'isolate'); |
| 1466 addChildDump(isolateDump, 'malloc', {numerics: {size: 1 }}); |
| 1467 return [mallocDump, v8Dump]; |
| 1468 })(); |
| 1439 pmdBrowser6.vmRegions = VMRegionClassificationNode.fromRegions([ | 1469 pmdBrowser6.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1440 new VMRegion(0xABCD, 99999, 0, '/dev/ashmem/dalvik-non moving space', | 1470 new VMRegion(0xABCD, 99999, 0, '/dev/ashmem/dalvik-non moving space', |
| 1441 { 'privateDirtyResident': 65536 }) | 1471 {privateDirtyResident: 65536}) |
| 1442 ]); | 1472 ]); |
| 1443 | 1473 |
| 1444 // Timestamp 7 (Chrome 1 + GPU Process). | 1474 // Timestamp 7 (Chrome 1 + GPU Process). |
| 1445 var gmd7 = addGlobalMemoryDump(model, 60, DETAILED); | 1475 var gmd7 = addGlobalMemoryDump(model, {ts: 60, levelOfDetail: DETAILED}); |
| 1446 var pmdBrowser7 = addProcessMemoryDump(gmd7, pChrome1, 63); | 1476 var pmdBrowser7 = addProcessMemoryDump(gmd7, pChrome1, {ts: 63}); |
| 1447 pmdBrowser7.memoryAllocatorDumps = [ | 1477 pmdBrowser7.memoryAllocatorDumps = [ |
| 1448 newAllocatorDump(pmdBrowser4, 'malloc', { size: 131072 }), | 1478 newAllocatorDump(pmdBrowser4, 'malloc', {numerics: {size: 131072}}), |
| 1449 newAllocatorDump(pmdBrowser4, 'sqlite', { size: 262144 }) | 1479 newAllocatorDump(pmdBrowser4, 'sqlite', {numerics: {size: 262144}}) |
| 1450 ]; | 1480 ]; |
| 1451 pmdBrowser7.vmRegions = VMRegionClassificationNode.fromRegions([ | 1481 pmdBrowser7.vmRegions = VMRegionClassificationNode.fromRegions([ |
| 1452 new VMRegion(0xABCD, 999999, 0, '/dev/ashmem/dalvik-non moving space', | 1482 new VMRegion(0xABCD, 999999, 0, '/dev/ashmem/dalvik-non moving space', |
| 1453 { 'privateDirtyResident': 524288 }) | 1483 {privateDirtyResident: 524288}) |
| 1454 ]); | 1484 ]); |
| 1455 var pmdGpu7 = addProcessMemoryDump(gmd7, pGpu1, 57); | 1485 var pmdGpu7 = addProcessMemoryDump(gmd7, pGpu1, {ts: 57}); |
| 1456 pmdGpu7.memoryAllocatorDumps = (function() { | 1486 pmdGpu7.memoryAllocatorDumps = (function() { |
| 1457 var gpuDump = newAllocatorDump(pmdGpu7, 'gpu', { 'size': 1048576 }); | 1487 var gpuDump = newAllocatorDump(pmdGpu7, 'gpu', |
| 1488 {numerics: {size: 1048576}}); |
| 1458 var memtrackDump = addChildDump(gpuDump, 'android_memtrack'); | 1489 var memtrackDump = addChildDump(gpuDump, 'android_memtrack'); |
| 1459 addChildDump(memtrackDump, 'gl', { 'memtrack_pss': 2097152 }); | 1490 addChildDump(memtrackDump, 'gl', {numerics: {memtrack_pss: 2097152}}); |
| 1460 return [gpuDump]; | 1491 return [gpuDump]; |
| 1461 })(); | 1492 })(); |
| 1462 }, { | 1493 }, undefined /* opt_options */, { |
| 1463 // WebView (GMD1, GMD6). | 1494 // WebView (GMD1, GMD6). |
| 1464 'memory:webview:all_processes:dump_count:detailed': { | 1495 'memory:webview:all_processes:dump_count:detailed': { |
| 1465 value: 1, | 1496 value: 1, |
| 1466 unit: unitlessNumber_smallerIsBetter, | 1497 unit: unitlessNumber_smallerIsBetter, |
| 1467 description: 'total number of detailed memory dumps added by WebView ' + | 1498 description: 'total number of detailed memory dumps added by WebView ' + |
| 1468 'to the trace' | 1499 'to the trace' |
| 1469 }, | 1500 }, |
| 1470 'memory:webview:all_processes:dump_count:light': { | 1501 'memory:webview:all_processes:dump_count:light': { |
| 1471 value: 1, | 1502 value: 1, |
| 1472 unit: unitlessNumber_smallerIsBetter, | 1503 unit: unitlessNumber_smallerIsBetter, |
| (...skipping 27 matching lines...) Expand all Loading... |
| 1500 value: [0, 32768], | 1531 value: [0, 32768], |
| 1501 unit: sizeInBytes_smallerIsBetter, | 1532 unit: sizeInBytes_smallerIsBetter, |
| 1502 description: 'total size of all allocated objects reported by Chrome ' + | 1533 description: 'total size of all allocated objects reported by Chrome ' + |
| 1503 'for all processes in WebView' | 1534 'for all processes in WebView' |
| 1504 }, | 1535 }, |
| 1505 'memory:webview:all_processes:reported_by_chrome:malloc:effective_size': { | 1536 'memory:webview:all_processes:reported_by_chrome:malloc:effective_size': { |
| 1506 value: [2, 16384], | 1537 value: [2, 16384], |
| 1507 unit: sizeInBytes_smallerIsBetter, | 1538 unit: sizeInBytes_smallerIsBetter, |
| 1508 description: 'effective size of malloc in all processes in WebView' | 1539 description: 'effective size of malloc in all processes in WebView' |
| 1509 }, | 1540 }, |
| 1541 'memory:webview:all_processes:reported_by_chrome:v8:allocated_by_malloc:effe
ctive_size': |
| 1542 { |
| 1543 value: [0, 1], |
| 1544 unit: sizeInBytes_smallerIsBetter, |
| 1545 description: 'effective size of objects allocated by malloc for v8 ' + |
| 1546 'in all processes in WebView' |
| 1547 }, |
| 1510 'memory:webview:all_processes:reported_by_chrome:v8:effective_size': { | 1548 'memory:webview:all_processes:reported_by_chrome:v8:effective_size': { |
| 1511 value: [4, 67108864], | 1549 value: [4, 67108864], |
| 1512 unit: sizeInBytes_smallerIsBetter, | 1550 unit: sizeInBytes_smallerIsBetter, |
| 1513 description: 'effective size of v8 in all processes in WebView' | 1551 description: 'effective size of v8 in all processes in WebView' |
| 1514 }, | 1552 }, |
| 1515 'memory:webview:all_processes:reported_by_chrome:v8:code_and_metadata_size': | 1553 'memory:webview:all_processes:reported_by_chrome:v8:code_and_metadata_size': |
| 1516 { | 1554 { |
| 1517 value: [33554432], | 1555 value: [33554432], |
| 1518 unit: sizeInBytes_smallerIsBetter, | 1556 unit: sizeInBytes_smallerIsBetter, |
| 1519 description: 'size of v8 code and metadata in all processes in ' + | 1557 description: 'size of v8 code and metadata in all processes in ' + |
| (...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1617 value: [33554432], | 1655 value: [33554432], |
| 1618 unit: sizeInBytes_smallerIsBetter, | 1656 unit: sizeInBytes_smallerIsBetter, |
| 1619 description: 'total size of code and metadata reported by Chrome ' + | 1657 description: 'total size of code and metadata reported by Chrome ' + |
| 1620 'for the browser process in WebView' | 1658 'for the browser process in WebView' |
| 1621 }, | 1659 }, |
| 1622 'memory:webview:browser_process:reported_by_chrome:malloc:effective_size': { | 1660 'memory:webview:browser_process:reported_by_chrome:malloc:effective_size': { |
| 1623 value: [2, 16384], | 1661 value: [2, 16384], |
| 1624 unit: sizeInBytes_smallerIsBetter, | 1662 unit: sizeInBytes_smallerIsBetter, |
| 1625 description: 'effective size of malloc in the browser process in WebView' | 1663 description: 'effective size of malloc in the browser process in WebView' |
| 1626 }, | 1664 }, |
| 1665 'memory:webview:browser_process:reported_by_chrome:v8:allocated_by_malloc:ef
fective_size': |
| 1666 { |
| 1667 value: [0, 1], |
| 1668 unit: sizeInBytes_smallerIsBetter, |
| 1669 description: 'effective size of objects allocated by malloc for v8 ' + |
| 1670 'in the browser process in WebView' |
| 1671 }, |
| 1627 'memory:webview:browser_process:reported_by_chrome:v8:effective_size': { | 1672 'memory:webview:browser_process:reported_by_chrome:v8:effective_size': { |
| 1628 value: [4, 67108864], | 1673 value: [4, 67108864], |
| 1629 unit: sizeInBytes_smallerIsBetter, | 1674 unit: sizeInBytes_smallerIsBetter, |
| 1630 description: 'effective size of v8 in the browser process in WebView' | 1675 description: 'effective size of v8 in the browser process in WebView' |
| 1631 }, | 1676 }, |
| 1632 'memory:webview:browser_process:reported_by_chrome:v8:allocated_objects_size
': | 1677 'memory:webview:browser_process:reported_by_chrome:v8:allocated_objects_size
': |
| 1633 { | 1678 { |
| 1634 value: [0, 32768], | 1679 value: [0, 32768], |
| 1635 unit: sizeInBytes_smallerIsBetter, | 1680 unit: sizeInBytes_smallerIsBetter, |
| 1636 description: 'size of all objects allocated by v8 in the browser ' + | 1681 description: 'size of all objects allocated by v8 in the browser ' + |
| (...skipping 810 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 2447 }, | 2492 }, |
| 2448 'memory:unknown_browser:browser_process:reported_by_chrome:sqlite:effective_
size': | 2493 'memory:unknown_browser:browser_process:reported_by_chrome:sqlite:effective_
size': |
| 2449 { | 2494 { |
| 2450 value: [8192], | 2495 value: [8192], |
| 2451 unit: sizeInBytes_smallerIsBetter, | 2496 unit: sizeInBytes_smallerIsBetter, |
| 2452 description: 'effective size of sqlite in the browser process in ' + | 2497 description: 'effective size of sqlite in the browser process in ' + |
| 2453 'an unknown browser' | 2498 'an unknown browser' |
| 2454 } | 2499 } |
| 2455 }); | 2500 }); |
| 2456 | 2501 |
| 2502 memoryMetricTest('rangeOfInterest', function(model) { |
| 2503 var pChrome = createChromeBrowserProcess(model); |
| 2504 var pWebView = createWebViewProcess(model); |
| 2505 |
| 2506 // Chrome: only the LIGHT dumps should be kept. |
| 2507 addProcessMemoryDump(addGlobalMemoryDump( |
| 2508 model, {ts: 5, duration: 4, levelOfDetail: DETAILED}), pChrome); |
| 2509 addProcessMemoryDump(addGlobalMemoryDump( |
| 2510 model, {ts: 10, duration: 2, levelOfDetail: LIGHT}), pChrome); |
| 2511 addProcessMemoryDump(addGlobalMemoryDump( |
| 2512 model, {ts: 13, duration: 3, levelOfDetail: LIGHT}), pChrome); |
| 2513 addProcessMemoryDump(addGlobalMemoryDump( |
| 2514 model, {ts: 20, duration: 1, levelOfDetail: LIGHT}), pChrome); |
| 2515 addProcessMemoryDump(addGlobalMemoryDump( |
| 2516 model, {ts: 22, duration: 5, levelOfDetail: DETAILED}), pChrome); |
| 2517 |
| 2518 // WebView: only the DETAILED dumps should be kept. |
| 2519 addProcessMemoryDump(addGlobalMemoryDump( |
| 2520 model, {ts: 4, duration: 1, levelOfDetail: LIGHT}), pWebView); |
| 2521 addProcessMemoryDump(addGlobalMemoryDump( |
| 2522 model, {ts: 5, duration: 5, levelOfDetail: DETAILED}), pWebView); |
| 2523 addProcessMemoryDump(addGlobalMemoryDump( |
| 2524 model, {ts: 10, duration: 0, levelOfDetail: DETAILED}), pWebView); |
| 2525 addProcessMemoryDump(addGlobalMemoryDump( |
| 2526 model, {ts: 11, duration: 7, levelOfDetail: DETAILED}), pWebView); |
| 2527 addProcessMemoryDump(addGlobalMemoryDump( |
| 2528 model, {ts: 19, duration: 2, levelOfDetail: DETAILED}), pWebView); |
| 2529 addProcessMemoryDump(addGlobalMemoryDump( |
| 2530 model, {ts: 21, duration: 5, levelOfDetail: LIGHT}), pWebView); |
| 2531 |
| 2532 // Unknown browser: only the LIGHT dump should be kept. |
| 2533 addGlobalMemoryDump(model, {ts: 5, duration: 3, levelOfDetail: DETAILED}); |
| 2534 addGlobalMemoryDump(model, {ts: 9, duration: 12, levelOfDetail: LIGHT}); |
| 2535 addGlobalMemoryDump(model, {ts: 22, duration: 3, levelOfDetail: DETAILED}); |
| 2536 }, { /* opt_options */ |
| 2537 rangeOfInterest: tr.b.Range.fromExplicitRange(10, 20) |
| 2538 }, { |
| 2539 'memory:chrome:all_processes:dump_count': { |
| 2540 value: 3, |
| 2541 unit: unitlessNumber_smallerIsBetter, |
| 2542 description: 'total number of all memory dumps added by Chrome to the ' + |
| 2543 'trace' |
| 2544 }, |
| 2545 'memory:chrome:all_processes:dump_count:detailed': { |
| 2546 value: 0, |
| 2547 unit: unitlessNumber_smallerIsBetter, |
| 2548 description: 'total number of detailed memory dumps added by Chrome to ' + |
| 2549 'the trace' |
| 2550 }, |
| 2551 'memory:chrome:all_processes:dump_count:light': { |
| 2552 value: 3, |
| 2553 unit: unitlessNumber_smallerIsBetter, |
| 2554 description: 'total number of light memory dumps added by Chrome to ' + |
| 2555 'the trace' |
| 2556 }, |
| 2557 'memory:chrome:all_processes:process_count': { |
| 2558 value: [1, 1, 1], |
| 2559 unit: unitlessNumber_smallerIsBetter, |
| 2560 description: 'total number of all processes in Chrome' |
| 2561 }, |
| 2562 'memory:chrome:browser_process:process_count': { |
| 2563 value: [1, 1, 1], |
| 2564 unit: unitlessNumber_smallerIsBetter, |
| 2565 description: 'total number of browser processes in Chrome' |
| 2566 }, |
| 2567 |
| 2568 'memory:webview:all_processes:dump_count': { |
| 2569 value: 4, |
| 2570 unit: unitlessNumber_smallerIsBetter, |
| 2571 description: 'total number of all memory dumps added by WebView to the ' + |
| 2572 'trace' |
| 2573 }, |
| 2574 'memory:webview:all_processes:dump_count:detailed': { |
| 2575 value: 4, |
| 2576 unit: unitlessNumber_smallerIsBetter, |
| 2577 description: 'total number of detailed memory dumps added by WebView ' + |
| 2578 'to the trace' |
| 2579 }, |
| 2580 'memory:webview:all_processes:dump_count:light': { |
| 2581 value: 0, |
| 2582 unit: unitlessNumber_smallerIsBetter, |
| 2583 description: 'total number of light memory dumps added by WebView to ' + |
| 2584 'the trace' |
| 2585 }, |
| 2586 'memory:webview:all_processes:process_count': { |
| 2587 value: [1, 1, 1, 1], |
| 2588 unit: unitlessNumber_smallerIsBetter, |
| 2589 description: 'total number of all processes in WebView' |
| 2590 }, |
| 2591 'memory:webview:all_processes:reported_by_os:private_dirty_size': { |
| 2592 value: [0, 0, 0, 0], |
| 2593 unit: sizeInBytes_smallerIsBetter, |
| 2594 description: 'total private dirty size reported by the OS for all ' + |
| 2595 'processes in WebView' |
| 2596 }, |
| 2597 'memory:webview:all_processes:reported_by_os:proportional_resident_size': { |
| 2598 value: [0, 0, 0, 0], |
| 2599 unit: sizeInBytes_smallerIsBetter, |
| 2600 description: 'total proportional resident size (PSS) reported by the ' + |
| 2601 'OS for all processes in WebView' |
| 2602 }, |
| 2603 'memory:webview:all_processes:reported_by_os:system_memory:ashmem:private_di
rty_size': |
| 2604 { |
| 2605 value: [0, 0, 0, 0], |
| 2606 unit: sizeInBytes_smallerIsBetter, |
| 2607 description: 'private dirty size of ashmem in all processes in ' + |
| 2608 'WebView' |
| 2609 }, |
| 2610 'memory:webview:all_processes:reported_by_os:system_memory:ashmem:proportion
al_resident_size': |
| 2611 { |
| 2612 value: [0, 0, 0, 0], |
| 2613 unit: sizeInBytes_smallerIsBetter, |
| 2614 description: 'proportional resident size (PSS) of ashmem in all ' + |
| 2615 'processes in WebView' |
| 2616 }, |
| 2617 'memory:webview:all_processes:reported_by_os:system_memory:java_heap:private
_dirty_size': |
| 2618 { |
| 2619 value: [0, 0, 0, 0], |
| 2620 unit: sizeInBytes_smallerIsBetter, |
| 2621 description: 'private dirty size of the Java heap in all processes ' + |
| 2622 'in WebView' |
| 2623 }, |
| 2624 'memory:webview:all_processes:reported_by_os:system_memory:java_heap:proport
ional_resident_size': |
| 2625 { |
| 2626 value: [0, 0, 0, 0], |
| 2627 unit: sizeInBytes_smallerIsBetter, |
| 2628 description: 'proportional resident size (PSS) of the Java heap in ' + |
| 2629 'all processes in WebView' |
| 2630 }, |
| 2631 'memory:webview:all_processes:reported_by_os:system_memory:native_heap:priva
te_dirty_size': |
| 2632 { |
| 2633 value: [0, 0, 0, 0], |
| 2634 unit: sizeInBytes_smallerIsBetter, |
| 2635 description: 'private dirty size of the native heap in all ' + |
| 2636 'processes in WebView' |
| 2637 }, |
| 2638 'memory:webview:all_processes:reported_by_os:system_memory:native_heap:propo
rtional_resident_size': |
| 2639 { |
| 2640 value: [0, 0, 0, 0], |
| 2641 unit: sizeInBytes_smallerIsBetter, |
| 2642 description: 'proportional resident size (PSS) of the native heap ' + |
| 2643 'in all processes in WebView' |
| 2644 }, |
| 2645 'memory:webview:all_processes:reported_by_os:system_memory:private_dirty_siz
e': |
| 2646 { |
| 2647 value: [0, 0, 0, 0], |
| 2648 unit: sizeInBytes_smallerIsBetter, |
| 2649 description: 'total private dirty size of system memory (RAM) used ' + |
| 2650 'by all processes in WebView' |
| 2651 }, |
| 2652 'memory:webview:all_processes:reported_by_os:system_memory:proportional_resi
dent_size': |
| 2653 { |
| 2654 value: [0, 0, 0, 0], |
| 2655 unit: sizeInBytes_smallerIsBetter, |
| 2656 description: 'total proportional resident size (PSS) of system ' + |
| 2657 'memory (RAM) used by all processes in WebView' |
| 2658 }, |
| 2659 'memory:webview:browser_process:process_count': { |
| 2660 value: [1, 1, 1, 1], |
| 2661 unit: unitlessNumber_smallerIsBetter, |
| 2662 description: 'total number of browser processes in WebView' |
| 2663 }, |
| 2664 'memory:webview:browser_process:reported_by_os:private_dirty_size': { |
| 2665 value: [0, 0, 0, 0], |
| 2666 unit: sizeInBytes_smallerIsBetter, |
| 2667 description: 'total private dirty size reported by the OS for the ' + |
| 2668 'browser process in WebView' |
| 2669 }, |
| 2670 'memory:webview:browser_process:reported_by_os:proportional_resident_size': |
| 2671 { |
| 2672 value: [0, 0, 0, 0], |
| 2673 unit: sizeInBytes_smallerIsBetter, |
| 2674 description: 'total proportional resident size (PSS) reported by ' + |
| 2675 'the OS for the browser process in WebView' |
| 2676 }, |
| 2677 'memory:webview:browser_process:reported_by_os:system_memory:ashmem:private_
dirty_size': |
| 2678 { |
| 2679 value: [0, 0, 0, 0], |
| 2680 unit: sizeInBytes_smallerIsBetter, |
| 2681 description: 'private dirty size of ashmem in the browser process ' + |
| 2682 'in WebView' |
| 2683 }, |
| 2684 'memory:webview:browser_process:reported_by_os:system_memory:ashmem:proporti
onal_resident_size': |
| 2685 { |
| 2686 value: [0, 0, 0, 0], |
| 2687 unit: sizeInBytes_smallerIsBetter, |
| 2688 description: 'proportional resident size (PSS) of ashmem in the ' + |
| 2689 'browser process in WebView' |
| 2690 }, |
| 2691 'memory:webview:browser_process:reported_by_os:system_memory:java_heap:priva
te_dirty_size': |
| 2692 { |
| 2693 value: [0, 0, 0, 0], |
| 2694 unit: sizeInBytes_smallerIsBetter, |
| 2695 description: 'private dirty size of the Java heap in the browser ' + |
| 2696 'process in WebView' |
| 2697 }, |
| 2698 'memory:webview:browser_process:reported_by_os:system_memory:java_heap:propo
rtional_resident_size': |
| 2699 { |
| 2700 value: [0, 0, 0, 0], |
| 2701 unit: sizeInBytes_smallerIsBetter, |
| 2702 description: 'proportional resident size (PSS) of the Java heap in ' + |
| 2703 'the browser process in WebView' |
| 2704 }, |
| 2705 'memory:webview:browser_process:reported_by_os:system_memory:native_heap:pri
vate_dirty_size': |
| 2706 { |
| 2707 value: [0, 0, 0, 0], |
| 2708 unit: sizeInBytes_smallerIsBetter, |
| 2709 description: 'private dirty size of the native heap in the browser ' + |
| 2710 'process in WebView' |
| 2711 }, |
| 2712 'memory:webview:browser_process:reported_by_os:system_memory:native_heap:pro
portional_resident_size': |
| 2713 { |
| 2714 value: [0, 0, 0, 0], |
| 2715 unit: sizeInBytes_smallerIsBetter, |
| 2716 description: 'proportional resident size (PSS) of the native heap ' + |
| 2717 'in the browser process in WebView' |
| 2718 }, |
| 2719 'memory:webview:browser_process:reported_by_os:system_memory:private_dirty_s
ize': |
| 2720 { |
| 2721 value: [0, 0, 0, 0], |
| 2722 unit: sizeInBytes_smallerIsBetter, |
| 2723 description: 'total private dirty size of system memory (RAM) used ' + |
| 2724 'by the browser process in WebView' |
| 2725 }, |
| 2726 'memory:webview:browser_process:reported_by_os:system_memory:proportional_re
sident_size': |
| 2727 { |
| 2728 value: [0, 0, 0, 0], |
| 2729 unit: sizeInBytes_smallerIsBetter, |
| 2730 description: 'total proportional resident size (PSS) of system ' + |
| 2731 'memory (RAM) used by the browser process in WebView' |
| 2732 }, |
| 2733 |
| 2734 'memory:unknown_browser:all_processes:dump_count': { |
| 2735 value: 1, |
| 2736 unit: unitlessNumber_smallerIsBetter, |
| 2737 description: 'total number of all memory dumps added by an unknown ' + |
| 2738 'browser to the trace' |
| 2739 }, |
| 2740 'memory:unknown_browser:all_processes:dump_count:detailed': { |
| 2741 value: 0, |
| 2742 unit: unitlessNumber_smallerIsBetter, |
| 2743 description: 'total number of detailed memory dumps added by an ' + |
| 2744 'unknown browser to the trace' |
| 2745 }, |
| 2746 'memory:unknown_browser:all_processes:dump_count:light': { |
| 2747 value: 1, |
| 2748 unit: unitlessNumber_smallerIsBetter, |
| 2749 description: 'total number of light memory dumps added by an unknown ' + |
| 2750 'browser to the trace' |
| 2751 } |
| 2752 }); |
| 2753 |
| 2457 test('dumpIdBrowserClashThrows', function() { | 2754 test('dumpIdBrowserClashThrows', function() { |
| 2458 var model = tr.c.TestUtils.newModel(function(model) { | 2755 var model = tr.c.TestUtils.newModel(function(model) { |
| 2459 var pWebView = createWebViewProcess(model); | 2756 var pWebView = createWebViewProcess(model); |
| 2460 var pChrome = createChromeBrowserProcess(model); | 2757 var pChrome = createChromeBrowserProcess(model); |
| 2461 | 2758 |
| 2462 var gmd = addGlobalMemoryDump(model, 10); | 2759 var gmd = addGlobalMemoryDump(model, {ts: 10}); |
| 2463 addProcessMemoryDump(gmd, pWebView, 9); | 2760 addProcessMemoryDump(gmd, pWebView, {ts: 9}); |
| 2464 addProcessMemoryDump(gmd, pChrome, 11); | 2761 addProcessMemoryDump(gmd, pChrome, {ts: 11}); |
| 2465 }); | 2762 }); |
| 2466 var values = new tr.v.ValueSet(); | 2763 var values = new tr.v.ValueSet(); |
| 2467 | 2764 |
| 2468 assert.throws(function() { | 2765 assert.throws(function() { |
| 2469 tr.metrics.sh.memoryMetric(values, model); | 2766 tr.metrics.sh.memoryMetric(values, model); |
| 2470 }, 'Memory dump ID clash across multiple browsers with PIDs: 1 and 2'); | 2767 }, 'Memory dump ID clash across multiple browsers with PIDs: 1 and 2'); |
| 2471 }); | 2768 }); |
| 2472 }); | 2769 }); |
| 2473 </script> | 2770 </script> |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2162963002:
[polymer] Merge of master into polymer10-migration (Closed)
Base URL: git@github.com:catapult-project/catapult.git@polymer10-migration