grpc 1.62.3 → 1.63.0

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -82,10 +82,9 @@ static void add_to_write_list(grpc_chttp2_write_cb** list,
   *list = cb;
 }
 
-static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                            grpc_chttp2_write_cb* cb, grpc_error_handle error) {
-  grpc_chttp2_complete_closure_step(t, s, &cb->closure, error,
-                                    "finish_write_cb");
+static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_write_cb* cb,
+                            grpc_error_handle error) {
+  grpc_chttp2_complete_closure_step(t, &cb->closure, error, "finish_write_cb");
   cb->next = t->write_cb_pool;
   t->write_cb_pool = cb;
 }
@@ -186,9 +185,9 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
       });
 }
 
-static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                        int64_t send_bytes, grpc_chttp2_write_cb** list,
-                        int64_t* ctr, grpc_error_handle error) {
+static bool update_list(grpc_chttp2_transport* t, int64_t send_bytes,
+                        grpc_chttp2_write_cb** list, int64_t* ctr,
+                        grpc_error_handle error) {
   bool sched_any = false;
   grpc_chttp2_write_cb* cb = *list;
   *list = nullptr;
@@ -197,7 +196,7 @@ static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
     grpc_chttp2_write_cb* next = cb->next;
     if (cb->call_at_byte <= *ctr) {
       sched_any = true;
-      finish_write_cb(t, s, cb, error);
+      finish_write_cb(t, cb, error);
     } else {
       add_to_write_list(list, cb);
     }
@@ -368,9 +367,7 @@ class WriteContext {
 
  private:
   grpc_chttp2_transport* const t_;
-  size_t target_write_size_ = grpc_core::IsWriteSizePolicyEnabled()
-                                  ? t_->write_size_policy.WriteTargetSize()
-                                  : 1024 * 1024;
+  size_t target_write_size_ = t_->write_size_policy.WriteTargetSize();
 
   // stats histogram counters: we increment these throughout this function,
   // and at the end publish to the central stats histograms
@@ -402,9 +399,7 @@ class DataSendContext {
         std::min<int64_t>(
             {t_->settings.peer().max_frame_size(), stream_remote_window(),
              t_->flow_control.remote_window(),
-             grpc_core::IsWriteSizeCapEnabled()
-                 ? static_cast<int64_t>(write_context_->target_write_size())
-                 : std::numeric_limits<uint32_t>::max()}),
+             static_cast<int64_t>(write_context_->target_write_size())}),
         0, std::numeric_limits<uint32_t>::max());
   }
 
@@ -428,8 +423,7 @@ class DataSendContext {
 
   void CallCallbacks() {
     if (update_list(
-            t_, s_,
-            static_cast<int64_t>(s_->sending_bytes - sending_bytes_before_),
+            t_, static_cast<int64_t>(s_->sending_bytes - sending_bytes_before_),
             &s_->on_flow_controlled_cbs, &s_->flow_controlled_bytes_flowed,
             absl::OkStatus())) {
       write_context_->NoteScheduledResults();
@@ -488,14 +482,19 @@ class StreamWriteContext {
     s_->send_initial_metadata = nullptr;
     s_->sent_initial_metadata = true;
     write_context_->NoteScheduledResults();
-    grpc_chttp2_complete_closure_step(
-        t_, s_, &s_->send_initial_metadata_finished, absl::OkStatus(),
-        "send_initial_metadata_finished");
+    grpc_chttp2_complete_closure_step(t_, &s_->send_initial_metadata_finished,
+                                      absl::OkStatus(),
+                                      "send_initial_metadata_finished");
     if (s_->call_tracer) {
-      s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kHeadWritten,
-          gpr_now(GPR_CLOCK_REALTIME), s_->t->flow_control.stats(),
-          s_->flow_control.stats()));
+      grpc_core::HttpAnnotation::WriteStats write_stats;
+      write_stats.target_write_size = write_context_->target_write_size();
+      s_->call_tracer->RecordAnnotation(
+          grpc_core::HttpAnnotation(
+              grpc_core::HttpAnnotation::Type::kHeadWritten,
+              gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s_->t->flow_control.stats())
+              .Add(s_->flow_control.stats())
+              .Add(write_stats));
     }
   }
 
@@ -582,9 +581,9 @@ class StreamWriteContext {
     SentLastFrame();
 
     write_context_->NoteScheduledResults();
-    grpc_chttp2_complete_closure_step(
-        t_, s_, &s_->send_trailing_metadata_finished, absl::OkStatus(),
-        "send_trailing_metadata_finished");
+    grpc_chttp2_complete_closure_step(t_, &s_->send_trailing_metadata_finished,
+                                      absl::OkStatus(),
+                                      "send_trailing_metadata_finished");
   }
 
   bool stream_became_writable() { return stream_became_writable_; }
@@ -619,9 +618,11 @@ class StreamWriteContext {
     grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
                                    absl::OkStatus());
     if (s_->call_tracer) {
-      s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kEnd, gpr_now(GPR_CLOCK_REALTIME),
-          s_->t->flow_control.stats(), s_->flow_control.stats()));
+      s_->call_tracer->RecordAnnotation(
+          grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kEnd,
+                                    gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s_->t->flow_control.stats())
+              .Add(s_->flow_control.stats()));
     }
   }
 
@@ -662,6 +663,7 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
       // Add this stream to the list of the contexts to be traced at TCP
       num_stream_bytes = t->outbuf.c_slice_buffer()->length - orig_len;
       s->byte_counter += static_cast<size_t>(num_stream_bytes);
