core: simplify timeout header processing

Changes slightly improve performance

Benchmark                    (serialized)    Mode     Cnt    Score    Error  Units
GrpcUtilBenchmark.encodeNew         1000n  sample  336623   51.718 ±  1.417  ns/op
GrpcUtilBenchmark.encodeNew         1000u  sample  236574   77.555 ± 20.875  ns/op
GrpcUtilBenchmark.encodeNew         1000m  sample  224392   71.155 ±  1.600  ns/op
GrpcUtilBenchmark.encodeNew         1000S  sample  229616   67.269 ±  2.037  ns/op
GrpcUtilBenchmark.encodeNew         1000M  sample  215301   70.282 ±  1.933  ns/op
GrpcUtilBenchmark.encodeNew         1000H  sample  225063   73.679 ± 20.430  ns/op
GrpcUtilBenchmark.encodeOld         1000n  sample  311832   85.519 ±  1.729  ns/op
GrpcUtilBenchmark.encodeOld         1000u  sample  291613   92.320 ±  1.732  ns/op
GrpcUtilBenchmark.encodeOld         1000m  sample  271871   93.447 ±  1.872  ns/op
GrpcUtilBenchmark.encodeOld         1000S  sample  234932  117.956 ± 16.810  ns/op
GrpcUtilBenchmark.encodeOld         1000M  sample  224636  124.310 ± 20.249  ns/op
GrpcUtilBenchmark.encodeOld         1000H  sample  226764  130.803 ± 19.211  ns/op
GrpcUtilBenchmark.parseNew          1000n  sample  320709   60.480 ±  1.303  ns/op
GrpcUtilBenchmark.parseNew          1000u  sample  316349   64.447 ± 13.673  ns/op
GrpcUtilBenchmark.parseNew          1000m  sample  318209   61.705 ±  2.580  ns/op
GrpcUtilBenchmark.parseNew          1000S  sample  319629   59.342 ±  1.758  ns/op
GrpcUtilBenchmark.parseNew          1000M  sample  305715   59.362 ±  1.489  ns/op
GrpcUtilBenchmark.parseNew          1000H  sample  314919   60.224 ±  1.563  ns/op
GrpcUtilBenchmark.parseOld          1000n  sample  279243   64.040 ±  1.510  ns/op
GrpcUtilBenchmark.parseOld          1000u  sample  278008   71.313 ± 13.620  ns/op
GrpcUtilBenchmark.parseOld          1000m  sample  272633   67.872 ±  2.967  ns/op
GrpcUtilBenchmark.parseOld          1000S  sample  280955   63.966 ±  2.490  ns/op
GrpcUtilBenchmark.parseOld          1000M  sample  257645   71.329 ±  2.117  ns/op
GrpcUtilBenchmark.parseOld          1000H  sample  282510   68.425 ± 17.650  ns/op

Author: carl-mastrangelo

core/src/main/java/io/grpc/internal/GrpcUtil.java

@@ -49,13 +49,6 @@
 import java.net.HttpURLConnection;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.AbstractMap.SimpleImmutableEntry;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -490,51 +483,48 @@ public Stopwatch get() {
   @VisibleForTesting
   static class TimeoutMarshaller implements Metadata.AsciiMarshaller<Long> {
 
-    @SuppressWarnings("unchecked") // asList uses an array which doesn't handle generics
-    private static final List<Map.Entry<Character, TimeUnit>> SERIALIZE_ORDER
-        = Collections.unmodifiableList(Arrays.<Entry<Character, TimeUnit>>asList(
-            new SimpleImmutableEntry<Character, TimeUnit>('n', TimeUnit.NANOSECONDS),
-            new SimpleImmutableEntry<Character, TimeUnit>('u', TimeUnit.MICROSECONDS),
-            new SimpleImmutableEntry<Character, TimeUnit>('m', TimeUnit.MILLISECONDS),
-            new SimpleImmutableEntry<Character, TimeUnit>('S', TimeUnit.SECONDS),
-            new SimpleImmutableEntry<Character, TimeUnit>('M', TimeUnit.MINUTES),
-            new SimpleImmutableEntry<Character, TimeUnit>('H', TimeUnit.HOURS)));
-
-    private static final Map<Character, TimeUnit> UNITS = createUnits();
-
-    private static Map<Character, TimeUnit> createUnits() {
-      Map<Character, TimeUnit> units = new HashMap<Character, TimeUnit>();
-      for (Entry<Character, TimeUnit> unit : SERIALIZE_ORDER) {
-        units.put(unit.getKey(), unit.getValue());
-      }
-      return Collections.unmodifiableMap(units);
-    }
-
     @Override
     public String toAsciiString(Long timeoutNanos) {
-      checkArgument(timeoutNanos >= 0, "Negative timeout");
-      // the smallest integer with 9 digits
-      int cutoff = 100000000;
-      for (Entry<Character, TimeUnit> unit : SERIALIZE_ORDER) {
-        long timeout = unit.getValue().convert(timeoutNanos, TimeUnit.NANOSECONDS);
-        if (timeout < cutoff) {
-          return Long.toString(timeout) + unit.getKey();
-        }
+      long cutoff = 100000000;
+      if (timeoutNanos < 0) {
+        throw new IllegalArgumentException("Timeout too small");
+      } else if (timeoutNanos < cutoff) {
+        return TimeUnit.NANOSECONDS.toNanos(timeoutNanos) + "n";
+      } else if (timeoutNanos < cutoff * 1000L) {
+        return TimeUnit.NANOSECONDS.toMicros(timeoutNanos) + "u";
+      } else if (timeoutNanos < cutoff * 1000L * 1000L) {
+        return TimeUnit.NANOSECONDS.toMillis(timeoutNanos) + "m";
+      } else if (timeoutNanos < cutoff * 1000L * 1000L * 1000L) {
+        return TimeUnit.NANOSECONDS.toSeconds(timeoutNanos) + "S";
+      } else if (timeoutNanos < cutoff * 1000L * 1000L * 1000L * 60L) {
+        return TimeUnit.NANOSECONDS.toMinutes(timeoutNanos) + "M";
+      } else {
+        return TimeUnit.NANOSECONDS.toHours(timeoutNanos) + "H";
       }
-      throw new IllegalArgumentException("Timeout too large");
     }
 
     @Override
     public Long parseAsciiString(String serialized) {
       checkArgument(serialized.length() > 0, "empty timeout");
       checkArgument(serialized.length() <= 9, "bad timeout format");
-      String valuePart = serialized.substring(0, serialized.length() - 1);
+      long value = Long.parseLong(serialized.substring(0, serialized.length() - 1));
       char unit = serialized.charAt(serialized.length() - 1);
-      TimeUnit timeUnit = UNITS.get(unit);
-      if (timeUnit != null) {
-        return timeUnit.toNanos(Long.parseLong(valuePart));
+      switch (unit) {
+        case 'n':
+          return TimeUnit.NANOSECONDS.toNanos(value);
+        case 'u':
+          return TimeUnit.MICROSECONDS.toNanos(value);
+        case 'm':
+          return TimeUnit.MILLISECONDS.toNanos(value);
+        case 'S':
+          return TimeUnit.SECONDS.toNanos(value);
+        case 'M':
+          return TimeUnit.MINUTES.toNanos(value);
+        case 'H':
+          return TimeUnit.HOURS.toNanos(value);
+        default:
+          throw new IllegalArgumentException(String.format("Invalid timeout unit: %s", unit));
       }
-      throw new IllegalArgumentException(String.format("Invalid timeout unit: %s", unit));
     }
   }