Backout 9a59028a3510 (bug 676349) on suspicion of breaking Win PGO builds
authorEd Morley <bmo@edmorley.co.uk>
Wed, 07 Dec 2011 02:22:09 +0000
changeset 83779 242ee41d7e5f45260b6865c504515d26c4af0679
parent 83778 09a56c8d58229bb359799f59e00706e5af666a8e
child 83780 ad09520aac4be708eef1f38fc86b32448501b2d4
push id519
push userakeybl@mozilla.com
push dateWed, 01 Feb 2012 00:38:35 +0000
treeherdermozilla-beta@788ea1ef610b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs676349
milestone11.0a1
backs out9a59028a35108dc809341ed9ecf9c71ba6e1538b
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backout 9a59028a3510 (bug 676349) on suspicion of breaking Win PGO builds
xpcom/ds/Makefile.in
xpcom/ds/TimeStamp_windows.cpp
--- a/xpcom/ds/Makefile.in
+++ b/xpcom/ds/Makefile.in
@@ -74,18 +74,16 @@ CPPSRCS		= \
 		nsUnicharBuffer.cpp \
 		nsVariant.cpp \
 		$(NULL)
 
 ifdef HAVE_CLOCK_MONOTONIC
 CPPSRCS += TimeStamp_posix.cpp
 else ifeq ($(OS_ARCH),Darwin)
 CPPSRCS += TimeStamp_darwin.cpp
-else ifeq ($(OS_ARCH),WINNT)
-CPPSRCS += TimeStamp_windows.cpp
 else
 CPPSRCS += TimeStamp.cpp
 endif
 
 EXPORTS_NAMESPACES = mozilla
 
 EXPORTS_mozilla = \
   CharTokenizer.h \
