Add benchmarks on java.io/nio integration and byte array reading

Author: fzhinkin

benchmarks/src/commonMain/kotlin/BufferOps.kt

@@ -340,4 +340,43 @@ open class BufferGetBenchmark {
 
     @Benchmark
     fun get() = buffer[offset]
+}
+
+open class BufferReadWriteByteArray: BufferRWBenchmarkBase() {
+    private var inputArray = ByteArray(0)
+    private var outputArray = ByteArray(0)
+
+    @Param("1", "1024", (SEGMENT_SIZE_IN_BYTES * 3).toString())
+    var size: Int = 0
+
+    @Setup
+    fun allocateArrays() {
+        inputArray = ByteArray(size)
+        outputArray = ByteArray(size)
+    }
+
+    @Benchmark
+    fun benchmark(blackhole: Blackhole) {
+        buffer.write(inputArray)
+        buffer.readFully(outputArray)
+        blackhole.consume(outputArray)
+    }
+}
+
+open class BufferReadNewByteArray: BufferRWBenchmarkBase() {
+    private var inputArray = ByteArray(0)
+
+    @Param("1", "1024", (SEGMENT_SIZE_IN_BYTES * 3).toString())
+    var size: Int = 0
+
+    @Setup
+    fun allocateArray() {
+        inputArray = ByteArray(size)
+    }
+
+    @Benchmark
+    fun benchmark(): ByteArray {
+        buffer.write(inputArray)
+        return buffer.readByteArray(size.toLong())
+    }
 }

benchmarks/src/jvmMain/kotlin/ByteBufferBenchmarks.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io.benchmarks
+
+import java.nio.ByteBuffer
+
+import kotlinx.benchmark.*
+
+open class ByteBufferReadWrite: BufferRWBenchmarkBase() {
+    private var inputBuffer = ByteBuffer.allocate(0)
+    private var outputBuffer = ByteBuffer.allocate(0)
+
+    @Param("1", "1024", (SEGMENT_SIZE_IN_BYTES * 3).toString())
+    var size: Int = 0
+
+    @Setup
+    fun allocateBuffers() {
+        inputBuffer = ByteBuffer.allocate(size)
+        inputBuffer.put(ByteArray(size))
+        outputBuffer = ByteBuffer.allocate(size)
+    }
+
+    @Benchmark
+    fun benchmark(): ByteBuffer {
+        inputBuffer.rewind()
+        outputBuffer.clear()
+        buffer.write(inputBuffer)
+        while (buffer.read(outputBuffer) > 0) {
+            // do nothing
+        }
+        return outputBuffer
+    }
+}

benchmarks/src/jvmMain/kotlin/StreamBenchmarks.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.io.benchmarks
+
+import kotlinx.benchmark.*
+
+open class InputStreamByteRead: BufferRWBenchmarkBase() {
+   private val stream = buffer.inputStream()
+
+    @Benchmark
+    fun benchmark(): Int {
+        buffer.writeByte(0)
+        return stream.read()
+    }
+}
+
+open class OutputStreamByteWrite: BufferRWBenchmarkBase() {
+    private val stream = buffer.outputStream()
+
+    @Benchmark
+    fun benchmark(): Byte {
+        stream.write(0)
+        return buffer.readByte()
+    }
+}
+
+abstract class StreamByteArrayBenchmarkBase: BufferRWBenchmarkBase() {
+    protected var inputArray = ByteArray(0)
+    protected var outputArray = ByteArray(0)
+
+    @Param("1", "128", SEGMENT_SIZE_IN_BYTES.toString())
+    var size: Int = 0
+
+    @Setup
+    fun setupArray() {
+        inputArray = ByteArray(size)
+        outputArray = ByteArray(size)
+    }
+}
+
+open class InputStreamByteArrayRead: StreamByteArrayBenchmarkBase() {
+    private val stream = buffer.inputStream()
+
+    @Benchmark
+    fun benchmark(blackhole: Blackhole) {
+        buffer.write(inputArray)
+        var offset = 0
+        while (offset < outputArray.size) {
+            offset += stream.read(outputArray, offset, outputArray.size - offset)
+        }
+        blackhole.consume(outputArray)
+    }
+}
+
+open class OutputStreamByteArrayWrite: StreamByteArrayBenchmarkBase() {
+    private val stream = buffer.outputStream()
+
+    @Benchmark
+    fun benchmark(blackhole: Blackhole) {
+        stream.write(outputArray)
+        buffer.readFully(inputArray)
+        blackhole.consume(inputArray)
+    }
+}