[java] Speed up JSON tokenising and decimal parsing

Profile-guided improvements to the JSON read path:

- Test for the four JSON whitespace characters before consulting
  Character.isWhitespace, which was a third of wire-payload parse time
- Parse decimals with Clinger's fast path when the significand fits
  exactly in a double, falling back to Double.parseDouble otherwise;
  a differential test pins results bit-for-bit to the JDK
- Replace the container deque with a byte-array stack and let
  ObjectCoercer handle nulls itself, trimming per-value overhead

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: shs96c

java/src/org/openqa/selenium/json/Input.java

@@ -74,6 +74,10 @@ public Input(Reader source) {
    *     input is exhausted
    */
   public int peek() {
+    int next = position + 1;
+    if (next < filled) {
+      return buffer[next];
+    }
     return fill() ? buffer[position + 1] : EOF;
   }
 
@@ -84,6 +88,11 @@ public int peek() {
    *     input is exhausted
    */
   public int read() {
+    int next = position + 1;
+    if (next < filled) {
+      position = next;
+      return buffer[next];
+    }
     return fill() ? buffer[++position] : EOF;
   }
 
@@ -151,7 +160,7 @@ public void skipWhitespace() {
     while (fill()) {
       int start = position + 1;
       for (int i = start; i < filled; i++) {
-        if (!Character.isWhitespace(buffer[i])) {
+        if (!isWhitespace(buffer[i])) {
           position = i - 1;
           return;
         }
@@ -160,6 +169,18 @@ public void skipWhitespace() {
     }
   }
 
+  /**
+   * Test for whitespace, checking the JSON whitespace characters (RFC 8259 §2) directly before
+   * consulting {@link Character#isWhitespace}, whose table lookups are measurably slower and which
+   * is retained only to stay lenient about exotic whitespace between tokens.
+   */
+  private static boolean isWhitespace(char c) {
+    if (c == ' ' || c == '\n' || c == '\t' || c == '\r') {
+      return true;
+    }
+    return Character.isWhitespace(c);
+  }
+
   /**
    * Consume ASCII digits, appending them to the supplied builder in bulk. Stops before the first
    * non-digit character, which is left unconsumed.

java/src/org/openqa/selenium/json/JsonInput.java

@@ -25,10 +25,8 @@
 import java.io.UncheckedIOException;
 import java.lang.reflect.Type;
 import java.time.Instant;
-import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Deque;
 import java.util.List;
 import java.util.Map;
 import java.util.function.BiFunction;
@@ -47,13 +45,13 @@ public class JsonInput implements Closeable {
   private JsonTypeCoercer coercer;
   private PropertySetting setter;
   private final Input input;
-  // Used when reading maps and collections so that we handle de-nesting and
-  // figuring out whether we're expecting a NAME properly.
-  private final Deque<Container> stack = new ArrayDeque<>();
+  // Stack of open containers, used to handle de-nesting and to figure out
+  // whether we're expecting a NAME. Kept as plain arrays (rather than a deque
+  // of objects) because the top of the stack is touched for every value read.
+  private byte[] containerState = new byte[16];
   // Parallel stack tracking whether the current container has seen at least
   // one element. Used by hasNext() to enforce comma separators between
-  // elements while remaining lenient about a single trailing comma. Kept as
-  // a plain array because it is touched for every element read.
+  // elements while remaining lenient about a single trailing comma.
   private boolean[] containerHasElement = new boolean[16];
   private int containerDepth;
   // Memoized type of the pending token; cleared whenever the token is consumed.
@@ -314,9 +312,7 @@ public Number nextNumber() {
         }
         return Long.valueOf(builder.toString());
       }
-      // JSON's number grammar is a subset of what parseDouble accepts, and parseDouble is
-      // considerably cheaper than going through BigDecimal.
-      double value = Double.parseDouble(builder.toString());
+      double value = parseDouble(builder);
       if (Double.isInfinite(value) || Double.isNaN(value)) {
         throw new JsonException("Number is out of range for a double: " + builder + ". " + input);
       }
@@ -330,6 +326,96 @@ private static boolean isDigit(int c) {
     return c >= '0' && c <= '9';
   }
 
+  /** Powers of ten that are exactly representable as doubles. */
+  private static final double[] POW_10 = {
+    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16,
+    1e17, 1e18, 1e19, 1e20, 1e21, 1e22
+  };
+
+  /**
+   * Parse a JSON number that contains a fraction or exponent, as lexed into {@code raw} by {@link
+   * #nextNumber}.
+   *
+   * <p>Uses Clinger's fast path where possible: when the significand has at most 15 digits it is
+   * exactly representable as a double, as are powers of ten up to 10^22, so a single floating-point
+   * multiply or divide performs the one correctly-rounded step the conversion needs. Everything
+   * else (long significands, large exponents) falls back to {@link Double#parseDouble}, so results
+   * are always bit-for-bit identical to the JDK.
+   */
+  private static double parseDouble(StringBuilder raw) {
+    int length = raw.length();
+    int index = 0;
+    boolean negative = false;
+    if (raw.charAt(0) == '-') {
+      negative = true;
+      index = 1;
+    }
+
+    long significand = 0;
+    int digits = 0;
+    int fractionDigits = 0;
+
+    while (index < length) {
+      char c = raw.charAt(index);
+      if (c < '0' || c > '9') {
+        break;
+      }
+      significand = significand * 10 + (c - '0');
+      digits++;
+      index++;
+    }
+
+    if (index < length && raw.charAt(index) == '.') {
+      index++;
+      while (index < length) {
+        char c = raw.charAt(index);
+        if (c < '0' || c > '9') {
+          break;
+        }
+        significand = significand * 10 + (c - '0');
+        digits++;
+        fractionDigits++;
+        index++;
+      }
+    }
+
+    int exponent = 0;
+    if (index < length) {
+      // By construction the remainder is ('e' | 'E') ('+' | '-')? 1*DIGIT.
+      index++;
+      boolean exponentNegative = false;
+      char sign = raw.charAt(index);
+      if (sign == '+' || sign == '-') {
+        exponentNegative = sign == '-';
+        index++;
+      }
+      while (index < length) {
+        // Clamp rather than overflow; anything this large falls back below anyway.
+        if (exponent < 100_000) {
+          exponent = exponent * 10 + (raw.charAt(index) - '0');
+        }
+        index++;
+      }
+      if (exponentNegative) {
+        exponent = -exponent;
+      }
+    }
+
+    int netExponent = exponent - fractionDigits;
+
+    if (digits <= 15 && netExponent >= -22 && netExponent <= 22) {
+      double value = (double) significand;
+      if (netExponent > 0) {
+        value = value * POW_10[netExponent];
+      } else if (netExponent < 0) {
+        value = value / POW_10[-netExponent];
+      }
+      return negative ? -value : value;
+    }
+
+    return Double.parseDouble(raw.toString());
+  }
+
   private static String describeChar(int c) {
     return c == Input.EOF ? "<EOF>" : "'" + (char) c + "'";
   }
@@ -377,7 +463,7 @@ public void nextEnd() {
    * @throws UncheckedIOException if an I/O exception is encountered
    */
   public boolean hasNext() {
-    if (stack.isEmpty()) {
+    if (containerDepth == 0) {
       throw new JsonException(
           "Unable to determine if an item has next when not in a container type. " + input);
     }
@@ -417,8 +503,7 @@ public boolean hasNext() {
    */
   public void beginArray() {
     expect(JsonType.START_COLLECTION);
-    stack.addFirst(Container.COLLECTION);
-    pushContainer();
+    pushContainer(COLLECTION);
     input.read();
   }
 
@@ -429,12 +514,11 @@ public void beginArray() {
    */
   public void endArray() {
     expect(JsonType.END_COLLECTION);
-    if (stack.peekFirst() != Container.COLLECTION) {
+    if (topContainer() != COLLECTION) {
       // The only other thing we could be closing is a map
       throw new JsonException(
           "Attempt to close a JSON List, but a JSON Object was expected. " + input);
     }
-    stack.removeFirst();
     containerDepth--;
     input.read();
   }
@@ -446,8 +530,7 @@ public void endArray() {
    */
   public void beginObject() {
     expect(JsonType.START_MAP);
-    stack.addFirst(Container.MAP_NAME);
-    pushContainer();
+    pushContainer(MAP_NAME);
     input.read();
   }
 
@@ -458,10 +541,9 @@ public void beginObject() {
    */
   public void endObject() {
     expect(JsonType.END_MAP);
-    if (stack.peekFirst() != Container.MAP_NAME) {
+    if (topContainer() != MAP_NAME) {
       throw new JsonException("Attempt to close a JSON Map, but not ready to. " + input);
     }
-    stack.removeFirst();
     containerDepth--;
     input.read();
   }
@@ -587,7 +669,7 @@ public <T> List<T> readArray(Type type) {
    * @return {@code true} is awaiting a property name; otherwise {@code false}
    */
   private boolean isReadingName() {
-    return stack.peekFirst() == Container.MAP_NAME;
+    return topContainer() == MAP_NAME;
   }
 
   /**
@@ -607,14 +689,13 @@ private void expect(JsonType type) {
     peekedType = null;
 
     // Special map handling. Woo!
-    Container top = stack.peekFirst();
+    byte top = topContainer();
 
     if (type == JsonType.NAME) {
-      if (top == Container.MAP_NAME) {
-        stack.removeFirst();
-        stack.addFirst(Container.MAP_VALUE);
+      if (top == MAP_NAME) {
+        containerState[containerDepth - 1] = MAP_VALUE;
         return;
-      } else if (top != null) {
+      } else if (top != NONE) {
         throw new JsonException("Unexpected attempt to read name. " + input);
       }
 
@@ -626,20 +707,26 @@ private void expect(JsonType type) {
       // Closing the container - don't treat as a new element in it.
       return;
     }
-    if (top == Container.MAP_VALUE) {
-      stack.removeFirst();
-      stack.addFirst(Container.MAP_NAME);
+    if (top == MAP_VALUE) {
+      containerState[containerDepth - 1] = MAP_NAME;
       markElementRead();
-    } else if (top == Container.COLLECTION) {
+    } else if (top == COLLECTION) {
       markElementRead();
     }
   }
 
-  private void pushContainer() {
-    if (containerDepth == containerHasElement.length) {
+  private byte topContainer() {
+    return containerDepth == 0 ? NONE : containerState[containerDepth - 1];
+  }
+
+  private void pushContainer(byte state) {
+    if (containerDepth == containerState.length) {
+      containerState = Arrays.copyOf(containerState, containerDepth * 2);
       containerHasElement = Arrays.copyOf(containerHasElement, containerDepth * 2);
     }
-    containerHasElement[containerDepth++] = false;
+    containerState[containerDepth] = state;
+    containerHasElement[containerDepth] = false;
+    containerDepth++;
   }
 
   private void markElementRead() {
@@ -788,14 +875,15 @@ private void skipWhitespace(Input input) {
     input.skipWhitespace();
   }
 
-  /** Used to track the current container processing state. */
-  private enum Container {
+  /** Container processing states: not in a container. */
+  private static final byte NONE = 0;
 
-    /** Processing a JSON array */
-    COLLECTION,
-    /** Processing a JSON object property name */
-    MAP_NAME,
-    /** Processing a JSON object property value */
-    MAP_VALUE,
-  }
+  /** Container processing states: processing a JSON array. */
+  private static final byte COLLECTION = 1;
+
+  /** Container processing states: processing a JSON object property name. */
+  private static final byte MAP_NAME = 2;
+
+  /** Container processing states: processing a JSON object property value. */
+  private static final byte MAP_VALUE = 3;
 }

java/src/org/openqa/selenium/json/JsonTypeCoercer.java

@@ -204,20 +204,17 @@ public Object apply(JsonInput json, PropertySetting setter) {
    * @return {@link BiFunction} object to deserialize the specified Java type
    */
   private BiFunction<JsonInput, PropertySetting, Object> buildCoercer(Type type) {
-    BiFunction<JsonInput, PropertySetting, Object> inner =
+    TypeCoercer<?> matched =
         coercers.stream()
             .filter(coercer -> coercer.test(narrow(type)))
             .findFirst()
-            .map(
-                coercer -> {
-                  @SuppressWarnings("unchecked")
-                  BiFunction<JsonInput, PropertySetting, Object> funct =
-                      (BiFunction<JsonInput, PropertySetting, Object>) coercer.apply(type);
-                  return funct;
-                })
             .orElseThrow(() -> new JsonException("Unable to find type coercer for " + type));
 
-    if (isOptional(type)) {
+    @SuppressWarnings("unchecked")
+    BiFunction<JsonInput, PropertySetting, Object> inner =
+        (BiFunction<JsonInput, PropertySetting, Object>) matched.apply(type);
+
+    if (matched.handlesNull() || isOptional(type)) {
       return inner;
     }
 

java/src/org/openqa/selenium/json/ObjectCoercer.java

@@ -35,6 +35,11 @@ public boolean test(Class type) {
     return Object.class.equals(type);
   }
 
+  @Override
+  boolean handlesNull() {
+    return true;
+  }
+
   @Override
   public BiFunction<JsonInput, PropertySetting, Object> apply(Type type) {
     // Resolve the possible target coercers once rather than paying a cache lookup per value.
@@ -49,6 +54,9 @@ public BiFunction<JsonInput, PropertySetting, Object> apply(Type type) {
 
     return (jsonInput, setting) -> {
       switch (jsonInput.peek()) {
+        case NULL:
+          return jsonInput.nextNull();
+
         case BOOLEAN:
           return booleanCoercer.apply(jsonInput, setting);
 

java/src/org/openqa/selenium/json/TypeCoercer.java

@@ -30,4 +30,12 @@ public abstract class TypeCoercer<T>
 
   @Override
   public abstract BiFunction<JsonInput, PropertySetting, T> apply(Type type);
+
+  /**
+   * Whether the functions produced by {@link #apply} handle a pending JSON null themselves. When
+   * {@code false}, {@link JsonTypeCoercer} consumes the null before the function is invoked.
+   */
+  boolean handlesNull() {
+    return false;
+  }
 }