speed up Double.toHexString

Author: wenshao

src/java.base/share/classes/java/lang/Double.java

@@ -33,6 +33,7 @@
 import jdk.internal.math.FloatingDecimal;
 import jdk.internal.math.DoubleConsts;
 import jdk.internal.math.DoubleToDecimal;
+import jdk.internal.util.DecimalDigits;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
 
 /**
@@ -707,51 +708,71 @@ public static String toHexString(double d) {
             // For infinity and NaN, use the decimal output.
             return Double.toString(d);
         else {
-            // Initialized to maximum size of output.
-            StringBuilder answer = new StringBuilder(24);
-
-            if (Math.copySign(1.0, d) == -1.0)    // value is negative,
-                answer.append("-");                  // so append sign info
-
-            answer.append("0x");
-
+            // Handle sign
+            boolean negative = Math.copySign(1.0, d) == -1.0;
             d = Math.abs(d);
 
-            if(d == 0.0) {
-                answer.append("0.0p0");
+            if (d == 0.0) {
+                return negative ? "-0x0.0p0" : "0x0.0p0";
             } else {
+                // Check if the value is subnormal (less than the smallest normal value)
                 boolean subnormal = (d < Double.MIN_NORMAL);
 
                 // Isolate significand bits and OR in a high-order bit
-                // so that the string representation has a known
-                // length.
+                // so that the string representation has a known length.
                 long signifBits = (Double.doubleToLongBits(d)
-                                   & DoubleConsts.SIGNIF_BIT_MASK) |
-                    0x1000000000000000L;
+                        & DoubleConsts.SIGNIF_BIT_MASK) |
+                        0x1000000000000000L;
+
+                // Calculate the number of trailing zeros in the significand (in groups of 4 bits)
+                // This is used to remove trailing zeros from the hex representation
+                int trailingZeros = Math.min(12, ((Long.numberOfTrailingZeros(signifBits) & 0xFC) >> 2));
+
+                // Determine the exponent value based on whether the number is subnormal or normal
+                int exp = subnormal ? Double.MIN_EXPONENT : Math.getExponent(d);
+
+                // Calculate the total length of the resulting string
+                int charlen = (negative ? 1 : 0) // sign character
+                        + 4 // "0x1." or "0x0."
+                        + 13 - trailingZeros // hex digits (13 max, minus trailing zeros)
+                        + 1 // "p"
+                        + DecimalDigits.stringSize(exp) // exponent
+                        ;
+
+                // Create a byte array to hold the result characters
+                byte[] chars = new byte[charlen];
+                int index = 0;
+
+                // Add the sign character if the number is negative
+                if (negative) {  // value is negative
+                    chars[index++] = '-';
+                }
+
+                // Add the prefix and the implicit bit ('1' for normal, '0' for subnormal)
+                // Subnormal values have a 0 implicit bit; normal values have a 1 implicit bit.
+                chars[index] = '0';
+                chars[index + 1] = 'x';
+                chars[index + 2] = (byte) (subnormal ? '0' : '1');
+                chars[index + 3] = '.';
+                index += 4;
+
+                // Convert significand to hex digits manually to avoid creating temporary strings
+                // Extract the 13 hex digits (52 bits) from signifBits
+                // We need to extract bits 48-51, 44-47, ..., 0-3 (13 groups of 4 bits)
+                for (int i = 0, end = 13 - trailingZeros; i < end; i++) {
+                    // Extract 4 bits at a time from left to right
+                    // Shift right by (12 - i) * 4 positions and mask with 0xF
+                    chars[index++] = Integer.digits[((int)(signifBits >> ((12 - i) << 2))) & 0xF];
+                }
 
-                // Subnormal values have a 0 implicit bit; normal
-                // values have a 1 implicit bit.
-                answer.append(subnormal ? "0." : "1.");
+                // Add the exponent indicator
+                chars[index] = 'p';
 
-                // Isolate the low-order 13 digits of the hex
-                // representation.  If all the digits are zero,
-                // replace with a single 0; otherwise, remove all
-                // trailing zeros.
-                String signif = Long.toHexString(signifBits).substring(3,16);
-                answer.append(signif.equals("0000000000000") ? // 13 zeros
-                              "0":
-                              signif.replaceFirst("0{1,12}$", ""));
+                // Append the exponent value to the character array
+                DecimalDigits.uncheckedGetCharsLatin1(exp, charlen, chars);
 
-                answer.append('p');
-                // If the value is subnormal, use the E_min exponent
-                // value for double; otherwise, extract and report d's
-                // exponent (the representation of a subnormal uses
-                // E_min -1).
-                answer.append(subnormal ?
-                              Double.MIN_EXPONENT:
-                              Math.getExponent(d));
+                return String.newStringWithLatin1Bytes(chars);
             }
-            return answer.toString();
         }
     }