Speed up deserializing doubles from Text

Author: Ahmed Eldawy

src/core/org/apache/hadoop/io/TextSerializerHelper.java

@@ -121,7 +121,7 @@ public static long deserializeHexLong(byte[] buf, int offset, int len) {
    * Deserializes and consumes a long from the given text. Consuming means all
    * characters read for deserialization are removed from the given text.
    * If separator is non-zero, a long is read and consumed up to the first
-   * occurence of this separator. The separator is also consumed.
+   * occurrence of this separator. The separator is also consumed.
    * @param text
    * @param separator
    * @return
@@ -142,12 +142,74 @@ public static long consumeHexLong(Text text, char separator) {
     return l;
   }
 
+  enum DoubleParseState {BeforeDecimal, AfterDecimal, AfterExp};
+  public static double deserializeDouble(byte[] buf, int offset, int len) {
+    DoubleParseState state = DoubleParseState.BeforeDecimal;
+
+    int exponent1 = 0; // Exponent part coming from the decimal point
+    boolean exponent2Negative = false;
+    int exponent2 = 0; // Exponent part written explicitly (e.g., E+32)
+
+    boolean mantissaNegative = false;
+    long mantissa = 0;
+    
+    while (len-- > 0) {
+      if (buf[offset] >= '0' && buf[offset] <= '9') {
+        switch(state) {
+        case AfterDecimal:
+          exponent1--;
+          // Fall through
+        case BeforeDecimal:
+          mantissa = mantissa * 10 + (buf[offset] - '0');
+          break;
+        case AfterExp:
+          exponent2 = exponent2 * 10 + (buf[offset] - '0');
+          break;
+        }
+      } else if (buf[offset] == '.') {
+        state = DoubleParseState.AfterDecimal;
+      } else if (buf[offset] == 'e' || buf[offset] == 'E') {
+        state = DoubleParseState.AfterExp;
+      } else if (buf[offset] == '-') {
+        if (state == DoubleParseState.BeforeDecimal) {
+          mantissaNegative = true;
+        } else if (state == DoubleParseState.AfterExp) {
+          exponent2Negative = true;
+        } else {
+          throw new RuntimeException("Error parsing double "+
+                new String(buf, offset, len)+" at position "+offset);
+        }
+      } else if (buf[offset] == '+') {
+        // Just skip. The default sign is positive
+      } else {
+        throw new RuntimeException("Error parsing double "+
+            new String(buf, offset, len)+" at position "+offset);
+      }
+      offset++;
+    }
+    
+    if (mantissaNegative)
+      mantissa = -mantissa;
+    if (exponent2Negative)
+      exponent2 = -exponent2;
+
+    int exponent = exponent1 + exponent2;
+    double d = mantissa;
+    if (exponent > 0) {
+      while (exponent-- != 0)
+        d *= 10;
+    } else if (exponent < 0) {
+      while (exponent++ != 0)
+        d /= 10;
+    }
+    return d;
+  }
 
   /**
    * Deserializes and consumes a double from the given text. Consuming means all
    * characters read for deserialization are removed from the given text.
    * If separator is non-zero, a double is read and consumed up to the first
-   * occurence of this separator. The separator is also consumed.
+   * occurrence of this separator. The separator is also consumed.
    * @param text
    * @param separator
    * @return
@@ -158,7 +220,7 @@ public static double consumeDouble(Text text, char separator) {
     // Skip until the separator or end of text
     while (i < text.getLength() && bytes[i] != separator)
       i++;
-    double d = Double.parseDouble(new String(bytes, 0, i));
+    double d = deserializeDouble(bytes, 0, i);
     if (i < text.getLength())
       i++;
     System.arraycopy(bytes, i, bytes, 0, text.getLength() - i);