Changeset 50711 in webkit for trunk/JavaScriptCore

Timestamp:

Nov 9, 2009, 8:14:34 PM (16 years ago)

Author:

[email protected]

Message:

Imported the v8 DST cache.

Reviewed by Oliver Hunt.

SunSpider says 1.5% faster.

• runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::resetDateCache): Reset the DST cache when resetting
other date data.

• runtime/JSGlobalData.h:

(JSC::DSTOffsetCache::DSTOffsetCache):
(JSC::DSTOffsetCache::reset): Added a struct for the DST cache.

• wtf/DateMath.cpp:

(WTF::calculateDSTOffsetSimple):
(WTF::calculateDSTOffset):
(WTF::parseDateFromNullTerminatedCharacters):
(JSC::getDSTOffset):
(JSC::gregorianDateTimeToMS):
(JSC::msToGregorianDateTime):
(JSC::parseDateFromNullTerminatedCharacters):

• wtf/DateMath.h: The imported code for probing and updating the cache.

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• runtime/JSGlobalData.cpp (modified) (1 diff)
• runtime/JSGlobalData.h (modified) (3 diffs)
• wtf/DateMath.cpp (modified) (9 diffs)
• wtf/DateMath.h (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2009-11-09  Geoffrey Garen  <[email protected]>
+
+        Reviewed by Oliver Hunt.
+
+        Imported the v8 DST cache.
+        
+        SunSpider says 1.5% faster.
+
+        * runtime/JSGlobalData.cpp:
+        (JSC::JSGlobalData::resetDateCache): Reset the DST cache when resetting
+        other date data.
+
+        * runtime/JSGlobalData.h:
+        (JSC::DSTOffsetCache::DSTOffsetCache):
+        (JSC::DSTOffsetCache::reset): Added a struct for the DST cache.
+
+        * wtf/DateMath.cpp:
+        (WTF::calculateDSTOffsetSimple):
+        (WTF::calculateDSTOffset):
+        (WTF::parseDateFromNullTerminatedCharacters):
+        (JSC::getDSTOffset):
+        (JSC::gregorianDateTimeToMS):
+        (JSC::msToGregorianDateTime):
+        (JSC::parseDateFromNullTerminatedCharacters):
+        * wtf/DateMath.h: The imported code for probing and updating the cache.
+
 2009-11-09  Geoffrey Garen  <[email protected]>
 

trunk/JavaScriptCore/runtime/JSGlobalData.cpp

@@ -256 +256 @@
 {
     cachedUTCOffset = NaN;
+    dstOffsetCache.reset();
     cachedDateString = UString();
     dateInstanceCache.reset();

trunk/JavaScriptCore/runtime/JSGlobalData.h

@@ -63 +63 @@
     struct Instruction;    
     struct VPtrSet;
+
+    struct DSTOffsetCache {
+        DSTOffsetCache()
+        {
+            reset();
+        }
+        
+        void reset()
+        {
+            offset = 0.0;
+            start = 0.0;
+            end = -1.0;
+            increment = 0.0;
+        }
+
+        double offset;
+        double start;
+        double end;
+        double increment;
+    };
 
     class JSGlobalData : public RefCounted<JSGlobalData> {
@@ -155 +175 @@
 
         double cachedUTCOffset;
-
+        DSTOffsetCache dstOffsetCache;
+        
         UString cachedDateString;
         double cachedDateStringValue;
@@ -173 +194 @@
         void createNativeThunk();
     };
-
+    
 } // namespace JSC
 

trunk/JavaScriptCore/wtf/DateMath.cpp

@@ -40 +40 @@
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
+
+ * Copyright 2006-2008 the V8 project authors. All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
@@ -381 +408 @@
 
 /*
- * Get the DST offset for the time passed in.  Takes
- * seconds (not milliseconds) and cannot handle dates before 1970
- * on some OS'
+ * Get the DST offset for the time passed in.
  */
-static double getDSTOffsetSimple(double localTimeSeconds, double utcOffset)
+static double calculateDSTOffsetSimple(double localTimeSeconds, double utcOffset)
 {
     if (localTimeSeconds > maxUnixTime)
@@ -414 +439 @@
 
 // Get the DST offset, given a time in UTC
-static double getDSTOffset(double ms, double utcOffset)
-{
-    // On Mac OS X, the call to localtime (see getDSTOffsetSimple) will return historically accurate
+static double calculateDSTOffset(double ms, double utcOffset)
+{
+    // On Mac OS X, the call to localtime (see calculateDSTOffsetSimple) will return historically accurate
     // DST information (e.g. New Zealand did not have DST from 1946 to 1974) however the JavaScript
     // standard explicitly dictates that historical information should not be considered when
@@ -432 +457 @@
     }
 
-    return getDSTOffsetSimple(ms / msPerSecond, utcOffset);
+    return calculateDSTOffsetSimple(ms / msPerSecond, utcOffset);
 }
 
@@ -803 +828 @@
     if (!haveTZ) {
         double utcOffset = calculateUTCOffset();
-        double dstOffset = getDSTOffset(ms, utcOffset);
+        double dstOffset = calculateDSTOffset(ms, utcOffset);
         offset = static_cast<int>((utcOffset + dstOffset) / msPerMinute);
     }
@@ -821 +846 @@
 #if USE(JSC)
 namespace JSC {
+
+// Get the DST offset for the time passed in.
+//
+// NOTE: The implementation relies on the fact that no time zones have
+// more than one daylight savings offset change per month.
+// If this function is called with NaN it returns NaN.
+static double getDSTOffset(ExecState* exec, double ms, double utcOffset)
+{
+    DSTOffsetCache& cache = exec->globalData().dstOffsetCache;
+    double start = cache.start;
+    double end = cache.end;
+
+    if (start <= ms) {
+        // If the time fits in the cached interval, return the cached offset.
+        if (ms <= end) return cache.offset;
+
+        // Compute a possible new interval end.
+        double newEnd = end + cache.increment;
+
+        if (ms <= newEnd) {
+            double endOffset = calculateDSTOffset(newEnd, utcOffset);
+            if (cache.offset == endOffset) {
+                // If the offset at the end of the new interval still matches
+                // the offset in the cache, we grow the cached time interval
+                // and return the offset.
+                cache.end = newEnd;
+                cache.increment = msPerMonth;
+                return endOffset;
+            } else {
+                double offset = calculateDSTOffset(ms, utcOffset);
+                if (offset == endOffset) {
+                    // The offset at the given time is equal to the offset at the
+                    // new end of the interval, so that means that we've just skipped
+                    // the point in time where the DST offset change occurred. Updated
+                    // the interval to reflect this and reset the increment.
+                    cache.start = ms;
+                    cache.end = newEnd;
+                    cache.increment = msPerMonth;
+                } else {
+                    // The interval contains a DST offset change and the given time is
+                    // before it. Adjust the increment to avoid a linear search for
+                    // the offset change point and change the end of the interval.
+                    cache.increment /= 3;
+                    cache.end = ms;
+                }
+                // Update the offset in the cache and return it.
+                cache.offset = offset;
+                return offset;
+            }
+        }
+    }
+
+    // Compute the DST offset for the time and shrink the cache interval
+    // to only contain the time. This allows fast repeated DST offset
+    // computations for the same time.
+    double offset = calculateDSTOffset(ms, utcOffset);
+    cache.offset = offset;
+    cache.start = ms;
+    cache.end = ms;
+    cache.increment = msPerMonth;
+    return offset;
+}
+
 /*
  * Get the difference in milliseconds between this time zone and UTC (GMT)
@@ -843 +931 @@
         double utcOffset = getUTCOffset(exec);
         result -= utcOffset;
-        result -= getDSTOffset(result, utcOffset);
+        result -= getDSTOffset(exec, result, utcOffset);
     }
 
@@ -856 +944 @@
     if (!outputIsUTC) {
         utcOff = getUTCOffset(exec);
-        dstOff = getDSTOffset(ms, utcOff);
+        dstOff = getDSTOffset(exec, ms, utcOff);
         ms += dstOff + utcOff;
     }
@@ -883 +971 @@
     if (!haveTZ) {
         double utcOffset = getUTCOffset(exec);
-        double dstOffset = getDSTOffset(ms, utcOffset);
+        double dstOffset = getDSTOffset(exec, ms, utcOffset);
         offset = static_cast<int>((utcOffset + dstOffset) / WTF::msPerMinute);
     }

trunk/JavaScriptCore/wtf/DateMath.h

@@ -75 +75 @@
 const double msPerHour = 60.0 * 60.0 * 1000.0;
 const double msPerDay = 24.0 * 60.0 * 60.0 * 1000.0;
+const double msPerMonth = 2592000000.0;
 
 } // namespace WTF