grpc-pb: Move JVM exception check to CODEC to avoid performance overhead

Signed-off-by: Johannes Zottele <[email protected]>

Author: Jozott00

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/pb/WireDecoder.kt

@@ -98,6 +98,8 @@ public interface WireDecoder : AutoCloseable {
     }
 }
 
+public expect fun checkForPlatformDecodeException(block: () -> Unit)
+
 /**
  * Creates a platform-specific [WireDecoder].
  *
@@ -108,4 +110,4 @@ public interface WireDecoder : AutoCloseable {
  *
  * @param source The buffer containing the encoded wire-format data.
  */
-internal expect fun WireDecoder(source: Buffer): WireDecoder
+public expect fun WireDecoder(source: Buffer): WireDecoder

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/pb/WireEncoder.kt

@@ -60,4 +60,6 @@ public interface WireEncoder {
 }
 
 
-internal expect fun WireEncoder(sink: Sink): WireEncoder
+public expect fun checkForPlatformEncodeException(block: () -> Unit)
+
+public expect fun WireEncoder(sink: Sink): WireEncoder

grpc/grpc-core/src/commonTest/kotlin/kotlinx/rpc/grpc/pb/WireCodecTest.kt

@@ -815,7 +815,9 @@ class WireCodecTest {
         buffer.writeByte(0)
 
         assertFailsWith<ProtobufDecodingException> {
-            WireDecoder(buffer).readTag()
+            checkForPlatformDecodeException {
+                WireDecoder(buffer).readTag()
+            }
         }
     }
 

grpc/grpc-core/src/jvmMain/kotlin/kotlinx/rpc/grpc/pb/WireDecoder.jvm.kt

