Add trigonometric table to the snapshot.

src/math.js

 // Copyright 2012 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
@@ skipping 60 matching lines @@
 function MathAtan2(y, x) {
   return %Math_atan2(TO_NUMBER_INLINE(y), TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.6
 function MathCeil(x) {
   return %Math_ceil(TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.7
-function MathCos(x) {
-  return MathCosImpl(x);
-}
+var MathCos;
 
 // ECMA 262 - 15.8.2.8
 function MathExp(x) {
   return %Math_exp(TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.9
 function MathFloor(x) {
   x = TO_NUMBER_INLINE(x);
   // It's more common to call this with a positive number that's out
@@ skipping 77 matching lines @@
 function MathRandom() {
   return %_RandomHeapNumber();
 }
 
 // ECMA 262 - 15.8.2.15
 function MathRound(x) {
   return %RoundNumber(TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.16
-function MathSin(x) {
-  return MathSinImpl(x);
-}
+var MathSin;
 
 // ECMA 262 - 15.8.2.17
 function MathSqrt(x) {
   return %_MathSqrt(TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.18
 function MathTan(x) {
-  return MathSinImpl(x) / MathCosImpl(x);
+  return MathSin(x) / MathCos(x);
 }
 
 // Non-standard extension.
 function MathImul(x, y) {
   return %NumberImul(TO_NUMBER_INLINE(x), TO_NUMBER_INLINE(y));
 }
 
 
-var MathSinImpl = function(x) {
-  InitTrigonometricFunctions();
-  return MathSinImpl(x);
-}
-
-
-var MathCosImpl = function(x) {
-  InitTrigonometricFunctions();
-  return MathCosImpl(x);
-}
-
-
 var InitTrigonometricFunctions;
 
 
 // Define constants and interpolation functions.
 // Also define the initialization function that populates the lookup table
 // and then wires up the function definitions.
 function SetupTrigonometricFunctions() {

[Sven Panne, 2013/11/21 08:09:27]

Hmmm, all this lazy-evaluation-by-hand magic is highly complicated. Furthermore,
every context using sin/cos will get its own tables, which is wasteful.

Another much easier and less wasteful approach is keeping the tables per Isolate
on the native side and use them in every context.

   var samples = 1800;   // Table size.  Do not change arbitrarily.
   var inverse_pi_half      = 0.636619772367581343;      // 2 / pi
   var inverse_pi_half_s_26 = 9.48637384723993156e-9;    // 2 / pi / (2^26)
   var s_26 = 1 << 26;
   var two_step_threshold   = 1 << 27;
   var index_convert        = 1145.915590261646418;      // samples / (pi / 2)
   // pi / 2 rounded up
   var pi_half              = 1.570796326794896780;      // 0x192d4454fb21f93f
   // We use two parts for pi/2 to emulate a higher precision.
   // pi_half_1 only has 26 significant bits for mantissa.
   // Note that pi_half > pi_half_1 + pi_half_2
   var pi_half_1            = 1.570796325802803040;      // 0x00000054fb21f93f
   var pi_half_2            = 9.920935796805404252e-10;  // 0x3326a611460b113e
-  var table_sin;
-  var table_cos_interval;
+
+  var table_sin = new InternalDoubleArray(samples + 2);
+  var table_cos_interval = new InternalDoubleArray(samples + 2);
+  %PopulateTrigonometricTable(table_sin, table_cos_interval, samples);
+
 
   // This implements sine using the following algorithm.
   // 1) Multiplication takes care of to-number conversion.
   // 2) Reduce x to the first quadrant [0, pi/2].
   //    Conveniently enough, in case of +/-Infinity, we get NaN.
   //    Note that we try to use only 26 instead of 52 significant bits for
   //    mantissa to avoid rounding errors when multiplying.  For very large
   //    input we therefore have additional steps.
   // 3) Replace x by (pi/2-x) if x was in the 2nd or 4th quadrant.
   // 4) Do a table lookup for the closest samples to the left and right of x.
   // 5) Find the derivatives at those sampling points by table lookup:
   //    dsin(x)/dx = cos(x) = sin(pi/2-x) for x in [0, pi/2].
   // 6) Use cubic spline interpolation to approximate sin(x).
   // 7) Negate the result if x was in the 3rd or 4th quadrant.
   // 8) Get rid of -0 by adding 0.
   var Interpolation = function(x, phase) {
     if (x < 0 || x > pi_half) {
       var multiple;
       while (x < -two_step_threshold || x > two_step_threshold) {
         // Let's assume this loop does not terminate.

[Sven Panne, 2013/11/21 08:09:27]

Hmmm, I am still not convinced that the loop will always terminate. The "proof"
here is not a real proof, what would be needed is the calculation of the actual
error propagation through the expressions in the loop body plus some strictly
monotonic value derived from it.

Let's see how this works out in practice...

         // All numbers x in each loop forms a set S.
         // (1) abs(x) > 2^27 for all x in S.
         // (2) abs(multiple) != 0 since (2^27 * inverse_pi_half_s26) > 1
         // (3) multiple is rounded down in 2^26 steps, so the rounding error is
         //     at most max(ulp, 2^26).
         // (4) so for x > 2^27, we subtract at most (1+pi/4)x and at least
         //     (1-pi/4)x
         // (5) The subtraction results in x' so that abs(x') <= abs(x)*pi/4.
         //     Note that this difference cannot be simply rounded off.
         // Set S cannot exist since (5) violates (1).  Loop must terminate.
@@ skipping 11 matching lines @@
     var t2 = 1 - t1;
     var y1 = table_sin[index];
     var y2 = table_sin[index + 1];
     var dy = y2 - y1;
     return (t2 * y1 + t1 * y2 +
                 t1 * t2 * ((table_cos_interval[index] - dy) * t2 +
                            (dy - table_cos_interval[index + 1]) * t1))
            * (1 - (phase & 2)) + 0;
   }
 
-  var MathSinInterpolation = function(x) {
+  MathSin = function(x) {
     x = x * 1;  // Convert to number and deal with -0.
     if (%_IsMinusZero(x)) return x;
     return Interpolation(x, 0);
   }
 
   // Cosine is sine with a phase offset.
-  var MathCosInterpolation = function(x) {
+  MathCos = function(x) {
     x = MathAbs(x);  // Convert to number and get rid of -0.
     return Interpolation(x, 1);
   };
 
   %SetInlineBuiltinFlag(Interpolation);
-  %SetInlineBuiltinFlag(MathSinInterpolation);
-  %SetInlineBuiltinFlag(MathCosInterpolation);
-
-  InitTrigonometricFunctions = function() {
-    table_sin = new global.Float64Array(samples + 2);
-    table_cos_interval = new global.Float64Array(samples + 2);
-    %PopulateTrigonometricTable(table_sin, table_cos_interval, samples);
-    MathSinImpl = MathSinInterpolation;
-    MathCosImpl = MathCosInterpolation;
-  }
 }
 
 SetupTrigonometricFunctions();
 
 
 // -------------------------------------------------------------------
 
 function SetUpMath() {
   %CheckIsBootstrapping();
 
@@ skipping 64 matching lines @@
     "min", MathMin,
     "imul", MathImul
   ));
 
   %SetInlineBuiltinFlag(MathSin);
   %SetInlineBuiltinFlag(MathCos);
   %SetInlineBuiltinFlag(MathTan);
 }
 
 SetUpMath();