tools/perf/benchmarks/smoothness.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 from core import perf_benchmark
   6
   7 from benchmarks import silk_flags
   8 from benchmarks import webgl_expectations
   9 from measurements import smoothness
  10 from telemetry import benchmark
  11 import page_sets
  12
  13
  14 class SmoothnessTop25(perf_benchmark.PerfBenchmark):
  15   """Measures rendering statistics while scrolling down the top 25 web pages.
  16
  17   http://www.chromium.org/developers/design-documents/rendering-benchmarks
  18   """
  19   test = smoothness.Smoothness
  20   page_set = page_sets.Top25SmoothPageSet
  21
  22   @classmethod
  23   def Name(cls):
  24     return 'smoothness.top_25_smooth'
  25
  26
  27 class SmoothnessToughFiltersCases(perf_benchmark.PerfBenchmark):
  28   """Measures frame rate and a variety of other statistics.
  29
  30   Uses a selection of pages making use of SVG and CSS Filter Effects.
  31   """
  32   test = smoothness.Smoothness
  33   page_set = page_sets.ToughFiltersCasesPageSet
  34
  35   @classmethod
  36   def Name(cls):
  37     return 'smoothness.tough_filters_cases'
  38
  39
  40 class SmoothnessToughPathRenderingCases(perf_benchmark.PerfBenchmark):
  41   """Tests a selection of pages with SVG and 2D Canvas paths.
  42
  43   Measures frame rate and a variety of other statistics.  """
  44   test = smoothness.Smoothness
  45   page_set = page_sets.ToughPathRenderingCasesPageSet
  46
  47   @classmethod
  48   def Name(cls):
  49     return 'smoothness.tough_path_rendering_cases'
  50
  51
  52 # crbug.com/388877, crbug.com/396127
  53 @benchmark.Disabled('mac', 'win', 'android')
  54 class SmoothnessToughCanvasCases(perf_benchmark.PerfBenchmark):
  55   """Measures frame rate and a variety of other statistics.
  56
  57   Uses a selection of pages making use of the 2D Canvas API.
  58   """
  59   test = smoothness.Smoothness
  60   page_set = page_sets.ToughCanvasCasesPageSet
  61
  62   @classmethod
  63   def Name(cls):
  64     return 'smoothness.tough_canvas_cases'
  65
  66
  67 @benchmark.Disabled('android')  # crbug.com/373812
  68 class SmoothnessToughWebGLCases(perf_benchmark.PerfBenchmark):
  69   test = smoothness.Smoothness
  70   page_set = page_sets.ToughWebglCasesPageSet
  71
  72   @classmethod
  73   def CreateExpectations(cls):
  74     return webgl_expectations.WebGLExpectations()
  75
  76   @classmethod
  77   def Name(cls):
  78     return 'smoothness.tough_webgl_cases'
  79
  80
  81 @benchmark.Enabled('android')
  82 class SmoothnessMaps(perf_benchmark.PerfBenchmark):
  83   page_set = page_sets.MapsPageSet
  84
  85   @classmethod
  86   def CreateExpectations(cls):
  87     return webgl_expectations.MapsExpectations()
  88
  89   @classmethod
  90   def Name(cls):
  91     return 'smoothness.maps'
  92
  93
  94 @benchmark.Disabled('android')
  95 class SmoothnessKeyDesktopMoveCases(perf_benchmark.PerfBenchmark):
  96   test = smoothness.Smoothness
  97   page_set = page_sets.KeyDesktopMoveCasesPageSet
  98
  99   @classmethod
 100   def Name(cls):
 101     return 'smoothness.key_desktop_move_cases'
 102
 103
 104 @benchmark.Enabled('android')
 105 class SmoothnessKeyMobileSites(perf_benchmark.PerfBenchmark):
 106   """Measures rendering statistics while scrolling down the key mobile sites.
 107
 108   http://www.chromium.org/developers/design-documents/rendering-benchmarks
 109   """
 110   test = smoothness.Smoothness
 111   page_set = page_sets.KeyMobileSitesSmoothPageSet
 112
 113   @classmethod
 114   def Name(cls):
 115     return 'smoothness.key_mobile_sites_smooth'
 116
 117
 118 @benchmark.Disabled('mac', 'win', 'android')
 119 class SmoothnessKeyMobileSitesWithSlimmingPaint(perf_benchmark.PerfBenchmark):
 120   """Measures smoothness on key mobile sites with --enable-slimming-paint.
 121
 122   http://www.chromium.org/developers/design-documents/rendering-benchmarks
 123   """
 124   test = smoothness.Smoothness
 125   page_set = page_sets.KeyMobileSitesSmoothPageSet
 126
 127   def SetExtraBrowserOptions(self, options):
 128     options.AppendExtraBrowserArgs(['--enable-slimming-paint'])
 129
 130   @classmethod
 131   def Name(cls):
 132     return 'smoothness.key_mobile_sites_with_slimming_paint_smooth'
 133
 134
 135 class SmoothnessToughAnimationCases(perf_benchmark.PerfBenchmark):
 136   test = smoothness.SmoothnessWithRestart
 137   page_set = page_sets.ToughAnimationCasesPageSet
 138
 139   @classmethod
 140   def Name(cls):
 141     return 'smoothness.tough_animation_cases'
 142
 143
 144 @benchmark.Enabled('android')
 145 class SmoothnessKeySilkCases(perf_benchmark.PerfBenchmark):
 146   """Measures rendering statistics for the key silk cases without GPU
 147   rasterization.
 148   """
 149   test = smoothness.Smoothness
 150   page_set = page_sets.KeySilkCasesPageSet
 151
 152   @classmethod
 153   def Name(cls):
 154     return 'smoothness.key_silk_cases'
 155
 156
 157 @benchmark.Enabled('android')
 158 class SmoothnessGpuRasterizationTop25(perf_benchmark.PerfBenchmark):
 159   """Measures rendering statistics for the top 25 with GPU rasterization.
 160   """
 161   tag = 'gpu_rasterization'
 162   test = smoothness.Smoothness
 163   page_set = page_sets.Top25SmoothPageSet
 164
 165   def SetExtraBrowserOptions(self, options):
 166     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 167
 168   @classmethod
 169   def Name(cls):
 170     return 'smoothness.gpu_rasterization.top_25_smooth'
 171
 172
 173 @benchmark.Enabled('android')
 174 class SmoothnessGpuRasterizationKeyMobileSites(perf_benchmark.PerfBenchmark):
 175   """Measures rendering statistics for the key mobile sites with GPU
 176   rasterization.
 177   """
 178   tag = 'gpu_rasterization'
 179   test = smoothness.Smoothness
 180   page_set = page_sets.KeyMobileSitesSmoothPageSet
 181
 182   def SetExtraBrowserOptions(self, options):
 183     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 184
 185   @classmethod
 186   def Name(cls):
 187     return 'smoothness.gpu_rasterization.key_mobile_sites_smooth'
 188
 189
 190 class SmoothnessGpuRasterizationToughPathRenderingCases(
 191     perf_benchmark.PerfBenchmark):
 192   """Tests a selection of pages with SVG and 2D canvas paths with GPU
 193   rasterization.
 194   """
 195   tag = 'gpu_rasterization'
 196   test = smoothness.Smoothness
 197   page_set = page_sets.ToughPathRenderingCasesPageSet
 198
 199   def SetExtraBrowserOptions(self, options):
 200     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 201
 202   @classmethod
 203   def Name(cls):
 204     return 'smoothness.gpu_rasterization.tough_path_rendering_cases'
 205
 206
 207 class SmoothnessGpuRasterizationFiltersCases(perf_benchmark.PerfBenchmark):
 208   """Tests a selection of pages with SVG and CSS filter effects with GPU
 209   rasterization.
 210   """
 211   tag = 'gpu_rasterization'
 212   test = smoothness.Smoothness
 213   page_set = page_sets.ToughFiltersCasesPageSet
 214
 215   def SetExtraBrowserOptions(self, options):
 216     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 217
 218   @classmethod
 219   def Name(cls):
 220     return 'smoothness.gpu_rasterization.tough_filters_cases'
 221
 222
 223 @benchmark.Enabled('android')
 224 class SmoothnessSyncScrollKeyMobileSites(perf_benchmark.PerfBenchmark):
 225   """Measures rendering statistics for the key mobile sites with synchronous
 226   (main thread) scrolling.
 227   """
 228   tag = 'sync_scroll'
 229   test = smoothness.Smoothness
 230   page_set = page_sets.KeyMobileSitesSmoothPageSet
 231
 232   def SetExtraBrowserOptions(self, options):
 233     silk_flags.CustomizeBrowserOptionsForSyncScrolling(options)
 234
 235   @classmethod
 236   def Name(cls):
 237     return 'smoothness.sync_scroll.key_mobile_sites_smooth'
 238
 239
 240 @benchmark.Enabled('android')
 241 class SmoothnessSimpleMobilePages(perf_benchmark.PerfBenchmark):
 242   """Measures rendering statistics for simple mobile sites page set.
 243   """
 244   test = smoothness.Smoothness
 245   page_set = page_sets.SimpleMobileSitesPageSet
 246
 247   @classmethod
 248   def Name(cls):
 249     return 'smoothness.simple_mobile_sites'
 250
 251
 252 @benchmark.Enabled('android')
 253 class SmoothnessFlingSimpleMobilePages(perf_benchmark.PerfBenchmark):
 254   """Measures rendering statistics for flinging a simple mobile sites page set.
 255   """
 256   test = smoothness.Smoothness
 257   page_set = page_sets.SimpleMobileSitesFlingPageSet
 258
 259   def SetExtraBrowserOptions(self, options):
 260     # As the fling parameters cannot be analytically determined to not
 261     # overscroll, disable overscrolling explicitly. Overscroll behavior is
 262     # orthogonal to fling performance, and its activation is only more noise.
 263     options.AppendExtraBrowserArgs('--disable-overscroll-edge-effect')
 264
 265   @classmethod
 266   def Name(cls):
 267     return 'smoothness.fling.simple_mobile_sites'
 268
 269
 270 @benchmark.Enabled('android', 'chromeos')
 271 class SmoothnessToughPinchZoomCases(perf_benchmark.PerfBenchmark):
 272   """Measures rendering statistics for pinch-zooming into the tough pinch zoom
 273   cases.
 274   """
 275   test = smoothness.Smoothness
 276   page_set = page_sets.ToughPinchZoomCasesPageSet
 277
 278   @classmethod
 279   def Name(cls):
 280     return 'smoothness.tough_pinch_zoom_cases'
 281
 282
 283 @benchmark.Enabled('android', 'chromeos')
 284 class SmoothnessToughScrollingWhileZoomedInCases(perf_benchmark.PerfBenchmark):
 285   """Measures rendering statistics for pinch-zooming then diagonal scrolling"""
 286   test = smoothness.Smoothness
 287   page_set = page_sets.ToughScrollingWhileZoomedInCasesPageSet
 288
 289   @classmethod
 290   def Name(cls):
 291     return 'smoothness.tough_scrolling_while_zoomed_in_cases'
 292
 293
 294 @benchmark.Enabled('android')
 295 class SmoothnessPolymer(perf_benchmark.PerfBenchmark):
 296   """Measures rendering statistics for Polymer cases.
 297   """
 298   test = smoothness.Smoothness
 299   page_set = page_sets.PolymerPageSet
 300
 301   @classmethod
 302   def Name(cls):
 303     return 'smoothness.polymer'
 304
 305
 306 @benchmark.Enabled('android')
 307 class SmoothnessGpuRasterizationPolymer(perf_benchmark.PerfBenchmark):
 308   """Measures rendering statistics for the Polymer cases with GPU rasterization.
 309   """
 310   tag = 'gpu_rasterization'
 311   test = smoothness.Smoothness
 312   page_set = page_sets.PolymerPageSet
 313
 314   def SetExtraBrowserOptions(self, options):
 315     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 316
 317   @classmethod
 318   def Name(cls):
 319     return 'smoothness.gpu_rasterization.polymer'
 320
 321
 322 class SmoothnessToughScrollingCases(perf_benchmark.PerfBenchmark):
 323   test = smoothness.Smoothness
 324   page_set = page_sets.ToughScrollingCasesPageSet
 325
 326   @classmethod
 327   def Name(cls):
 328     return 'smoothness.tough_scrolling_cases'
 329
 330
 331 class SmoothnessImageDecodingCases(perf_benchmark.PerfBenchmark):
 332   """Measures decoding statistics for jpeg images.
 333   """
 334   test = smoothness.Smoothness
 335   page_set = page_sets.ImageDecodingCasesPageSet
 336
 337   def SetExtraBrowserOptions(self, options):
 338     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 339     options.AppendExtraBrowserArgs('--disable-accelerated-jpeg-decoding')
 340
 341   @classmethod
 342   def Name(cls):
 343     return 'smoothness.image_decoding_cases'
 344
 345
 346 class SmoothnessGpuImageDecodingCases(perf_benchmark.PerfBenchmark):
 347   """Measures decoding statistics for jpeg images with GPU rasterization.
 348   """
 349   tag = 'gpu_rasterization_and_decoding'
 350   test = smoothness.Smoothness
 351   page_set = page_sets.ImageDecodingCasesPageSet
 352
 353   def SetExtraBrowserOptions(self, options):
 354     silk_flags.CustomizeBrowserOptionsForGpuRasterization(options)
 355     # TODO(sugoi): Remove the following line once M41 goes stable
 356     options.AppendExtraBrowserArgs('--enable-accelerated-jpeg-decoding')
 357
 358   @classmethod
 359   def Name(cls):
 360     return 'smoothness.gpu_rasterization_and_decoding.image_decoding_cases'
 361
 362
 363 @benchmark.Enabled('android')
 364 class SmoothnessPathologicalMobileSites(perf_benchmark.PerfBenchmark):
 365   """Measures task execution statistics while scrolling pathological sites.
 366   """
 367   test = smoothness.Smoothness
 368   page_set = page_sets.PathologicalMobileSitesPageSet
 369
 370   @classmethod
 371   def Name(cls):
 372     return 'smoothness.pathological_mobile_sites'
 373
 374
 375 @benchmark.Enabled('android')
 376 class SmoothnessSyncScrollPathologicalMobileSites(perf_benchmark.PerfBenchmark):
 377   """Measures task execution statistics while sync-scrolling pathological sites.
 378   """
 379   tag = 'sync_scroll'
 380   page_set = page_sets.PathologicalMobileSitesPageSet
 381   test = smoothness.Smoothness
 382
 383   def SetExtraBrowserOptions(self, options):
 384     silk_flags.CustomizeBrowserOptionsForSyncScrolling(options)
 385
 386   @classmethod
 387   def Name(cls):
 388     return 'smoothness.sync_scroll.pathological_mobile_sites'
 389
 390
 391 class SmoothnessToughAnimatedImageCases(perf_benchmark.PerfBenchmark):
 392   test = smoothness.Smoothness
 393   page_set = page_sets.ToughAnimatedImageCasesPageSet
 394
 395   @classmethod
 396   def Name(cls):
 397     return 'smoothness.tough_animated_image_cases'