Optimize hex formatting and parsing implementation #KT-58218

Merge-request: KT-MR-11702 Merged-by: Abduqodiri Qurbonzoda <abduqodiri.qurbonzoda@jetbrains.com>
2023-09-08 22:40:56 +00:00
parent eb0a301a8f
commit ba374bb45c
4 changed files with 714 additions and 166 deletions
@@ -5,15 +5,56 @@

 package kotlin.text

+// Benchmarks repository: https://github.com/qurbonzoda/KotlinHexFormatBenchmarks
+
 private const val LOWER_CASE_HEX_DIGITS = "0123456789abcdef"
 private const val UPPER_CASE_HEX_DIGITS = "0123456789ABCDEF"

-// case-insensitive parsing
-private val HEX_DIGITS_TO_DECIMAL = IntArray(128) { -1 }.apply {
+/**
+ * The table for converting Byte values to their two-digit hex representation.
+ *
+ * It's used for formatting ByteArray. Storing the hex representation
+ * of each Byte value makes it possible to access the table only once per Byte.
+ * This noticeably improves performance, especially for large ByteArray's.
+ */
+private val BYTE_TO_LOWER_CASE_HEX_DIGITS = IntArray(256) {
+    (LOWER_CASE_HEX_DIGITS[(it shr 4)].code shl 8) or LOWER_CASE_HEX_DIGITS[(it and 0xF)].code
+}
+
+/**
+ * The table for converting Byte values to their two-digit hex representation.
+ *
+ * @see BYTE_TO_LOWER_CASE_HEX_DIGITS
+ */
+private val BYTE_TO_UPPER_CASE_HEX_DIGITS = IntArray(256) {
+    (UPPER_CASE_HEX_DIGITS[(it shr 4)].code shl 8) or UPPER_CASE_HEX_DIGITS[(it and 0xF)].code
+}
+
+/**
+ * The table for converting hex digits (both lowercase and uppercase) to their `Int` decimal value.
+ *
+ * Although `Char.code` of every hex digit is less than 128, the table size is 256 for the following reason:
+ * If the string whose chars are being converted is ASCII-encoded, the JIT optimizes `charAt` to a byte-sized load.
+ * When the table is 256 entries wide then both the `code ushr 8 == 0` and array bounds check are eliminated.
+ * This noticeably improves performance for ASCII strings.
+ */
+private val HEX_DIGITS_TO_DECIMAL = IntArray(256) { -1 }.apply {
    LOWER_CASE_HEX_DIGITS.forEachIndexed { index, char -> this[char.code] = index }
    UPPER_CASE_HEX_DIGITS.forEachIndexed { index, char -> this[char.code] = index }
 }

+/**
+ * The table for converting hex digits (both lowercase and uppercase) to their `Long` decimal value.
+ *
+ * Because `Int.toLong()` noticeably impacted performance, this separate table was introduced.
+ *
+ * @see HEX_DIGITS_TO_DECIMAL
+ */
+private val HEX_DIGITS_TO_LONG_DECIMAL = LongArray(256) { -1 }.apply {
+    LOWER_CASE_HEX_DIGITS.forEachIndexed { index, char -> this[char.code] = index.toLong() }
+    UPPER_CASE_HEX_DIGITS.forEachIndexed { index, char -> this[char.code] = index.toLong() }
+}
+
 // -------------------------- format and parse ByteArray --------------------------

 /**
@@ -55,9 +96,101 @@ public fun ByteArray.toHexString(
        return ""
    }

-    val digits = if (format.upperCase) UPPER_CASE_HEX_DIGITS else LOWER_CASE_HEX_DIGITS
-
+    val byteToDigits = if (format.upperCase) BYTE_TO_UPPER_CASE_HEX_DIGITS else BYTE_TO_LOWER_CASE_HEX_DIGITS
    val bytesFormat = format.bytes
+
+    // Optimize for formats with unspecified bytesPerLine and bytesPerGroup
+    if (bytesFormat.noLineAndGroupSeparator) {
+        return toHexStringNoLineAndGroupSeparator(startIndex, endIndex, bytesFormat, byteToDigits)
+    }
+
+    return toHexStringSlowPath(startIndex, endIndex, bytesFormat, byteToDigits)
+}
+
+@ExperimentalStdlibApi
+private fun ByteArray.toHexStringNoLineAndGroupSeparator(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat,
+    byteToDigits: IntArray
+): String {
+    // Optimize for formats with a short byteSeparator and no bytePrefix/Suffix
+    if (bytesFormat.shortByteSeparatorNoPrefixAndSuffix) {
+        return toHexStringShortByteSeparatorNoPrefixAndSuffix(startIndex, endIndex, bytesFormat, byteToDigits)
+    }
+
+    return toHexStringNoLineAndGroupSeparatorSlowPath(startIndex, endIndex, bytesFormat, byteToDigits)
+}
+
+@ExperimentalStdlibApi
+private fun ByteArray.toHexStringShortByteSeparatorNoPrefixAndSuffix(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat,
+    byteToDigits: IntArray
+): String {
+    val byteSeparatorLength = bytesFormat.byteSeparator.length
+    require(byteSeparatorLength <= 1)
+
+    val numberOfBytes = endIndex - startIndex
+    var charIndex = 0
+
+    if (byteSeparatorLength == 0) {
+        val charArray = CharArray(checkFormatLength(2L * numberOfBytes))
+        for (byteIndex in startIndex until endIndex) {
+            charIndex = formatByteAt(byteIndex, byteToDigits, charArray, charIndex)
+        }
+        return charArray.concatToString()
+    } else {
+        val charArray = CharArray(checkFormatLength(3L * numberOfBytes - 1))
+        val byteSeparatorChar = bytesFormat.byteSeparator[0]
+
+        charIndex = formatByteAt(startIndex, byteToDigits, charArray, charIndex)
+        for (byteIndex in startIndex + 1 until endIndex) {
+            charArray[charIndex++] = byteSeparatorChar
+            charIndex = formatByteAt(byteIndex, byteToDigits, charArray, charIndex)
+        }
+
+        return charArray.concatToString()
+    }
+}
+
+@ExperimentalStdlibApi
+private fun ByteArray.toHexStringNoLineAndGroupSeparatorSlowPath(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat,
+    byteToDigits: IntArray
+): String {
+    val bytePrefix = bytesFormat.bytePrefix
+    val byteSuffix = bytesFormat.byteSuffix
+    val byteSeparator = bytesFormat.byteSeparator
+
+    val formatLength = formattedStringLength(
+        numberOfBytes = endIndex - startIndex,
+        byteSeparator.length,
+        bytePrefix.length,
+        byteSuffix.length
+    )
+    val charArray = CharArray(formatLength)
+    var charIndex = 0
+
+    charIndex = formatByteAt(startIndex, bytePrefix, byteSuffix, byteToDigits, charArray, charIndex)
+    for (byteIndex in startIndex + 1 until endIndex) {
+        charIndex = byteSeparator.toCharArrayIfNotEmpty(charArray, charIndex)
+        charIndex = formatByteAt(byteIndex, bytePrefix, byteSuffix, byteToDigits, charArray, charIndex)
+    }
+
+    return charArray.concatToString()
+}
+
+@ExperimentalStdlibApi
+private fun ByteArray.toHexStringSlowPath(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat,
+    byteToDigits: IntArray
+): String {
    val bytesPerLine = bytesFormat.bytesPerLine
    val bytesPerGroup = bytesFormat.bytesPerGroup
    val bytePrefix = bytesFormat.bytePrefix
@@ -66,7 +199,7 @@ public fun ByteArray.toHexString(
    val groupSeparator = bytesFormat.groupSeparator

    val formatLength = formattedStringLength(
-        totalBytes = endIndex - startIndex,
+        numberOfBytes = endIndex - startIndex,
        bytesPerLine,
        bytesPerGroup,
        groupSeparator.length,
@@ -74,42 +207,77 @@ public fun ByteArray.toHexString(
        bytePrefix.length,
        byteSuffix.length
    )
+    val charArray = CharArray(formatLength)
+    var charIndex = 0

    var indexInLine = 0
    var indexInGroup = 0

-    return buildString(formatLength) {
-        for (i in startIndex until endIndex) {
-            val byte = this@toHexString[i].toInt() and 0xFF
-
-            if (indexInLine == bytesPerLine) {
-                append('\n')
-                indexInLine = 0
-                indexInGroup = 0
-            } else if (indexInGroup == bytesPerGroup) {
-                append(groupSeparator)
-                indexInGroup = 0
-            }
-            if (indexInGroup != 0) {
-                append(byteSeparator)
-            }
-
-            append(bytePrefix)
-            append(digits[byte shr 4])
-            append(digits[byte and 0xF])
-            append(byteSuffix)
-
-            indexInGroup += 1
-            indexInLine += 1
+    for (byteIndex in startIndex until endIndex) {
+        if (indexInLine == bytesPerLine) {
+            charArray[charIndex++] = '\n'
+            indexInLine = 0
+            indexInGroup = 0
+        } else if (indexInGroup == bytesPerGroup) {
+            charIndex = groupSeparator.toCharArrayIfNotEmpty(charArray, charIndex)
+            indexInGroup = 0
+        }
+        if (indexInGroup != 0) {
+            charIndex = byteSeparator.toCharArrayIfNotEmpty(charArray, charIndex)
        }

-        check(formatLength == length)
+        charIndex = formatByteAt(byteIndex, bytePrefix, byteSuffix, byteToDigits, charArray, charIndex)
+
+        indexInGroup += 1
+        indexInLine += 1
    }
+
+    check(charIndex == formatLength)
+    return charArray.concatToString()
+}
+
+private fun ByteArray.formatByteAt(
+    index: Int,
+    bytePrefix: String,
+    byteSuffix: String,
+    byteToDigits: IntArray,
+    destination: CharArray,
+    destinationOffset: Int
+): Int {
+    var offset = bytePrefix.toCharArrayIfNotEmpty(destination, destinationOffset)
+    offset = formatByteAt(index, byteToDigits, destination, offset)
+    return byteSuffix.toCharArrayIfNotEmpty(destination, offset)
+}
+
+private fun ByteArray.formatByteAt(
+    index: Int,
+    byteToDigits: IntArray,
+    destination: CharArray,
+    destinationOffset: Int
+): Int {
+    val byte = this[index].toInt() and 0xFF
+    val byteDigits = byteToDigits[byte]
+    destination[destinationOffset] = (byteDigits shr 8).toChar()
+    destination[destinationOffset + 1] = (byteDigits and 0xFF).toChar()
+    return destinationOffset + 2
+}
+
+private fun formattedStringLength(
+    numberOfBytes: Int,
+    byteSeparatorLength: Int,
+    bytePrefixLength: Int,
+    byteSuffixLength: Int
+): Int {
+    require(numberOfBytes > 0)
+
+    val charsPerByte = 2L + bytePrefixLength + byteSuffixLength + byteSeparatorLength
+    val formatLength = numberOfBytes * charsPerByte - byteSeparatorLength
+    return checkFormatLength(formatLength)
 }

 // Declared internal for testing
 internal fun formattedStringLength(
-    totalBytes: Int,
+    numberOfBytes: Int,
    bytesPerLine: Int,
    bytesPerGroup: Int,
    groupSeparatorLength: Int,
@@ -117,34 +285,37 @@ internal fun formattedStringLength(
    bytePrefixLength: Int,
    byteSuffixLength: Int
 ): Int {
-    require(totalBytes > 0)
+    require(numberOfBytes > 0)
    // By contract bytesPerLine and bytesPerGroup are > 0

-    val lineSeparators = (totalBytes - 1) / bytesPerLine
+    val lineSeparators = (numberOfBytes - 1) / bytesPerLine
    val groupSeparators = run {
        val groupSeparatorsPerLine = (bytesPerLine - 1) / bytesPerGroup
-        val bytesInLastLine = (totalBytes % bytesPerLine).let { if (it == 0) bytesPerLine else it }
+        val bytesInLastLine = (numberOfBytes % bytesPerLine).let { if (it == 0) bytesPerLine else it }
        val groupSeparatorsInLastLine = (bytesInLastLine - 1) / bytesPerGroup
        lineSeparators * groupSeparatorsPerLine + groupSeparatorsInLastLine
    }
-    val byteSeparators = totalBytes - 1 - lineSeparators - groupSeparators
+    val byteSeparators = numberOfBytes - 1 - lineSeparators - groupSeparators

-    // The max totalLength is achieved when
-    // totalBytes, bytePrefix/Suffix/Separator.length = Int.MAX_VALUE.
+    // The max formatLength is achieved when
+    // numberOfBytes, bytePrefix/Suffix/Separator.length = Int.MAX_VALUE.
    // The result is 3 * Int.MAX_VALUE * Int.MAX_VALUE + Int.MAX_VALUE,
    // which is > Long.MAX_VALUE, but < ULong.MAX_VALUE.

-    val totalLength: Long = lineSeparators.toLong() /* * lineSeparator.length = 1 */ +
+    val formatLength: Long = lineSeparators.toLong() /* * lineSeparator.length = 1 */ +
            groupSeparators.toLong() * groupSeparatorLength.toLong() +
            byteSeparators.toLong() * byteSeparatorLength.toLong() +
-            totalBytes.toLong() * (bytePrefixLength.toLong() + 2L + byteSuffixLength.toLong())
+            numberOfBytes.toLong() * (bytePrefixLength.toLong() + 2L + byteSuffixLength.toLong())

-    if (totalLength !in 0..Int.MAX_VALUE) {
+    return checkFormatLength(formatLength)
+}
+
+private fun checkFormatLength(formatLength: Long): Int {
+    if (formatLength !in 0..Int.MAX_VALUE) {
        // TODO: Common OutOfMemoryError?
-        throw IllegalArgumentException("The resulting string length is too big: ${totalLength.toULong()}")
+        throw IllegalArgumentException("The resulting string length is too big: ${formatLength.toULong()}")
    }
-
-    return totalLength.toInt()
+    return formatLength.toInt()
 }

 /**
@@ -191,14 +362,119 @@ private fun String.hexToByteArray(
    }

    val bytesFormat = format.bytes
+
+    // Optimize for formats with unspecified bytesPerLine and bytesPerGroup
+    if (bytesFormat.noLineAndGroupSeparator) {
+        hexToByteArrayNoLineAndGroupSeparator(startIndex, endIndex, bytesFormat)?.let { return it }
+    }
+
+    return hexToByteArraySlowPath(startIndex, endIndex, bytesFormat)
+}
+
+@ExperimentalStdlibApi
+private fun String.hexToByteArrayNoLineAndGroupSeparator(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat
+): ByteArray? {
+    // Optimize for formats with a short byteSeparator and no bytePrefix/Suffix
+    if (bytesFormat.shortByteSeparatorNoPrefixAndSuffix) {
+        return hexToByteArrayShortByteSeparatorNoPrefixAndSuffix(startIndex, endIndex, bytesFormat)
+    }
+
+    return hexToByteArrayNoLineAndGroupSeparatorSlowPath(startIndex, endIndex, bytesFormat)
+}
+
+@ExperimentalStdlibApi
+private fun String.hexToByteArrayShortByteSeparatorNoPrefixAndSuffix(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat
+): ByteArray? {
+    val byteSeparatorLength = bytesFormat.byteSeparator.length
+    require(byteSeparatorLength <= 1)
+
+    val numberOfChars = endIndex - startIndex
+    var charIndex = 0
+
+    if (byteSeparatorLength == 0) {
+        if (numberOfChars and 1 != 0) return null
+        val numberOfBytes = numberOfChars shr 1
+        val byteArray = ByteArray(numberOfBytes)
+        for (byteIndex in 0 until numberOfBytes) {
+            byteArray[byteIndex] = parseByteAt(charIndex)
+            charIndex += 2
+        }
+        return byteArray
+    } else {
+        if (numberOfChars % 3 != 2) return null
+        val numberOfBytes = numberOfChars / 3 + 1
+        val byteArray = ByteArray(numberOfBytes)
+        val byteSeparatorChar = bytesFormat.byteSeparator[0]
+        byteArray[0] = parseByteAt(charIndex)
+        charIndex += 2
+        for (byteIndex in 1 until numberOfBytes) {
+            if (this[charIndex] != byteSeparatorChar) {
+                checkContainsAt(charIndex, endIndex, bytesFormat.byteSeparator, bytesFormat.ignoreCase, "byte separator")
+            }
+            byteArray[byteIndex] = parseByteAt(charIndex + 1)
+            charIndex += 3
+        }
+        return byteArray
+    }
+}
+
+@ExperimentalStdlibApi
+private fun String.hexToByteArrayNoLineAndGroupSeparatorSlowPath(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat
+): ByteArray? {
+    val bytePrefix = bytesFormat.bytePrefix
+    val byteSuffix = bytesFormat.byteSuffix
+    val byteSeparator = bytesFormat.byteSeparator
+    val byteSeparatorLength = byteSeparator.length
+    val charsPerByte = 2L + bytePrefix.length + byteSuffix.length + byteSeparatorLength
+    val numberOfChars = (endIndex - startIndex).toLong()
+    val numberOfBytes = ((numberOfChars + byteSeparatorLength) / charsPerByte).toInt()
+
+    // Go to the default implementation when the string length doesn't match
+    if (numberOfBytes * charsPerByte - byteSeparatorLength != numberOfChars) {
+        return null
+    }
+
+    val ignoreCase = bytesFormat.ignoreCase
+
+    val byteArray = ByteArray(numberOfBytes)
+    var charIndex = startIndex
+
+    charIndex = checkContainsAt(charIndex, endIndex, bytePrefix, ignoreCase, "byte prefix")
+    val between = byteSuffix + byteSeparator + bytePrefix
+    for (byteIndex in 0 until numberOfBytes - 1) {
+        byteArray[byteIndex] = parseByteAt(charIndex)
+        charIndex = checkContainsAt(charIndex + 2, endIndex, between, ignoreCase, "byte suffix + byte separator + byte prefix")
+    }
+    byteArray[numberOfBytes - 1] = parseByteAt(charIndex)
+    checkContainsAt(charIndex + 2, endIndex, byteSuffix, ignoreCase, "byte suffix")
+
+    return byteArray
+}
+
+@ExperimentalStdlibApi
+private fun String.hexToByteArraySlowPath(
+    startIndex: Int,
+    endIndex: Int,
+    bytesFormat: HexFormat.BytesHexFormat
+): ByteArray {
    val bytesPerLine = bytesFormat.bytesPerLine
    val bytesPerGroup = bytesFormat.bytesPerGroup
    val bytePrefix = bytesFormat.bytePrefix
    val byteSuffix = bytesFormat.byteSuffix
    val byteSeparator = bytesFormat.byteSeparator
    val groupSeparator = bytesFormat.groupSeparator
+    val ignoreCase = bytesFormat.ignoreCase

-    val resultCapacity = parsedByteArrayMaxSize(
+    val parseMaxSize = parsedByteArrayMaxSize(
        stringLength = endIndex - startIndex,
        bytesPerLine,
        bytesPerGroup,
@@ -207,37 +483,42 @@ private fun String.hexToByteArray(
        bytePrefix.length,
        byteSuffix.length
    )
-    val result = ByteArray(resultCapacity)
+    val byteArray = ByteArray(parseMaxSize)

-    var i = startIndex
+    var charIndex = startIndex
    var byteIndex = 0
    var indexInLine = 0
    var indexInGroup = 0

-    while (i < endIndex) {
+    while (charIndex < endIndex) {
        if (indexInLine == bytesPerLine) {
-            i = checkNewLineAt(i, endIndex)
+            charIndex = checkNewLineAt(charIndex, endIndex)
            indexInLine = 0
            indexInGroup = 0
        } else if (indexInGroup == bytesPerGroup) {
-            i = checkContainsAt(groupSeparator, i, endIndex, "group separator")
+            charIndex = checkContainsAt(charIndex, endIndex, groupSeparator, ignoreCase, "group separator")
            indexInGroup = 0
        } else if (indexInGroup != 0) {
-            i = checkContainsAt(byteSeparator, i, endIndex, "byte separator")
+            charIndex = checkContainsAt(charIndex, endIndex, byteSeparator, ignoreCase, "byte separator")
        }
        indexInLine += 1
        indexInGroup += 1

-        i = checkContainsAt(bytePrefix, i, endIndex, "byte prefix")
-
-        checkHexLength(i, (i + 2).coerceAtMost(endIndex), maxDigits = 2, requireMaxLength = true)
-
-        result[byteIndex++] = ((decimalFromHexDigitAt(i++) shl 4) or decimalFromHexDigitAt(i++)).toByte()
-
-        i = checkContainsAt(byteSuffix, i, endIndex, "byte suffix")
+        charIndex = checkContainsAt(charIndex, endIndex, bytePrefix, ignoreCase, "byte prefix")
+        if (endIndex - 2 < charIndex) {
+            throwInvalidNumberOfDigits(charIndex, endIndex, maxDigits = 2, requireMaxLength = true)
+        }
+        byteArray[byteIndex++] = parseByteAt(charIndex)
+        charIndex = checkContainsAt(charIndex + 2, endIndex, byteSuffix, ignoreCase, "byte suffix")
    }

-    return if (byteIndex == result.size) result else result.copyOf(byteIndex)
+    return if (byteIndex == byteArray.size) byteArray else byteArray.copyOf(byteIndex)
+}
+
+private fun String.parseByteAt(index: Int): Byte {
+    val high = decimalFromHexDigitAt(index)
+    val low = decimalFromHexDigitAt(index + 1)
+    return ((high shl 4) or low).toByte()
 }

 // Declared internal for testing
@@ -329,7 +610,24 @@ private fun String.checkNewLineAt(index: Int, endIndex: Int): Int {
 */
@ExperimentalStdlibApi
@SinceKotlin("1.9")
-public fun Byte.toHexString(format: HexFormat = HexFormat.Default): String = toLong().toHexStringImpl(format, bits = 8)
+public fun Byte.toHexString(format: HexFormat = HexFormat.Default): String {
+    val digits = if (format.upperCase) UPPER_CASE_HEX_DIGITS else LOWER_CASE_HEX_DIGITS
+    val numberFormat = format.number
+
+    // Optimize for digits-only formats
+    if (numberFormat.isDigitsOnly) {
+        val charArray = CharArray(2)
+        val value = this.toInt()
+        charArray[0] = digits[(value shr 4) and 0xF]
+        charArray[1] = digits[value and 0xF]
+        return if (numberFormat.removeLeadingZeros)
+            charArray.concatToString(startIndex = (countLeadingZeroBits() shr 2).coerceAtMost(1))
+        else
+            charArray.concatToString()
+    }
+
+    return toLong().toHexStringImpl(numberFormat, digits, bits = 8)
+}

 /**
 * Parses a `Byte` value from this string using the specified [format].
@@ -362,7 +660,7 @@ public fun String.hexToByte(format: HexFormat = HexFormat.Default): Byte = hexTo
@ExperimentalStdlibApi
 //@SinceKotlin("1.9")
 private fun String.hexToByte(startIndex: Int = 0, endIndex: Int = length, format: HexFormat = HexFormat.Default): Byte =
-    hexToLongImpl(startIndex, endIndex, format, maxDigits = 2).toByte()
+    hexToIntImpl(startIndex, endIndex, format, maxDigits = 2).toByte()

 // -------------------------- format and parse Short --------------------------

@@ -375,7 +673,26 @@ private fun String.hexToByte(startIndex: Int = 0, endIndex: Int = length, format
 */
@ExperimentalStdlibApi
@SinceKotlin("1.9")
-public fun Short.toHexString(format: HexFormat = HexFormat.Default): String = toLong().toHexStringImpl(format, bits = 16)
+public fun Short.toHexString(format: HexFormat = HexFormat.Default): String {
+    val digits = if (format.upperCase) UPPER_CASE_HEX_DIGITS else LOWER_CASE_HEX_DIGITS
+    val numberFormat = format.number
+
+    // Optimize for digits-only formats
+    if (numberFormat.isDigitsOnly) {
+        val charArray = CharArray(4)
+        val value = this.toInt()
+        charArray[0] = digits[(value shr 12) and 0xF]
+        charArray[1] = digits[(value shr 8) and 0xF]
+        charArray[2] = digits[(value shr 4) and 0xF]
+        charArray[3] = digits[value and 0xF]
+        return if (numberFormat.removeLeadingZeros)
+            charArray.concatToString(startIndex = (countLeadingZeroBits() shr 2).coerceAtMost(3))
+        else
+            charArray.concatToString()
+    }
+
+    return toLong().toHexStringImpl(numberFormat, digits, bits = 16)
+}

 /**
 * Parses a `Short` value from this string using the specified [format].
@@ -408,7 +725,7 @@ public fun String.hexToShort(format: HexFormat = HexFormat.Default): Short = hex
@ExperimentalStdlibApi
 //@SinceKotlin("1.9")
 private fun String.hexToShort(startIndex: Int = 0, endIndex: Int = length, format: HexFormat = HexFormat.Default): Short =
-    hexToLongImpl(startIndex, endIndex, format, maxDigits = 4).toShort()
+    hexToIntImpl(startIndex, endIndex, format, maxDigits = 4).toShort()

 // -------------------------- format and parse Int --------------------------

@@ -421,7 +738,30 @@ private fun String.hexToShort(startIndex: Int = 0, endIndex: Int = length, forma
 */
@ExperimentalStdlibApi
@SinceKotlin("1.9")
-public fun Int.toHexString(format: HexFormat = HexFormat.Default): String = toLong().toHexStringImpl(format, bits = 32)
+public fun Int.toHexString(format: HexFormat = HexFormat.Default): String {
+    val digits = if (format.upperCase) UPPER_CASE_HEX_DIGITS else LOWER_CASE_HEX_DIGITS
+    val numberFormat = format.number
+
+    // Optimize for digits-only formats
+    if (numberFormat.isDigitsOnly) {
+        val charArray = CharArray(8)
+        val value = this
+        charArray[0] = digits[(value shr 28) and 0xF]
+        charArray[1] = digits[(value shr 24) and 0xF]
+        charArray[2] = digits[(value shr 20) and 0xF]
+        charArray[3] = digits[(value shr 16) and 0xF]
+        charArray[4] = digits[(value shr 12) and 0xF]
+        charArray[5] = digits[(value shr 8) and 0xF]
+        charArray[6] = digits[(value shr 4) and 0xF]
+        charArray[7] = digits[value and 0xF]
+        return if (numberFormat.removeLeadingZeros)
+            charArray.concatToString(startIndex = (countLeadingZeroBits() shr 2).coerceAtMost(7))
+        else
+            charArray.concatToString()
+    }
+
+    return toLong().toHexStringImpl(numberFormat, digits, bits = 32)
+}

 /**
 * Parses an `Int` value from this string using the specified [format].
@@ -454,7 +794,7 @@ public fun String.hexToInt(format: HexFormat = HexFormat.Default): Int = hexToIn
@ExperimentalStdlibApi
 //@SinceKotlin("1.9")
 private fun String.hexToInt(startIndex: Int = 0, endIndex: Int = length, format: HexFormat = HexFormat.Default): Int =
-    hexToLongImpl(startIndex, endIndex, format, maxDigits = 8).toInt()
+    hexToIntImpl(startIndex, endIndex, format, maxDigits = 8)

 // -------------------------- format and parse Long --------------------------

@@ -467,7 +807,38 @@ private fun String.hexToInt(startIndex: Int = 0, endIndex: Int = length, format:
 */
@ExperimentalStdlibApi
@SinceKotlin("1.9")
-public fun Long.toHexString(format: HexFormat = HexFormat.Default): String = toHexStringImpl(format, bits = 64)
+public fun Long.toHexString(format: HexFormat = HexFormat.Default): String {
+    val digits = if (format.upperCase) UPPER_CASE_HEX_DIGITS else LOWER_CASE_HEX_DIGITS
+    val numberFormat = format.number
+
+    // Optimize for digits-only formats
+    if (numberFormat.isDigitsOnly) {
+        val charArray = CharArray(16)
+        val value = this
+        charArray[0] = digits[((value shr 60) and 0xF).toInt()]
+        charArray[1] = digits[((value shr 56) and 0xF).toInt()]
+        charArray[2] = digits[((value shr 52) and 0xF).toInt()]
+        charArray[3] = digits[((value shr 48) and 0xF).toInt()]
+        charArray[4] = digits[((value shr 44) and 0xF).toInt()]
+        charArray[5] = digits[((value shr 40) and 0xF).toInt()]
+        charArray[6] = digits[((value shr 36) and 0xF).toInt()]
+        charArray[7] = digits[((value shr 32) and 0xF).toInt()]
+        charArray[8] = digits[((value shr 28) and 0xF).toInt()]
+        charArray[9] = digits[((value shr 24) and 0xF).toInt()]
+        charArray[10] = digits[((value shr 20) and 0xF).toInt()]
+        charArray[11] = digits[((value shr 16) and 0xF).toInt()]
+        charArray[12] = digits[((value shr 12) and 0xF).toInt()]
+        charArray[13] = digits[((value shr 8) and 0xF).toInt()]
+        charArray[14] = digits[((value shr 4) and 0xF).toInt()]
+        charArray[15] = digits[(value and 0xF).toInt()]
+        return if (numberFormat.removeLeadingZeros)
+            charArray.concatToString(startIndex = (countLeadingZeroBits() shr 2).coerceAtMost(15))
+        else
+            charArray.concatToString()
+    }
+
+    return toHexStringImpl(numberFormat, digits, bits = 64)
+}

 /**
 * Parses a `Long` value from this string using the specified [format].
@@ -505,86 +876,174 @@ private fun String.hexToLong(startIndex: Int = 0, endIndex: Int = length, format
 // -------------------------- private format and parse functions --------------------------

@ExperimentalStdlibApi
-private fun Long.toHexStringImpl(format: HexFormat, bits: Int): String {
+private fun Long.toHexStringImpl(numberFormat: HexFormat.NumberHexFormat, digits: String, bits: Int): String {
    require(bits and 0x3 == 0)

-    val digits = if (format.upperCase) UPPER_CASE_HEX_DIGITS else LOWER_CASE_HEX_DIGITS
    val value = this
+    val numberOfHexDigits = bits shr 2

-    val prefix = format.number.prefix
-    val suffix = format.number.suffix
-    val formatLength = prefix.length + (bits shr 2) + suffix.length
-    var removeZeros = format.number.removeLeadingZeros
+    val prefix = numberFormat.prefix
+    val suffix = numberFormat.suffix
+    var removeZeros = numberFormat.removeLeadingZeros

-    return buildString(formatLength) {
-        append(prefix)
+    val formatLength = prefix.length.toLong() + numberOfHexDigits + suffix.length
+    val charArray = CharArray(checkFormatLength(formatLength))

-        var shift = bits
-        while (shift > 0) {
-            shift -= 4
-            val decimal = ((value shr shift) and 0xF).toInt()
-            removeZeros = removeZeros && decimal == 0 && shift > 0
-            if (!removeZeros) {
-                append(digits[decimal])
-            }
+    var charIndex = prefix.toCharArrayIfNotEmpty(charArray, 0)
+
+    var shift = bits
+    repeat(numberOfHexDigits) {
+        shift -= 4
+        val decimal = ((value shr shift) and 0xF).toInt()
+        removeZeros = removeZeros && decimal == 0 && shift > 0
+        if (!removeZeros) {
+            charArray[charIndex++] = digits[decimal]
        }
-
-        append(suffix)
    }
+
+    charIndex = suffix.toCharArrayIfNotEmpty(charArray, charIndex)
+
+    return if (charIndex == charArray.size) charArray.concatToString() else charArray.concatToString(endIndex = charIndex)
+}
+
+@OptIn(ExperimentalStdlibApi::class)
+private fun String.toCharArrayIfNotEmpty(destination: CharArray, destinationOffset: Int): Int {
+    when (length) {
+        0 -> { /* do nothing */ }
+        1 -> destination[destinationOffset] = this[0]
+        else -> toCharArray(destination, destinationOffset)
+    }
+    return destinationOffset + length
 }

@ExperimentalStdlibApi
-private fun String.hexToLongImpl(startIndex: Int = 0, endIndex: Int = length, format: HexFormat, maxDigits: Int): Long {
+private fun String.hexToIntImpl(startIndex: Int, endIndex: Int, format: HexFormat, maxDigits: Int): Int {
    AbstractList.checkBoundsIndexes(startIndex, endIndex, length)

-    val prefix = format.number.prefix
-    val suffix = format.number.suffix
+    val numberFormat = format.number

-    if (prefix.length + suffix.length >= endIndex - startIndex) {
-        throw NumberFormatException(
-            "Expected a hexadecimal number with prefix \"$prefix\" and suffix \"$suffix\", but was ${substring(startIndex, endIndex)}"
-        )
+    // Optimize for digits-only formats
+    if (numberFormat.isDigitsOnly) {
+        checkMaxDigits(startIndex, endIndex, maxDigits)
+        return parseInt(startIndex, endIndex)
    }

-    val digitsStartIndex = checkContainsAt(prefix, startIndex, endIndex, "prefix")
+    val prefix = numberFormat.prefix
+    val suffix = numberFormat.suffix
+    checkPrefixSuffixMaxDigits(startIndex, endIndex, prefix, suffix, numberFormat.ignoreCase, maxDigits)
+    return parseInt(startIndex + prefix.length, endIndex - suffix.length)
+}
+
+@ExperimentalStdlibApi
+private fun String.hexToLongImpl(startIndex: Int, endIndex: Int, format: HexFormat, maxDigits: Int): Long {
+    AbstractList.checkBoundsIndexes(startIndex, endIndex, length)
+
+    val numberFormat = format.number
+
+    // Optimize for digits-only formats
+    if (numberFormat.isDigitsOnly) {
+        checkMaxDigits(startIndex, endIndex, maxDigits)
+        return parseLong(startIndex, endIndex)
+    }
+
+    val prefix = numberFormat.prefix
+    val suffix = numberFormat.suffix
+    checkPrefixSuffixMaxDigits(startIndex, endIndex, prefix, suffix, numberFormat.ignoreCase, maxDigits)
+    return parseLong(startIndex + prefix.length, endIndex - suffix.length)
+}
+
+private fun String.checkPrefixSuffixMaxDigits(
+    startIndex: Int,
+    endIndex: Int,
+    prefix: String,
+    suffix: String,
+    ignoreCase: Boolean,
+    maxDigits: Int
+) {
+    if (endIndex - startIndex - prefix.length <= suffix.length) {
+        throwInvalidPrefixSuffix(startIndex, endIndex, prefix, suffix)
+    }
+
+    val digitsStartIndex = checkContainsAt(startIndex, endIndex, prefix, ignoreCase, "prefix")
    val digitsEndIndex = endIndex - suffix.length
-    checkContainsAt(suffix, digitsEndIndex, endIndex, "suffix")
+    checkContainsAt(digitsEndIndex, endIndex, suffix, ignoreCase, "suffix")

-    checkHexLength(digitsStartIndex, digitsEndIndex, maxDigits, requireMaxLength = false)
+    checkMaxDigits(digitsStartIndex, digitsEndIndex, maxDigits)
+}

-    var result = 0L
-    for (i in digitsStartIndex until digitsEndIndex) {
-        result = (result shl 4) or decimalFromHexDigitAt(i).toLong()
+private fun String.checkMaxDigits(startIndex: Int, endIndex: Int, maxDigits: Int) {
+    if (startIndex >= endIndex || endIndex - startIndex > maxDigits) {
+        throwInvalidNumberOfDigits(startIndex, endIndex, maxDigits, requireMaxLength = false)
+    }
+}
+
+private fun String.parseInt(startIndex: Int, endIndex: Int): Int {
+    var result = 0
+    for (i in startIndex until endIndex) {
+        result = (result shl 4) or decimalFromHexDigitAt(i)
    }
    return result
 }

-private fun String.checkContainsAt(part: String, index: Int, endIndex: Int, partName: String): Int {
-    val end = index + part.length
-    if (end > endIndex || !regionMatches(index, part, 0, part.length, ignoreCase = true)) {
-        throw NumberFormatException(
-            "Expected $partName \"$part\" at index $index, but was ${this.substring(index, end.coerceAtMost(endIndex))}"
-        )
+private fun String.parseLong(startIndex: Int, endIndex: Int): Long {
+    var result = 0L
+    for (i in startIndex until endIndex) {
+        result = (result shl 4) or longDecimalFromHexDigitAt(i)
    }
-    return end
+    return result
 }

-private fun String.checkHexLength(startIndex: Int, endIndex: Int, maxDigits: Int, requireMaxLength: Boolean) {
-    val digitsLength = endIndex - startIndex
-    val isCorrectLength = if (requireMaxLength) digitsLength == maxDigits else digitsLength <= maxDigits
-    if (!isCorrectLength) {
-        val specifier = if (requireMaxLength) "exactly" else "at most"
-        val substring = substring(startIndex, endIndex)
-        throw NumberFormatException(
-            "Expected $specifier $maxDigits hexadecimal digits at index $startIndex, but was $substring of length $digitsLength"
-        )
+@Suppress("NOTHING_TO_INLINE")
+private inline fun String.checkContainsAt(index: Int, endIndex: Int, part: String, ignoreCase: Boolean, partName: String): Int {
+    if (part.isEmpty()) return index
+    for (i in part.indices) {
+        if (!part[i].equals(this[index + i], ignoreCase)) {
+            throwNotContainedAt(index, endIndex, part, partName)
+        }
    }
+    return index + part.length
 }

-private fun String.decimalFromHexDigitAt(index: Int): Int {
+@Suppress("NOTHING_TO_INLINE")
+private inline fun String.decimalFromHexDigitAt(index: Int): Int {
    val code = this[index].code
-    if (code > 127 || HEX_DIGITS_TO_DECIMAL[code] < 0) {
-        throw NumberFormatException("Expected a hexadecimal digit at index $index, but was ${this[index]}")
+    if (code ushr 8 == 0 && HEX_DIGITS_TO_DECIMAL[code] >= 0) {
+        return HEX_DIGITS_TO_DECIMAL[code]
    }
-    return HEX_DIGITS_TO_DECIMAL[code]
+    throwInvalidDigitAt(index)
+}
+
+@Suppress("NOTHING_TO_INLINE")
+private inline fun String.longDecimalFromHexDigitAt(index: Int): Long {
+    val code = this[index].code
+    if (code ushr 8 == 0 && HEX_DIGITS_TO_LONG_DECIMAL[code] >= 0) {
+        return HEX_DIGITS_TO_LONG_DECIMAL[code]
+    }
+    throwInvalidDigitAt(index)
+}
+
+private fun String.throwInvalidNumberOfDigits(startIndex: Int, endIndex: Int, maxDigits: Int, requireMaxLength: Boolean) {
+    val specifier = if (requireMaxLength) "exactly" else "at most"
+    val substring = substring(startIndex, endIndex)
+    throw NumberFormatException(
+        "Expected $specifier $maxDigits hexadecimal digits at index $startIndex, but was $substring of length ${endIndex - startIndex}"
+    )
+}
+
+private fun String.throwNotContainedAt(index: Int, endIndex: Int, part: String, partName: String) {
+    val substring = substring(index, (index + part.length).coerceAtMost(endIndex))
+    throw NumberFormatException(
+        "Expected $partName \"$part\" at index $index, but was $substring"
+    )
+}
+
+private fun String.throwInvalidPrefixSuffix(startIndex: Int, endIndex: Int, prefix: String, suffix: String) {
+    val substring = substring(startIndex, endIndex)
+    throw NumberFormatException(
+        "Expected a hexadecimal number with prefix \"$prefix\" and suffix \"$suffix\", but was $substring"
+    )
+}
+
+private fun String.throwInvalidDigitAt(index: Int): Nothing {
+    throw NumberFormatException("Expected a hexadecimal digit at index $index, but was ${this[index]}")
 }
@@ -79,6 +79,22 @@ public class HexFormat internal constructor(
        val byteSuffix: String
    ) {

+        internal val noLineAndGroupSeparator: Boolean =
+            bytesPerLine == Int.MAX_VALUE && bytesPerGroup == Int.MAX_VALUE
+
+        internal val shortByteSeparatorNoPrefixAndSuffix: Boolean =
+            bytePrefix.isEmpty() && byteSuffix.isEmpty() && byteSeparator.length <= 1
+
+        /**
+         * Whether to ignore case when parsing format strings.
+         * If false, case-sensitive parsing is conducted, which is faster.
+         */
+        internal val ignoreCase: Boolean =
+            groupSeparator.isCaseSensitive() ||
+                    byteSeparator.isCaseSensitive() ||
+                    bytePrefix.isCaseSensitive() ||
+                    byteSuffix.isCaseSensitive()
+
        override fun toString(): String = buildString {
            append("BytesHexFormat(").appendLine()
            appendOptionsTo(this, indent = "    ").appendLine()
@@ -227,6 +243,14 @@ public class HexFormat internal constructor(
        val removeLeadingZeros: Boolean
    ) {

+        internal val isDigitsOnly: Boolean = prefix.isEmpty() && suffix.isEmpty()
+
+        /**
+         * Whether to ignore case when parsing format strings.
+         * If false, case-sensitive parsing is conducted, which is faster.
+         */
+        internal val ignoreCase: Boolean = prefix.isCaseSensitive() || suffix.isCaseSensitive()
+
        override fun toString(): String = buildString {
            append("NumberHexFormat(").appendLine()
            appendOptionsTo(this, indent = "    ").appendLine()
@@ -409,3 +433,9 @@ public class HexFormat internal constructor(
 public inline fun HexFormat(builderAction: HexFormat.Builder.() -> Unit): HexFormat {
    return HexFormat.Builder().apply(builderAction).build()
 }
+
+// --- private functions ---
+
+private fun String.isCaseSensitive(): Boolean {
+    return this.any { it >= '\u0080' || it.isLetter() }
+}