Optimize succinctBytes, succinctDuration

src/main/java/io/airlift/units/DataSize.java

@@ -73,7 +73,7 @@ public static DataSize ofBytes(long bytes)
      */
     public static DataSize succinctBytes(long bytes)
     {
-        return ofBytes(bytes).succinct();
+        return new DataSize(bytes, succinctUnit(bytes));
     }
 
     /**
@@ -85,7 +85,8 @@ public static DataSize succinctBytes(long bytes)
     @Deprecated
     public static DataSize succinctDataSize(double size, Unit unit)
     {
-        return new DataSize(roundDoubleSizeInUnitToLongBytes(size, unit), unit).succinct();
+        long roundedSize = roundDoubleSizeInUnitToLongBytes(size, unit);
+        return new DataSize(roundedSize, succinctUnit(roundedSize));
     }
 
     private final long bytes;
@@ -164,7 +165,7 @@ public long roundTo(Unit unit)
         return (long) rounded;
     }
 
-    private Unit succinctUnit()
+    private static Unit succinctUnit(long bytes)
     {
         Unit unitToUse = Unit.BYTE;
         for (Unit unitToTest : DATASIZE_UNITS) {
@@ -190,12 +191,15 @@ public DataSize convertTo(Unit unit)
 
     public DataSize to(Unit unit)
     {
+        if (unit == this.unit) {
+            return this;
+        }
         return new DataSize(bytes, unit);
     }
 
     public DataSize succinct()
     {
-        return to(succinctUnit());
+        return to(succinctUnit(bytes));
     }
 
     /**

src/main/java/io/airlift/units/Duration.java

@@ -63,7 +63,12 @@ public static Duration succinctDuration(double value, TimeUnit unit)
         if (value == 0) {
             return ZERO;
         }
-        return new Duration(value, unit).convertToMostSuccinctTimeUnit();
+
+        TimeUnit succinctUnit = succinctUnit(value, unit);
+        if (succinctUnit == unit) {
+            return new Duration(value, unit);
+        }
+        return new Duration(convertValue(value, unit, succinctUnit), succinctUnit);
     }
 
     private final double value;
@@ -101,8 +106,7 @@ public TimeUnit getUnit()
 
     public double getValue(TimeUnit timeUnit)
     {
-        requireNonNull(timeUnit, "timeUnit is null");
-        return value * (millisPerTimeUnit(this.unit) / millisPerTimeUnit(timeUnit));
+        return convertValue(value, unit, timeUnit);
     }
 
     public long roundTo(TimeUnit timeUnit)
@@ -117,23 +121,15 @@ public long roundTo(TimeUnit timeUnit)
 
     public Duration convertTo(TimeUnit timeUnit)
     {
-        requireNonNull(timeUnit, "timeUnit is null");
+        if (this.unit == timeUnit) {
+            return this;
+        }
         return new Duration(getValue(timeUnit), timeUnit);
     }
 
     public Duration convertToMostSuccinctTimeUnit()
     {
-        TimeUnit unitToUse = NANOSECONDS;
-        for (TimeUnit unitToTest : TIME_UNITS) {
-            // since time units are powers of ten, we can get rounding errors here, so fuzzy match
-            if (getValue(unitToTest) > 0.9999) {
-                unitToUse = unitToTest;
-            }
-            else {
-                break;
-            }
-        }
-        return convertTo(unitToUse);
+        return convertTo(succinctUnit(value, unit));
     }
 
     public java.time.Duration toJavaTime()
@@ -202,6 +198,32 @@ public static Duration valueOf(String duration)
         return new Duration(value, timeUnit);
     }
 
+    private static TimeUnit succinctUnit(double value, TimeUnit unit)
+    {
+        TimeUnit unitToUse = NANOSECONDS;
+        for (TimeUnit unitToTest : TIME_UNITS) {
+            // since time units are powers of ten, we can get rounding errors here, so fuzzy match
+            if (convertValue(value, unit, unitToTest) > 0.9999) {
+                unitToUse = unitToTest;
+            }
+            else {
+                break;
+            }
+        }
+        return unitToUse;
+    }
+
+    private static double convertValue(double value, TimeUnit fromUnit, TimeUnit toUnit)
+    {
+        requireNonNull(fromUnit, "fromUnit is null");
+        requireNonNull(toUnit, "toUnit is null");
+        if (fromUnit == toUnit) {
+            return value;
+        }
+
+        return value * (millisPerTimeUnit(fromUnit) / millisPerTimeUnit(toUnit));
+    }
+
     @Override
     public int compareTo(Duration o)
     {