def testNoneAndEmptyCategory(self):
a = chrome_trace_category_filter.ChromeTraceCategoryFilter()
self.assertEquals(a.stable_filter_string, '')
self.assertEquals(a.filter_string, '')
self.assertEquals(str(a.GetDictForChromeTracing()), '{}')
# Initializing chrome trace category filter with empty string is the same
# as initialization with None.
b = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='')
self.assertEquals(b.stable_filter_string, '')
self.assertEquals(b.filter_string, '')
self.assertEquals(str(b.GetDictForChromeTracing()), '{}')
def testBasic(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
'x,-y,disabled-by-default-z,DELAY(7;foo)')
config = chrome_trace_config.ChromeTraceConfig()
config.SetCategoryFilter(category_filter)
config.record_mode = chrome_trace_config.RECORD_UNTIL_FULL
# Trace config for startup tracing.
self.assertEquals({
'excluded_categories': ['y'],
'included_categories': ['x', 'disabled-by-default-z'],
'record_mode': 'record-until-full',
'synthetic_delays': ['DELAY(7;foo)']
}, config.GetChromeTraceConfigForStartupTracing())
# Trace config for DevTools (modern API).
self.assertEquals({
'excludedCategories': ['y'],
'includedCategories': ['x', 'disabled-by-default-z'],
'recordMode': 'recordUntilFull',
'syntheticDelays': ['DELAY(7;foo)']
}, config.GetChromeTraceConfigForDevTools())
# Trace categories and options for DevTools (legacy API).
self.assertFalse(config.requires_modern_devtools_tracing_start_api)
self.assertEquals(
('x,disabled-by-default-z,-y,DELAY(7;foo)',
'record-until-full'),
config.GetChromeTraceCategoriesAndOptionsForDevTools())
def CreateCoreTimelineBasedMeasurementOptions(self):
if not self.enable_systrace:
return timeline_based_measurement.Options()
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
# "blink.console" is used for marking ranges in
# cache_temperature.MarkTelemetryInternal.
cat_filter.AddIncludedCategory('blink.console')
# "toplevel" category is used to capture TaskQueueManager events.
cat_filter.AddIncludedCategory('toplevel')
if self.extra_chrome_categories:
cat_filter.AddFilterString(self.extra_chrome_categories)
if self.enable_rcs:
# V8 needed categories
cat_filter.AddIncludedCategory('v8')
cat_filter.AddDisabledByDefault('disabled-by-default-v8.runtime_stats')
tbm_options = timeline_based_measurement.Options(
overhead_level=cat_filter)
tbm_options.SetTimelineBasedMetrics(['runtimeStatsTotalMetric'])
return tbm_options
tbm_options = timeline_based_measurement.Options(overhead_level=cat_filter)
tbm_options.SetTimelineBasedMetrics(['tracingMetric'])
return tbm_options
def CreateTimelineBasedMeasurementOptions(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'])
return options
def CreateTimelineBasedMeasurementOptions(self):
options = timeline_based_measurement.Options()
options.config.chrome_trace_config.SetCategoryFilter(
chrome_trace_category_filter.ChromeTraceCategoryFilter(','.join(
self.TRACING_CATEGORIES)))
options.SetTimelineBasedMetrics(['systemHealthMetrics'])
return options
def CreateTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='webrtc,webkit.console,blink.console')
options = timeline_based_measurement.Options(category_filter)
options.SetLegacyTimelineBasedMetrics(
[webrtc_rendering_timeline.WebRtcRenderingTimelineMetric()])
return options
def testAddFilter(self):
cf = chrome_trace_category_filter.ChromeTraceCategoryFilter()
cf.AddFilter('x')
cf.AddFilter('-y')
cf.AddFilter('disabled-by-default-z')
cf.AddFilter('DELAY(7;foo)')
self.CheckBasicCategoryFilters(cf)
def __init__(self):
self._record_mode = RECORD_AS_MUCH_AS_POSSIBLE
self._category_filter = (
chrome_trace_category_filter.ChromeTraceCategoryFilter())
self._memory_dump_config = None
self._enable_systrace = False
self._uma_histogram_names = []
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 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'])
return options
def CreateV8TimelineBasedMeasurementOptions():
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
category_filter.AddIncludedCategory('v8')
category_filter.AddIncludedCategory('blink.console')
options = timeline_based_measurement.Options(category_filter)
options.SetTimelineBasedMetric('executionMetric')
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
# TODO(fmeawad): most of the cat_filter information is extracted from
# page_cycler_v2 TimelineBasedMeasurementOptionsForLoadingMetric because
# used by the loadingMetric because the runtimeStatsMetric uses the
# interactive time calculated internally by the loadingMetric.
# It is better to share the code so that we can keep them in sync.
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
# "blink.console" is used for marking ranges in
# cache_temperature.MarkTelemetryInternal.
cat_filter.AddIncludedCategory('blink.console')
# "navigation" and "blink.user_timing" are needed to capture core
# navigation events.
cat_filter.AddIncludedCategory('navigation')
cat_filter.AddIncludedCategory('blink.user_timing')
# "loading" is needed for first-meaningful-paint computation.
cat_filter.AddIncludedCategory('loading')
# "toplevel" category is used to capture TaskQueueManager events
# necessary to compute time-to-interactive.
cat_filter.AddIncludedCategory('toplevel')
# V8 needed categories
cat_filter.AddIncludedCategory('v8')
cat_filter.AddDisabledByDefault('disabled-by-default-v8.runtime_stats')
tbm_options = timeline_based_measurement.Options(
overhead_level=cat_filter)
tbm_options.SetTimelineBasedMetrics(['runtimeStatsMetric'])
return tbm_options
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):
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
cat_filter.AddIncludedCategory(IDB_CATEGORY)
cat_filter.AddIncludedCategory(TIMELINE_REQUIRED_CATEGORY)
return timeline_based_measurement.Options(
overhead_level=cat_filter)
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 CreateCoreTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
)
category_filter.AddIncludedCategory('latency')
options = timeline_based_measurement.Options(category_filter)
options.SetTimelineBasedMetrics(['tabsMetric'])
return options
def testHeapProfilerForSmoke(self):
story_set = self.CreateEmptyPageSet()
story_set.AddStory(
TestTimelinebasedMeasurementPage(story_set,
story_set.base_dir,
measure_memory=True,
trigger_slow=True))
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='-*,disabled-by-default-memory-infra')
options = tbm_module.Options(overhead_level=cat_filter)
options.config.enable_chrome_trace = True
options.SetTimelineBasedMetrics(['memoryMetric'])
tbm = tbm_module.TimelineBasedMeasurement(options)
self._options.browser_options.AppendExtraBrowserArgs([
'--memlog=all', '--memlog-sampling', '--memlog-stack-mode=pseudo'
])
results = self.RunMeasurement(tbm,
story_set,
run_options=self._options)
self.assertFalse(results.had_failures)
DUMP_COUNT_METRIC = 'memory:chrome:all_processes:dump_count'
dumps_detailed = results.FindAllPageSpecificValuesNamed(
DUMP_COUNT_METRIC + ':detailed_avg')
dumps_heap_profiler = results.FindAllPageSpecificValuesNamed(
DUMP_COUNT_METRIC + ':heap_profiler_avg')
self.assertEquals(1, len(dumps_detailed))
self.assertEquals(1, len(dumps_heap_profiler))
self.assertGreater(dumps_detailed[0].value, 0)
self.assertEquals(dumps_detailed[0].value,
dumps_heap_profiler[0].value)
def CreateCoreTimelineBasedMeasurementOptions(self):
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='rail,toplevel,uma')
cat_filter.AddIncludedCategory('accessibility')
# Needed for the metric reported by page.
cat_filter.AddIncludedCategory('blink.user_timing')
# Needed for the console error metric.
cat_filter.AddIncludedCategory('v8.console')
options = timeline_based_measurement.Options(cat_filter)
options.config.enable_chrome_trace = True
options.config.enable_cpu_trace = True
options.config.chrome_trace_config.EnableUMAHistograms(
*SYSTEM_HEALTH_BENCHMARK_UMA)
options.SetTimelineBasedMetrics([
'accessibilityMetric',
'consoleErrorMetric',
'cpuTimeMetric',
'limitedCpuTimeMetric',
'reportedByPageMetric',
'tracingMetric',
'umaMetric',
# Unless --experimentatil-tbmv3-metric flag is used, the following tbmv3
# metrics do nothing.
'tbmv3:accessibility_metric',
'tbmv3:cpu_time_metric',
])
loading_metrics_category.AugmentOptionsForLoadingMetrics(options)
# The EQT metric depends on the same categories as the loading metric.
options.AddTimelineBasedMetric('expectedQueueingTimeMetric')
return options
def testFirstPaintMetricSmoke(self):
ps = self.CreateEmptyPageSet()
ps.AddStory(TestTimelinebasedMeasurementPage(ps, ps.base_dir))
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='*,blink.console,navigation,blink.user_timing,loading,' +
'devtools.timeline,disabled-by-default-blink.debug.layout')
options = tbm_module.Options(overhead_level=cat_filter)
options.SetTimelineBasedMetrics(['loadingMetric'])
tbm = tbm_module.TimelineBasedMeasurement(options)
results = self.RunMeasurement(tbm, ps, self._options)
self.assertEquals(0, len(results.failures), results.failures)
v_ttfcp_max = results.FindAllPageSpecificValuesNamed(
'timeToFirstContentfulPaint_max')
self.assertEquals(len(v_ttfcp_max), 1)
self.assertIsNotNone(v_ttfcp_max[0].page)
self.assertGreater(v_ttfcp_max[0].value, 0)
v_ttfmp_max = results.FindAllPageSpecificValuesNamed(
'timeToFirstMeaningfulPaint_max')
self.assertEquals(len(v_ttfmp_max), 1)
self.assertIsNotNone(v_ttfmp_max[0].page)
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):
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
# "blink.console" is used for marking ranges in
# cache_temperature.MarkTelemetryInternal.
cat_filter.AddIncludedCategory('blink.console')
# "navigation" and "blink.user_timing" are needed to capture core
# navigation events.
cat_filter.AddIncludedCategory('navigation')
cat_filter.AddIncludedCategory('blink.user_timing')
# "loading" is needed for first-meaningful-paint computation.
cat_filter.AddIncludedCategory('loading')
# "toplevel" category is used to capture TaskQueueManager events
# necessary to compute time-to-interactive.
cat_filter.AddIncludedCategory('toplevel')
# V8 needed categories
cat_filter.AddIncludedCategory('v8')
cat_filter.AddDisabledByDefault('disabled-by-default-v8.runtime_stats')
tbm_options = timeline_based_measurement.Options(
overhead_level=cat_filter)
tbm_options.SetTimelineBasedMetrics(['runtimeStatsMetric'])
return tbm_options
def testIncludeAndExcludeCategoryRaisesAssertion(self):
a = chrome_trace_category_filter.ChromeTraceCategoryFilter()
a.AddIncludedCategory('foo')
self.assertRaises(AssertionError, a.AddExcludedCategory, 'foo')
a = chrome_trace_category_filter.ChromeTraceCategoryFilter()
a.AddExcludedCategory('foo')
self.assertRaises(AssertionError, a.AddIncludedCategory, 'foo')
self.assertRaises(
AssertionError,
chrome_trace_category_filter.ChromeTraceCategoryFilter, 'foo,-foo')
self.assertRaises(
AssertionError,
chrome_trace_category_filter.ChromeTraceCategoryFilter, '-foo,foo')
def CreateV8TimelineBasedMeasurementOptions():
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
category_filter.AddIncludedCategory('v8')
category_filter.AddIncludedCategory('blink.console')
category_filter.AddDisabledByDefault('disabled-by-default-v8.compile')
options = timeline_based_measurement.Options(category_filter)
options.SetTimelineBasedMetrics(['executionMetric'])
return options
def CreateTimelineBasedMeasurementOptions(self):
custom_categories = ['gpu', 'toplevel', 'viz']
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
','.join(custom_categories))
options = timeline_based_measurement.Options(category_filter)
options.config.enable_platform_display_trace = True
options.SetTimelineBasedMetrics(['frameCycleDurationMetric'])
return options
def CreateTimelineBasedMeasurementOptions(self):
cat_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter()
cat_filter.AddIncludedCategory(JITTER_CATEGORY)
cat_filter.AddIncludedCategory(TIMELINE_REQUIRED_CATEGORY)
options = timeline_based_measurement.Options(overhead_level=cat_filter)
options.SetLegacyTimelineBasedMetrics(
[jitter_timeline.JitterTimelineMetric()])
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='toplevel')
options = timeline_based_measurement.Options(category_filter)
options.config.enable_chrome_trace = True
options.config.enable_cpu_trace = True
options.SetTimelineBasedMetrics(['cpuTimeMetric'])
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='uma')
options = timeline_based_measurement.Options(category_filter)
# Add more buffer since we are opening a lot of tabs.
options.config.chrome_trace_config.SetTraceBufferSizeInKb(600 * 1024)
options.SetTimelineBasedMetrics(['umaMetric'])
return options
def CreateTimelineBasedMeasurementOptions(self):
options = timeline_based_measurement.Options(
chrome_trace_category_filter.ChromeTraceCategoryFilter())
options.config.chrome_trace_config.category_filter.AddFilterString(
'rail')
options.config.enable_battor_trace = True
options.config.enable_chrome_trace = True
return options
def CreateCoreTimelineBasedMeasurementOptions(self):
startup_category_filter = (
chrome_trace_category_filter.ChromeTraceCategoryFilter(
filter_string='startup,blink.user_timing'))
options = timeline_based_measurement.Options(
overhead_level=startup_category_filter)
options.SetLegacyTimelineBasedMetrics(
[startup.StartupTimelineMetric()])
return options
def CreateTimelineBasedMeasurementOptions(self):
media_router_category = 'media_router'
category_filter = chrome_trace_category_filter.ChromeTraceCategoryFilter(
media_router_category)
category_filter.AddIncludedCategory('blink.console')
options = timeline_based_measurement.Options(category_filter)
options.SetLegacyTimelineBasedMetrics([
media_router_timeline_metric.MediaRouterMetric()])
return options
