def CreateCoreTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
)
# 'toplevel' category provides CPU time slices used by # cpuTimeMetric.
category_filter.AddIncludedCategory('toplevel')
# 'rail' category is used by powerMetric to attribute different period of
# time to different activities, such as video_animation, etc.
category_filter.AddIncludedCategory('rail')
# Collect media related events required by mediaMetric.
category_filter.AddIncludedCategory('media')
# Collect memory data.
category_filter.AddDisabledByDefault(
'disabled-by-default-memory-infra')
options = timeline_based_measurement.Options(category_filter)
options.config.enable_battor_trace = True
options.config.enable_android_graphics_memtrack = True
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
options.SetTimelineBasedMetrics(
['powerMetric', 'mediaMetric', 'cpuTimeMetric', 'memoryMetric'])
return options
def CreateTimelineBasedMeasurementOptions(self):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
# EQT categories.
'blink.user_timing',
'loading',
'navigation',
'toplevel',
# V8 categories.
'blink.console',
'disabled-by-default-v8.compile',
'disabled-by-default-v8.gc',
'renderer.scheduler',
'v8',
'webkit.console'
]
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(categories))
options = timeline_based_measurement.Options(category_filter)
# TODO(ulan): Add frame time discrepancy once it is ported to TBMv2,
# see crbug.com/606841.
options.SetTimelineBasedMetrics(
['expectedQueueingTimeMetric', 'v8AndMemoryMetrics'])
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def CreateTimelineBasedMeasurementOptions(self):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
# UE categories requred by runtimeStatsTotalMetric to bucket
# runtimeStats by UE.
'rail',
# EQT categories.
'blink.user_timing',
'loading',
'navigation',
'toplevel',
# V8 categories.
'blink.console',
'disabled-by-default-v8.gc',
'renderer.scheduler',
'v8',
'webkit.console',
'disabled-by-default-v8.runtime_stats',
]
options = timeline_based_measurement.Options(
chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(categories)))
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.SetTimelineBasedMetrics([
'expectedQueueingTimeMetric', 'runtimeStatsTotalMetric', 'gcMetric'])
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
categories = [
# Implicitly disable all categories.
'-*',
# V8.
'blink.console',
'disabled-by-default-v8.gc',
'renderer.scheduler',
'v8',
'webkit.console',
# Smoothness.
'benchmark',
'blink',
'blink.console',
'trace_event_overhead',
'webkit.console',
# Memory.
'blink.console',
'disabled-by-default-memory-infra'
]
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(categories))
options = timeline_based_measurement.Options(category_filter)
options.SetTimelineBasedMetrics([
'gcMetric', 'memoryMetric', 'responsivenessMetric'])
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def CreateTimelineBasedMeasurementOptions(self):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
# EQT categories.
'blink.user_timing',
'loading',
'navigation',
'toplevel',
# V8 categories.
'blink.console',
'disabled-by-default-v8.compile',
'disabled-by-default-v8.gc',
'renderer.scheduler',
'v8',
'webkit.console',
# TODO(crbug.com/616441, primiano): Remove this temporary workaround,
# which enables memory-infra V8 code stats in V8 code size benchmarks
# only (to not slow down detailed memory dumps in other benchmarks).
'disabled-by-default-memory-infra.v8.code_stats',
]
options = timeline_based_measurement.Options(
chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(categories)))
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.SetTimelineBasedMetrics([
'expectedQueueingTimeMetric', 'v8AndMemoryMetrics'])
return options
def testMemoryDumpConfigFormat(self):
config = chrome_trace_config.ChromeTraceConfig()
config.record_mode = chrome_trace_config.ECHO_TO_CONSOLE
dump_config = chrome_trace_config.MemoryDumpConfig()
config.SetMemoryDumpConfig(dump_config)
# Trace config for startup tracing.
self.assertEquals(
{
'memory_dump_config': {
'triggers': []
},
'record_mode': 'trace-to-console'
}, config.GetChromeTraceConfigForStartupTracing())
# Trace config for DevTools (modern API).
self.assertEquals(
{
'memoryDumpConfig': {
'triggers': []
},
'recordMode': 'traceToConsole'
}, config.GetChromeTraceConfigForDevTools())
dump_config.AddTrigger('light', 250)
dump_config.AddTrigger('detailed', 2000)
# Trace config for startup tracing.
self.assertEquals(
{
'memory_dump_config': {
'triggers': [{
'mode': 'light',
'periodic_interval_ms': 250
}, {
'mode': 'detailed',
'periodic_interval_ms': 2000
}]
},
'record_mode': 'trace-to-console'
}, config.GetChromeTraceConfigForStartupTracing())
# Trace config for DevTools (modern API).
self.assertEquals(
{
'memoryDumpConfig': {
'triggers': [{
'mode': 'light',
'periodicIntervalMs': 250
}, {
'mode': 'detailed',
'periodicIntervalMs': 2000
}]
},
'recordMode': 'traceToConsole'
}, config.GetChromeTraceConfigForDevTools())
def AugmentOptionsForV8Metrics(options, enable_runtime_call_stats=True):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
'toplevel',
# V8 categories.
'cppgc',
'disabled-by-default-cppgc',
'disabled-by-default-v8.gc',
'v8',
'v8.wasm',
'v8.console',
'webkit.console',
# Blink categories.
'blink.resource',
'blink_gc',
'partition_alloc',
# Needed for the metric reported by page.
'blink.user_timing'
]
options.ExtendTraceCategoryFilter(categories)
if enable_runtime_call_stats:
options.AddTraceCategoryFilter('disabled-by-default-v8.runtime_stats')
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
# On low-end devices there's not enough memory to hold 400Mb buffer (See
# crbug.com/1218139).
device_memory = GetDeviceTotalMemory()
if device_memory and device_memory < LOW_END_DEVICE_MEMORY_KB:
options.config.chrome_trace_config.SetTraceBufferSizeInKb(200 * 1024)
else:
options.config.chrome_trace_config.SetTraceBufferSizeInKb(400 * 1024)
metrics = [
'blinkGcMetric',
'blinkResourceMetric',
'consoleErrorMetric',
'expectedQueueingTimeMetric',
'gcMetric',
'memoryMetric',
'pcscanMetric',
'reportedByPageMetric',
'wasmMetric',
]
options.ExtendTimelineBasedMetric(metrics)
if enable_runtime_call_stats:
options.AddTimelineBasedMetric('runtimeStatsTotalMetric')
return options
def testMemoryDumpConfigFormat(self):
config = chrome_trace_config.ChromeTraceConfig()
config.record_mode = chrome_trace_config.ECHO_TO_CONSOLE
dump_config = chrome_trace_config.MemoryDumpConfig()
config.SetMemoryDumpConfig(dump_config)
# Trace config for startup tracing.
self.assertEquals({
'enable_systrace': False,
'memory_dump_config': {'triggers': []},
'record_mode': 'trace-to-console'
}, config.GetChromeTraceConfigForStartupTracing())
# Trace config for DevTools (modern API).
self.assertEquals({
'enableSystrace': False,
'memoryDumpConfig': {'triggers': []},
'recordMode': 'traceToConsole'
}, config.GetChromeTraceConfigForDevTools())
# Trace categories and options for DevTools (legacy API).
self.assertTrue(config.requires_modern_devtools_tracing_start_api)
with self.assertRaises(AssertionError):
config.GetChromeTraceCategoriesAndOptionsForDevTools()
dump_config.AddTrigger('light', 250)
dump_config.AddTrigger('detailed', 2000)
# Trace config for startup tracing.
self.assertEquals({
'enable_systrace': False,
'memory_dump_config': {
'triggers': [
{'mode': 'light', 'periodic_interval_ms': 250},
{'mode': 'detailed', 'periodic_interval_ms': 2000}
]
},
'record_mode': 'trace-to-console'
}, config.GetChromeTraceConfigForStartupTracing())
# Trace config for DevTools (modern API).
self.assertEquals({
'enableSystrace': False,
'memoryDumpConfig': {
'triggers': [
{'mode': 'light', 'periodicIntervalMs': 250},
{'mode': 'detailed', 'periodicIntervalMs': 2000}
]
},
'recordMode': 'traceToConsole'
}, config.GetChromeTraceConfigForDevTools())
# Trace categories and options for DevTools (legacy API).
self.assertTrue(config.requires_modern_devtools_tracing_start_api)
with self.assertRaises(AssertionError):
config.GetChromeTraceCategoriesAndOptionsForDevTools()
def CreateCoreTimelineBasedMeasurementOptions(self):
tbm_options = timeline_based_measurement.Options(
chrome_trace_category_filter.ChromeTraceCategoryFilter(
'-*,disabled-by-default-memory-infra'))
# Setting an empty memory dump config disables periodic dumps.
tbm_options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
# Set required tracing categories for leak detection
tbm_options.AddTimelineBasedMetric('leakDetectionMetric')
return tbm_options
def CreateTimelineBasedMeasurementOptions(self):
options = timeline_based_measurement.Options(
chrome_trace_category_filter.ChromeTraceCategoryFilter(
'-*,disabled-by-default-memory-infra'))
options.config.enable_android_graphics_memtrack = True
options.SetTimelineBasedMetrics(['memoryMetric'])
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
# Enable only memory-infra category with periodic background mode dumps
# every 200 milliseconds.
trace_memory = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='-*,blink.console,disabled-by-default-memory-infra')
options = timeline_based_measurement.Options(overhead_level=trace_memory)
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('background', 200)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.SetTimelineBasedMetrics(['tracingMetric'])
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='-*,disabled-by-default-memory-infra')
# Needed for the console error metric.
cat_filter.AddIncludedCategory('v8.console')
options = timeline_based_measurement.Options(cat_filter)
options.config.enable_android_graphics_memtrack = True
options.SetTimelineBasedMetrics(['consoleErrorMetric', 'memoryMetric'])
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
v8_categories = [
'blink.console', 'renderer.scheduler', 'v8', 'webkit.console']
memory_categories = ['blink.console', 'disabled-by-default-memory-infra']
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(['-*'] + v8_categories + memory_categories))
options = timeline_based_measurement.Options(category_filter)
options.SetTimelineBasedMetrics(['v8AndMemoryMetrics'])
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def _get_memory_usage(self):
"""Helper function to get the memory usage.
It returns a tuple of six elements:
(browser_usage, renderer_usage, gpu_usage, kernel_usage,
total_usage, graphics_usage)
All are expected in the unit of KB.
browser_usage: the RSS of the browser process
renderer_usage: the total RSS of all renderer processes
gpu_usage: the total RSS of all gpu processes
kernel_usage: the memory used in kernel
total_usage: the sum of the above memory usages. The graphics_usage is
not included because the composition of the graphics
memory is much more complicated (could be from video card,
user space, or kenerl space). It doesn't make so much
sense to sum it up with others.
graphics_usage: the memory usage reported by the graphics driver
"""
config = tracing_config.TracingConfig()
config.chrome_trace_config.category_filter.AddExcludedCategory("*")
config.chrome_trace_config.category_filter.AddDisabledByDefault(
"disabled-by-default-memory-infra")
config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
config.enable_chrome_trace = True
self.browser.platform.tracing_controller.StartTracing(config)
# Force to collect garbage before measuring memory
for t in self.browser.tabs:
t.CollectGarbage()
self.browser.DumpMemory()
trace_data = self.browser.platform.tracing_controller.StopTracing()[0]
model = TimelineModel(trace_data)
memory_dump = model.IterGlobalMemoryDumps().next()
process_memory = collections.defaultdict(int)
for process_memory_dump in memory_dump.IterProcessMemoryDumps():
process_name = process_memory_dump.process_name
process_memory[process_name] += sum(
process_memory_dump.GetMemoryUsage().values())
result = (process_memory[KEY_BROWSER] / 1024,
process_memory[KEY_RENDERER] / 1024,
process_memory[KEY_GPU] / 1024,
_get_kernel_memory_usage())
# total = browser + renderer + gpu + kernal
result += (sum(result), _get_graphics_memory_usage())
return result
def CreateCoreTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
for category in self.COMMON_TRACE_CATEGORIES:
category_filter.AddFilter(category)
options = timeline_based_measurement.Options(category_filter)
options.config.enable_android_graphics_memtrack = True
options.config.enable_platform_display_trace = True
options.SetTimelineBasedMetrics(['frameCycleDurationMetric',
'memoryMetric'])
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def CreateTimelineBasedMeasurementOptions(self):
# Enable only memory-infra, to get memory dumps, and blink.console, to get
# the timeline markers used for mapping threads to tabs.
trace_memory = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='-*,blink.console,disabled-by-default-memory-infra')
tbm_options = timeline_based_measurement.Options(
overhead_level=trace_memory)
tbm_options.config.enable_android_graphics_memtrack = True
tbm_options.SetTimelineBasedMetrics(['memoryMetric'])
# Setting an empty memory dump config disables periodic dumps.
tbm_options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return tbm_options
def AugmentOptionsForV8BrowsingMetrics(options,
enable_runtime_call_stats=True):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
# UE categories required by runtimeStatsTotalMetric to bucket
# runtimeStats by UE.
'rail',
# EQT categories.
'blink.user_timing',
'loading',
'navigation',
'toplevel',
# V8 categories.
'disabled-by-default-v8.gc',
'renderer.scheduler',
'v8',
'v8.console',
'webkit.console',
# TODO(crbug.com/616441, primiano): Remove this temporary workaround,
# which enables memory-infra V8 code stats in V8 code size benchmarks
# only (to not slow down detailed memory dumps in other benchmarks).
'disabled-by-default-memory-infra.v8.code_stats',
# Blink categories.
'blink_gc',
]
options.ExtendTraceCategoryFilter(categories)
if enable_runtime_call_stats:
options.AddTraceCategoryFilter('disabled-by-default-v8.runtime_stats')
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.config.chrome_trace_config.SetTraceBufferSizeInKb(400 * 1024)
metrics = [
'blinkGcMetric',
'consoleErrorMetric',
'expectedQueueingTimeMetric',
'gcMetric',
'memoryMetric',
]
options.ExtendTimelineBasedMetric(metrics)
if enable_runtime_call_stats:
options.AddTimelineBasedMetric('runtimeStatsTotalMetric')
return options
def CreateTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
'-*, disabled-by-default-memory-infra,'
# TODO(crbug.com/616441, primiano): Remove this temporary workaround,
# which enables memory-infra V8 code stats in V8 code size benchmarks
# only (to not slow down detailed memory dumps in other benchmarks).
'disabled-by-default-memory-infra.v8.code_stats')
options = timeline_based_measurement.Options(category_filter)
# Trigger periodic light memory dumps every 20 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 20)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.SetTimelineBasedMetric('memoryMetric')
return options
def AugmentOptionsForV8BrowsingMetrics(options,
enable_runtime_call_stats=True):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
'toplevel',
# V8 categories.
'disabled-by-default-v8.gc',
'v8',
'v8.wasm',
'v8.console',
'webkit.console',
# Blink categories.
'blink_gc',
'partition_alloc',
# Needed for the metric reported by page.
'blink.user_timing'
]
options.ExtendTraceCategoryFilter(categories)
if enable_runtime_call_stats:
options.AddTraceCategoryFilter('disabled-by-default-v8.runtime_stats')
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.config.chrome_trace_config.SetTraceBufferSizeInKb(400 * 1024)
options.config.chrome_trace_config.EnableUMAHistograms(
*V8_BROWSING_BENCHMARK_UMA)
metrics = [
'blinkGcMetric',
'consoleErrorMetric',
'expectedQueueingTimeMetric',
'gcMetric',
'memoryMetric',
'reportedByPageMetric',
'umaMetric',
'wasmMetric',
]
options.ExtendTimelineBasedMetric(metrics)
if enable_runtime_call_stats:
options.AddTimelineBasedMetric('runtimeStatsTotalMetric')
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
memory_categories = ['blink.console', 'disabled-by-default-memory-infra']
gpu_categories = ['gpu']
debug_categories = ['toplevel', 'viz']
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(['-*'] + memory_categories + gpu_categories
+ debug_categories))
options = timeline_based_measurement.Options(category_filter)
options.config.enable_android_graphics_memtrack = True
options.config.enable_platform_display_trace = True
options.SetTimelineBasedMetrics(['memoryMetric', 'webvrMetric'])
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='-*,toplevel,rail,disabled-by-default-memory-infra')
options = timeline_based_measurement.Options(cat_filter)
options.SetTimelineBasedMetrics([
'cpuTimeMetric',
'loadingMetric',
'memoryMetric',
'tracingMetric',
])
loading_metrics_category.AugmentOptionsForLoadingMetrics(options)
# Disable periodic dumps by setting default config.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def testDumpMemorySuccess(self):
# Check that dumping memory before tracing starts raises an exception.
self.assertRaises(Exception, self._browser.DumpMemory)
# Start tracing with memory dumps enabled.
config = tracing_config.TracingConfig()
config.chrome_trace_config.category_filter.AddDisabledByDefault(
'disabled-by-default-memory-infra')
config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
config.enable_chrome_trace = True
self._tracing_controller.StartTracing(config)
# Request several memory dumps in a row and test that they were all
# successfully created with unique IDs.
expected_dump_ids = []
for _ in xrange(self._REQUESTED_DUMP_COUNT):
dump_id = self._browser.DumpMemory()
self.assertIsNotNone(dump_id)
self.assertNotIn(dump_id, expected_dump_ids)
expected_dump_ids.append(dump_id)
tracing_data = self._tracing_controller.StopTracing()
# Check that clock sync data is in tracing data.
clock_sync_found = False
trace_handles = tracing_data.GetTracesFor(trace_data.CHROME_TRACE_PART)
self.assertEqual(len(trace_handles), 1)
with open(trace_handles[0].file_path) as f:
trace = json.load(f)
for event in trace['traceEvents']:
if event['name'] == 'clock_sync' or 'ClockSyncEvent' in event[
'name']:
clock_sync_found = True
break
self.assertTrue(clock_sync_found)
# Check that dumping memory after tracing stopped raises an exception.
self.assertRaises(Exception, self._browser.DumpMemory)
# Test that trace data is parsable.
model = model_module.TimelineModel(tracing_data)
self.assertGreater(len(model.processes), 0)
# Test that the resulting model contains the requested memory dumps in the
# correct order (and nothing more).
actual_dump_ids = [d.dump_id for d in model.IterGlobalMemoryDumps()]
self.assertEqual(actual_dump_ids, expected_dump_ids)
def CreateCoreTimelineBasedMemoryMeasurementOptions():
"""Creates necessary TBM options for measuring memory usage.
Separated out so that code can be re-used in other benchmarks.
"""
# Enable only memory-infra, to get memory dumps, and blink.console, to get
# the timeline markers used for mapping threads to tabs.
trace_memory = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='-*,blink.console,disabled-by-default-memory-infra')
tbm_options = timeline_based_measurement.Options(
overhead_level=trace_memory)
tbm_options.config.enable_android_graphics_memtrack = True
tbm_options.SetTimelineBasedMetrics(['memoryMetric'])
# Setting an empty memory dump config disables periodic dumps.
tbm_options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return tbm_options
def CreateTimelineBasedMeasurementOptions(self):
v8_categories = [
'blink.console', 'disabled-by-default-v8.gc',
'renderer.scheduler', 'v8', 'webkit.console']
smoothness_categories = [
'webkit.console', 'blink.console', 'benchmark', 'trace_event_overhead']
memory_categories = ['blink.console', 'disabled-by-default-memory-infra']
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(['-*'] + v8_categories +
smoothness_categories + memory_categories))
options = timeline_based_measurement.Options(category_filter)
# TODO(ulan): Add frame time discrepancy once it is ported to TBMv2,
# see crbug.com/606841.
options.SetTimelineBasedMetrics(['v8AndMemoryMetrics'])
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
return options
def AugmentOptionsForV8BrowsingMetrics(options,
enable_runtime_call_stats=True):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
'toplevel',
# V8 categories.
'disabled-by-default-v8.gc',
'v8',
'v8.console',
'webkit.console',
# Blink categories.
'blink_gc',
]
options.ExtendTraceCategoryFilter(categories)
if enable_runtime_call_stats:
options.AddTraceCategoryFilter('disabled-by-default-v8.runtime_stats')
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.config.chrome_trace_config.SetTraceBufferSizeInKb(400 * 1024)
metrics = [
'blinkGcMetric',
'consoleErrorMetric',
'expectedQueueingTimeMetric',
'gcMetric',
'memoryMetric',
]
options.ExtendTimelineBasedMetric(metrics)
if enable_runtime_call_stats:
options.AddTimelineBasedMetric('runtimeStatsTotalMetric')
return options
def CreateTimelineBasedMeasurementOptions(self):
categories = [
# Disable all categories by default.
'-*',
# Memory categories.
'disabled-by-default-memory-infra',
# V8 categories.
'blink.console',
'disabled-by-default-v8.gc',
'renderer.scheduler',
'v8',
'webkit.console',
]
options = timeline_based_measurement.Options(
chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(categories)))
options.config.enable_android_graphics_memtrack = True
# Trigger periodic light memory dumps every 1000 ms.
memory_dump_config = chrome_trace_config.MemoryDumpConfig()
memory_dump_config.AddTrigger('light', 1000)
options.config.chrome_trace_config.SetMemoryDumpConfig(memory_dump_config)
options.SetTimelineBasedMetrics(['v8AndMemoryMetrics'])
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
# 'toplevel' category provides CPU time slices used by # cpuTimeMetric.
category_filter.AddIncludedCategory('toplevel')
# Collect media related events required by mediaMetric.
category_filter.AddIncludedCategory('media')
# Collect memory data.
category_filter.AddDisabledByDefault('disabled-by-default-memory-infra')
options = timeline_based_measurement.Options(category_filter)
options.config.enable_android_graphics_memtrack = True
# Setting an empty memory dump config disables periodic dumps.
options.config.chrome_trace_config.SetMemoryDumpConfig(
chrome_trace_config.MemoryDumpConfig())
# Note that memoryMetric is added using GetExtraTracingMetrics() for
# certain stories.
options.SetTimelineBasedMetrics(['mediaMetric', 'cpuTimeMetric'])
return options
