grpc 1.82.2 → 1.83.0.pre1

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

@@ -25,203 +25,168 @@
 #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
 
-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) {
+static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
+                     grpc_slice_buffer* output,
+                     int (*flate)(z_stream* zs, int flush)) {
   int r = Z_STREAM_END;  // Do not fail on an empty input.
   int flush;
   size_t i;
-  uint32_t remaining_output_size = max_output_size.value_or(UINT32_MAX);
-  SliceBuffer output_sb;
+  grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
   const uInt uint_max = ~uInt{0};
-  auto outbuf = MutableSlice::CreateUninitialized(
-      std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
 
-  GRPC_CHECK(outbuf.length() <= uint_max);
-  zs->avail_out = static_cast<uInt>(outbuf.length());
-  zs->next_out = const_cast<uint8_t*>(outbuf.begin());
+  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);
   flush = Z_NO_FLUSH;
-  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());
+  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]);
     do {
       if (zs->avail_out == 0) {
-        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());
+        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);
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
         VLOG(2) << "zlib error (" << r << ")";
-        return absl::InternalError("Decompression failed due to zlib error");
+        goto error;
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
       VLOG(2) << "zlib: not all input consumed";
-      return absl::InternalError(
-          "Decompression failed due to not all input "
-          "consumed");
+      goto error;
     }
   }
   if (r != Z_STREAM_END) {
     VLOG(2) << "zlib: Data error";
-    return absl::InternalError("Decompression failed due to data error");
+    goto error;
   }
 
-  // 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;
+  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;
 }
 
-void* ZallocGpr(void* /*opaque*/, unsigned int items, unsigned int size) {
+static void* zalloc_gpr(void* /*opaque*/, unsigned int items,
+                        unsigned int size) {
   return gpr_malloc(items * size);
 }
 
-void ZFreeGpr(void* /*opaque*/, void* address) { gpr_free(address); }
+static void zfree_gpr(void* /*opaque*/, void* address) { gpr_free(address); }
 
-std::optional<SliceBuffer> ZlibCompress(const SliceBuffer& input, int gzip) {
+static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
+                         int gzip) {
   z_stream zs;
-  absl::StatusOr<SliceBuffer> compression_result;
+  int r;
+  size_t i;
+  size_t count_before = output->count;
+  size_t length_before = output->length;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = ZallocGpr;
-  zs.zfree = ZFreeGpr;
-  bool r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-                        15 | (gzip ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
+  zs.zalloc = zalloc_gpr;
+  zs.zfree = zfree_gpr;
+  r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
+                   8, Z_DEFAULT_STRATEGY);
   GRPC_CHECK(r == Z_OK);
-  compression_result = ZlibBody(&zs, input, deflate, input.Length());
-  deflateEnd(&zs);
-  if (compression_result.ok() &&
-      compression_result->Length() < input.Length()) {
-    return std::move(*compression_result);
+  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;
   }
-  return std::nullopt;
+  deflateEnd(&zs);
+  return r;
 }
 
-absl::StatusOr<SliceBuffer> ZlibDecompress(
-    const SliceBuffer& input, int gzip,
-    std::optional<uint32_t> max_output_size) {
+static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
+                           int gzip) {
   z_stream zs;
-  absl::StatusOr<SliceBuffer> decompression_result;
+  int r;
+  size_t i;
+  size_t count_before = output->count;
+  size_t length_before = output->length;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = ZallocGpr;
-  zs.zfree = ZFreeGpr;
-  bool r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
+  zs.zalloc = zalloc_gpr;
+  zs.zfree = zfree_gpr;
+  r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
   GRPC_CHECK(r == Z_OK);
-  decompression_result = ZlibBody(&zs, input, inflate, max_output_size);
+  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;
+  }
   inflateEnd(&zs);
-  return decompression_result;
+  return r;
 }
 
-}  // namespace
+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;
+}
 
