mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-26 23:54:56 +00:00
164 lines
4.7 KiB
C
164 lines
4.7 KiB
C
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* 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/. */
|
|
|
|
#ifndef vm_Time_h
|
|
#define vm_Time_h
|
|
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
/*
|
|
* Broken down form of 64 bit time value.
|
|
*/
|
|
struct PRMJTime {
|
|
int32_t tm_usec; /* microseconds of second (0-999999) */
|
|
int8_t tm_sec; /* seconds of minute (0-59) */
|
|
int8_t tm_min; /* minutes of hour (0-59) */
|
|
int8_t tm_hour; /* hour of day (0-23) */
|
|
int8_t tm_mday; /* day of month (1-31) */
|
|
int8_t tm_mon; /* month of year (0-11) */
|
|
int8_t tm_wday; /* 0=sunday, 1=monday, ... */
|
|
int32_t tm_year; /* absolute year, AD */
|
|
int16_t tm_yday; /* day of year (0 to 365) */
|
|
int8_t tm_isdst; /* non-zero if DST in effect */
|
|
};
|
|
|
|
/* Some handy constants */
|
|
#define PRMJ_USEC_PER_SEC 1000000L
|
|
#define PRMJ_USEC_PER_MSEC 1000L
|
|
|
|
/* Return the current local time in micro-seconds */
|
|
extern int64_t
|
|
PRMJ_Now();
|
|
|
|
/* Initialize the resources associated with PRMJ_Now. */
|
|
#if defined(XP_WIN)
|
|
extern void
|
|
PRMJ_NowInit();
|
|
#else
|
|
inline void
|
|
PRMJ_NowInit() {}
|
|
#endif
|
|
|
|
/* Release the resources associated with PRMJ_Now; don't call PRMJ_Now again */
|
|
#ifdef XP_WIN
|
|
extern void
|
|
PRMJ_NowShutdown();
|
|
#else
|
|
inline void
|
|
PRMJ_NowShutdown() {}
|
|
#endif
|
|
|
|
/* Format a time value into a buffer. Same semantics as strftime() */
|
|
extern size_t
|
|
PRMJ_FormatTime(char* buf, int buflen, const char* fmt, PRMJTime* tm);
|
|
|
|
|
|
/**
|
|
* Requesting the number of cycles from the CPU.
|
|
*
|
|
* `rdtsc`, or Read TimeStamp Cycle, is an instruction provided by
|
|
* x86-compatible CPUs that lets processes request the number of
|
|
* cycles spent by the CPU executing instructions since the CPU was
|
|
* started. It may be used for performance monitoring, but you should
|
|
* be aware of the following limitations.
|
|
*
|
|
*
|
|
* 1. The value is *not* monotonic.
|
|
*
|
|
* The value is reset to 0 whenever a CPU is turned off (e.g. computer
|
|
* in full hibernation, single CPU going turned off). Moreover, on
|
|
* multi-core/multi-CPU architectures, the cycles of each core/CPU are
|
|
* generally not synchronized. Therefore, is a process or thread is
|
|
* rescheduled to another core/CPU, the result of `rdtsc` may decrease
|
|
* arbitrarily.
|
|
*
|
|
* The only way to prevent this is to pin your thread to a particular
|
|
* CPU, which is generally not a good idea.
|
|
*
|
|
*
|
|
*
|
|
* 2. The value increases independently.
|
|
*
|
|
* The value may increase whenever the CPU executes an instruction,
|
|
* regardless of the process that has issued this
|
|
* instruction. Moreover, if a process or thread is rescheduled to
|
|
* another core/CPU, the result of `rdtsc` may increase arbitrarily.
|
|
*
|
|
* The only way to prevent this is to ensure that your thread is the
|
|
* sole owner of the CPU. See [1] for an example. This is also
|
|
* generally not a good idea.
|
|
*
|
|
*
|
|
*
|
|
* 3. The value does not measure time.
|
|
*
|
|
* On older architectures (pre-Pentium 4), there was no constant mapping
|
|
* between rdtsc and CPU time.
|
|
*
|
|
*
|
|
* 4. Instructions may be reordered.
|
|
*
|
|
* The CPU can reorder instructions. Also, rdtsc does not necessarily
|
|
* wait until all previous instructions have finished executing before
|
|
* reading the counter. Similarly, subsequent instructions may begin
|
|
* execution before the read operation is performed. If you use rdtsc
|
|
* for micro-benchmarking, you may end up measuring something else
|
|
* than what you expect. See [1] for a study of countermeasures.
|
|
*
|
|
*
|
|
* ** Performance
|
|
*
|
|
* According to unchecked sources on the web, the overhead of rdtsc is
|
|
* expected to be 150-200 cycles on old architectures, 6-50 on newer
|
|
* architectures. Agner's instruction tables [2] seem to confirm the latter
|
|
* results.
|
|
*
|
|
*
|
|
* [1]
|
|
* http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/ia-32-ia-64-benchmark-code-execution-paper.pdf
|
|
* [2] http://www.agner.org/optimize/instruction_tables.pdf
|
|
*/
|
|
|
|
#define MOZ_HAVE_RDTSC 1
|
|
|
|
#if defined(_WIN32)
|
|
|
|
#include <intrin.h>
|
|
static __inline uint64_t
|
|
ReadTimestampCounter(void)
|
|
{
|
|
return __rdtsc();
|
|
}
|
|
|
|
#elif defined(__i386__)
|
|
|
|
static __inline__ uint64_t
|
|
ReadTimestampCounter(void)
|
|
{
|
|
uint64_t x;
|
|
__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
|
|
return x;
|
|
}
|
|
|
|
#elif defined(__x86_64__)
|
|
|
|
static __inline__ uint64_t
|
|
ReadTimestampCounter(void)
|
|
{
|
|
unsigned hi, lo;
|
|
__asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
|
|
return ( (uint64_t)lo)|( ((uint64_t)hi)<<32 );
|
|
}
|
|
|
|
#else
|
|
|
|
#undef MOZ_HAVE_RDTSC
|
|
|
|
#endif
|
|
|
|
#endif /* vm_Time_h */
|