perf(encoding): varint encoding - manual loop-unroll in decodeSingleByteRun for single-byte varints (#578)

Summary:
Pull Request resolved: #578

Manually loop-unroll `decodeSingleByteRun` with a 3-tier approach:
1. 32-element (4-word) unrolled loop with combined high-bit check
   `(w0 | w1 | w2 | w3) & kHighBits` to minimize branch overhead
2. 8-element (1-word) loop for smaller runs
3. Single-element trailing loop to pick up individual single-byte
   varints before multi-byte values

Also extracts the byte-expansion logic into a reusable `expandWord()`
helper for clarity.

Reviewed By: xiaoxmeng

Differential Revision: D96619597

Author: srsuryadev

dwio/nimble/common/Varint.cpp

@@ -846,28 +846,71 @@ using varint::bulkVarintDecodeBmi2;
 using varint::readVarint32;
 using varint::readVarint64;
 
+// Expand a single 8-byte word of single-byte varints into output elements.
+template <typename T>
+inline void expandByteWord(uint64_t word, T* output) {
+  output[0] = static_cast<T>(word & 0xFF);
+  output[1] = static_cast<T>((word >> 8) & 0xFF);
+  output[2] = static_cast<T>((word >> 16) & 0xFF);
+  output[3] = static_cast<T>((word >> 24) & 0xFF);
+  output[4] = static_cast<T>((word >> 32) & 0xFF);
+  output[5] = static_cast<T>((word >> 40) & 0xFF);
+  output[6] = static_cast<T>((word >> 48) & 0xFF);
+  output[7] = static_cast<T>((word >> 56) & 0xFF);
+}
+
 // Process runs of single-byte varints using 8-byte word reads.
+// Unrolled 4x (32 elements per iteration) for the common case where
+// most values are single-byte (0-127).
 // Returns the number of elements remaining after processing.
 template <typename T>
 inline uint64_t
 bulkDecodeSingleByteRun(uint64_t n, const char*& pos, T*& output) {
-  while (n >= 8) {
+  constexpr uint64_t kHighBits = 0x8080808080808080ULL;
+  constexpr uint64_t batchSize = 32;
+  constexpr uint64_t wordSize = 8;
+
+  // Process 32 elements (4 words) at a time.
+  while (n >= batchSize) {
+    uint64_t w0 = *reinterpret_cast<const uint64_t*>(pos);
+    uint64_t w1 = *reinterpret_cast<const uint64_t*>(pos + wordSize);
+    uint64_t w2 = *reinterpret_cast<const uint64_t*>(pos + 2 * wordSize);
+    uint64_t w3 = *reinterpret_cast<const uint64_t*>(pos + 3 * wordSize);
+    if ((w0 | w1 | w2 | w3) & kHighBits) {
+      break;
+    }
+    expandByteWord(w0, output);
+    expandByteWord(w1, output + wordSize);
+    expandByteWord(w2, output + (2 * wordSize));
+    expandByteWord(w3, output + (3 * wordSize));
+    pos += batchSize;
+    output += batchSize;
+    n -= batchSize;
+  }
+
+  // Process 8 elements (1 word) at a time.
+  while (n >= wordSize) {
     uint64_t word = *reinterpret_cast<const uint64_t*>(pos);
-    if (word & 0x8080808080808080ULL) {
+    if (word & kHighBits) {
       break;
     }
-    output[0] = static_cast<T>(word & 0xFF);
-    output[1] = static_cast<T>((word >> 8) & 0xFF);
-    output[2] = static_cast<T>((word >> 16) & 0xFF);
-    output[3] = static_cast<T>((word >> 24) & 0xFF);
-    output[4] = static_cast<T>((word >> 32) & 0xFF);
-    output[5] = static_cast<T>((word >> 40) & 0xFF);
-    output[6] = static_cast<T>((word >> 48) & 0xFF);
-    output[7] = static_cast<T>((word >> 56) & 0xFF);
-    pos += 8;
-    output += 8;
-    n -= 8;
+    expandByteWord(word, output);
+    pos += wordSize;
+    output += wordSize;
+    n -= wordSize;
   }
+
+  // Handle trailing single-byte varints one at a time.
+  while (n > 0) {
+    uint8_t byte = static_cast<uint8_t>(*pos);
+    if (byte & 0x80) {
+      break;
+    }
+    *output++ = static_cast<T>(byte);
+    ++pos;
+    --n;
+  }
+
   return n;
 }