216 lines
8.6 KiB
C++
216 lines
8.6 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_DateTime_h
|
|
#define vm_DateTime_h
|
|
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/Atomics.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/FloatingPoint.h"
|
|
#include "mozilla/MathAlgorithms.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "js/Conversions.h"
|
|
#include "js/Date.h"
|
|
#include "js/Initialization.h"
|
|
#include "js/Value.h"
|
|
|
|
namespace js {
|
|
|
|
/* Constants defined by ES5 15.9.1.10. */
|
|
const double HoursPerDay = 24;
|
|
const double MinutesPerHour = 60;
|
|
const double SecondsPerMinute = 60;
|
|
const double msPerSecond = 1000;
|
|
const double msPerMinute = msPerSecond * SecondsPerMinute;
|
|
const double msPerHour = msPerMinute * MinutesPerHour;
|
|
|
|
/* ES5 15.9.1.2. */
|
|
const double msPerDay = msPerHour * HoursPerDay;
|
|
|
|
/*
|
|
* Additional quantities not mentioned in the spec. Be careful using these!
|
|
* They aren't doubles (and aren't defined in terms of all the other constants
|
|
* so that they can be used in constexpr scenarios; if you need constants that
|
|
* trigger floating point semantics, you'll have to manually cast to get it.
|
|
*/
|
|
const unsigned SecondsPerHour = 60 * 60;
|
|
const unsigned SecondsPerDay = SecondsPerHour * 24;
|
|
|
|
const double StartOfTime = -8.64e15;
|
|
const double EndOfTime = 8.64e15;
|
|
|
|
/*
|
|
* Stores date/time information, particularly concerning the current local
|
|
* time zone, and implements a small cache for daylight saving time offset
|
|
* computation.
|
|
*
|
|
* The basic idea is premised upon this fact: the DST offset never changes more
|
|
* than once in any thirty-day period. If we know the offset at t_0 is o_0,
|
|
* the offset at [t_1, t_2] is also o_0, where t_1 + 3_0 days == t_2,
|
|
* t_1 <= t_0, and t0 <= t2. (In other words, t_0 is always somewhere within a
|
|
* thirty-day range where the DST offset is constant: DST changes never occur
|
|
* more than once in any thirty-day period.) Therefore, if we intelligently
|
|
* retain knowledge of the offset for a range of dates (which may vary over
|
|
* time), and if requests are usually for dates within that range, we can often
|
|
* provide a response without repeated offset calculation.
|
|
*
|
|
* Our caching strategy is as follows: on the first request at date t_0 compute
|
|
* the requested offset o_0. Save { start: t_0, end: t_0, offset: o_0 } as the
|
|
* cache's state. Subsequent requests within that range are straightforwardly
|
|
* handled. If a request for t_i is far outside the range (more than thirty
|
|
* days), compute o_i = dstOffset(t_i) and save { start: t_i, end: t_i,
|
|
* offset: t_i }. Otherwise attempt to *overextend* the range to either
|
|
* [start - 30d, end] or [start, end + 30d] as appropriate to encompass
|
|
* t_i. If the offset o_i30 is the same as the cached offset, extend the
|
|
* range. Otherwise the over-guess crossed a DST change -- compute
|
|
* o_i = dstOffset(t_i) and either extend the original range (if o_i == offset)
|
|
* or start a new one beneath/above the current one with o_i30 as the offset.
|
|
*
|
|
* This cache strategy results in 0 to 2 DST offset computations. The naive
|
|
* always-compute strategy is 1 computation, and since cache maintenance is a
|
|
* handful of integer arithmetic instructions the speed difference between
|
|
* always-1 and 1-with-cache is negligible. Caching loses if two computations
|
|
* happen: when the date is within 30 days of the cached range and when that
|
|
* 30-day range crosses a DST change. This is relatively uncommon. Further,
|
|
* instances of such are often dominated by in-range hits, so caching is an
|
|
* overall slight win.
|
|
*
|
|
* Why 30 days? For correctness the duration must be smaller than any possible
|
|
* duration between DST changes. Past that, note that 1) a large duration
|
|
* increases the likelihood of crossing a DST change while reducing the number
|
|
* of cache misses, and 2) a small duration decreases the size of the cached
|
|
* range while producing more misses. Using a month as the interval change is
|
|
* a balance between these two that tries to optimize for the calendar month at
|
|
* a time that a site might display. (One could imagine an adaptive duration
|
|
* that accommodates near-DST-change dates better; we don't believe the
|
|
* potential win from better caching offsets the loss from extra complexity.)
|
|
*/
|
|
class DateTimeInfo
|
|
{
|
|
static DateTimeInfo instance;
|
|
|
|
// Date/time info is shared across all threads in DateTimeInfo::instance,
|
|
// for consistency with ICU's handling of its default time zone. Thus we
|
|
// need something to protect concurrent accesses.
|
|
//
|
|
// The spec implicitly assumes DST and time zone adjustment information
|
|
// never change in the course of a function -- sometimes even across
|
|
// reentrancy. So make critical sections as narrow as possible, and use a
|
|
// bog-standard spinlock with busy-waiting in case of contention for
|
|
// simplicity.
|
|
class MOZ_RAII AcquireLock
|
|
{
|
|
static mozilla::Atomic<bool, mozilla::ReleaseAcquire> spinLock;
|
|
|
|
public:
|
|
AcquireLock() {
|
|
while (!spinLock.compareExchange(false, true))
|
|
continue;
|
|
}
|
|
~AcquireLock() {
|
|
MOZ_ASSERT(spinLock, "spinlock should have been acquired");
|
|
spinLock = false;
|
|
}
|
|
};
|
|
|
|
friend const char* JS::detail::InitWithFailureDiagnostic(bool);
|
|
|
|
// Initialize global date/time tracking state. This operation occurs
|
|
// during, and is restricted to, SpiderMonkey initialization.
|
|
static void init();
|
|
|
|
public:
|
|
/*
|
|
* Get the DST offset in milliseconds at a UTC time. This is usually
|
|
* either 0 or |msPerSecond * SecondsPerHour|, but at least one exotic time
|
|
* zone (Lord Howe Island, Australia) has a fractional-hour offset, just to
|
|
* keep things interesting.
|
|
*/
|
|
static int64_t getDSTOffsetMilliseconds(int64_t utcMilliseconds) {
|
|
AcquireLock lock;
|
|
|
|
return DateTimeInfo::instance.internalGetDSTOffsetMilliseconds(utcMilliseconds);
|
|
}
|
|
|
|
/* ES5 15.9.1.7. */
|
|
static double localTZA() {
|
|
AcquireLock lock;
|
|
|
|
return DateTimeInfo::instance.localTZA_;
|
|
}
|
|
|
|
private:
|
|
// We don't want anyone accidentally calling *only*
|
|
// DateTimeInfo::updateTimeZoneAdjustment() to respond to a system time
|
|
// zone change (missing the necessary poking of ICU as well), so ensure
|
|
// only JS::ResetTimeZone() can call this via access restrictions.
|
|
friend void JS::ResetTimeZone();
|
|
|
|
static void updateTimeZoneAdjustment() {
|
|
AcquireLock lock;
|
|
|
|
DateTimeInfo::instance.internalUpdateTimeZoneAdjustment();
|
|
}
|
|
|
|
/*
|
|
* The current local time zone adjustment, cached because retrieving this
|
|
* dynamically is Slow, and a certain venerable benchmark which shall not
|
|
* be named depends on it being fast.
|
|
*
|
|
* SpiderMonkey occasionally and arbitrarily updates this value from the
|
|
* system time zone to attempt to keep this reasonably up-to-date. If
|
|
* temporary inaccuracy can't be tolerated, JSAPI clients may call
|
|
* JS::ResetTimeZone to forcibly sync this with the system time zone.
|
|
*/
|
|
double localTZA_;
|
|
|
|
/*
|
|
* Compute the DST offset at the given UTC time in seconds from the epoch.
|
|
* (getDSTOffsetMilliseconds attempts to return a cached value, but in case
|
|
* of a cache miss it calls this method. The cache is represented through
|
|
* the offset* and *{Start,End}Seconds fields below.)
|
|
*/
|
|
int64_t computeDSTOffsetMilliseconds(int64_t utcSeconds);
|
|
|
|
int64_t offsetMilliseconds;
|
|
int64_t rangeStartSeconds, rangeEndSeconds; // UTC-based
|
|
|
|
int64_t oldOffsetMilliseconds;
|
|
int64_t oldRangeStartSeconds, oldRangeEndSeconds; // UTC-based
|
|
|
|
/*
|
|
* Cached offset in seconds from the current UTC time to the current
|
|
* local standard time (i.e. not including any offset due to DST).
|
|
*/
|
|
int32_t utcToLocalStandardOffsetSeconds;
|
|
|
|
static const int64_t MaxUnixTimeT = 2145859200; /* time_t 12/31/2037 */
|
|
|
|
static const int64_t RangeExpansionAmount = 30 * SecondsPerDay;
|
|
|
|
int64_t internalGetDSTOffsetMilliseconds(int64_t utcMilliseconds);
|
|
void internalUpdateTimeZoneAdjustment();
|
|
|
|
void sanityCheck();
|
|
};
|
|
|
|
/**
|
|
* ICU's default time zone, used for various date/time formatting operations
|
|
* that include the local time in the representation, is allowed to go stale
|
|
* for unfortunate performance reasons. Call this function when an up-to-date
|
|
* default time zone is required, to resync ICU's default time zone with
|
|
* reality.
|
|
*/
|
|
extern void
|
|
ResyncICUDefaultTimeZone();
|
|
|
|
} /* namespace js */
|
|
|
|
#endif /* vm_DateTime_h */
|