-std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
-                                           const SliceBuffer& input) {
+static int compress_inner(grpc_compression_algorithm algorithm,
+                          grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       // the fallback path always needs to be send uncompressed: we simply
       // rely on that here
-      return std::nullopt;
+      return 0;
     case GRPC_COMPRESS_DEFLATE:
-      return ZlibCompress(input, 0);
+      return zlib_compress(input, output, 0);
     case GRPC_COMPRESS_GZIP:
-      return ZlibCompress(input, 1);
+      return zlib_compress(input, output, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return std::nullopt;
+  return 0;
 }
 
-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) {
-  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;
+  if (!compress_inner(algorithm, input, output)) {
+    copy(input, output);
+    return 0;
   }
-  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
-  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
-  return retval;
+  return 1;
 }
 
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  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;
+  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_slice_buffer_swap(input, input_sb.c_slice_buffer());
-  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
-  return 1;
+  LOG(ERROR) << "invalid compression algorithm " << algorithm;
+  return 0;
 }

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

@@ -23,13 +23,6 @@
 #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.
@@ -42,21 +35,4 @@ 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/event_engine/extensions/receive_coalescing_extension.h

@@ -37,10 +37,6 @@ class ReceiveCoalescingExtension {
   /// It is safe to call this only when there are no outstanding Reads on
   /// the Endpoint.
   virtual void DisableRpcReceiveCoalescing() = 0;
-
-  /// If invoked, the endpoint tries to preserve proper order and alignment of
-  /// any memory that maybe shared across reads.
-  virtual void EnforceRxMemoryAlignment() = 0;
 };
 
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/extensions/tcp_trace.h

@@ -36,7 +36,7 @@ class TcpTraceExtension {
   // Enable TCP telemetry collection using the Instrumentation API.
   virtual void EnableTcpTelemetry(
       grpc_core::RefCountedPtr<grpc_core::CollectionScope> collection_scope,
-      bool is_control_endpoint) = 0;
+      bool is_control_endpoint, bool trace_full_buffer) = 0;
 };
 
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/posix_engine.cc

@@ -76,14 +76,6 @@ namespace grpc_event_engine::experimental {
 
 namespace {
 
-bool ShouldUsePosixPoller() {
-#if defined(GRPC_PYTHON_BUILD)
-  return grpc_core::IsEventEnginePollerForPythonEnabled();
-#else
-  return true;
-#endif
-}
-
 #if GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
 
 // Thread pool can outlive EE but we need to ensure the ordering if both
@@ -434,10 +426,8 @@ PosixEventEngine::PosixEventEngine(const Options& options)
     : connection_shards_(options.connection_shards),
       executor_(MakeThreadPool(options.reserve_threads)),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
-  if (ShouldUsePosixPoller()) {
-    poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
-    SchedulePoller();
-  }
+  poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
+  SchedulePoller();
 }
 
 #endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/shim.cc

@@ -21,14 +21,10 @@
 
 namespace grpc_event_engine::experimental {
 
-bool UseEventEngineClient() {
-  return !EventEngineExperimentDisabledForPython() &&
-         grpc_core::IsEventEngineClientEnabled();
-}
+bool UseEventEngineClient() { return grpc_core::IsEventEngineClientEnabled(); }
 
 bool UseEventEngineListener() {
-  return !EventEngineExperimentDisabledForPython() &&
-         grpc_core::IsEventEngineListenerEnabled();
+  return grpc_core::IsEventEngineListenerEnabled();
 }
 
 bool UsePollsetAlternative() {
@@ -36,14 +32,4 @@ bool UsePollsetAlternative() {
          grpc_core::IsPollsetAlternativeEnabled();
 }
 
-// Returns true if the poller is disabled by build configuration or experiment
-// flags.
-bool EventEngineExperimentDisabledForPython() {
-#ifdef GRPC_PYTHON_BUILD
-  return !grpc_core::IsEventEnginePollerForPythonEnabled();
-#else
-  return false;
-#endif
-}
-
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/shim.h

@@ -35,10 +35,6 @@ bool UseEventEngineListener();
 // may disable the poller in some builds.
 bool UsePollsetAlternative();
 
-// Returns true if the poller is disabled by build configuration or experiment
-// flags.
-bool EventEngineExperimentDisabledForPython();
-
 }  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_SHIM_H