grpc-native: Change packed input value type to List

Jozott00 · Mr3zee · commit 939ed809b30d · 2025-07-28T19:23:50.000+02:00
Signed-off-by: Johannes Zottele &lt;official@johannes-zottele.at&gt;
diff --git a/grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/internal/KTag.kt b/grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/internal/KTag.kt
@@ -4,6 +4,8 @@
 
 package kotlinx.rpc.grpc.internal
 
+import kotlinx.rpc.grpc.internal.KTag.Companion.K_TAG_TYPE_BITS
+
 internal enum class WireType {
     VARINT, // 0
     FIXED64, // 1
@@ -22,11 +24,16 @@ internal data class KTag(val fieldNr: Int, val wireType: WireType) {
     companion object {
         // Number of bits in a tag which identify the wire type.
         const val K_TAG_TYPE_BITS: Int = 3;
+
         // Mask for those bits. (just 0b111)
         val K_TAG_TYPE_MASK: UInt = (1u shl K_TAG_TYPE_BITS) - 1u
     }
 }
 
+internal fun KTag.toRawKTag(): UInt {
+    return (fieldNr.toUInt() shl K_TAG_TYPE_BITS) or wireType.ordinal.toUInt()
+}
+
 internal fun KTag.Companion.from(rawKTag: UInt): KTag? {
     val type = (rawKTag and K_TAG_TYPE_MASK).toInt()
     val field = (rawKTag shr K_TAG_TYPE_BITS).toInt()
diff --git a/grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/internal/WireEncoder.kt b/grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/internal/WireEncoder.kt
@@ -33,12 +33,12 @@ internal interface WireEncoder {
     fun writeEnum(fieldNr: Int, value: Int): Boolean
     fun writeBytes(fieldNr: Int, value: ByteArray): Boolean
     fun writeString(fieldNr: Int, value: String): Boolean
-    fun writePackedFixed32(fieldNr: Int, value: UIntArray): Boolean
-    fun writePackedFixed64(fieldNr: Int, value: ULongArray): Boolean
-    fun writePackedSFixed32(fieldNr: Int, value: IntArray): Boolean
-    fun writePackedSFixed64(fieldNr: Int, value: LongArray): Boolean
-    fun writePackedFloat(fieldNr: Int, value: FloatArray): Boolean
-    fun writePackedDouble(fieldNr: Int, value: DoubleArray): Boolean
+    fun writePackedFixed32(fieldNr: Int, value: List<UInt>): Boolean
+    fun writePackedFixed64(fieldNr: Int, value: List<ULong>): Boolean
+    fun writePackedSFixed32(fieldNr: Int, value: List<Int>): Boolean
+    fun writePackedSFixed64(fieldNr: Int, value: List<Long>): Boolean
+    fun writePackedFloat(fieldNr: Int, value: List<Float>): Boolean
+    fun writePackedDouble(fieldNr: Int, value: List<Double>): Boolean
 }
 
 
diff --git a/grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/WireDecoder.native.kt b/grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/WireDecoder.native.kt
@@ -10,6 +10,7 @@ import kotlinx.io.Buffer
 import libprotowire.*
 import kotlin.experimental.ExperimentalNativeApi
 import kotlin.math.min
+import kotlin.native.ref.createCleaner
 
 // maximum buffer size to allocate as contiguous memory in bytes
 private const val MAX_PACKED_BULK_SIZE: Int = 1_000_000
@@ -44,14 +45,17 @@ internal class WireDecoderNative(private val source: Buffer) : WireDecoder {
         pw_decoder_new(zeroCopyCInput)
             ?: error("Failed to create proto wire decoder")
     }
+    
+    val rawCleaner = createCleaner(raw) {
+        pw_decoder_delete(it)
+    }
 
 
     override fun close() {
-        // delete the underlying decoder.
-        // this will also fix the position in the source buffer
+        // this will fix the position in the source buffer
         // (done by deconstructor of CodedInputStream)
-        pw_decoder_delete(raw)
-        // close zero inputs on close
+        pw_decoder_close(raw)
+
         zeroCopyInput.get().close()
         zeroCopyInput.dispose()
     }
@@ -243,7 +247,7 @@ internal class WireDecoderNative(private val source: Buffer) : WireDecoder {
         Pinned<DoubleArray>::addressOf,
         DoubleArray::asList,
     )
-    
+
     /*
      * Based on the length of the packed repeated field, one of two list strategies is chosen.
      * If the length is less or equal a specific threshold (MAX_PACKED_BULK_SIZE),
diff --git a/grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/WireEncoder.native.kt b/grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/WireEncoder.native.kt
@@ -125,46 +125,44 @@ internal class WireEncoderNative(private val sink: Sink) : WireEncoder {
         }
     }
 
-    override fun writePackedFixed32(fieldNr: Int, value: UIntArray) =
-        writePackedInternal(fieldNr, value, UIntArray::size, UInt.SIZE_BYTES)
-        { it.addressOf(0) }
+    override fun writePackedFixed32(fieldNr: Int, value: List<UInt>) =
+        writePackedInternal(fieldNr, value, UInt.SIZE_BYTES, ::pw_encoder_write_fixed32_no_tag)
 
-    override fun writePackedFixed64(fieldNr: Int, value: ULongArray) =
-        writePackedInternal(fieldNr, value, ULongArray::size, ULong.SIZE_BYTES)
-        { it.addressOf(0) }
+    override fun writePackedFixed64(fieldNr: Int, value: List<ULong>) =
+        writePackedInternal(fieldNr, value, ULong.SIZE_BYTES, ::pw_encoder_write_fixed64_no_tag)
 
-    override fun writePackedSFixed32(fieldNr: Int, value: IntArray) =
-        writePackedInternal(fieldNr, value, IntArray::size, Int.SIZE_BYTES)
-        { it.addressOf(0) }
+    override fun writePackedSFixed32(fieldNr: Int, value: List<Int>) =
+        writePackedInternal(fieldNr, value, Int.SIZE_BYTES, ::pw_encoder_write_sfixed32_no_tag)
 
-    override fun writePackedSFixed64(fieldNr: Int, value: LongArray) =
-        writePackedInternal(fieldNr, value, LongArray::size, Long.SIZE_BYTES)
-        { it.addressOf(0) }
+    override fun writePackedSFixed64(fieldNr: Int, value: List<Long>) =
+        writePackedInternal(fieldNr, value, Long.SIZE_BYTES, ::pw_encoder_write_sfixed64_no_tag)
 
-    override fun writePackedFloat(fieldNr: Int, value: FloatArray) =
-        writePackedInternal(fieldNr, value, FloatArray::size, Float.SIZE_BYTES)
-        { it.addressOf(0) }
+    override fun writePackedFloat(fieldNr: Int, value: List<Float>) =
+        writePackedInternal(fieldNr, value, Float.SIZE_BYTES, ::pw_encoder_write_float_no_tag)
 
-    override fun writePackedDouble(fieldNr: Int, value: DoubleArray) =
-        writePackedInternal(fieldNr, value, DoubleArray::size, Double.SIZE_BYTES)
-        { it.addressOf(0) }
+    override fun writePackedDouble(fieldNr: Int, value: List<Double>) =
+        writePackedInternal(fieldNr, value, Double.SIZE_BYTES, ::pw_encoder_write_double_no_tag)
 }
 
 internal actual fun WireEncoder(sink: Sink): WireEncoder = WireEncoderNative(sink)
 
 
 @OptIn(ExperimentalForeignApi::class)
-private inline fun <A : Any> WireEncoderNative.writePackedInternal(
+private inline fun <T> WireEncoderNative.writePackedInternal(
     fieldNr: Int,
-    value: A,
-    crossinline sizeOf: A.() -> Int,
-    sizeBytes: Int,
-    crossinline ptr: (Pinned<A>) -> COpaquePointer
+    value: List<T>,
+    byteSize: Int,
+    crossinline writer: (CValuesRef<pw_encoder_t>?, T) -> Boolean
 ): Boolean {
-    val len = sizeOf(value)
-    if (len == 0) return pw_encoder_write_bytes(raw, fieldNr, null, 0)
-    val bytes = len * sizeBytes
-    return value.usePinned { pinned ->
-        pw_encoder_write_bytes(raw, fieldNr, ptr(pinned), bytes)
+    val ktag = KTag(fieldNr, WireType.LENGTH_DELIMITED).toRawKTag()
+    pw_encoder_write_tag(raw, ktag)
+    // write the field size of the packed field
+    val fieldSize = value.size * byteSize;
+    pw_encoder_write_int32_no_tag(raw, fieldSize)
+    for (v in value) {
+        if (!writer(raw, v)) {
+            return false
+        }
     }
+    return true
 }
diff --git a/grpc/grpc-core/src/nativeTest/kotlin/kotlinx/rpc/grpc/internal/WireCodecTest.kt b/grpc/grpc-core/src/nativeTest/kotlin/kotlinx/rpc/grpc/internal/WireCodecTest.kt
@@ -664,16 +664,14 @@ class WireCodecTest {
         assertTrue(buffer.exhausted())
     }
 
-
-    private inline fun <A, T> runPackedTest(
-        arr: A,
-        crossinline write: WireEncoder.(Int, A) -> Boolean,
-        crossinline read: WireDecoder.() -> List<T>?,
-        crossinline asList: (A) -> List<T>
+    private fun <T> runPackedTest(
+        list: List<T>,
+        write: WireEncoder.(Int, List<T>) -> Boolean,
+        read: WireDecoder.() -> List<T>?,
     ) {
         val buf = Buffer()
         with(WireEncoder(buf)) {
-            assertTrue(write(1, arr))
+            assertTrue(write(1, list))
             flush()
         }
         WireDecoder(buf).use { dec ->
@@ -682,56 +680,50 @@ class WireCodecTest {
                 assertEquals(WireType.LENGTH_DELIMITED, wireType)
             }
             val test = dec.read()
-            assertEquals(asList(arr), test)
+            assertEquals(list, test)
         }
         assertTrue(buf.exhausted())
     }
 
     @Test
     fun testPackedFixed32() = runPackedTest(
-        UIntArray(1_000_000) { UInt.MAX_VALUE + it.toUInt() },
+        List(1_000_000) { UInt.MAX_VALUE + it.toUInt() },
         WireEncoder::writePackedFixed32,
-        WireDecoder::readPackedFixed32,
-        UIntArray::asList
+        WireDecoder::readPackedFixed32
     )
 
     @Test
     fun testPackedFixed64() = runPackedTest(
-        ULongArray(1_000_000) { UInt.MAX_VALUE + it.toULong() },
+        List(1_000_000) { UInt.MAX_VALUE + it.toULong() },
         WireEncoder::writePackedFixed64,
         WireDecoder::readPackedFixed64,
-        ULongArray::asList
     )
 
     @Test
     fun testPackedSFixed32() = runPackedTest(
-        IntArray(1_000_000) { Int.MAX_VALUE + it },
+        List(1_000_000) { Int.MAX_VALUE + it },
         WireEncoder::writePackedSFixed32,
-        WireDecoder::readPackedSFixed32,
-        IntArray::asList
+        WireDecoder::readPackedSFixed32
     )
 
     @Test
     fun testPackedSFixed64() = runPackedTest(
-        LongArray(1_000_000) { Long.MAX_VALUE + it },
+        List(1_000_000) { Long.MAX_VALUE + it },
         WireEncoder::writePackedSFixed64,
-        WireDecoder::readPackedSFixed64,
-        LongArray::asList
+        WireDecoder::readPackedSFixed64
     )
 
     @Test
     fun testPackedFloat() = runPackedTest(
-        FloatArray(1_000_000) { it.toFloat() / 3.3f * ((it and 1) * 2 - 1) },
+        List(1_000_000) { it.toFloat() / 3.3f * ((it and 1) * 2 - 1) },
         WireEncoder::writePackedFloat,
         WireDecoder::readPackedFloat,
-        FloatArray::asList
     )
 
     @Test
     fun testPackedDouble() = runPackedTest(
-        DoubleArray(1_000_000) { it.toDouble() / 3.3 * ((it and 1) * 2 - 1) },
+        List(1_000_000) { it.toDouble() / 3.3 * ((it and 1) * 2 - 1) },
         WireEncoder::writePackedDouble,
         WireDecoder::readPackedDouble,
-        DoubleArray::asList
     )
 }
diff --git a/grpc/grpcpp-c/include/protowire.h b/grpc/grpcpp-c/include/protowire.h
@@ -51,6 +51,22 @@ extern "C" {
     bool pw_encoder_write_string(pw_encoder_t *self, int field_no, const char *data, int size);
     bool pw_encoder_write_bytes(pw_encoder_t *self, int field_no, const void *data, int size);
 
+    // No tag writers
+    bool pw_encoder_write_tag(pw_encoder_t *self, uint32_t tag);
+    bool pw_encoder_write_bool_no_tag(pw_encoder_t *self, bool value);
+    bool pw_encoder_write_int32_no_tag(pw_encoder_t *self, int32_t value);
+    bool pw_encoder_write_int64_no_tag(pw_encoder_t *self, int64_t value);
+    bool pw_encoder_write_uint32_no_tag(pw_encoder_t *self, uint32_t value);
+    bool pw_encoder_write_uint64_no_tag(pw_encoder_t *self, uint64_t value);
+    bool pw_encoder_write_sint32_no_tag(pw_encoder_t *self, int32_t value);
+    bool pw_encoder_write_sint64_no_tag(pw_encoder_t *self, int64_t value);
+    bool pw_encoder_write_fixed32_no_tag(pw_encoder_t *self, uint32_t value);
+    bool pw_encoder_write_fixed64_no_tag(pw_encoder_t *self, uint64_t value);
+    bool pw_encoder_write_sfixed32_no_tag(pw_encoder_t *self, int32_t value);
+    bool pw_encoder_write_sfixed64_no_tag(pw_encoder_t *self, int64_t value);
+    bool pw_encoder_write_float_no_tag(pw_encoder_t *self, float value);
+    bool pw_encoder_write_double_no_tag(pw_encoder_t *self, double value);
+
 
     //// WIRE DECODER ////
 
@@ -78,6 +94,7 @@ extern "C" {
      */
     pw_decoder_t * pw_decoder_new(pw_zero_copy_input_t zero_copy_input);
     void pw_decoder_delete(pw_decoder_t *self);
+    void pw_decoder_close(pw_decoder_t *self);
 
     uint32_t pw_decoder_read_tag(pw_decoder_t *self);
     bool pw_decoder_read_bool(pw_decoder_t *self, bool *value);
diff --git a/grpc/grpcpp-c/src/protowire.cpp b/grpc/grpcpp-c/src/protowire.cpp
@@ -180,6 +180,35 @@ extern "C" {
         return check(self);
     }
 
+    bool pw_encoder_write_tag(pw_encoder_t *self, uint32_t tag) {
+        self->cos.WriteTag(tag);
+        return check(self);
+    }
+
+#define WRITE_FIELD_NO_TAG( funcSuffix, wireTy, cTy) \
+bool pw_encoder_write_##funcSuffix##_no_tag(pw_encoder_t *self, cTy value) { \
+WireFormatLite::Write##wireTy##NoTag(value, &self->cos); \
+return check(self); \
+}
+
+    WRITE_FIELD_NO_TAG( bool, Bool, bool)
+    WRITE_FIELD_NO_TAG( int32, Int32, int32_t)
+    WRITE_FIELD_NO_TAG( int64, Int64, int64_t)
+    WRITE_FIELD_NO_TAG( uint32, UInt32, uint32_t)
+    WRITE_FIELD_NO_TAG( uint64, UInt64, uint64_t)
+    WRITE_FIELD_NO_TAG( sint32, SInt32, int32_t)
+    WRITE_FIELD_NO_TAG( sint64, SInt64, int64_t)
+    WRITE_FIELD_NO_TAG( fixed32, Fixed32, uint32_t)
+    WRITE_FIELD_NO_TAG( fixed64, Fixed64, uint64_t)
+    WRITE_FIELD_NO_TAG( sfixed32, SFixed32, int32_t)
+    WRITE_FIELD_NO_TAG( sfixed64, SFixed64, int64_t)
+    WRITE_FIELD_NO_TAG( float, Float, float)
+    WRITE_FIELD_NO_TAG( double, Double, double)
+    WRITE_FIELD_NO_TAG( enum, Enum, int)
+
+
+    /// DECODER IMPLEMENATION ///
+
     pw_decoder_t *pw_decoder_new(pw_zero_copy_input_t zero_copy_input) {
         return new pw_decoder_t(zero_copy_input);
     }
@@ -188,6 +217,11 @@ extern "C" {
         delete self;
     }
 
+    void pw_decoder_close(pw_decoder_t *self) {
+        // the deconstructor backs the stream up to the current position.
+        self->cis.~CodedInputStream();
+    }
+
     uint32_t pw_decoder_read_tag(pw_decoder_t *self) {
         return self->cis.ReadTag();
     }
