Optimize number-to-string conversions.

runtime/lib/integers.dart

Index: runtime/lib/integers.dart
===================================================================
--- runtime/lib/integers.dart	(revision 39698)
+++ runtime/lib/integers.dart	(working copy)
@@ -293,6 +293,32 @@
     0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39
   ];
 
+  /**
+   * Result of int.toString for -99, -98, ..., 98, 99.
+   */
+  static const _smallLookupTable = const [
+    "-99", "-98", "-97", "-96", "-95", "-94", "-93", "-92", "-91", "-90",
+    "-89", "-88", "-87", "-86", "-85", "-84", "-83", "-82", "-81", "-80",
+    "-79", "-78", "-77", "-76", "-75", "-74", "-73", "-72", "-71", "-70",
+    "-69", "-68", "-67", "-66", "-65", "-64", "-63", "-62", "-61", "-60",
+    "-59", "-58", "-57", "-56", "-55", "-54", "-53", "-52", "-51", "-50",
+    "-49", "-48", "-47", "-46", "-45", "-44", "-43", "-42", "-41", "-40",
+    "-39", "-38", "-37", "-36", "-35", "-34", "-33", "-32", "-31", "-30",
+    "-29", "-28", "-27", "-26", "-25", "-24", "-23", "-22", "-21", "-20",
+    "-19", "-18", "-17", "-16", "-15", "-14", "-13", "-12", "-11", "-10",
+    "-9", "-8", "-7", "-6", "-5", "-4", "-3", "-2", "-1", "0",
+    "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
+    "11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
+    "21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
+    "31", "32", "33", "34", "35", "36", "37", "38", "39", "40",
+    "41", "42", "43", "44", "45", "46", "47", "48", "49", "50",
+    "51", "52", "53", "54", "55", "56", "57", "58", "59", "60",
+    "61", "62", "63", "64", "65", "66", "67", "68", "69", "70",
+    "71", "72", "73", "74", "75", "76", "77", "78", "79", "80",
+    "81", "82", "83", "84", "85", "86", "87", "88", "89", "90",
+    "91", "92", "93", "94", "95", "96", "97", "98", "99",

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

Trailing comma.

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

Done.

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

There isn't anything inherently wrong with a trailing comma in Dart. I would
actually prefer it for "tables" like this one, because it makes it easier to add
more lines or rearrange lines.
(But this is VM code, so do go with the VM preferred style here).

+  ];
+
   // Powers of 10 above 1000000 are indistinguishable by eye.
   static const int _POW_10_7  = 10000000;
   static const int _POW_10_8  = 100000000;
@@ -320,20 +346,12 @@
   }
 
   String toString() {
+    if (this < 100 && this > -100) return _smallLookupTable[this + 99];

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

Would it make sense to put this after the sign check?
Then we would have:
  if (this < 0) return _negativeToString(this);
  if (this < 100) return _posSmallLookupTable[this];
and in _negativeToSTring
  if (this > -100) return _negSmallLookupTable[this + 99];

It seems to have one less test for the positive case (but then, -99..99 test can
be done in one compare by a good compiler).
I.e., do we have a benchmark that can see what is best?

     if (this < 0) return _negativeToString(this);
     // Inspired by Andrei Alexandrescu: "Three Optimization Tips for C++"
     // Avoid expensive remainder operation by doing it on more than
     // one digit at a time.
     const int DIGIT_ZERO = 0x30;
-    if (this < 10) {
-      return _OneByteString._allocate(1).._setAt(0, DIGIT_ZERO + this);
-    }
-    if (this < 100) {
-      int digitIndex = 2 * this;
-      return _OneByteString._allocate(2)
-          .._setAt(0, _digitTable[digitIndex])
-          .._setAt(1, _digitTable[digitIndex + 1]);
-    }
     int length = _positiveBase10Length(this);
     _OneByteString result = _OneByteString._allocate(length);
     int index = length - 1;