Optimize TcParser::RepeatedVarint

We spend more time on reallocating than parsing, so
count and preallocate space once. Saves some cpu and
a lot or RAM.

name                                        cpu/op        cpu/op      vs base
BM_Parse_MemberParseFromString               748.7n ± 3%   682.3n ± 1%  -8.87% (p=0.002 n=6)
BM_Parse_RiegeliParseFromString              749.0n ± 3%   680.5n ± 1%  -9.15% (p=0.002 n=6)
BM_Parse_RiegeliParseFromChain               758.7n ± 3%   691.8n ± 8%  -8.82% (p=0.002 n=6)
BM_Parse_MemberParseFromCord                 767.2n ± 4%   701.6n ± 4%  -8.55% (p=0.002 n=6)
BM_Parse_RiegeliParseFromCord                765.9n ± 3%   704.0n ± 2%  -8.08% (p=0.002 n=6)

name                                        peak-mem(Bytes)/op  peak-mem(Bytes)/op  vs base
BM_Parse_MemberParseFromString               3.072k ± 0%          1.792k ± 0%  -41.67% (p=0.002 n=6)
BM_Parse_RiegeliParseFromString              3.072k ± 0%          1.792k ± 0%  -41.67% (p=0.002 n=6)
BM_Parse_RiegeliParseFromChain               3.072k ± 0%          1.792k ± 0%  -41.67% (p=0.002 n=6)
BM_Parse_MemberParseFromCord                 3.072k ± 0%          1.792k ± 0%  -41.67% (p=0.002 n=6)
BM_Parse_RiegeliParseFromCord                3.072k ± 0%          1.792k ± 0%  -41.67% (p=0.002 n=6

PiperOrigin-RevId: 819415796

Author: TocarIP

src/google/protobuf/generated_message_tctable_lite.cc

@@ -1157,20 +1157,39 @@ PROTOBUF_ALWAYS_INLINE const char* TcParser::RepeatedVarint(
   }
   SetCachedHasBitForRepeated(hasbits, data.hasbit_idx());
   auto& field = RefAt<RepeatedField<FieldType>>(msg, data.offset());
-  Arena* arena = msg->GetArena();
   const auto expected_tag = UnalignedLoad<TagType>(ptr);
+  // Count the number of varint (same as number of bytes with 0 in top bit)
+  // and preallocte space in repeated field.
+  int len = 0;
+  auto ptr2 = ptr;
+  do {
+    ptr2 += sizeof(TagType);
+    // Defend against overflowing avaible data due to malformed input of
+    // infinite number of bytes with top bit set. Longest legal varin is 10
+    // bytes, which is also < 16 bytes of slop.
+    int limit = 10;
+    while ((*ptr2 & 0x80) && limit--) ptr2++;
+    len++;
+    ptr2++;
+    if (ABSL_PREDICT_FALSE(!ctx->DataAvailable(ptr2))) break;
+  } while (UnalignedLoadNoPrefetch<TagType>(ptr2) == expected_tag);
+  int added = 0;
+  field.Reserve(field.size() + len);
+  // Allows us to skip SOO checks.
+  FieldType* x = field.AddNAlreadyReserved(len);
   do {
+    ABSL_DCHECK(ctx->DataAvailable(ptr));
+    ABSL_DCHECK_EQ(UnalignedLoadNoPrefetch<TagType>(ptr), expected_tag);
     ptr += sizeof(TagType);
     FieldType tmp;
     ptr = ParseVarint(ptr, &tmp);
     if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
       PROTOBUF_MUSTTAIL return Error(PROTOBUF_TC_PARAM_NO_DATA_PASS);
     }
-    field.AddWithArena(arena, ZigZagDecodeHelper<FieldType, zigzag>(tmp));
-    if (ABSL_PREDICT_FALSE(!ctx->DataAvailable(ptr))) {
-      PROTOBUF_MUSTTAIL return ToParseLoop(PROTOBUF_TC_PARAM_NO_DATA_PASS);
-    }
-  } while (UnalignedLoad<TagType>(ptr) == expected_tag);
+    added++;
+    *x = (ZigZagDecodeHelper<FieldType, zigzag>(tmp));
+    x++;
+  } while (added < len);
   PROTOBUF_MUSTTAIL return ToTagDispatch(PROTOBUF_TC_PARAM_NO_DATA_PASS);
 }