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