grpc 1.83.0 → 1.83.2

data/src/core/lib/compression/message_compress.cc

@@ -25,168 +25,203 @@
 #include <zconf.h>
 #include <zlib.h>
 
+#include <algorithm>
+#include <cstdint>
+#include <optional>
+
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/status_helper.h"
 #include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 
-static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
-                     grpc_slice_buffer* output,
-                     int (*flate)(z_stream* zs, int flush)) {
+namespace grpc_core {
+namespace {
+
+absl::StatusOr<SliceBuffer> ZlibBody(z_stream* zs, const SliceBuffer& input,
+                                     int (*flate)(z_stream* zs, int flush),
+                                     std::optional<uint32_t> max_output_size) {
   int r = Z_STREAM_END;  // Do not fail on an empty input.
   int flush;
   size_t i;
-  grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
+  uint32_t remaining_output_size = max_output_size.value_or(UINT32_MAX);
+  SliceBuffer output_sb;
   const uInt uint_max = ~uInt{0};
+  auto outbuf = MutableSlice::CreateUninitialized(
+      std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
 
-  GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-  zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
-  zs->next_out = GRPC_SLICE_START_PTR(outbuf);
+  GRPC_CHECK(outbuf.length() <= uint_max);
+  zs->avail_out = static_cast<uInt>(outbuf.length());
+  zs->next_out = const_cast<uint8_t*>(outbuf.begin());
   flush = Z_NO_FLUSH;
-  for (i = 0; i < input->count; i++) {
-    if (i == input->count - 1) flush = Z_FINISH;
-    GRPC_CHECK(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
-    zs->avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(input->slices[i]);
-    zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]);
+  for (i = 0; i < input.Count(); i++) {
+    if (i == input.Count() - 1) {
+      flush = Z_FINISH;
+    }
+    GRPC_CHECK(input[i].length() <= uint_max);
+    zs->avail_in = static_cast<uInt>(input[i].length());
+    zs->next_in = const_cast<uint8_t*>(input[i].begin());
     do {
       if (zs->avail_out == 0) {
-        grpc_slice_buffer_add_indexed(output, outbuf);
-        outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-        GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-        zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
-        zs->next_out = GRPC_SLICE_START_PTR(outbuf);
+        if (max_output_size.has_value() && remaining_output_size == 0) {
+          VLOG(2) << "zlib: max provided output size exceeded";
+          return absl::ResourceExhaustedError(
+              "Decompressed message larger than max");
+        }
+        output_sb.AppendIndexed(Slice(std::move(outbuf)));
+        outbuf = MutableSlice::CreateUninitialized(
+            std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
+        // Update remaining output size to reflect the size of the slice we just
+        // filled with compressed / decompressed data.
+        if (max_output_size.has_value()) {
+          remaining_output_size -= outbuf.length();
+        }
+        GRPC_CHECK(outbuf.length() <= uint_max);
+        zs->avail_out = static_cast<uInt>(outbuf.length());
+        zs->next_out = const_cast<uint8_t*>(outbuf.begin());
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
         VLOG(2) << "zlib error (" << r << ")";
-        goto error;
+        return absl::InternalError("Decompression failed due to zlib error");
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
       VLOG(2) << "zlib: not all input consumed";
-      goto error;
+      return absl::InternalError(
+          "Decompression failed due to not all input "
+          "consumed");
     }
   }
   if (r != Z_STREAM_END) {
     VLOG(2) << "zlib: Data error";
-    goto error;
+    return absl::InternalError("Decompression failed due to data error");
   }
 
-  GRPC_CHECK(outbuf.refcount);
-  outbuf.data.refcounted.length -= zs->avail_out;
-  grpc_slice_buffer_add_indexed(output, outbuf);
-
-  return 1;
-
-error:
-  grpc_core::CSliceUnref(outbuf);
-  return 0;
+  // TODO(vigneshbabu): Add a Truncate() method to the Slice type to avoid using
+  // the underlying C type here.
+  grpc_slice slice = outbuf.TakeCSlice();
+  if (slice.refcount) {
+    slice.data.refcounted.length -= zs->avail_out;
+  } else {
+    slice.data.inlined.length -= zs->avail_out;
+  }
+  output_sb.AppendIndexed(Slice(slice));
+  return output_sb;
 }
 
-static void* zalloc_gpr(void* /*opaque*/, unsigned int items,
-                        unsigned int size) {
+void* ZallocGpr(void* /*opaque*/, unsigned int items, unsigned int size) {
   return gpr_malloc(items * size);
 }
 
-static void zfree_gpr(void* /*opaque*/, void* address) { gpr_free(address); }
+void ZFreeGpr(void* /*opaque*/, void* address) { gpr_free(address); }
 
-static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
-                         int gzip) {
+std::optional<SliceBuffer> ZlibCompress(const SliceBuffer& input, int gzip) {
   z_stream zs;
-  int r;
-  size_t i;
-  size_t count_before = output->count;
-  size_t length_before = output->length;
+  absl::StatusOr<SliceBuffer> compression_result;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = zalloc_gpr;
-  zs.zfree = zfree_gpr;
-  r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
-                   8, Z_DEFAULT_STRATEGY);
+  zs.zalloc = ZallocGpr;
+  zs.zfree = ZFreeGpr;
+  bool r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                        15 | (gzip ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
   GRPC_CHECK(r == Z_OK);
-  r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
-  if (!r) {
-    for (i = count_before; i < output->count; i++) {
-      grpc_core::CSliceUnref(output->slices[i]);
-    }
-    output->count = count_before;
-    output->length = length_before;
-  }
+  compression_result = ZlibBody(&zs, input, deflate, input.Length());
   deflateEnd(&zs);
-  return r;
+  if (compression_result.ok() &&
+      compression_result->Length() < input.Length()) {
+    return std::move(*compression_result);
+  }
+  return std::nullopt;
 }
 
-static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
-                           int gzip) {
+absl::StatusOr<SliceBuffer> ZlibDecompress(
+    const SliceBuffer& input, int gzip,
+    std::optional<uint32_t> max_output_size) {
   z_stream zs;
-  int r;
-  size_t i;
-  size_t count_before = output->count;
-  size_t length_before = output->length;
+  absl::StatusOr<SliceBuffer> decompression_result;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = zalloc_gpr;
-  zs.zfree = zfree_gpr;
-  r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
+  zs.zalloc = ZallocGpr;
+  zs.zfree = ZFreeGpr;
+  bool r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
   GRPC_CHECK(r == Z_OK);
-  r = zlib_body(&zs, input, output, inflate);
-  if (!r) {
-    for (i = count_before; i < output->count; i++) {
-      grpc_core::CSliceUnref(output->slices[i]);
-    }
-    output->count = count_before;
-    output->length = length_before;
-  }
+  decompression_result = ZlibBody(&zs, input, inflate, max_output_size);
   inflateEnd(&zs);
-  return r;
+  return decompression_result;
 }
 
-static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  size_t i;
-  for (i = 0; i < input->count; i++) {
-    grpc_slice_buffer_add(output, grpc_core::CSliceRef(input->slices[i]));
-  }
-  return 1;
-}
+}  // namespace
 
-static int compress_inner(grpc_compression_algorithm algorithm,
-                          grpc_slice_buffer* input, grpc_slice_buffer* output) {
+std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
+                                           const SliceBuffer& input) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       // the fallback path always needs to be send uncompressed: we simply
       // rely on that here
-      return 0;
+      return std::nullopt;
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_compress(input, output, 0);
+      return ZlibCompress(input, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_compress(input, output, 1);
+      return ZlibCompress(input, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return 0;
+  return std::nullopt;
 }
 
+absl::StatusOr<SliceBuffer> MessageDecompress(
+    grpc_compression_algorithm algorithm, const SliceBuffer& input,
+    std::optional<uint32_t> max_output_size) {
+  switch (algorithm) {
+    case GRPC_COMPRESS_NONE: {
+      SliceBuffer output;
+      output.Append(input);
+      return output;
+    }
+    case GRPC_COMPRESS_DEFLATE:
+      return ZlibDecompress(input, 0, max_output_size);
+    case GRPC_COMPRESS_GZIP:
+      return ZlibDecompress(input, 1, max_output_size);
+    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+      break;
+  }
+  LOG(ERROR) << "invalid compression algorithm " << algorithm;
+  return absl::InternalError("Invalid compression algorithm");
+}
+
+}  // namespace grpc_core
+
 int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  if (!compress_inner(algorithm, input, output)) {
-    copy(input, output);
-    return 0;
+  int retval = 1;
+  grpc_core::SliceBuffer input_sb;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  std::optional<grpc_core::SliceBuffer> output_sb =
+      grpc_core::MessageCompress(algorithm, input_sb);
+  if (!output_sb.has_value()) {
+    output_sb.emplace();
+    output_sb->Append(input_sb);
+    retval = 0;
   }
-  return 1;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
+  return retval;
 }
 
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      return copy(input, output);
-    case GRPC_COMPRESS_DEFLATE:
-      return zlib_decompress(input, output, 0);
-    case GRPC_COMPRESS_GZIP:
-      return zlib_decompress(input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
-      break;
+  grpc_core::SliceBuffer input_sb;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+
+  absl::StatusOr<grpc_core::SliceBuffer> output_sb =
+      grpc_core::MessageDecompress(algorithm, input_sb, std::nullopt);
+  if (!output_sb.ok()) {
+    return 0;
   }
-  LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return 0;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
+  return 1;
 }

data/src/core/lib/compression/message_compress.h

@@ -23,6 +23,13 @@
 #include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 
+#include <cstdint>
+#include <optional>
+
+#include "src/core/lib/slice/slice_buffer.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
 // compress 'input' to 'output' using 'algorithm'.
 // On success, appends compressed slices to output and returns 1.
 // On failure, appends uncompressed slices to output and returns 0.
@@ -35,4 +42,21 @@ int grpc_msg_compress(grpc_compression_algorithm algorithm,
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
+namespace grpc_core {
+
+// Compresses 'input' using 'algorithm'.
+// On success, returns a SliceBuffer containing the compressed data.
+// On failure, returns nullopt.
+std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
+                                           const SliceBuffer& input);
+// Decompresses 'input'.
+// On success, returns a SliceBuffer containing the decompressed data.
+// On failure, returns a non-OK status.
+// Fails if the decompressed data would be larger than max_output_size.
+absl::StatusOr<SliceBuffer> MessageDecompress(
+    grpc_compression_algorithm algorithm, const SliceBuffer& input,
+    std::optional<uint32_t> max_output_size);
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H

data/src/core/lib/experiments/experiments.cc

@@ -103,6 +103,9 @@ const char* const description_h2_max_deallocating_streams_headroom =
     "Separate allocated max concurrent streams.";
 const char* const additional_constraints_h2_max_deallocating_streams_headroom =
     "{}";
+const char* const description_header_data_frame =
+    "Managing header and data memory better";
+const char* const additional_constraints_header_data_frame = "{}";
 const char* const description_inproc_cancel_stream =
     "If set, cancel inproc stream inside the transport mutex.";
 const char* const additional_constraints_inproc_cancel_stream = "{}";
@@ -336,6 +339,8 @@ const ExperimentMetadata g_experiment_metadata[] = {
      description_h2_max_deallocating_streams_headroom,
      additional_constraints_h2_max_deallocating_streams_headroom, nullptr, 0,
      false, true},
+    {"header_data_frame", description_header_data_frame,
+     additional_constraints_header_data_frame, nullptr, 0, true, true},
     {"inproc_cancel_stream", description_inproc_cancel_stream,
      additional_constraints_inproc_cancel_stream, nullptr, 0, true, true},
     {"keep_alive_ping_timer_batch", description_keep_alive_ping_timer_batch,
@@ -348,7 +353,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"memory_optimization_02", description_memory_optimization_02,
      additional_constraints_memory_optimization_02, nullptr, 0, false, false},
     {"message_size_refactoring", description_message_size_refactoring,
-     additional_constraints_message_size_refactoring, nullptr, 0, false, true},
+     additional_constraints_message_size_refactoring, nullptr, 0, true, true},
     {"metadata_outstanding_token_refactor",
      description_metadata_outstanding_token_refactor,
      additional_constraints_metadata_outstanding_token_refactor, nullptr, 0,
@@ -380,7 +385,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"ph2_client_server", description_ph2_client_server,
      additional_constraints_ph2_client_server, nullptr, 0, false, true},
     {"ph2_perf_01", description_ph2_perf_01, additional_constraints_ph2_perf_01,
-     nullptr, 0, false, true},
+     nullptr, 0, true, true},
     {"ph2_server", description_ph2_server, additional_constraints_ph2_server,
      nullptr, 0, false, true},
     {"pick_first_ignore_empty_updates",
@@ -554,6 +559,9 @@ const char* const description_h2_max_deallocating_streams_headroom =
     "Separate allocated max concurrent streams.";
 const char* const additional_constraints_h2_max_deallocating_streams_headroom =
     "{}";
+const char* const description_header_data_frame =
+    "Managing header and data memory better";
+const char* const additional_constraints_header_data_frame = "{}";
 const char* const description_inproc_cancel_stream =
     "If set, cancel inproc stream inside the transport mutex.";
 const char* const additional_constraints_inproc_cancel_stream = "{}";
@@ -787,6 +795,8 @@ const ExperimentMetadata g_experiment_metadata[] = {
      description_h2_max_deallocating_streams_headroom,
      additional_constraints_h2_max_deallocating_streams_headroom, nullptr, 0,
      false, true},
+    {"header_data_frame", description_header_data_frame,
+     additional_constraints_header_data_frame, nullptr, 0, true, true},
     {"inproc_cancel_stream", description_inproc_cancel_stream,
      additional_constraints_inproc_cancel_stream, nullptr, 0, true, true},
     {"keep_alive_ping_timer_batch", description_keep_alive_ping_timer_batch,
@@ -799,7 +809,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"memory_optimization_02", description_memory_optimization_02,
      additional_constraints_memory_optimization_02, nullptr, 0, false, false},
     {"message_size_refactoring", description_message_size_refactoring,
-     additional_constraints_message_size_refactoring, nullptr, 0, false, true},
+     additional_constraints_message_size_refactoring, nullptr, 0, true, true},
     {"metadata_outstanding_token_refactor",
      description_metadata_outstanding_token_refactor,
      additional_constraints_metadata_outstanding_token_refactor, nullptr, 0,
@@ -831,7 +841,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"ph2_client_server", description_ph2_client_server,
      additional_constraints_ph2_client_server, nullptr, 0, false, true},
     {"ph2_perf_01", description_ph2_perf_01, additional_constraints_ph2_perf_01,
-     nullptr, 0, false, true},
+     nullptr, 0, true, true},
     {"ph2_server", description_ph2_server, additional_constraints_ph2_server,
      nullptr, 0, false, true},
     {"pick_first_ignore_empty_updates",
@@ -1005,6 +1015,9 @@ const char* const description_h2_max_deallocating_streams_headroom =
     "Separate allocated max concurrent streams.";
 const char* const additional_constraints_h2_max_deallocating_streams_headroom =
     "{}";
+const char* const description_header_data_frame =
+    "Managing header and data memory better";
+const char* const additional_constraints_header_data_frame = "{}";
 const char* const description_inproc_cancel_stream =
     "If set, cancel inproc stream inside the transport mutex.";
 const char* const additional_constraints_inproc_cancel_stream = "{}";
@@ -1238,6 +1251,8 @@ const ExperimentMetadata g_experiment_metadata[] = {
      description_h2_max_deallocating_streams_headroom,
      additional_constraints_h2_max_deallocating_streams_headroom, nullptr, 0,
      false, true},
+    {"header_data_frame", description_header_data_frame,
+     additional_constraints_header_data_frame, nullptr, 0, true, true},
     {"inproc_cancel_stream", description_inproc_cancel_stream,
      additional_constraints_inproc_cancel_stream, nullptr, 0, true, true},
     {"keep_alive_ping_timer_batch", description_keep_alive_ping_timer_batch,
@@ -1250,7 +1265,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"memory_optimization_02", description_memory_optimization_02,
      additional_constraints_memory_optimization_02, nullptr, 0, false, false},
     {"message_size_refactoring", description_message_size_refactoring,
-     additional_constraints_message_size_refactoring, nullptr, 0, false, true},
+     additional_constraints_message_size_refactoring, nullptr, 0, true, true},
     {"metadata_outstanding_token_refactor",
      description_metadata_outstanding_token_refactor,
      additional_constraints_metadata_outstanding_token_refactor, nullptr, 0,
@@ -1282,7 +1297,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"ph2_client_server", description_ph2_client_server,
      additional_constraints_ph2_client_server, nullptr, 0, false, true},
     {"ph2_perf_01", description_ph2_perf_01, additional_constraints_ph2_perf_01,
-     nullptr, 0, false, true},
+     nullptr, 0, true, true},
     {"ph2_server", description_ph2_server, additional_constraints_ph2_server,
      nullptr, 0, false, true},
     {"pick_first_ignore_empty_updates",

data/src/core/lib/experiments/experiments.h

@@ -93,13 +93,16 @@ inline bool IsFailRecvMetadataOnDeadlineExceededEnabled() { return false; }
 inline bool IsFreeLargeAllocatorEnabled() { return false; }
 inline bool IsFuseFiltersEnabled() { return false; }
 inline bool IsH2MaxDeallocatingStreamsHeadroomEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_HEADER_DATA_FRAME
+inline bool IsHeaderDataFrameEnabled() { return true; }
 #define GRPC_EXPERIMENT_IS_INCLUDED_INPROC_CANCEL_STREAM
 inline bool IsInprocCancelStreamEnabled() { return true; }
 inline bool IsKeepAlivePingTimerBatchEnabled() { return false; }
 inline bool IsLocalConnectorSecureEnabled() { return false; }
 inline bool IsMemoryOptimization01Enabled() { return false; }
 inline bool IsMemoryOptimization02Enabled() { return false; }
-inline bool IsMessageSizeRefactoringEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_MESSAGE_SIZE_REFACTORING
+inline bool IsMessageSizeRefactoringEnabled() { return true; }
 inline bool IsMetadataOutstandingTokenRefactorEnabled() { return false; }
 inline bool IsMetadataPublishToAppTagEnabled() { return false; }
 #define GRPC_EXPERIMENT_IS_INCLUDED_MONITORING_EXPERIMENT
@@ -118,7 +121,8 @@ inline bool IsOptimization06Enabled() { return false; }
 inline bool IsOtelExportTelemetryDomainsEnabled() { return false; }
 inline bool IsPh2ClientEnabled() { return false; }
 inline bool IsPh2ClientServerEnabled() { return false; }
-inline bool IsPh2Perf01Enabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_PH2_PERF_01
+inline bool IsPh2Perf01Enabled() { return true; }
 inline bool IsPh2ServerEnabled() { return false; }
 inline bool IsPickFirstIgnoreEmptyUpdatesEnabled() { return false; }
 inline bool IsPipelinedReadSecureEndpointEnabled() { return false; }
@@ -185,13 +189,16 @@ inline bool IsFailRecvMetadataOnDeadlineExceededEnabled() { return false; }
 inline bool IsFreeLargeAllocatorEnabled() { return false; }
 inline bool IsFuseFiltersEnabled() { return false; }
 inline bool IsH2MaxDeallocatingStreamsHeadroomEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_HEADER_DATA_FRAME
+inline bool IsHeaderDataFrameEnabled() { return true; }
 #define GRPC_EXPERIMENT_IS_INCLUDED_INPROC_CANCEL_STREAM
 inline bool IsInprocCancelStreamEnabled() { return true; }
 inline bool IsKeepAlivePingTimerBatchEnabled() { return false; }
 inline bool IsLocalConnectorSecureEnabled() { return false; }
 inline bool IsMemoryOptimization01Enabled() { return false; }
 inline bool IsMemoryOptimization02Enabled() { return false; }
-inline bool IsMessageSizeRefactoringEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_MESSAGE_SIZE_REFACTORING
+inline bool IsMessageSizeRefactoringEnabled() { return true; }
 inline bool IsMetadataOutstandingTokenRefactorEnabled() { return false; }
 inline bool IsMetadataPublishToAppTagEnabled() { return false; }
 #define GRPC_EXPERIMENT_IS_INCLUDED_MONITORING_EXPERIMENT
@@ -210,7 +217,8 @@ inline bool IsOptimization06Enabled() { return false; }
 inline bool IsOtelExportTelemetryDomainsEnabled() { return false; }
 inline bool IsPh2ClientEnabled() { return false; }
 inline bool IsPh2ClientServerEnabled() { return false; }
-inline bool IsPh2Perf01Enabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_PH2_PERF_01
+inline bool IsPh2Perf01Enabled() { return true; }
 inline bool IsPh2ServerEnabled() { return false; }
 inline bool IsPickFirstIgnoreEmptyUpdatesEnabled() { return false; }
 inline bool IsPipelinedReadSecureEndpointEnabled() { return false; }
@@ -277,13 +285,16 @@ inline bool IsFailRecvMetadataOnDeadlineExceededEnabled() { return false; }
 inline bool IsFreeLargeAllocatorEnabled() { return false; }
 inline bool IsFuseFiltersEnabled() { return false; }
 inline bool IsH2MaxDeallocatingStreamsHeadroomEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_HEADER_DATA_FRAME
+inline bool IsHeaderDataFrameEnabled() { return true; }
 #define GRPC_EXPERIMENT_IS_INCLUDED_INPROC_CANCEL_STREAM
 inline bool IsInprocCancelStreamEnabled() { return true; }
 inline bool IsKeepAlivePingTimerBatchEnabled() { return false; }
 inline bool IsLocalConnectorSecureEnabled() { return false; }
 inline bool IsMemoryOptimization01Enabled() { return false; }
 inline bool IsMemoryOptimization02Enabled() { return false; }
-inline bool IsMessageSizeRefactoringEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_MESSAGE_SIZE_REFACTORING
+inline bool IsMessageSizeRefactoringEnabled() { return true; }
 inline bool IsMetadataOutstandingTokenRefactorEnabled() { return false; }
 inline bool IsMetadataPublishToAppTagEnabled() { return false; }
 #define GRPC_EXPERIMENT_IS_INCLUDED_MONITORING_EXPERIMENT
@@ -302,7 +313,8 @@ inline bool IsOptimization06Enabled() { return false; }
 inline bool IsOtelExportTelemetryDomainsEnabled() { return false; }
 inline bool IsPh2ClientEnabled() { return false; }
 inline bool IsPh2ClientServerEnabled() { return false; }
-inline bool IsPh2Perf01Enabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_PH2_PERF_01
+inline bool IsPh2Perf01Enabled() { return true; }
 inline bool IsPh2ServerEnabled() { return false; }
 inline bool IsPickFirstIgnoreEmptyUpdatesEnabled() { return false; }
 inline bool IsPipelinedReadSecureEndpointEnabled() { return false; }
@@ -354,6 +366,7 @@ enum ExperimentIds {
   kExperimentIdFreeLargeAllocator,
   kExperimentIdFuseFilters,
   kExperimentIdH2MaxDeallocatingStreamsHeadroom,
+  kExperimentIdHeaderDataFrame,
   kExperimentIdInprocCancelStream,
   kExperimentIdKeepAlivePingTimerBatch,
   kExperimentIdLocalConnectorSecure,
@@ -479,6 +492,10 @@ inline bool IsFuseFiltersEnabled() {
 inline bool IsH2MaxDeallocatingStreamsHeadroomEnabled() {
   return IsExperimentEnabled<kExperimentIdH2MaxDeallocatingStreamsHeadroom>();
 }
+#define GRPC_EXPERIMENT_IS_INCLUDED_HEADER_DATA_FRAME
+inline bool IsHeaderDataFrameEnabled() {
+  return IsExperimentEnabled<kExperimentIdHeaderDataFrame>();
+}
 #define GRPC_EXPERIMENT_IS_INCLUDED_INPROC_CANCEL_STREAM
 inline bool IsInprocCancelStreamEnabled() {
   return IsExperimentEnabled<kExperimentIdInprocCancelStream>();

data/src/core/lib/surface/legacy_channel.cc

@@ -180,7 +180,9 @@ grpc_call* LegacyChannel::CreateCall(
   args.authority = std::move(authority);
   args.send_deadline = deadline;
   args.registered_method = registered_method;
-  args.arena_init_function = arena_init_function;
+  if (arena_init_function.has_value()) {
+    args.arena_init_function.emplace(*arena_init_function);
+  }
   grpc_call* call;
   GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call));
   return call;

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.83.0'
+  VERSION = '1.83.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grpc
 version: !ruby/object:Gem::Version
-  version: 1.83.0
+  version: 1.83.2
 platform: ruby
 authors:
 - gRPC Authors
@@ -3981,7 +3981,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.23
 specification_version: 4
 summary: GRPC system in Ruby
 test_files: