Refactor BenchmarkResult.Add to take enum for data_type

build/android/pylib/perf_tests_helper.py

 # Copyright (c) 2012 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.
 
 import re
 import sys
 
 import android_commands

[bulach, 2013/08/19 08:43:01]

forgot to mention, I think this is leftover from previous refactorings, so it
should be reasonably straightforward to put this and result_data_type (probably
as perf_result_data_type) under build/util/lib...

 import json
 import logging
 import math
 
-# Valid values of result type.
-RESULT_TYPES = {'unimportant': 'RESULT ',
-                'default': '*RESULT ',
-                'informational': '',
-                'unimportant-histogram': 'HISTOGRAM ',
-                'histogram': '*HISTOGRAM '}
 
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                 os.pardir, os.pardir, os.pardir,
+                                 'tools', 'telemetry')))

[bulach, 2013/08/19 08:37:58]

hmm, this is dodgy :)

tools/telemetry already depends on android/pylib, this circular dependency would
make things worse.. :(

any chance of moving result_data_type here? or maybe even better, let's get this
out of build/android and into build/util/lib, so that both android and telemetry
can depend one way on it, and it'd be self-contained there, wdyt?

probably best to do a separate patch just copying this file out first: android
depends on it downstream, so we'll need to have a copy, then I can change
downstream, and later on I'll be happy to nuke it from orbit.

+
+from telemetry.page import result_data_type
+
+
+# Mapping from result type to test output
+RESULT_TYPES = {result_data_type.UNIMPORTANT: 'RESULT ',
+                result_data_type.DEFAULT: '*RESULT ',
+                result_data_type.INFORMATIONAL: '',
+                result_data_type.UNIMPORTANT_HISTOGRAM: 'HISTOGRAM ',
+                result_data_type.HISTOGRAM: '*HISTOGRAM '}
 
 def _EscapePerfResult(s):
   """Escapes |s| for use in a perf result."""
   return re.sub('[\:|=/#&,]', '_', s)
 
 
 def _Flatten(values):
   """Returns a simple list without sub-lists."""
   ret = []
   for entry in values:
@@ skipping 46 matching lines @@
   else:
     value = values[0]
   return value, avg, sd
 
 
 def PrintPages(page_list):
   """Prints list of pages to stdout in the format required by perf tests."""
   print 'Pages: [%s]' % ','.join([_EscapePerfResult(p) for p in page_list])
 
 
-def PrintPerfResult(measurement, trace, values, units, result_type='default',
+def PrintPerfResult(measurement, trace, values, units,
+                    result_type=result_data_type.DEFAULT,
                     print_to_stdout=True):
   """Prints numerical data to stdout in the format required by perf tests.
 
   The string args may be empty but they must not contain any colons (:) or
   equals signs (=).
 
   Args:
     measurement: A description of the quantity being measured, e.g. "vm_peak".
     trace: A description of the particular data point, e.g. "reference".
     values: A list of numeric measured values. An N-dimensional list will be
         flattened and treated as a simple list.
     units: A description of the units of measure, e.g. "bytes".
-    result_type: Accepts values of RESULT_TYPES.
+    result_type: Accepts values of result_data_type.ALL_TYPES.
     print_to_stdout: If True, prints the output in stdout instead of returning
         the output to caller.
 
     Returns:
       String of the formated perf result.
   """
-  assert result_type in RESULT_TYPES, 'result type: %s is invalid' % result_type
+  assert (result_data_type.IsValidType(result_type),
+          'result type: %s is invalid' % result_type)
 
   trace_name = _EscapePerfResult(trace)
 
-  if result_type in ['unimportant', 'default', 'informational']:
+  if (result_type == result_data_type.UNIMPORTANT or
+      result_type == result_data_type.DEFAULT or
+      result_type == result_data_type.INFORMATIONAL):
     assert isinstance(values, list)
     assert len(values)
     assert '/' not in measurement
     value, avg, sd = _MeanAndStdDevFromList(_Flatten(values))
     output = '%s%s: %s%s%s %s' % (
         RESULT_TYPES[result_type],
         _EscapePerfResult(measurement),
         trace_name,
         # Do not show equal sign if the trace is empty. Usually it happens when
         # measurement is enough clear to describe the result.
         '= ' if trace_name else '',
         value,
         units)
   else:
-    assert(result_type in ['histogram', 'unimportant-histogram'])
+    assert result_data_type.IsHistogram(result_type)
     assert isinstance(values, list)
     # The histograms can only be printed individually, there's no computation
     # across different histograms.
     assert len(values) == 1
     value = values[0]
     output = '%s%s: %s= %s' % (
         RESULT_TYPES[result_type],
         _EscapePerfResult(measurement),
         trace_name,
         value)
@@ skipping 57 matching lines @@
     """Resets the original performance mode of the device."""
     self._SetScalingGovernorInternal(self._original_scaling_governor)
 
   def _SetScalingGovernorInternal(self, value):
     for cpu in range(self._kernel_max + 1):
       scaling_governor_file = PerfControl._SCALING_GOVERNOR_FMT % cpu
       if self._adb.FileExistsOnDevice(scaling_governor_file):
         logging.info('Writing scaling governor mode \'%s\' -> %s' %
                      (value, scaling_governor_file))
         self._adb.SetProtectedFileContents(scaling_governor_file, value)