Use ByteArray.copyInto instead of loops when processing buffered data (#70)

05nelsonm · web-flow · commit b93b188f49ea · 2024-12-19T16:00:43.000-05:00
diff --git a/library/digest/src/commonMain/kotlin/org/kotlincrypto/core/digest/internal/-Buffer.kt b/library/digest/src/commonMain/kotlin/org/kotlincrypto/core/digest/internal/-Buffer.kt
@@ -73,92 +73,85 @@ internal value class Buffer private constructor(internal val value: ByteArray) {
 }
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun Buffer.update(
+internal inline fun Buffer.commonUpdate(
     input: Byte,
-    bufOffsGetAndIncrement: () -> Int,
-    bufOffsReset: () -> Unit,
-    compress: (buf: ByteArray, offset: Int) -> Unit,
-    compressCountIncrement: () -> Unit,
+    bufOffsPlusPlus: Int,
+    doCompression: (buf: ByteArray, offset: Int) -> Unit,
 ) {
-    val bufOffs = bufOffsGetAndIncrement()
-    value[bufOffs] = input
-
-    // value.size == blockSize
-    if ((bufOffs + 1) != value.size) return
-    compress(value, 0)
-    compressCountIncrement()
-    bufOffsReset()
+    val buf = value
+    buf[bufOffsPlusPlus] = input
+
+    // buf.size == blockSize
+    if ((bufOffsPlusPlus + 1) != buf.size) return
+    doCompression(buf, 0)
 }
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun Buffer.update(
+internal inline fun Buffer.commonUpdate(
     input: ByteArray,
     offset: Int,
     len: Int,
-    bufOffsGet: () -> Int,
-    bufOffsGetAndIncrement: () -> Int,
-    bufOffsReset: () -> Unit,
+    bufOffs: Int,
+    bufOffsSet: (value: Int) -> Unit,
     compress: (buf: ByteArray, offset: Int) -> Unit,
-    compressCountIncrement: () -> Unit,
+    compressCountAdd: (value: Int) -> Unit,
 ) {
-    var i = offset
-    var remaining = len
-
-    // Fill buffer if not already empty
-    while (bufOffsGet() != 0 && remaining > 0) {
-        update(
-            input[i++],
-            bufOffsGetAndIncrement,
-            bufOffsReset,
-            compress,
-            compressCountIncrement,
-        )
-        --remaining
-    }
+    val buf = value
+    val blockSize = buf.size
+    var offsInput = offset
+    val limit = offsInput + len
+    var offsBuf = bufOffs
+    var compressions = 0
+
+    if (offsBuf > 0) {
+        // Need to use buffered data (if possible)
+
+        if (offsBuf + len < blockSize) {
+            // Not enough for a compression. Add it to the buffer.
+            input.copyInto(buf, offsBuf, offsInput, limit)
+            bufOffsSet(offsBuf + len)
+            return
+        }
 
-    // Chunk
-    while (remaining >= value.size) {
-        compress(input, i)
-        i += value.size
-        remaining -= value.size
-        compressCountIncrement()
+        // Add enough input to do a compression
+        val needed = blockSize - offsBuf
+        input.copyInto(buf, offsBuf, offsInput, offsInput + needed)
+        compress(buf, 0)
+        offsBuf = 0
+        offsInput += needed
+        compressions++
     }
 
-    // Add remaining to buffer
-    while (remaining-- > 0) {
-        update(
-            input[i++],
-            bufOffsGetAndIncrement,
-            bufOffsReset,
-            compress,
-            compressCountIncrement,
-        )
+    // Chunk blocks (if possible)
+    while (offsInput < limit) {
+        val offsNext = offsInput + blockSize
+
+        if (offsNext > limit) {
+            // Not enough for a compression. Add it to the buffer.
+            input.copyInto(buf, 0, offsInput, limit)
+            offsBuf = limit - offsInput
+            break
+        }
+
+        compress(input, offsInput)
+        compressions++
+        offsInput = offsNext
     }
+
+    // Update globals
+    bufOffsSet(offsBuf)
+    compressCountAdd(compressions)
 }
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun Buffer.digest(
+internal inline fun Buffer.commonDigest(
     bufOffs: Int,
     compressCount: Long,
     digest: (bitLength: Long, offs: Int, buf: ByteArray) -> ByteArray,
-    resetBufOffs: () -> Unit,
-    resetCompressCount: () -> Unit,
-    resetDigest: () -> Unit,
+    reset: () -> Unit,
 ): ByteArray {
     val bitLength = ((compressCount * value.size) + bufOffs) * 8
     val final = digest(bitLength, bufOffs, value)
-    reset(resetBufOffs, resetCompressCount, resetDigest)
+    reset()
     return final
 }
-
-@Suppress("NOTHING_TO_INLINE")
-internal inline fun Buffer.reset(
-    resetBufOffs: () -> Unit,
-    resetCompressCount: () -> Unit,
-    resetDigest: () -> Unit,
-) {
-    value.fill(0)
-    resetBufOffs()
-    resetCompressCount()
-    resetDigest()
-}
diff --git a/library/digest/src/jvmMain/kotlin/org/kotlincrypto/core/digest/Digest.kt b/library/digest/src/jvmMain/kotlin/org/kotlincrypto/core/digest/Digest.kt
@@ -99,13 +99,11 @@ public actual abstract class Digest: MessageDigest, Algorithm, Cloneable, Copyab
         updateDigest(input, offset, len)
     }
 
-    public actual final override fun digest(): ByteArray = buf.digest(
+    public actual final override fun digest(): ByteArray = buf.commonDigest(
         bufOffs = bufOffs,
         compressCount = compressCount,
         digest = ::digest,
-        resetBufOffs = { bufOffs = 0 },
-        resetCompressCount = { compressCount = 0 },
-        resetDigest = ::resetDigest,
+        reset = ::reset,
     )
     public actual final override fun digest(input: ByteArray): ByteArray {
         updateDigest(input, 0, input.size)
@@ -115,11 +113,10 @@ public actual abstract class Digest: MessageDigest, Algorithm, Cloneable, Copyab
     public final override fun digest(buf: ByteArray, offset: Int, len: Int): Int = super.digest(buf, offset, len)
 
     public actual final override fun reset() {
-        buf.reset(
-            resetBufOffs = { bufOffs = 0 },
-            resetCompressCount = { compressCount = 0 },
-            resetDigest = ::resetDigest,
-        )
+        buf.value.fill(0)
+        bufOffs = 0
+        compressCount = 0
+        resetDigest()
     }
 
     public final override fun clone(): Any = copy()
@@ -145,12 +142,14 @@ public actual abstract class Digest: MessageDigest, Algorithm, Cloneable, Copyab
      * if necessary.
      * */
     protected actual open fun updateDigest(input: Byte) {
-        buf.update(
+        buf.commonUpdate(
             input = input,
-            bufOffsGetAndIncrement = { bufOffs++ },
-            bufOffsReset = { bufOffs = 0 },
-            compress = ::compress,
-            compressCountIncrement = { compressCount++ },
+            bufOffsPlusPlus = bufOffs++,
+            doCompression = { buf, offset ->
+                compress(buf, offset)
+                bufOffs = 0
+                compressCount++
+            },
         )
     }
 
@@ -160,15 +159,14 @@ public actual abstract class Digest: MessageDigest, Algorithm, Cloneable, Copyab
      * override and intercept if necessary.
      * */
     protected actual open fun updateDigest(input: ByteArray, offset: Int, len: Int) {
-        buf.update(
+        buf.commonUpdate(
             input = input,
             offset = offset,
             len = len,
-            bufOffsGet = { bufOffs },
-            bufOffsGetAndIncrement = { bufOffs++ },
-            bufOffsReset = { bufOffs = 0 },
+            bufOffs = bufOffs,
+            bufOffsSet = { bufOffs = it },
             compress = ::compress,
-            compressCountIncrement = { compressCount++ },
+            compressCountAdd = { compressCount += it },
         )
     }
 
diff --git a/library/digest/src/nonJvmMain/kotlin/org/kotlincrypto/core/digest/Digest.kt b/library/digest/src/nonJvmMain/kotlin/org/kotlincrypto/core/digest/Digest.kt
@@ -95,25 +95,22 @@ public actual abstract class Digest: Algorithm, Copyable<Digest>, Resettable, Up
         updateDigest(input, offset, len)
     }
 
-    public actual fun digest(): ByteArray = buf.digest(
+    public actual fun digest(): ByteArray = buf.commonDigest(
         bufOffs = bufOffs,
         compressCount = compressCount,
         digest = ::digest,
-        resetBufOffs = { bufOffs = 0 },
-        resetCompressCount = { compressCount = 0 },
-        resetDigest = ::resetDigest,
+        reset = ::reset,
     )
     public actual fun digest(input: ByteArray): ByteArray {
         updateDigest(input, 0, input.size)
         return digest()
     }
 
     public actual final override fun reset() {
-        buf.reset(
-            resetBufOffs = { bufOffs = 0 },
-            resetCompressCount = { compressCount = 0 },
-            resetDigest = ::resetDigest,
-        )
+        buf.value.fill(0)
+        bufOffs = 0
+        compressCount = 0
+        resetDigest()
     }
 
     public actual final override fun copy(): Digest = buf.toState(
@@ -138,12 +135,14 @@ public actual abstract class Digest: Algorithm, Copyable<Digest>, Resettable, Up
      * if necessary.
      * */
     protected actual open fun updateDigest(input: Byte) {
-        buf.update(
+        buf.commonUpdate(
             input = input,
-            bufOffsGetAndIncrement = { bufOffs++ },
-            bufOffsReset = { bufOffs = 0 },
-            compress = ::compress,
-            compressCountIncrement = { compressCount++ },
+            bufOffsPlusPlus = bufOffs++,
+            doCompression = { buf, offset ->
+                compress(buf, offset)
+                bufOffs = 0
+                compressCount++
+            },
         )
     }
 
@@ -153,15 +152,14 @@ public actual abstract class Digest: Algorithm, Copyable<Digest>, Resettable, Up
      * override and intercept if necessary.
      * */
     protected actual open fun updateDigest(input: ByteArray, offset: Int, len: Int) {
-        buf.update(
+        buf.commonUpdate(
             input = input,
             offset = offset,
             len = len,
-            bufOffsGet = { bufOffs },
-            bufOffsGetAndIncrement = { bufOffs++ },
-            bufOffsReset = { bufOffs = 0 },
+            bufOffs = bufOffs,
+            bufOffsSet = { bufOffs = it },
             compress = ::compress,
-            compressCountIncrement = { compressCount++ },
+            compressCountAdd = { compressCount += it },
         )
     }
 
