Optimize number-to-string conversions.

runtime/lib/double.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class _Double extends _Num implements double {
   factory _Double.fromInteger(int value)
       native "Double_doubleFromInteger";
 
   Type get runtimeType => double;
 
@@ skipping 118 matching lines @@
     }
     if (lowerLimit.isNaN) return lowerLimit;
     if (this.compareTo(lowerLimit) < 0) return lowerLimit;
     if (this.compareTo(upperLimit) > 0) return upperLimit;
     return this;
   }
 
   int toInt() native "Double_toInt";
   double toDouble() { return this; }
 
+  // Number of keys + values. Should be a power of 2.
+  static const int CACHE_LENGTH = 16;

[Ivan Posva, 2014/08/29 20:58:47]

How about enforcing the comment by:
static const int CACHE_SIZE_LOG2 = 3;
static const int CACHE_LENGTH = 1 << (CACHE_SIZE_LOG2 + 1);
...

[koda, 2014/08/29 21:02:33]

Done.

+  static const int CACHE_MASK = CACHE_LENGTH - 1;
+  // Each key (double) followed by its toString result.
+  static final List _cache = new List(CACHE_LENGTH);
+  static int _cacheEvictIndex = 0;

[Lasse Reichstein Nielsen, 2014/09/01 07:14:21]

This "optimization" seems a little too speculative to me.
Are there cases, outside of silly benchmarks, where the same four doubles keep
getting toString'ed? If so, is it always the same doubles (e.g., -1.0, 0.0, 1.0,
and 2.0) so we could just hardcode those?

+
+  String toString() {
+    // TODO(koda): Consider optimizing all small integral values.
+    if (identical(0.0, this)) {
+      return "0.0";
+    }
+    // TODO(koda): Consider starting at most recently inserted.
+    for (int i = 0; i < CACHE_LENGTH; i += 2) {
+      // Need 'identical' to handle negative zero, etc.
+      if (identical(_cache[i], this)) {
+        return _cache[i + 1];
+      }
+    }
+    String result = super.toString();
+    // Replace the least recently inserted entry.
+    _cache[_cacheEvictIndex] = this;
+    _cache[_cacheEvictIndex + 1] = result;
+    _cacheEvictIndex = (_cacheEvictIndex + 2) & CACHE_MASK;
+    return result;
+  }
+
   String toStringAsFixed(int fractionDigits) {
     // See ECMAScript-262, 15.7.4.5 for details.
 
     if (fractionDigits is! int) {
       throw new ArgumentError(fractionDigits);
     }
     // Step 2.
     if (fractionDigits < 0 || fractionDigits > 20) {
       throw new RangeError(fractionDigits);
     }
@@ skipping 87 matching lines @@
         return EQUAL;
       }
     } else if (isNaN) {
       return other.isNaN ? EQUAL : GREATER;
     } else {
       // Other is NaN.
       return LESS;
     }
   }
 }