Equalizing samples when comparing middle revision against good and bad.

scripts/slave/recipe_modules/auto_bisect/revision_state.py

 # Copyright 2015 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.
 
 """An interface for holding state and result of revisions in a bisect job.
 
 When implementing support for tests other than perf, one should extend this
 class so that the bisect module and recipe can use it.
 
 See perf_revision_state for an example.
@@ skipping 521 matching lines @@
     either direction, this is expected to timeout eventually. This scenario
     should be rather rare, since it is expected that the fkbr and lkgr are
     significantly different as a precondition.
 
     Returns:
       True if the results of testing this revision are significantly different
       from those of testing the earliest known bad revision.
       False if they are instead significantly different form those of testing
       the latest knwon good revision.
     """
+    lkgr = self.bisector.lkgr
+    fkbr = self.bisector.fkbr
 
     if self.bisector.is_return_code_mode():
-      return self.overall_return_code == self.bisector.lkgr.overall_return_code
+      return self.overall_return_code == lkgr.overall_return_code
 
     while True:
       diff_from_good = self.bisector.significantly_different(
-          self.bisector.lkgr.values, self.values)
+          lkgr.values[:len(fkbr.values)], self.values)
       diff_from_bad = self.bisector.significantly_different(
-          self.bisector.fkbr.values, self.values)
+          fkbr.values[:len(lkgr.values)], self.values)
 
       if diff_from_good and diff_from_bad:
         # Multiple regressions.
         # For now, proceed bisecting the biggest difference of the means.
-        dist_from_good = abs(self.mean_value - self.bisector.lkgr.mean_value)
-        dist_from_bad = abs(self.mean_value - self.bisector.fkbr.mean_value)
+        dist_from_good = abs(self.mean_value - lkgr.mean_value)
+        dist_from_bad = abs(self.mean_value - fkbr.mean_value)
         if dist_from_good > dist_from_bad:
           # TODO(robertocn): Add way to handle the secondary regression
-          #self.bisector.handle_secondary_regression(self, self.bisector.fkbr)
+          #self.bisector.handle_secondary_regression(self, fkbr)
           return False
         else:
-          #self.bisector.handle_secondary_regression(self.bisector.lkgr, self)
+          #self.bisector.handle_secondary_regression(lkgr, self)
           return True
 
       if diff_from_good or diff_from_bad:  # pragma: no cover
         return diff_from_bad
 
       self._next_retest()  # pragma: no cover
 
   def revision_string(self):
     if self._rev_str:
       return self._rev_str
@@ skipping 26 matching lines @@
     else:
       next_revision_to_test.retest()
 
   def __repr__(self):
     if self.overall_return_code is not None:
       return ('RevisionState(rev=%s, values=%r, overall_return_code=%r, '
               'std_dev=%r)') % (self.revision_string(), self.values,
                                 self.overall_return_code, self.std_dev)
     return ('RevisionState(rev=%s, values=%r, mean_value=%r, std_dev=%r)' % (
         self.revision_string(), self.values, self.mean_value, self.std_dev))