Remove whitelist from generate_perf_data

tools/perf/core/perf_data_generator.py

 #!/usr/bin/env python
 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Script to generate chromium.perf.json and chromium.perf.fyi.json in
 the src/testing/buildbot directory and benchmark.csv in the src/tools/perf
 directory. Maintaining these files by hand is too unwieldy.
 """
 import argparse
@@ skipping 104 matching lines @@
 
 
 def add_builder(waterfall, name, additional_compile_targets=None):
   waterfall['builders'][name] = added = {}
   if additional_compile_targets:
     added['additional_compile_targets'] = additional_compile_targets
 
   return waterfall
 
 def add_tester(waterfall, name, perf_id, platform, target_bits=64,
-              num_host_shards=1, num_device_shards=1, swarming=None,
-              use_whitelist=False):
+              num_host_shards=1, num_device_shards=1, swarming=None):
   del perf_id # this will be needed
   waterfall['testers'][name] = {
     'platform': platform,
     'num_device_shards': num_device_shards,
     'num_host_shards': num_host_shards,
     'target_bits': target_bits,
-    'use_whitelist': use_whitelist
   }
 
   if swarming:
     waterfall['testers'][name]['swarming_dimensions'] = swarming
     waterfall['testers'][name]['swarming'] = True
 
   return waterfall
 
 
 def get_fyi_waterfall_config():
@@ skipping 449 matching lines @@
 def generate_cplusplus_isolate_script_test(dimension):
   return [
     generate_isolate_script_entry(
         [get_swarming_dimension(dimension, shard)], [], name, name,
         ignore_task_failure=False)
     for name, shard in dimension['perf_tests']
   ]
 
 
 def generate_telemetry_tests(tester_config, benchmarks, benchmark_sharding_map,
-                             use_whitelist, benchmark_ref_build_blacklist):
+                             benchmark_ref_build_blacklist):
   isolated_scripts = []
   # First determine the browser that you need based on the tester
   browser_name = ''
   if tester_config['platform'] == 'android':
     browser_name = 'android-chromium'
   elif (tester_config['platform'] == 'win'
     and tester_config['target_bits'] == 64):
     browser_name = 'release_x64'
   else:
     browser_name ='release'
 
   num_shards = len(tester_config['swarming_dimensions'][0]['device_ids'])
   current_shard = 0
   for benchmark in benchmarks:
     # First figure out swarming dimensions this test needs to be triggered on.
     # For each set of dimensions it is only triggered on one of the devices
     swarming_dimensions = []
     for dimension in tester_config['swarming_dimensions']:
       device_affinity = None
       if benchmark_sharding_map:
         sharding_map = benchmark_sharding_map.get(str(num_shards), None)
-        if not sharding_map and not use_whitelist:
+        if not sharding_map:
           raise Exception('Invalid number of shards, generate new sharding map')
-        if use_whitelist:
-          device_affinity = current_shard
-        else:
-          device_affinity = sharding_map.get(benchmark.Name(), None)
+        device_affinity = sharding_map.get(benchmark.Name(), None)
       else:
         # No sharding map was provided, default to legacy device
         # affinity algorithm
         device_affinity = bot_utils.GetDeviceAffinity(
           num_shards, benchmark.Name())
       if device_affinity is None:
         raise Exception('Device affinity for benchmark %s not found'
           % benchmark.Name())
       swarming_dimensions.append(
           get_swarming_dimension(dimension, device_affinity))
 
     test = generate_telemetry_test(
       swarming_dimensions, benchmark.Name(), browser_name)
     isolated_scripts.append(test)
     # Now create another executable for this benchmark on the reference browser
     # if it is not blacklisted from running on the reference browser.
     if benchmark.Name() not in benchmark_ref_build_blacklist:
       reference_test = generate_telemetry_test(
         swarming_dimensions, benchmark.Name(),'reference')
       isolated_scripts.append(reference_test)
       if current_shard == (num_shards - 1):
         current_shard = 0
       else:
         current_shard += 1
 
   return isolated_scripts
 
 
-BENCHMARK_NAME_WHITELIST = set([
-    u'smoothness.top_25_smooth',
-    u'sunspider',
-    u'system_health.webview_startup',
-    u'page_cycler_v2.intl_hi_ru',
-    u'dromaeo.cssqueryjquery',
-])
-
 # List of benchmarks that are to never be run on a waterfall.
 BENCHMARK_NAME_BLACKLIST = [
     'multipage_skpicture_printer',
     'multipage_skpicture_printer_ct',
     'rasterize_and_record_micro_ct',
     'repaint_ct',
     'multipage_skpicture_printer',
     'multipage_skpicture_printer_ct',
     'skpicture_printer',
     'skpicture_printer_ct',
 ]
 
+
 # Overrides the default 2 hour timeout for swarming tasks.
 BENCHMARK_SWARMING_TIMEOUTS = {
     'loading.mobile': 14400, # 4 hours
     'system_health.memory_mobile': 10800, # 4 hours
 }
 
+
 # List of benchmarks that are to never be run with reference builds.
 BENCHMARK_REF_BUILD_BLACKLIST = [
   'power.idle_platform',
 ]
 
 
-def current_benchmarks(use_whitelist):
+
+def current_benchmarks():
   benchmarks_dir = os.path.join(src_dir(), 'tools', 'perf', 'benchmarks')
   top_level_dir = os.path.dirname(benchmarks_dir)
 
   all_benchmarks = discover.DiscoverClasses(
       benchmarks_dir, top_level_dir, benchmark_module.Benchmark,
       index_by_class_name=True).values()
   # Remove all blacklisted benchmarks
   for blacklisted in BENCHMARK_NAME_BLACKLIST:
     for benchmark in all_benchmarks:
       if benchmark.Name() == blacklisted:
         all_benchmarks.remove(benchmark)
         break
 
-  if use_whitelist:
-    all_benchmarks = (
-        bench for bench in all_benchmarks
-        if bench.Name() in BENCHMARK_NAME_WHITELIST)
   return sorted(all_benchmarks, key=lambda b: b.Name())
 
 
 # Returns a sorted list of (benchmark, avg_runtime) pairs for every
 # benchmark in the all_benchmarks list where avg_runtime is in seconds.  Also
 # returns a list of benchmarks whose run time have not been seen before
 def get_sorted_benchmark_list_by_time(all_benchmarks):
   runtime_list = []
   benchmark_avgs = {}
   new_benchmarks = []
@@ skipping 37 matching lines @@
   # device affinity algorithm
   for benchmark in new_benchmarks:
      device_affinity = bot_utils.GetDeviceAffinity(num_shards, benchmark.Name())
      benchmark_to_shard_dict[benchmark.Name()] = device_affinity
   return benchmark_to_shard_dict
 
 
 def generate_all_tests(waterfall):
   tests = {}
 
-  all_benchmarks = current_benchmarks(False)
-  whitelist_benchmarks = current_benchmarks(True)
+  all_benchmarks = current_benchmarks()
   # Get benchmark sharding according to common sharding configurations
   # Currently we only have bots sharded 5 directions and 1 direction
   benchmark_sharding_map = {}
   benchmark_sharding_map['22'] = shard_benchmarks(22, all_benchmarks)
   benchmark_sharding_map['5'] = shard_benchmarks(5, all_benchmarks)
   benchmark_sharding_map['1'] = shard_benchmarks(1, all_benchmarks)
   benchmark_sharding_map['21'] = shard_benchmarks(21, all_benchmarks)
 
   for name, config in waterfall['testers'].iteritems():
-    use_whitelist = config['use_whitelist']
     benchmark_list = all_benchmarks
-    if use_whitelist:
-      benchmark_list = whitelist_benchmarks
     if config.get('swarming', False):
       # Our current configuration only ever has one set of swarming dimensions
       # Make sure this still holds true
       if len(config['swarming_dimensions']) > 1:
         raise Exception('Invalid assumption on number of swarming dimensions')
       # Generate benchmarks
       sharding_map = benchmark_sharding_map
       isolated_scripts = generate_telemetry_tests(
-          config, benchmark_list, sharding_map, use_whitelist,
+          config, benchmark_list, sharding_map,
           BENCHMARK_REF_BUILD_BLACKLIST)
       # Generate swarmed non-telemetry tests if present
       if config['swarming_dimensions'][0].get('perf_tests', False):
         isolated_scripts += generate_cplusplus_isolate_script_test(
           config['swarming_dimensions'][0])
       tests[name] = {
         'isolated_scripts': sorted(isolated_scripts, key=lambda x: x['name'])
       }
     else:
       # scripts are only currently run in addition to the main waterfall.  They
@@ skipping 84 matching lines @@
 }
 
 
 # Returns a dictionary mapping waterfall benchmark name to benchmark owner
 # metadata
 def get_all_waterfall_benchmarks_metadata():
   return get_all_benchmarks_metadata(NON_TELEMETRY_BENCHMARKS)
 
 
 def get_all_benchmarks_metadata(metadata):
-  benchmark_list = current_benchmarks(False)
+  benchmark_list = current_benchmarks()
 
   for benchmark in benchmark_list:
     emails = decorators.GetEmails(benchmark)
     if emails:
       emails = ', '.join(emails)
     metadata[benchmark.Name()] = BenchmarkMetadata(
         emails, decorators.GetComponent(benchmark))
   return metadata
 
 
@@ skipping 80 matching lines @@
       return 0
     else:
       print ('The perf JSON config files are not up-to-date. Please run %s '
              'without --validate-only flag to update the perf JSON '
              'configs and benchmark.csv.') % sys.argv[0]
       return 1
   else:
     update_all_tests([fyi_waterfall, waterfall])
     update_benchmark_csv()
   return 0