Merge pull request #1614 from square/jwilson.0409.promote_fast_js_hex

Custom JS implementation of decodeHex

Author: swankjesse

okio/build.gradle.kts

@@ -44,7 +44,7 @@ plugins {
  *       '-- wasmWasi
  * ```
  *
- * The `nonJvm` source set excludes that platform.
+ * The `nonJvm`, `nonJs`, `nonApple`, etc. source sets exclude the corresponding platforms.
  *
  * The `hashFunctions` source set builds on all platforms. It ships as a main source set on non-JVM
  * platforms and as a test source set on the JVM platform.
@@ -93,6 +93,10 @@ kotlin {
       dependsOn(commonMain)
     }
 
+    val nonJsMain by creating {
+      dependsOn(commonMain)
+    }
+
     val systemFileSystemMain by creating {
       dependsOn(commonMain)
     }
@@ -115,6 +119,7 @@ kotlin {
     val jvmMain by getting {
       dependsOn(zlibMain)
       dependsOn(systemFileSystemMain)
+      dependsOn(nonJsMain)
     }
     val jvmTest by getting {
       kotlin.srcDir("src/hashFunctions")
@@ -149,9 +154,11 @@ kotlin {
               children = mingwTargets,
           ).also { mingwMain ->
             mingwMain.dependsOn(nonAppleMain)
+            mingwMain.dependsOn(nonJsMain)
           }
           createSourceSet("unixMain", parent = nativeMain)
             .also { unixMain ->
+              unixMain.dependsOn(nonJsMain)
               createSourceSet(
                   "linuxMain",
                   parent = unixMain,
@@ -175,6 +182,7 @@ kotlin {
     if (kmpWasmEnabled) {
       createSourceSet("wasmMain", parent = commonMain, children = wasmTargets)
         .also { wasmMain ->
+          wasmMain.dependsOn(nonJsMain)
           wasmMain.dependsOn(nonJvmMain)
           wasmMain.dependsOn(nonAppleMain)
         }

okio/src/commonMain/kotlin/okio/internal/ByteString.kt

@@ -289,32 +289,13 @@ internal inline fun String.commonDecodeBase64(): ByteString? {
 }
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun String.commonDecodeHex(): ByteString {
-  require(length % 2 == 0) { "Unexpected hex string: $this" }
-
-  val result = ByteArray(length / 2)
-  for (i in result.indices) {
-    val d1 = decodeHexDigit(this[i * 2]) shl 4
-    val d2 = decodeHexDigit(this[i * 2 + 1])
-    result[i] = (d1 + d2).toByte()
-  }
-  return ByteString(result)
-}
+internal expect inline fun String.commonDecodeHex(): ByteString
 
 /** Writes the contents of this byte string to `buffer`.  */
 internal fun ByteString.commonWrite(buffer: Buffer, offset: Int, byteCount: Int) {
   buffer.write(data, offset, byteCount)
 }
 
-private fun decodeHexDigit(c: Char): Int {
-  return when (c) {
-    in '0'..'9' -> c - '0'
-    in 'a'..'f' -> c - 'a' + 10
-    in 'A'..'F' -> c - 'A' + 10
-    else -> throw IllegalArgumentException("Unexpected hex digit: $c")
-  }
-}
-
 @Suppress("NOTHING_TO_INLINE")
 internal inline fun ByteString.commonToString(): String {
   if (data.isEmpty()) return "[size=0]"

okio/src/jsMain/kotlin/okio/internal/ByteStringJs.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2025 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package okio.internal
+
+import okio.ByteString
+
+private val charToNibble = js(
+  """
+    {
+      0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
+      a: 10, b: 11, c: 12, d: 13, e: 14, f: 15,
+      A: 10, B: 11, C: 12, D: 13, E: 14, F: 15
+    }
+    """,
+)
+
+/**
+ * Here we implement a custom hex decoder because the vanilla Kotlin one is too slow. The Kotlin
+ * transpiles to reasonable-looking but very inefficient JavaScript!
+ *
+ * This does a plain JavaScript implementation of hex decoding, and it's dramatically faster. In
+ * one measurement hex decoding went from 25% of CPU samples to 0% of them.
+ */
+@Suppress("NOTHING_TO_INLINE")
+internal actual inline fun String.commonDecodeHex(): ByteString {
+  require(length % 2 == 0) { "Unexpected hex string: $this" }
+
+  val string = this
+  val charToNibble = charToNibble
+  val result = ByteArray(string.length / 2)
+  var invalidDigitIndex = -1
+
+  js(
+    """
+      var stringIndex = 0;
+      var byteIndex = 0;
+      while (stringIndex < string.length) {
+        var charA = string[stringIndex++];
+        var nibbleA = charToNibble[charA];
+
+        var charB = string[stringIndex++];
+        var nibbleB = charToNibble[charB];
+
+        if (nibbleA == null || nibbleB == null) {
+          invalidDigitIndex = stringIndex;
+          break;
+        }
+
+        result[byteIndex++] = (nibbleA << 4) | nibbleB;
+      }
+      """,
+  )
+
+  require(invalidDigitIndex == -1) {
+    "Unexpected hex digit: ${string[invalidDigitIndex]}"
+  }
+
+  return ByteString(result)
+}

okio/src/nonJsMain/kotlin/okio/internal/ByteStringNonJs.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2025 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@file:JvmName("-ByteStringNonJs") // A leading '-' hides this class from Java.
+
+package okio.internal
+
+import kotlin.jvm.JvmName
+import okio.ByteString
+
+@Suppress("NOTHING_TO_INLINE")
+internal actual inline fun String.commonDecodeHex(): ByteString {
+  require(length % 2 == 0) { "Unexpected hex string: $this" }
+
+  val result = ByteArray(length / 2)
+  for (i in result.indices) {
+    val d1 = decodeHexDigit(this[i * 2]) shl 4
+    val d2 = decodeHexDigit(this[i * 2 + 1])
+    result[i] = (d1 + d2).toByte()
+  }
+  return ByteString(result)
+}
+
+private fun decodeHexDigit(c: Char): Int {
+  return when (c) {
+    in '0'..'9' -> c - '0'
+    in 'a'..'f' -> c - 'a' + 10
+    in 'A'..'F' -> c - 'A' + 10
+    else -> throw IllegalArgumentException("Unexpected hex digit: $c")
+  }
+}