+      ++s->write_counter;
       if (s->traced && grpc_endpoint_can_track_err(t->ep)) {
         grpc_core::CopyContextFn copy_context_fn =
             grpc_core::GrpcHttp2GetCopyContextFn();
@@ -669,7 +671,8 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
             grpc_core::GrpcHttp2GetWriteTimestampsCallback() != nullptr) {
           t->cl->emplace_back(copy_context_fn(s->context),
                               outbuf_relative_start_pos, num_stream_bytes,
-                              s->byte_counter, s->tcp_tracer);
+                              s->byte_counter, s->write_counter - 1,
+                              s->tcp_tracer);
         }
       }
       outbuf_relative_start_pos += num_stream_bytes;
@@ -741,7 +744,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
 
   while (grpc_chttp2_list_pop_writing_stream(t, &s)) {
     if (s->sending_bytes != 0) {
-      update_list(t, s, static_cast<int64_t>(s->sending_bytes),
+      update_list(t, static_cast<int64_t>(s->sending_bytes),
                   &s->on_write_finished_cbs, &s->flow_controlled_bytes_written,
                   error);
       s->sending_bytes = 0;

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -22,10 +22,12 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/inproc/legacy_inproc_transport.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -155,7 +157,7 @@ bool UsePromiseBasedTransport() {
   return true;
 }
 
-RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
+OrphanablePtr<Channel> MakeLameChannel(absl::string_view why,
                                        absl::Status error) {
   gpr_log(GPR_ERROR, "%s: %s", std::string(why).c_str(),
           std::string(error.message()).c_str());
@@ -164,11 +166,11 @@ RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
   if (grpc_error_get_int(error, StatusIntProperty::kRpcStatus, &integer)) {
     status = static_cast<grpc_status_code>(integer);
   }
-  return RefCountedPtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
+  return OrphanablePtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
       nullptr, status, std::string(why).c_str())));
 }
 
-RefCountedPtr<Channel> MakeInprocChannel(Server* server,
+OrphanablePtr<Channel> MakeInprocChannel(Server* server,
                                          ChannelArgs client_channel_args) {
   auto transports = MakeInProcessTransportPair();
   auto client_transport = std::move(transports.first);
@@ -183,7 +185,7 @@ RefCountedPtr<Channel> MakeInprocChannel(Server* server,
     return MakeLameChannel("Failed to create server channel", std::move(error));
   }
   std::ignore = server_transport.release();  // consumed by SetupTransport
-  auto channel = Channel::Create(
+  auto channel = ChannelCreate(
       "inproc",
       client_channel_args.Set(GRPC_ARG_DEFAULT_AUTHORITY, "inproc.authority"),
       GRPC_CLIENT_DIRECT_CHANNEL, client_transport.release());

data/src/core/ext/transport/inproc/legacy_inproc_transport.cc

@@ -61,6 +61,7 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -267,18 +268,18 @@ struct inproc_stream {
   grpc_stream_refcount* refs;
   grpc_core::Arena* arena;
 
-  grpc_metadata_batch to_read_initial_md{arena};
+  grpc_metadata_batch to_read_initial_md;
   bool to_read_initial_md_filled = false;
-  grpc_metadata_batch to_read_trailing_md{arena};
+  grpc_metadata_batch to_read_trailing_md;
   bool to_read_trailing_md_filled = false;
   bool ops_needed = false;
   // Write buffer used only during gap at init time when client-side
   // stream is set up but server side stream is not yet set up
-  grpc_metadata_batch write_buffer_initial_md{arena};
+  grpc_metadata_batch write_buffer_initial_md;
   bool write_buffer_initial_md_filled = false;
   grpc_core::Timestamp write_buffer_deadline =
       grpc_core::Timestamp::InfFuture();
-  grpc_metadata_batch write_buffer_trailing_md{arena};
+  grpc_metadata_batch write_buffer_trailing_md;
   bool write_buffer_trailing_md_filled = false;
   grpc_error_handle write_buffer_cancel_error;
 
@@ -456,7 +457,7 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     // Send trailing md to the other side indicating cancellation
     s->trailing_md_sent = true;
 
-    grpc_metadata_batch fake_md(s->arena);
+    grpc_metadata_batch fake_md;
     inproc_stream* other = s->other_side;
     grpc_metadata_batch* dest = (other == nullptr)
                                     ? &s->write_buffer_trailing_md
@@ -479,7 +480,7 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     if (!s->t->is_client) {
       // If this is a server, provide initial metadata with a path and
       // authority since it expects that as well as no error yet
-      grpc_metadata_batch fake_md(s->arena);
+      grpc_metadata_batch fake_md;
       fake_md.Set(grpc_core::HttpPathMetadata(),
                   grpc_core::Slice::FromStaticString("/"));
       fake_md.Set(grpc_core::HttpAuthorityMetadata(),
@@ -902,7 +903,7 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
     // already have
     s->trailing_md_sent = true;
 
-    grpc_metadata_batch cancel_md(s->arena);
+    grpc_metadata_batch cancel_md;
 
     grpc_metadata_batch* dest = (other == nullptr)
                                     ? &s->write_buffer_trailing_md
@@ -1264,7 +1265,7 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
       server_transport, nullptr, server_args, nullptr);
   grpc_channel* channel = nullptr;
   if (error.ok()) {
-    auto new_channel = grpc_core::Channel::Create(
+    auto new_channel = grpc_core::ChannelCreate(
         "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
     if (!new_channel.ok()) {
       GPR_ASSERT(!channel);