author Brian Birtles <birtles@gmail.com>
Thu, 25 Sep 2014 14:25:49 +0900
changeset 207117 af942cc33a8385e684ecc850f74af424482211b3
parent 207115 dc77f42529f7b494895c19365939f400b7176b62
child 208343 79ea9a38b446e5e46b66fec7365d2ed5e50891a8
permissions -rw-r--r--
Bug 1039924 part 3 - Templatize TimeDuration so it can support different behaviors with regards to tick count arithmetic; r=froydnj This patch prepares the way for having a separate StickyTimeDuration class by factoring TimeDuration into a templated base class: BaseTimeDuration. BaseTimeDuration takes a templated parameter, ValueCalculator, which is a helper object that defines how various arithmetic operations are performed on its mValue member (an int64_t count of ticks). This patch does not actually define or use the ValueCalculator parameter yet but simply performs the renaming and templatization. With regards to the templatization, arithmetic operators are defined to take objects with the same ValueCalculator template parameter (so that we don't, for example, apply non-safe arithmetic to a StickyTimeDuration). However, comparison operators are defined to also operate on objects with a different ValueCalculator template parameter since comparison should be independent of the type of arithmetic used. Likewise, the constructor and assignment operator are defined to operate on objects with a different ValueCalculator template parameter so that objects can be converted from TimeDuration to StickyTimeDuration and vice-versa. The constructor is marked as explicit, however, so that we don't silently convert a StickyTimeDuration to a TimeDuration and unwittingly apply non-safe arithmetic to a StickyTimeDuration. TimeDuration is defined as a specialization of BaseTimeDuration that uses TimeDurationValueCalculator as its ValueCalculator type. TimeDurationValueCalculator is filled-in in a subsequent patch.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// Implement TimeStamp::Now() with mach_absolute_time
// The "tick" unit for mach_absolute_time is defined using mach_timebase_info() which
// gives a conversion ratio to nanoseconds. For more information see Apple's QA1398.
// This code is inspired by Chromium's time_mac.cc. The biggest
// differences are that we explicitly initialize using
// TimeStamp::Initialize() instead of lazily in Now() and that
// we store the time value in ticks and convert when needed instead
// of storing the time value in nanoseconds.

#include <mach/mach_time.h>
#include <sys/time.h>
#include <sys/sysctl.h>
#include <time.h>
#include <unistd.h>

#include "mozilla/TimeStamp.h"
#include "nsDebug.h"

// Estimate of the smallest duration of time we can measure.
static uint64_t sResolution;
static uint64_t sResolutionSigDigs;

static const uint64_t kNsPerMs   =    1000000;
static const uint64_t kUsPerSec  =    1000000;
static const double kNsPerMsd    =    1000000.0;
static const double kNsPerSecd   = 1000000000.0;

static bool gInitialized = false;
static double sNsPerTick;

static uint64_t
  // mach_absolute_time is it when it comes to ticks on the Mac.  Other calls
  // with less precision (such as TickCount) just call through to
  // mach_absolute_time.
  // At the time of writing mach_absolute_time returns the number of nanoseconds
  // since boot. This won't overflow 64bits for 500+ years so we aren't going
  // to worry about that possiblity
  return mach_absolute_time();

static uint64_t
  uint64_t start = ClockTime();
  uint64_t end = ClockTime();
  uint64_t minres = (end - start);

  // 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
  for (int i = 0; i < 9; ++i) {
    start = ClockTime();
    end = ClockTime();

    uint64_t candidate = (start - end);
    if (candidate < minres) {
      minres = candidate;

  if (0 == minres) {
    // measurable resolution is either incredibly low, ~1ns, or very
    // high.  fall back on NSPR's resolution assumption
    minres = 1 * kNsPerMs;

  return minres;

namespace mozilla {

BaseTimeDurationPlatformUtils::ToSeconds(int64_t aTicks)
  NS_ABORT_IF_FALSE(gInitialized, "calling TimeDuration too early");
  return (aTicks * sNsPerTick) / kNsPerSecd;

BaseTimeDurationPlatformUtils::ToSecondsSigDigits(int64_t aTicks)
  NS_ABORT_IF_FALSE(gInitialized, "calling TimeDuration too early");
  // don't report a value < mResolution ...
  int64_t valueSigDigs = sResolution * (aTicks / sResolution);
  // and chop off insignificant digits
  valueSigDigs = sResolutionSigDigs * (valueSigDigs / sResolutionSigDigs);
  return (valueSigDigs * sNsPerTick) / kNsPerSecd;

BaseTimeDurationPlatformUtils::TicksFromMilliseconds(double aMilliseconds)
  NS_ABORT_IF_FALSE(gInitialized, "calling TimeDuration too early");
  return (aMilliseconds * kNsPerMsd) / sNsPerTick;

  NS_ABORT_IF_FALSE(gInitialized, "calling TimeDuration too early");
  return static_cast<int64_t>(sResolution);

  if (gInitialized) {
    return NS_OK;

  mach_timebase_info_data_t timebaseInfo;
  // Apple's QA1398 suggests that the output from mach_timebase_info
  // will not change while a program is running, so it should be safe
  // to cache the result.
  kern_return_t kr = mach_timebase_info(&timebaseInfo);
  if (kr != KERN_SUCCESS) {
    NS_RUNTIMEABORT("mach_timebase_info failed");

  sNsPerTick = double(timebaseInfo.numer) / timebaseInfo.denom;

  sResolution = ClockResolutionNs();

  // find the number of significant digits in sResolution, for the
  // sake of ToSecondsSigDigits()
  for (sResolutionSigDigs = 1;
       !(sResolutionSigDigs == sResolution ||
         10 * sResolutionSigDigs > sResolution);
       sResolutionSigDigs *= 10);

  gInitialized = true;

  return NS_OK;


TimeStamp::Now(bool aHighResolution)
  return TimeStamp(ClockTime());

// Computes and returns the process uptime in microseconds.
// Returns 0 if an error was encountered.

  struct timeval tv;
  int rv = gettimeofday(&tv, nullptr);

  if (rv == -1) {
    return 0;

  int mib[] = {
  u_int mibLen = sizeof(mib) / sizeof(mib[0]);

  struct kinfo_proc proc;
  size_t bufferSize = sizeof(proc);
  rv = sysctl(mib, mibLen, &proc, &bufferSize, nullptr, 0);

  if (rv == -1) {
    return 0;

  uint64_t startTime =
    ((uint64_t)proc.kp_proc.p_un.__p_starttime.tv_sec * kUsPerSec) +
  uint64_t now = (tv.tv_sec * kUsPerSec) + tv.tv_usec;

  if (startTime > now) {
    return 0;

  return now - startTime;

} // namespace mozilla