deleted file mode 100644
--- a/xpcom/ds/TimeStamp_windows.cpp
+++ /dev/null
@@ -1,651 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim:set ts=2 sw=2 sts=2 et cindent: */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla code.
- *
- * The Initial Developer of the Original Code is the Mozilla Foundation.
- * Portions created by the Initial Developer are Copyright (C) 2011
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Honza Bambas <honzab.moz@firemni.cz>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-// Implement TimeStamp::Now() with QueryPerformanceCounter() controlled with
-// values of GetTickCount().
-
-// XXX Forcing log to be able to catch issues in the field.  Should be removed
-// before this reaches the Release or even Beta channel.
-#define FORCE_PR_LOG
-
-#include "mozilla/TimeStamp.h"
-#include "mozilla/Mutex.h"
-#include "mozilla/Services.h"
-#include "nsIObserver.h"
-#include "nsIObserverService.h"
-#include "nsThreadUtils.h"
-#include "nsAutoPtr.h"
-#include <pratom.h>
-#include <windows.h>
-
-#include "prlog.h"
-#include <stdio.h>
-
-#if defined(PR_LOGGING)
-// Log module for mozilla::TimeStamp for Windows logging...
-//
-// To enable logging (see prlog.h for full details):
-//
-//    set NSPR_LOG_MODULES=TimeStampWindows:5
-//    set NSPR_LOG_FILE=nspr.log
-//
-// this enables PR_LOG_DEBUG level information and places all output in
-// the file nspr.log
-  PRLogModuleInfo* timeStampLog = PR_NewLogModule("TimeStampWindows");
-  #define LOG(x)  PR_LOG(timeStampLog, PR_LOG_DEBUG, x)
-#else
-  #define LOG(x)
-#endif /* PR_LOGGING */
-
-// Estimate of the smallest duration of time we can measure.
-static volatile ULONGLONG sResolution;
-static volatile ULONGLONG sResolutionSigDigs;
-static const double   kNsPerSecd  = 1000000000.0;
-static const LONGLONG kNsPerSec   = 1000000000;
-static const LONGLONG kNsPerMillisec = 1000000;
-
-
-// ----------------------------------------------------------------------------
-// Global constants
-// ----------------------------------------------------------------------------
-
-// After this time we always recalibrate the skew.
-//
-// On most platforms QPC and GTC have not quit the same slope, so after some
-// time the two values will disperse.  The 4s calibration interval has been
-// chosen mostly arbitrarily based on tests.
-//
-// Mostly, 4 seconds has been chosen based on the sleep/wake issue - timers
-// shift after wakeup.  I wanted to make the time as reasonably short as
-// possible to always recalibrate after even a very short standby time (quit
-// reasonable test case).  So, there is a lot of space to prolong it
-// to say 20 seconds or even more, needs testing in the field, though.
-//
-// Value is number of [ms].
-static const ULONGLONG kCalibrationInterval = 4000;
-
-// On every read of QPC we check the overflow of skew difference doesn't go
-// over this number of milliseconds.  Both timer functions jitter so we have
-// to have some limit.  The value is based on tests.
-//
-// Changing kCalibrationInterval influences this limit: prolonging
-// just kCalibrationInterval means to be more sensitive to threshold overflows.
-//
-// How this constant is used (also see CheckCalibration function):
-// First, adjust the limit linearly to the calibration interval:
-//   LIMIT = (GTC_now - GTC_calib) / kCalibrationInterval
-// Then, check the skew difference overflow is in this adjusted limit:
-//   ABS((QPC_now - GTC_now) - (QPC_calib - GTC_calib)) - THRESHOLD < LIMIT
-//
-// Thresholds are calculated dynamically, see sUnderrunThreshold and
-// sOverrunThreshold below.
-//
-// Value is number of [ms].
-static const ULONGLONG kOverflowLimit = 100;
-
-// If we are not able to get the value of GTC time increment, use this value
-// which is the most usual increment.
-static const DWORD kDefaultTimeIncrement = 156001;
-
-// ----------------------------------------------------------------------------
-// Global variables, not changing at runtime
-// ----------------------------------------------------------------------------
-
-/**
- * The [mt] unit:
- *
- * Many values are kept in ticks of the Performance Coutner x 1000,
- * further just referred as [mt], meaning milli-ticks.
- *
- * This is needed to preserve maximum precision of the performance frequency
- * representation.  GetTickCount values in milliseconds are multiplied with
- * frequency per second.  Therefor we need to multiply QPC value by 1000 to
- * have the same units to allow simple arithmentic with both QPC and GTC.
- */
-
-#define ms2mt(x) ((x) * sFrequencyPerSec)
-#define mt2ms(x) ((x) / sFrequencyPerSec)
-#define mt2ms_d(x) (double(x) / sFrequencyPerSec)
-
-// Result of QueryPerformanceFrequency
-static LONGLONG sFrequencyPerSec = 0;
-
-// Lower and upper bound that QueryPerformanceCounter - GetTickCount must not
-// go under or over when compared to the calibrated QPC - GTC difference (skew)
-// Values are based on the GetTickCount update interval.
-//
-// Schematically, QPC works correctly if ((QPC_now - GTC_now) -
-// (QPC_calib - GTC_calib)) is in  [sUnderrunThreshold, sOverrunThreshold]
-// interval every time we access them.
-//
-// Kept in [mt]
-static LONGLONG sUnderrunThreshold;
-static LONGLONG sOverrunThreshold;
-
-// ----------------------------------------------------------------------------
-// Global lock
-// ----------------------------------------------------------------------------
-
-// Thread spin count before entering the full wait state for sTimeStampLock.
-// Inspired by Rob Arnold's work on PRMJ_Now().
-static const DWORD kLockSpinCount = 4096;
-
-// Common mutex (thanks the relative complexity of the logic, this is better
-// then using CMPXCHG8B.)
-// It is protecting the globals bellow.
-CRITICAL_SECTION sTimeStampLock;
-
-// ----------------------------------------------------------------------------
-// Globals heavily chaning at runtime, protected with sTimeStampLock mutex
-// ----------------------------------------------------------------------------
-
-// The calibrated difference between QPC and GTC.
-//
-// Kept in [mt]
-static LONGLONG sSkew = 0;
-
-// Keeps the last result we have returned from TickCount64 (bellow).  Protects
-// from roll over and going backward.
-//
-// Kept in [ms]
-static ULONGLONG sLastGTCResult = 0;
-
-// Holder of the last result of our main hi-res function.  Protects from going
-// backward.
-//
-// Kept in [mt]
-static ULONGLONG sLastResult = 0;
-
-// Time of the last performed calibration.
-//
-// Kept in [ms]
-static ULONGLONG sLastCalibrated;
-
-// After we have detected a run out of bounderies set this to true.  This
-// then disallows use of QPC result for the hi-res timer.
-static bool sFallBackToGTC = false;
-
-// Set to true to force recalibration on QPC read.  This is generally set after
-// system wake up, during which skew can change a lot.
-static bool sForceRecalibrate = false;
-
-
-namespace mozilla {
-
-
-static ULONGLONG
-CalibratedPerformanceCounter();
-
-
-// ----------------------------------------------------------------------------
-// Critical Section helper class
-// ----------------------------------------------------------------------------
-
-class AutoCriticalSection
-{
-public:
-  AutoCriticalSection(LPCRITICAL_SECTION section)
-    : mSection(section)
-  {
-    ::EnterCriticalSection(mSection);
-  }
-  ~AutoCriticalSection()
-  {
-    ::LeaveCriticalSection(mSection);
-  }
-private:
-  LPCRITICAL_SECTION mSection;
-};
-
-
-// ----------------------------------------------------------------------------
-// System standby and wakeup status observer.  Needed to ignore skew jump after
-// the system has been woken up, happens mostly on XP.
-// ----------------------------------------------------------------------------
-
-class StandbyObserver : public nsIObserver
-{
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSIOBSERVER
-
-public:
-  StandbyObserver()
-  {
-    LOG(("TimeStamp: StandByObserver::StandByObserver()"));
-  }
-
-  ~StandbyObserver()
-  {
-    LOG(("TimeStamp: StandByObserver::~StandByObserver()"));
-  }
-
-  static inline void Ensure()
-  {
-    if (sInitialized)
-      return;
-
-    // Not available to init on other then the main thread since using
-    // the ObserverService.
-    if (!NS_IsMainThread())
-      return;
-
-    nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
-    if (!obs)
-      return; // Too soon...
-
-    sInitialized = true;
-
-    nsRefPtr<StandbyObserver> observer = new StandbyObserver();
-    obs->AddObserver(observer, "wake_notification", false);
-
-    // There is no need to remove the observer, observer service is the only
-    // referer and we don't hold reference back to the observer service.
-  }
-
-private:
-  static bool sInitialized;
-};
-
-NS_IMPL_THREADSAFE_ISUPPORTS1(StandbyObserver, nsIObserver)
-
-bool
-StandbyObserver::sInitialized = false;
-
-NS_IMETHODIMP
-StandbyObserver::Observe(nsISupports *subject,
-                         const char *topic,
-                         const PRUnichar *data)
-{
-  AutoCriticalSection lock(&sTimeStampLock);
-
-  // Clear the potentiall fallback flag now and try using
-  // QPC again after wake up.
-  sFallBackToGTC = false;
-  sForceRecalibrate = true;
-  LOG(("TimeStamp: system has woken up, reset GTC fallback"));
-
-  return NS_OK;
-}
-
-
-// ----------------------------------------------------------------------------
-// The timer core implementation
-// ----------------------------------------------------------------------------
-
-static void
-InitThresholds()
-{
-  DWORD timeAdjustment = 0, timeIncrement = 0;
-  BOOL timeAdjustmentDisabled;
-  GetSystemTimeAdjustment(&timeAdjustment,
-                          &timeIncrement,
-                          &timeAdjustmentDisabled);
-
-  if (!timeIncrement)
-    timeIncrement = kDefaultTimeIncrement;
-
-  // Ceiling to a millisecond
-  // Example values: 156001, 210000
-  DWORD timeIncrementCeil = timeIncrement;
-  // Don't want to round up if already rounded, values will be: 156000, 209999
-  timeIncrementCeil -= 1;
-  // Convert to ms, values will be: 15, 20
-  timeIncrementCeil /= 10000;
-  // Round up, values will be: 16, 21
-  timeIncrementCeil += 1;
-  // Convert back to 100ns, values will be: 160000, 210000
-  timeIncrementCeil *= 10000;
-
-  // How many milli-ticks has the interval
-  LONGLONG ticksPerGetTickCountResolution =
-    (PRInt64(timeIncrement) * sFrequencyPerSec) / 10000LL;
-
-  // How many milli-ticks has the interval rounded up
-  LONGLONG ticksPerGetTickCountResolutionCeiling =
-    (PRInt64(timeIncrementCeil) * sFrequencyPerSec) / 10000LL;
-
-
-  // I observed differences about 2 times of the GTC resolution.  GTC may
-  // jump by 32 ms in two steps, therefor use the ceiling value.
-  sUnderrunThreshold =
-    LONGLONG((-2) * ticksPerGetTickCountResolutionCeiling);
-
-  // QPC should go no further then 2 * GTC resolution
-  sOverrunThreshold =
-    LONGLONG((+2) * ticksPerGetTickCountResolution);
-}
-
-static void
-InitResolution()
-{
-  // 10 total trials is arbitrary: what we're trying to avoid by
-  // looping is getting unlucky and being interrupted by a context
-  // switch or signal, or being bitten by paging/cache effects
-
-  ULONGLONG minres = ~0ULL;
-  int loops = 10;
-  do {
-    ULONGLONG start = CalibratedPerformanceCounter();
-    ULONGLONG end = CalibratedPerformanceCounter();
-
-    ULONGLONG candidate = (end - start);
-    if (candidate < minres)
-      minres = candidate;
-  } while (--loops && minres);
-
-  if (0 == minres) {
-    minres = 1;
-  }
-
-  // Converting minres that is in [mt] to nanosecods, multiplicating
-  // the argument to preserve resolution.
-  ULONGLONG result = mt2ms(minres * kNsPerMillisec);
-  if (0 == result) {
-    result = 1;
-  }
-
-  sResolution = result;
-
-  // find the number of significant digits in mResolution, for the
-  // sake of ToSecondsSigDigits()
-  ULONGLONG sigDigs;
-  for (sigDigs = 1;
-       !(sigDigs == result
-         || 10*sigDigs > result);
-       sigDigs *= 10);
-
-  sResolutionSigDigs = sigDigs;
-}
-
-// Function protecting GetTickCount result from rolling over, result is in [ms]
-// @param gtc
-// Result of GetTickCount().  Passing it as an arg lets us call it out
-// of the common mutex.
-static inline ULONGLONG
-TickCount64(DWORD now)
-{
-  ULONGLONG lastResultHiPart = sLastGTCResult & (~0ULL << 32);
-  ULONGLONG result = lastResultHiPart | ULONGLONG(now);
-
-  // It may happen that when accessing GTC on multiple threads the results
-  // may differ (GTC value may be lower due to running before the others
-  // right around the overflow moment).  That falsely shifts the high part.
-  // Easiest solution is to check for a significant difference.
-
-  if (sLastGTCResult > result) {
-    if ((sLastGTCResult - result) > (1ULL << 31))
-      result += 1ULL << 32;
-    else
-      result = sLastGTCResult;
-  }
-
-  sLastGTCResult = result;
-  return result;
-}
-
-// Result is in [mt]
-static inline ULONGLONG
-PerformanceCounter()
-{
-  LARGE_INTEGER pc;
-  ::QueryPerformanceCounter(&pc);
-  return pc.QuadPart * 1000ULL;
-}
-
-// Called when we detect a larger deviation of QPC to disable it.
-static inline void
-RecordFlaw()
-{
-  sFallBackToGTC = true;
-
-  LOG(("TimeStamp: falling back to GTC :("));
-
-#if 0
-  // This code has been disabled, because we:
-  // 0. InitResolution must not be called under the lock (would reenter) while
-  //    we shouldn't release it here just to allow it
-  // 1. may return back to using QPC after system wake up
-  // 2. InitResolution for GTC will probably return 0 anyway (increments
-  //    only every 15 or 16 ms.)
-  //
-  // There is no need to drop sFrequencyPerSec to 1, result of TickCount64
-  // is multiplied and later divided with sFrequencyPerSec.  Changing it
-  // here may introduce sync problems.  Syncing access to sFrequencyPerSec
-  // is overkill.  Drawback is we loose some bits from the upper bound of
-  // the 64 bits timer value, usualy up to 7, it means the app cannot run
-  // more then some 4'000'000 years :)
-  InitResolution();
-#endif
-}
-
-// Check the current skew is in bounderies and occasionally recalculate it.
-// Return true if QPC is OK to use, return false to use GTC only.
-//
-// Arguments:
-// overflow - the calculated overflow out of the bounderies for skew difference
-// qpc - current value of QueryPerformanceCounter
-// gtc - current value of GetTickCount, more actual according possible system
-//       sleep between read of QPC and GTC
-static inline bool
-CheckCalibration(LONGLONG overflow, ULONGLONG qpc, ULONGLONG gtc)
-{
-  if (sFallBackToGTC) {
-    // We are forbidden to use QPC
-    return false;
-  }
-
-  ULONGLONG sinceLastCalibration = gtc - sLastCalibrated;
-
-  if (overflow && !sForceRecalibrate) {
-    // Calculate trend of the overflow to correspond to the calibration
-    // interval, we may get here long after the last calibration because we
-    // either didn't read the hi-res function or the system was suspended.
-    ULONGLONG trend = LONGLONG(overflow *
-      (double(kCalibrationInterval) / sinceLastCalibration));
-
-    LOG(("TimeStamp: calibration after %llus with overflow %1.4fms"
-         ", adjusted trend per calibration interval is %1.4fms",
-         sinceLastCalibration / 1000,
-         mt2ms_d(overflow),
-         mt2ms_d(trend)));
-
-    if (trend > ms2mt(kOverflowLimit)) {
-      // This sets sFallBackToGTC, we have detected
-      // an unreliability of QPC, stop using it.
-      RecordFlaw();
-      return false;
-    }
-  }
-
-  if (sinceLastCalibration > kCalibrationInterval || sForceRecalibrate) {
-    // Recalculate the skew now
-    sSkew = qpc - ms2mt(gtc);
-    sLastCalibrated = gtc;
-    LOG(("TimeStamp: new skew is %1.2fms (force:%d)",
-      mt2ms_d(sSkew), sForceRecalibrate));
-
-    sForceRecalibrate = false;
-  }
-
-  return true;
-}
-
-// The main function.  Result is in [mt] ensuring to not go back and be mostly
-// reliable with highest possible resolution.
-static ULONGLONG
-CalibratedPerformanceCounter()
-{
-  // XXX This is using ObserverService, cannot instantiate in the static
-  // startup, really needs a better initation code here.
-  StandbyObserver::Ensure();
-
-  // Don't hold the lock over call to QueryPerformanceCounter, since it is
-  // the largest bottleneck, let threads read the value concurently to have
-  // possibly a better performance.
-
-  ULONGLONG qpc = PerformanceCounter();
-  DWORD gtcw = GetTickCount();
-
-  AutoCriticalSection lock(&sTimeStampLock);
-
-  // Rollover protection
-  ULONGLONG gtc = TickCount64(gtcw);
-
-  LONGLONG diff = qpc - ms2mt(gtc) - sSkew;
-  LONGLONG overflow = 0;
-
-  if (diff < sUnderrunThreshold) {
-    overflow = sUnderrunThreshold - diff;
-  }
-  else if (diff > sOverrunThreshold) {
-    overflow = diff - sOverrunThreshold;
-  }
-
-  ULONGLONG result = qpc;
-  if (!CheckCalibration(overflow, qpc, gtc)) {
-    // We are back on GTC, QPC has been observed unreliable
-    result = ms2mt(gtc) + sSkew;
-  }
-
-#if 0
-  LOG(("TimeStamp: result = %1.2fms, diff = %1.4fms",
-      mt2ms_d(result), mt2ms_d(diff)));
-#endif
-
-  if (result > sLastResult)
-    sLastResult = result;
-
-  return sLastResult;
-}
-
-// ----------------------------------------------------------------------------
-// TimeDuration and TimeStamp implementation
-// ----------------------------------------------------------------------------
-
-double
-TimeDuration::ToSeconds() const
-{
-  return double(mValue) / (sFrequencyPerSec * 1000ULL);
-}
-
-double
-TimeDuration::ToSecondsSigDigits() const
-{
-  AutoCriticalSection lock(&sTimeStampLock);
-
-  // don't report a value < mResolution ...
-  LONGLONG resolution = sResolution;
-  LONGLONG resolutionSigDigs = sResolutionSigDigs;
-  LONGLONG valueSigDigs = resolution * (mValue / resolution);
-  // and chop off insignificant digits
-  valueSigDigs = resolutionSigDigs * (valueSigDigs / resolutionSigDigs);
-  return double(valueSigDigs) / kNsPerSecd;
-}
-
-TimeDuration
-TimeDuration::FromMilliseconds(double aMilliseconds)
-{
-  return TimeDuration::FromTicks(PRInt64(ms2mt(aMilliseconds)));
-}
-
-TimeDuration
-TimeDuration::Resolution()
-{
-  AutoCriticalSection lock(&sTimeStampLock);
-
-  return TimeDuration::FromTicks(PRInt64(sResolution));
-}
-
-struct TimeStampInitialization
-{
-  TimeStampInitialization() {
-    TimeStamp::Startup();
-  }
-  ~TimeStampInitialization() {
-    TimeStamp::Shutdown();
-  }
-};
-
-static TimeStampInitialization initOnce;
-
-nsresult
-TimeStamp::Startup()
-{
-  // Decide which implementation to use for the high-performance timer.
-
-  InitializeCriticalSectionAndSpinCount(&sTimeStampLock, kLockSpinCount);
-
-  LARGE_INTEGER freq;
-  BOOL QPCAvailable = ::QueryPerformanceFrequency(&freq);
-  if (!QPCAvailable) {
-    // No Performance Counter.  Fall back to use GetTickCount.
-    sFrequencyPerSec = 1;
-    sFallBackToGTC = true;
-    InitResolution();
-
-    LOG(("TimeStamp: using GetTickCount"));
-    return NS_OK;
-  }
-
-  sFrequencyPerSec = freq.QuadPart;
-
-  ULONGLONG qpc = PerformanceCounter();
-  sLastCalibrated = TickCount64(::GetTickCount());
-  sSkew = qpc - ms2mt(sLastCalibrated);
-
-  InitThresholds();
-  InitResolution();
-
-  LOG(("TimeStamp: initial skew is %1.2fms", mt2ms_d(sSkew)));
-
-  return NS_OK;
-}
-
-void
-TimeStamp::Shutdown()
-{
-  DeleteCriticalSection(&sTimeStampLock);
-}
-
-TimeStamp
-TimeStamp::Now()
-{
-  return TimeStamp(PRUint64(CalibratedPerformanceCounter()));
-}
-
-} // namespace mozilla