The Tor Browser / file revision

 /* -*- 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 POSIX clocks.

 //

 // The "tick" unit for POSIX clocks is simply a nanosecond, as this is

 // the smallest unit of time representable by struct timespec.  That

 // doesn't mean that a nanosecond is the resolution of TimeDurations

 // obtained with this API; see TimeDuration::Resolution;

 //

 #include <sys/syscall.h>

 #include <time.h>

 #include <unistd.h>

 #if defined(__DragonFly__) || defined(__FreeBSD__) \

     || defined(__NetBSD__) || defined(__OpenBSD__)

 #include <sys/param.h>

 #include <sys/sysctl.h>

 #endif

 #if defined(__DragonFly__) || defined(__FreeBSD__)

 #include <sys/user.h>

 #endif

 #if defined(__NetBSD__)

 #undef KERN_PROC

 #define KERN_PROC KERN_PROC2

 #define KINFO_PROC struct kinfo_proc2

 #else

 #define KINFO_PROC struct kinfo_proc

 #endif

 #if defined(__DragonFly__)

 #define KP_START_SEC kp_start.tv_sec

 #define KP_START_USEC kp_start.tv_usec

 #elif defined(__FreeBSD__)

 #define KP_START_SEC ki_start.tv_sec

 #define KP_START_USEC ki_start.tv_usec

 #else

 #define KP_START_SEC p_ustart_sec

 #define KP_START_USEC p_ustart_usec

 #endif

 #include "mozilla/TimeStamp.h"

 #include "nsCRT.h"

 #include "prprf.h"

 #include "prthread.h"

 #include "nsDebug.h"

 // Estimate of the smallest duration of time we can measure.

 static uint64_t sResolution;

 static uint64_t sResolutionSigDigs;

 static const uint16_t kNsPerUs   =       1000;

 static const uint64_t kNsPerMs   =    1000000;

 static const uint64_t kNsPerSec  = 1000000000; 

 static const double kNsPerMsd    =    1000000.0;

 static const double kNsPerSecd   = 1000000000.0;

 static uint64_t

 TimespecToNs(const struct timespec& ts)

 {

   uint64_t baseNs = uint64_t(ts.tv_sec) * kNsPerSec;

   return baseNs + uint64_t(ts.tv_nsec);

 }

 static uint64_t

 ClockTimeNs()

 {

   struct timespec ts;

   // this can't fail: we know &ts is valid, and TimeStamp::Startup()

   // checks that CLOCK_MONOTONIC is supported (and aborts if not)

   clock_gettime(CLOCK_MONOTONIC, &ts);

   // tv_sec is defined to be relative to an arbitrary point in time,

   // but it would be madness for that point in time to be earlier than

   // the Epoch.  So we can safely assume that even if time_t is 32

   // bits, tv_sec won't overflow while the browser is open.  Revisit

   // this argument if we're still building with 32-bit time_t around

   // the year 2037.

   return TimespecToNs(ts);

 }

 static uint64_t

 ClockResolutionNs()

 {

   // NB: why not rely on clock_getres()?  Two reasons: (i) it might

   // lie, and (ii) it might return an "ideal" resolution that while

   // theoretically true, could never be measured in practice.  Since

   // clock_gettime() likely involves a system call on your platform,

   // the "actual" timing resolution shouldn't be lower than syscall

   // overhead.

   uint64_t start = ClockTimeNs();

   uint64_t end = ClockTimeNs();

   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 = ClockTimeNs();

     end = ClockTimeNs();

     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 clock_getres()

     struct timespec ts;

     if (0 == clock_getres(CLOCK_MONOTONIC, &ts)) {

       minres = TimespecToNs(ts);

     }

   }

   if (0 == minres) {

     // clock_getres probably failed.  fall back on NSPR's resolution

     // assumption

     minres = 1 * kNsPerMs;

   }

   return minres;

 }

 namespace mozilla {

 double

 TimeDuration::ToSeconds() const

 {

   return double(mValue) / kNsPerSecd;

 }

 double

 TimeDuration::ToSecondsSigDigits() const

 {

   // don't report a value < mResolution ...

   int64_t valueSigDigs = sResolution * (mValue / sResolution);

   // and chop off insignificant digits

   valueSigDigs = sResolutionSigDigs * (valueSigDigs / sResolutionSigDigs);

   return double(valueSigDigs) / kNsPerSecd;

 }

 TimeDuration

 TimeDuration::FromMilliseconds(double aMilliseconds)

 {

   return TimeDuration::FromTicks(aMilliseconds * kNsPerMsd);

 }

 TimeDuration

 TimeDuration::Resolution()

 {

   return TimeDuration::FromTicks(int64_t(sResolution));

 }

 static bool gInitialized = false;

 nsresult

 TimeStamp::Startup()

 {

   if (gInitialized)

     return NS_OK;

   struct timespec dummy;

   if (0 != clock_gettime(CLOCK_MONOTONIC, &dummy))

       NS_RUNTIMEABORT("CLOCK_MONOTONIC is absent!");

   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;

 }

 void

 TimeStamp::Shutdown()

 {

 }

 TimeStamp

 TimeStamp::Now(bool aHighResolution)

 {

   return TimeStamp(ClockTimeNs());

 }

 #if defined(LINUX) || defined(ANDROID)

 // Calculates the amount of jiffies that have elapsed since boot and up to the

 // starttime value of a specific process as found in its /proc/*/stat file.

 // Returns 0 if an error occurred.

 static uint64_t

 JiffiesSinceBoot(const char *aFile)

 {

   char stat[512];

   FILE *f = fopen(aFile, "r");

   if (!f)

     return 0;

   int n = fread(&stat, 1, sizeof(stat) - 1, f);

   fclose(f);

   if (n <= 0)

     return 0;

   stat[n] = 0;

   long long unsigned startTime = 0; // instead of uint64_t to keep GCC quiet

   char *s = strrchr(stat, ')');

   if (!s)

     return 0;

   int rv = sscanf(s + 2,

                   "%*c %*d %*d %*d %*d %*d %*u %*u %*u %*u "

                   "%*u %*u %*u %*d %*d %*d %*d %*d %*d %llu",

                   &startTime);

   if (rv != 1 || !startTime)

     return 0;

   return startTime;

 }

 // Computes the interval that has elapsed between the thread creation and the

 // process creation by comparing the starttime fields in the respective

 // /proc/*/stat files. The resulting value will be a good approximation of the

 // process uptime. This value will be stored at the address pointed by aTime;

 // if an error occurred 0 will be stored instead.

 static void

 ComputeProcessUptimeThread(void *aTime)

 {

   uint64_t *uptime = static_cast<uint64_t *>(aTime);

   long hz = sysconf(_SC_CLK_TCK);

   *uptime = 0;

   if (!hz)

     return;

   char threadStat[40];

   sprintf(threadStat, "/proc/self/task/%d/stat", (pid_t) syscall(__NR_gettid));

   uint64_t threadJiffies = JiffiesSinceBoot(threadStat);

   uint64_t selfJiffies = JiffiesSinceBoot("/proc/self/stat");

   if (!threadJiffies || !selfJiffies)

     return;

   *uptime = ((threadJiffies - selfJiffies) * kNsPerSec) / hz;

 }

 // Computes and returns the process uptime in us on Linux & its derivatives.

 // Returns 0 if an error was encountered.

 uint64_t

 TimeStamp::ComputeProcessUptime()

 {

   uint64_t uptime = 0;

   PRThread *thread = PR_CreateThread(PR_USER_THREAD,

                                      ComputeProcessUptimeThread,

                                      &uptime,

                                      PR_PRIORITY_NORMAL,

                                      PR_GLOBAL_THREAD,

                                      PR_JOINABLE_THREAD,

                                      0);

   PR_JoinThread(thread);

   return uptime / kNsPerUs;

 }

 #elif defined(__DragonFly__) || defined(__FreeBSD__) \

       || defined(__NetBSD__) || defined(__OpenBSD__)

 // Computes and returns the process uptime in us on various BSD flavors.

 // Returns 0 if an error was encountered.

 uint64_t

 TimeStamp::ComputeProcessUptime()

 {

   struct timespec ts;

   int rv = clock_gettime(CLOCK_REALTIME, &ts);

   if (rv == -1) {

     return 0;

   }

   int mib[] = {

     CTL_KERN,

     KERN_PROC,

     KERN_PROC_PID,

     getpid(),

 #if defined(__NetBSD__) || defined(__OpenBSD__)

     sizeof(KINFO_PROC),

     1,

 #endif

   };

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

   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_START_SEC * kNsPerSec)

     + (proc.KP_START_USEC * kNsPerUs);

   uint64_t now = ((uint64_t)ts.tv_sec * kNsPerSec) + ts.tv_nsec;

   if (startTime > now)

     return 0;

   return (now - startTime) / kNsPerUs;

 }

 #else

 uint64_t

 TimeStamp::ComputeProcessUptime()

 {

   return 0;

 }

 #endif

 } // namespace mozilla