@@ -15,79 +15,79 @@ internal class WireDecoderJvm(source: Buffer) : WireDecoder {
     // there is no way to omit coping here
     internal val codedInputStream: CodedInputStream = CodedInputStream.newInstance(source.asInputStream())
 
-    override fun readTag(): KTag? = checked {
+    override fun readTag(): KTag? {
         val tag = codedInputStream.readTag().toUInt()
         if (tag == 0u) {
             return null
         }
         return KTag.from(tag)
     }
 
-    override fun readBool(): Boolean = checked {
+    override fun readBool(): Boolean {
         return codedInputStream.readBool()
     }
 
-    override fun readInt32(): Int = checked {
+    override fun readInt32(): Int {
         return codedInputStream.readInt32()
     }
 
-    override fun readInt64(): Long = checked {
+    override fun readInt64(): Long {
         return codedInputStream.readInt64()
     }
 
-    override fun readUInt32(): UInt = checked {
+    override fun readUInt32(): UInt {
         // todo check java unsigned types
         return codedInputStream.readUInt32().toUInt()
     }
 
-    override fun readUInt64(): ULong = checked {
+    override fun readUInt64(): ULong {
         // todo check java unsigned types
         return codedInputStream.readUInt64().toULong()
     }
 
-    override fun readSInt32(): Int = checked {
+    override fun readSInt32(): Int {
         return codedInputStream.readSInt32()
     }
 
-    override fun readSInt64(): Long = checked {
+    override fun readSInt64(): Long {
         return codedInputStream.readSInt64()
     }
 
-    override fun readFixed32(): UInt = checked {
+    override fun readFixed32(): UInt {
         // todo check java unsigned types
         return codedInputStream.readFixed32().toUInt()
     }
 
-    override fun readFixed64(): ULong = checked {
+    override fun readFixed64(): ULong {
         // todo check java unsigned types
         return codedInputStream.readFixed64().toULong()
     }
 
-    override fun readSFixed32(): Int = checked {
+    override fun readSFixed32(): Int {
         return codedInputStream.readSFixed32()
     }
 
-    override fun readSFixed64(): Long = checked {
+    override fun readSFixed64(): Long {
         return codedInputStream.readSFixed64()
     }
 
-    override fun readFloat(): Float = checked {
+    override fun readFloat(): Float {
         return codedInputStream.readFloat()
     }
 
-    override fun readDouble(): Double = checked {
+    override fun readDouble(): Double {
         return codedInputStream.readDouble()
     }
 
-    override fun readEnum(): Int = checked {
+    override fun readEnum(): Int {
         return codedInputStream.readEnum()
     }
 
-    override fun readString(): String = checked {
+    override fun readString(): String {
         return codedInputStream.readStringRequireUtf8()
     }
 
-    override fun readBytes(): ByteArray = checked {
+    override fun readBytes(): ByteArray {
         return codedInputStream.readByteArray()
     }
 
@@ -114,21 +114,19 @@ internal class WireDecoderJvm(source: Buffer) : WireDecoder {
     )
 }
 
-internal actual fun WireDecoder(source: Buffer): WireDecoder {
-    return WireDecoderJvm(source)
-}
 
-/**
- * Turns a [InvalidProtocolBufferException] into our own [ProtobufDecodingException].
- */
-private inline fun <reified T> checked(block: () -> T): T {
+public actual fun checkForPlatformDecodeException(block: () -> Unit) {
     try {
         return block()
     } catch (e: InvalidProtocolBufferException) {
         throw e.toDecodingException()
     }
 }
 
+public actual fun WireDecoder(source: Buffer): WireDecoder {
+    return WireDecoderJvm(source)
+}
+
 private fun InvalidProtocolBufferException.toDecodingException(): ProtobufDecodingException {
     return ProtobufDecodingException(message ?: "Failed to decode protobuf message.", cause)
 }

grpc/grpc-core/src/jvmMain/kotlin/kotlinx/rpc/grpc/pb/WireEncoder.jvm.kt

@@ -17,103 +17,103 @@ private class WireEncoderJvm(sink: Sink) : WireEncoder {
         codedOutputStream.flush()
     }
 
-    override fun writeBool(fieldNr: Int, value: Boolean) = checked {
+    override fun writeBool(fieldNr: Int, value: Boolean) {
         codedOutputStream.writeBool(fieldNr, value)
     }
 
-    override fun writeInt32(fieldNr: Int, value: Int) = checked {
+    override fun writeInt32(fieldNr: Int, value: Int) {
         codedOutputStream.writeInt32(fieldNr, value)
     }
 
-    override fun writeInt64(fieldNr: Int, value: Long) = checked {
+    override fun writeInt64(fieldNr: Int, value: Long) {
         codedOutputStream.writeInt64(fieldNr, value)
     }
 
-    override fun writeUInt32(fieldNr: Int, value: UInt) = checked {
+    override fun writeUInt32(fieldNr: Int, value: UInt) {
         // todo check java unsigned types
         codedOutputStream.writeUInt32(fieldNr, value.toInt())
     }
 
-    override fun writeUInt64(fieldNr: Int, value: ULong) = checked {
+    override fun writeUInt64(fieldNr: Int, value: ULong) {
         // todo check java unsigned types
         codedOutputStream.writeUInt64(fieldNr, value.toLong())
     }
 
-    override fun writeSInt32(fieldNr: Int, value: Int) = checked {
+    override fun writeSInt32(fieldNr: Int, value: Int) {
         codedOutputStream.writeSInt32(fieldNr, value)
     }
 
-    override fun writeSInt64(fieldNr: Int, value: Long) = checked {
+    override fun writeSInt64(fieldNr: Int, value: Long) {
         codedOutputStream.writeSInt64(fieldNr, value)
     }
 
-    override fun writeFixed32(fieldNr: Int, value: UInt) = checked {
+    override fun writeFixed32(fieldNr: Int, value: UInt) {
         // todo check java unsigned types
         codedOutputStream.writeFixed32(fieldNr, value.toInt())
     }
 
-    override fun writeFixed64(fieldNr: Int, value: ULong) = checked {
+    override fun writeFixed64(fieldNr: Int, value: ULong) {
         // todo check java unsigned types
         codedOutputStream.writeFixed64(fieldNr, value.toLong())
     }
 
-    override fun writeSFixed32(fieldNr: Int, value: Int) = checked {
+    override fun writeSFixed32(fieldNr: Int, value: Int) {
         codedOutputStream.writeSFixed32(fieldNr, value)
     }
 
-    override fun writeSFixed64(fieldNr: Int, value: Long) = checked {
+    override fun writeSFixed64(fieldNr: Int, value: Long) {
         codedOutputStream.writeSFixed64(fieldNr, value)
     }
 
-    override fun writeFloat(fieldNr: Int, value: Float) = checked {
+    override fun writeFloat(fieldNr: Int, value: Float) {
         codedOutputStream.writeFloat(fieldNr, value)
     }
 
-    override fun writeDouble(fieldNr: Int, value: Double) = checked {
+    override fun writeDouble(fieldNr: Int, value: Double) {
         codedOutputStream.writeDouble(fieldNr, value)
     }
 
-    override fun writeEnum(fieldNr: Int, value: Int) = checked {
+    override fun writeEnum(fieldNr: Int, value: Int) {
         codedOutputStream.writeEnum(fieldNr, value)
     }
 
-    override fun writeBytes(fieldNr: Int, value: ByteArray) = checked {
+    override fun writeBytes(fieldNr: Int, value: ByteArray) {
         codedOutputStream.writeByteArray(fieldNr, value)
     }
 
-    override fun writeString(fieldNr: Int, value: String) = checked {
+    override fun writeString(fieldNr: Int, value: String) {
         codedOutputStream.writeString(fieldNr, value)
     }
 
     override fun writePackedBool(
         fieldNr: Int,
         value: List<Boolean>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize, CodedOutputStream::writeBoolNoTag)
     }
 
     override fun writePackedInt32(
         fieldNr: Int,
         value: List<Int>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize, CodedOutputStream::writeInt32NoTag)
     }
 
     override fun writePackedInt64(
         fieldNr: Int,
         value: List<Long>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize, CodedOutputStream::writeInt64NoTag)
     }
 
     override fun writePackedUInt32(
         fieldNr: Int,
         value: List<UInt>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize) { codedOutputStream, v ->
             codedOutputStream.writeUInt32NoTag(v.toInt())
         }
@@ -123,7 +123,7 @@ private class WireEncoderJvm(sink: Sink) : WireEncoder {
         fieldNr: Int,
         value: List<ULong>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize) { codedOutputStream, v ->
             codedOutputStream.writeUInt64NoTag(v.toLong())
         }
@@ -133,43 +133,43 @@ private class WireEncoderJvm(sink: Sink) : WireEncoder {
         fieldNr: Int,
         value: List<Int>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize, CodedOutputStream::writeSInt32NoTag)
     }
 
     override fun writePackedSInt64(
         fieldNr: Int,
         value: List<Long>,
         fieldSize: Int,
-    ) = checked {
+    ) {
         writePackedInternal(fieldNr, value, fieldSize, CodedOutputStream::writeSInt64NoTag)
     }
 
-    override fun writePackedFixed32(fieldNr: Int, value: List<UInt>) = checked {
+    override fun writePackedFixed32(fieldNr: Int, value: List<UInt>) {
         writePackedInternal(fieldNr, value, value.size * UInt.SIZE_BYTES) { codedOutputStream, v ->
             codedOutputStream.writeFixed32NoTag(v.toInt())
         }
     }
 
-    override fun writePackedFixed64(fieldNr: Int, value: List<ULong>) = checked {
+    override fun writePackedFixed64(fieldNr: Int, value: List<ULong>) {
         writePackedInternal(fieldNr, value, value.size * ULong.SIZE_BYTES) { codedOutputStream, v ->
             codedOutputStream.writeFixed64NoTag(v.toLong())
         }
     }
 
-    override fun writePackedSFixed32(fieldNr: Int, value: List<Int>) = checked {
+    override fun writePackedSFixed32(fieldNr: Int, value: List<Int>) {
         writePackedInternal(fieldNr, value, value.size * Int.SIZE_BYTES, CodedOutputStream::writeSFixed32NoTag)
     }
 
-    override fun writePackedSFixed64(fieldNr: Int, value: List<Long>) = checked {
+    override fun writePackedSFixed64(fieldNr: Int, value: List<Long>) {
         writePackedInternal(fieldNr, value, value.size * Long.SIZE_BYTES, CodedOutputStream::writeSFixed64NoTag)
     }
 
-    override fun writePackedFloat(fieldNr: Int, value: List<Float>) = checked {
+    override fun writePackedFloat(fieldNr: Int, value: List<Float>) {
         writePackedInternal(fieldNr, value, value.size * Float.SIZE_BYTES, CodedOutputStream::writeFloatNoTag)
     }
 
-    override fun writePackedDouble(fieldNr: Int, value: List<Double>) = checked {
+    override fun writePackedDouble(fieldNr: Int, value: List<Double>) {
         writePackedInternal(fieldNr, value, value.size * Double.SIZE_BYTES, CodedOutputStream::writeDoubleNoTag)
     }
 
@@ -188,7 +188,7 @@ private class WireEncoderJvm(sink: Sink) : WireEncoder {
         value: List<T>,
         fieldSize: Int,
         crossinline writer: (CodedOutputStream, T) -> Unit,
-    ) = checked {
+    ) {
         codedOutputStream.writeTag(fieldNr, WireType.LENGTH_DELIMITED.ordinal)
         // write the field size of the packed field
         codedOutputStream.writeInt32NoTag(fieldSize)
@@ -198,17 +198,14 @@ private class WireEncoderJvm(sink: Sink) : WireEncoder {
     }
 }
 
-internal actual fun WireEncoder(sink: Sink): WireEncoder {
+public actual fun WireEncoder(sink: Sink): WireEncoder {
     return WireEncoderJvm(sink)
 }
 
-/**
- * Wraps a [kotlinx.io.IOException] in our own [kotlinx.rpc.grpc.ProtobufEncodingException].
- */
-private inline fun checked(crossinline block: () -> Unit) {
+public actual fun checkForPlatformEncodeException(block: () -> Unit) {
     try {
         return block()
     } catch (e: IOException) {
         throw ProtobufEncodingException("Failed to encode protobuf message.", e)
     }
-}
+}

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/pb/WireDecoder.native.kt

@@ -301,4 +301,8 @@ internal class WireDecoderNative(private val source: Buffer) : WireDecoder {
     }
 }
 
-internal actual fun WireDecoder(source: Buffer): WireDecoder = WireDecoderNative(source)
+public actual fun WireDecoder(source: Buffer): WireDecoder = WireDecoderNative(source)
+
+public actual fun checkForPlatformDecodeException(block: () -> Unit) {
+    block()
+}