grpc 1.25.0 → 1.26.0

data/src/core/ext/filters/client_channel/xds/xds_client.h

@@ -19,6 +19,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <set>
+
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/xds/xds_api.h"
 #include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
@@ -28,7 +30,6 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/set.h"
 #include "src/core/lib/gprpp/string_view.h"
 #include "src/core/lib/iomgr/combiner.h"
 
@@ -73,7 +74,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // an error initializing the client.
   XdsClient(Combiner* combiner, grpc_pollset_set* interested_parties,
             StringView server_name,
-            UniquePtr<ServiceConfigWatcherInterface> watcher,
+            std::unique_ptr<ServiceConfigWatcherInterface> watcher,
             const grpc_channel_args& channel_args, grpc_error** error);
   ~XdsClient();
 
@@ -85,7 +86,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // cancellation.  (Because the caller does not own the watcher, the
   // pointer must not be used for any other purpose.)
   void WatchClusterData(StringView cluster,
-                        UniquePtr<ClusterWatcherInterface> watcher);
+                        std::unique_ptr<ClusterWatcherInterface> watcher);
   void CancelClusterDataWatch(StringView cluster,
                               ClusterWatcherInterface* watcher);
 
@@ -95,13 +96,15 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // cancellation.  (Because the caller does not own the watcher, the
   // pointer must not be used for any other purpose.)
   void WatchEndpointData(StringView cluster,
-                         UniquePtr<EndpointWatcherInterface> watcher);
+                         std::unique_ptr<EndpointWatcherInterface> watcher);
   void CancelEndpointDataWatch(StringView cluster,
                                EndpointWatcherInterface* watcher);
 
   // Adds and removes client stats for cluster.
-  void AddClientStats(StringView cluster, XdsClientStats* client_stats);
-  void RemoveClientStats(StringView cluster, XdsClientStats* client_stats);
+  void AddClientStats(StringView lrs_server, StringView cluster,
+                      XdsClientStats* client_stats);
+  void RemoveClientStats(StringView lrs_server, StringView cluster,
+                         XdsClientStats* client_stats);
 
   // Resets connection backoff state.
   void ResetBackoff();
@@ -169,11 +172,12 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   };
 
   struct ClusterState {
-    Map<ClusterWatcherInterface*, UniquePtr<ClusterWatcherInterface>>
+    std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
         cluster_watchers;
-    Map<EndpointWatcherInterface*, UniquePtr<EndpointWatcherInterface>>
+    std::map<EndpointWatcherInterface*,
+             std::unique_ptr<EndpointWatcherInterface>>
         endpoint_watchers;
-    Set<XdsClientStats*> client_stats;
+    std::set<XdsClientStats*> client_stats;
     // The latest data seen from EDS.
     EdsUpdate eds_update;
   };
@@ -192,15 +196,15 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
 
   static const grpc_arg_pointer_vtable kXdsClientVtable;
 
-  UniquePtr<char> build_version_;
+  grpc_core::UniquePtr<char> build_version_;
 
   Combiner* combiner_;
   grpc_pollset_set* interested_parties_;
 
-  UniquePtr<XdsBootstrap> bootstrap_;
+  std::unique_ptr<XdsBootstrap> bootstrap_;
 
-  UniquePtr<char> server_name_;
-  UniquePtr<ServiceConfigWatcherInterface> service_config_watcher_;
+  grpc_core::UniquePtr<char> server_name_;
+  std::unique_ptr<ServiceConfigWatcherInterface> service_config_watcher_;
   // TODO(juanlishen): Once we implement LDS support, this will no
   // longer be needed.
   grpc_closure service_config_notify_;
@@ -208,8 +212,9 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // The channel for communicating with the xds server.
   OrphanablePtr<ChannelState> chand_;
 
-  // TODO(roth): When we need support for multiple clusters, replace
-  // cluster_state_ with a map keyed by cluster name.
+  // TODO(juanlishen): As part of adding CDS support, replace
+  // cluster_state_ with a map keyed by cluster name, so that we can
+  // support multiple clusters for both CDS and EDS.
   ClusterState cluster_state_;
   // Map<StringView /*cluster*/, ClusterState, StringLess> clusters_;
 

data/src/core/ext/filters/client_channel/xds/xds_client_stats.cc

@@ -90,7 +90,7 @@ XdsClientStats::LocalityStats::GetSnapshotAndReset() {
       const char* metric_name = p.first.get();
       LoadMetric& metric_value = p.second;
       snapshot.load_metric_stats.emplace(
-          UniquePtr<char>(gpr_strdup(metric_name)),
+          grpc_core::UniquePtr<char>(gpr_strdup(metric_name)),
           metric_value.GetSnapshotAndReset());
     }
   }
@@ -178,12 +178,14 @@ void XdsClientStats::PruneLocalityStats() {
   }
 }
 
-void XdsClientStats::AddCallDropped(const UniquePtr<char>& category) {
+void XdsClientStats::AddCallDropped(
+    const grpc_core::UniquePtr<char>& category) {
   total_dropped_requests_.FetchAdd(1, MemoryOrder::RELAXED);
   MutexLock lock(&dropped_requests_mu_);
   auto iter = dropped_requests_.find(category);
   if (iter == dropped_requests_.end()) {
-    dropped_requests_.emplace(UniquePtr<char>(gpr_strdup(category.get())), 1);
+    dropped_requests_.emplace(
+        grpc_core::UniquePtr<char>(gpr_strdup(category.get())), 1);
   } else {
     ++iter->second;
   }

data/src/core/ext/filters/client_channel/xds/xds_client_stats.h

@@ -46,8 +46,9 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
     }
   };
 
-  XdsLocalityName(UniquePtr<char> region, UniquePtr<char> zone,
-                  UniquePtr<char> subzone)
+  XdsLocalityName(grpc_core::UniquePtr<char> region,
+                  grpc_core::UniquePtr<char> zone,
+                  grpc_core::UniquePtr<char> subzone)
       : region_(std::move(region)),
         zone_(std::move(zone)),
         sub_zone_(std::move(subzone)) {}
@@ -73,10 +74,10 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
   }
 
  private:
-  UniquePtr<char> region_;
-  UniquePtr<char> zone_;
-  UniquePtr<char> sub_zone_;
-  UniquePtr<char> human_readable_string_;
+  grpc_core::UniquePtr<char> region_;
+  grpc_core::UniquePtr<char> zone_;
+  grpc_core::UniquePtr<char> sub_zone_;
+  grpc_core::UniquePtr<char> human_readable_string_;
 };
 
 // The stats classes (i.e., XdsClientStats, LocalityStats, and LoadMetric) can
@@ -111,9 +112,10 @@ class XdsClientStats {
       double total_metric_value_{0};
     };
 
-    using LoadMetricMap = Map<UniquePtr<char>, LoadMetric, StringLess>;
+    using LoadMetricMap =
+        std::map<grpc_core::UniquePtr<char>, LoadMetric, StringLess>;
     using LoadMetricSnapshotMap =
-        Map<UniquePtr<char>, LoadMetric::Snapshot, StringLess>;
+        std::map<grpc_core::UniquePtr<char>, LoadMetric::Snapshot, StringLess>;
 
     struct Snapshot {
       // TODO(juanlishen): Change this to const method when const_iterator is
@@ -177,15 +179,16 @@ class XdsClientStats {
 
   // TODO(juanlishen): The value type of Map<> must be movable in current
   // implementation. To avoid making LocalityStats movable, we wrap it by
-  // UniquePtr<>. We should remove this wrapper if the value type of Map<>
+  // std::unique_ptr<>. We should remove this wrapper if the value type of Map<>
   // doesn't have to be movable.
   using LocalityStatsMap =
-      Map<RefCountedPtr<XdsLocalityName>, RefCountedPtr<LocalityStats>,
-          XdsLocalityName::Less>;
+      std::map<RefCountedPtr<XdsLocalityName>, RefCountedPtr<LocalityStats>,
+               XdsLocalityName::Less>;
   using LocalityStatsSnapshotMap =
-      Map<RefCountedPtr<XdsLocalityName>, LocalityStats::Snapshot,
-          XdsLocalityName::Less>;
-  using DroppedRequestsMap = Map<UniquePtr<char>, uint64_t, StringLess>;
+      std::map<RefCountedPtr<XdsLocalityName>, LocalityStats::Snapshot,
+               XdsLocalityName::Less>;
+  using DroppedRequestsMap =
+      std::map<grpc_core::UniquePtr<char>, uint64_t, StringLess>;
   using DroppedRequestsSnapshotMap = DroppedRequestsMap;
 
   struct Snapshot {
@@ -208,7 +211,7 @@ class XdsClientStats {
   RefCountedPtr<LocalityStats> FindLocalityStats(
       const RefCountedPtr<XdsLocalityName>& locality_name);
   void PruneLocalityStats();
-  void AddCallDropped(const UniquePtr<char>& category);
+  void AddCallDropped(const grpc_core::UniquePtr<char>& category);
 
  private:
   // The stats for each locality.

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -27,10 +27,9 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/http2_errors.h"
 
-// The idle filter is enabled in client channel by default.
-// Set GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS to [1000, INT_MAX) in channel args to
-// configure the idle timeout.
-#define DEFAULT_IDLE_TIMEOUT_MS (30 /*minutes*/ * 60 * 1000)
+// TODO(juanlishen): The idle filter is disabled in client channel by default
+// due to b/143502997. Try to fix the bug and enable the filter by default.
+#define DEFAULT_IDLE_TIMEOUT_MS INT_MAX
 // The user input idle timeout smaller than this would be capped to it.
 #define MIN_IDLE_TIMEOUT_MS (1 /*second*/ * 1000)
 
@@ -283,7 +282,8 @@ void ChannelData::DecreaseCallCount() {
 }
 
 ChannelData::ChannelData(grpc_channel_element* elem,
-                         grpc_channel_element_args* args, grpc_error** error)
+                         grpc_channel_element_args* args,
+                         grpc_error** /*error*/)
     : elem_(elem),
       channel_stack_(args->channel_stack),
       client_idle_timeout_(GetClientIdleTimeout(args->channel_args)) {
@@ -352,7 +352,7 @@ void ChannelData::IdleTimerCallback(void* arg, grpc_error* error) {
 }
 
 void ChannelData::IdleTransportOpCompleteCallback(void* arg,
-                                                  grpc_error* error) {
+                                                  grpc_error* /*error*/) {
   ChannelData* chand = static_cast<ChannelData*>(arg);
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "idle transport op");
 }
@@ -389,15 +389,15 @@ class CallData {
 };
 
 grpc_error* CallData::Init(grpc_call_element* elem,
-                           const grpc_call_element_args* args) {
+                           const grpc_call_element_args* /*args*/) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   chand->IncreaseCallCount();
   return GRPC_ERROR_NONE;
 }
 
 void CallData::Destroy(grpc_call_element* elem,
-                       const grpc_call_final_info* final_info,
-                       grpc_closure* ignored) {
+                       const grpc_call_final_info* /*final_info*/,
+                       grpc_closure* /*ignored*/) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   chand->DecreaseCallCount();
 }
@@ -416,7 +416,7 @@ const grpc_channel_filter grpc_client_idle_filter = {
     "client_idle"};
 
 static bool MaybeAddClientIdleFilter(grpc_channel_stack_builder* builder,
-                                     void* arg) {
+                                     void* /*arg*/) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   if (!grpc_channel_args_want_minimal_stack(channel_args) &&

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -38,7 +38,7 @@
 
 // The on_complete callback used when sending a cancel_error batch down the
 // filter stack.  Yields the call combiner when the batch returns.
-static void yield_call_combiner(void* arg, grpc_error* ignored) {
+static void yield_call_combiner(void* arg, grpc_error* /*ignored*/) {
   grpc_deadline_state* deadline_state = static_cast<grpc_deadline_state*>(arg);
   GRPC_CALL_COMBINER_STOP(deadline_state->call_combiner,
                           "got on_complete from cancel_stream batch");
@@ -133,8 +133,9 @@ static void recv_trailing_metadata_ready(void* arg, grpc_error* error) {
   grpc_deadline_state* deadline_state = static_cast<grpc_deadline_state*>(arg);
   cancel_timer_if_needed(deadline_state);
   // Invoke the original callback.
-  GRPC_CLOSURE_RUN(deadline_state->original_recv_trailing_metadata_ready,
-                   GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          deadline_state->original_recv_trailing_metadata_ready,
+                          GRPC_ERROR_REF(error));
 }
 
 // Inject our own recv_trailing_metadata_ready callback into op.
@@ -175,7 +176,7 @@ static void start_timer_after_init(void* arg, grpc_error* error) {
                              "scheduling deadline timer");
     return;
   }
-  grpc_core::Delete(state);
+  delete state;
   GRPC_CALL_COMBINER_STOP(deadline_state->call_combiner,
                           "done scheduling deadline timer");
 }
@@ -196,10 +197,10 @@ grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
     // create a closure to start the timer, and we schedule that closure
     // to be run after call stack initialization is done.
     struct start_timer_after_init_state* state =
-        grpc_core::New<start_timer_after_init_state>(elem, deadline);
+        new start_timer_after_init_state(elem, deadline);
     GRPC_CLOSURE_INIT(&state->closure, start_timer_after_init, state,
                       grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_SCHED(&state->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, GRPC_ERROR_NONE);
   }
 }
 
@@ -233,14 +234,14 @@ void grpc_deadline_state_client_start_transport_stream_op_batch(
 //
 
 // Constructor for channel_data.  Used for both client and server filters.
-static grpc_error* deadline_init_channel_elem(grpc_channel_element* elem,
+static grpc_error* deadline_init_channel_elem(grpc_channel_element* /*elem*/,
                                               grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
   return GRPC_ERROR_NONE;
 }
 
 // Destructor for channel_data.  Used for both client and server filters.
-static void deadline_destroy_channel_elem(grpc_channel_element* elem) {}
+static void deadline_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
 
 // Call data used for both client and server filter.
 typedef struct base_call_data {
@@ -268,9 +269,9 @@ static grpc_error* deadline_init_call_elem(grpc_call_element* elem,
 }
 
 // Destructor for call_data.  Used for both client and server filters.
-static void deadline_destroy_call_elem(grpc_call_element* elem,
-                                       const grpc_call_final_info* final_info,
-                                       grpc_closure* ignored) {
+static void deadline_destroy_call_elem(
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {
   grpc_deadline_state* deadline_state =
       static_cast<grpc_deadline_state*>(elem->call_data);
   deadline_state->~grpc_deadline_state();
@@ -290,8 +291,9 @@ static void recv_initial_metadata_ready(void* arg, grpc_error* error) {
   server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
   start_timer_if_needed(elem, calld->recv_initial_metadata->deadline);
   // Invoke the next callback.
-  GRPC_CLOSURE_RUN(calld->next_recv_initial_metadata_ready,
-                   GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->next_recv_initial_metadata_ready,
+                          GRPC_ERROR_REF(error));
 }
 
 // Method for starting a call op for server filter.

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -99,8 +99,7 @@ struct channel_data {
 };
 }  // namespace
 
-static grpc_error* client_filter_incoming_metadata(grpc_call_element* elem,
-                                                   grpc_metadata_batch* b) {
+static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
   if (b->idx.named.status != nullptr) {
     /* If both gRPC status and HTTP status are provided in the response, we
      * should prefer the gRPC status code, as mentioned in
@@ -177,7 +176,7 @@ static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
-    error = client_filter_incoming_metadata(elem, calld->recv_initial_metadata);
+    error = client_filter_incoming_metadata(calld->recv_initial_metadata);
     calld->recv_initial_metadata_error = GRPC_ERROR_REF(error);
   } else {
     GRPC_ERROR_REF(error);
@@ -189,7 +188,7 @@ static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
         calld->call_combiner, &calld->recv_trailing_metadata_ready,
         calld->recv_trailing_metadata_error, "continue recv_trailing_metadata");
   }
-  GRPC_CLOSURE_RUN(closure, error);
+  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
 static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
@@ -204,22 +203,23 @@ static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
     return;
   }
   if (error == GRPC_ERROR_NONE) {
-    error =
-        client_filter_incoming_metadata(elem, calld->recv_trailing_metadata);
+    error = client_filter_incoming_metadata(calld->recv_trailing_metadata);
   } else {
     GRPC_ERROR_REF(error);
   }
   error = grpc_error_add_child(
       error, GRPC_ERROR_REF(calld->recv_initial_metadata_error));
-  GRPC_CLOSURE_RUN(calld->original_recv_trailing_metadata_ready, error);
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_recv_trailing_metadata_ready, error);
 }
 
 static void send_message_on_complete(void* arg, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->send_message_cache.Destroy();
-  GRPC_CLOSURE_RUN(calld->original_send_message_on_complete,
-                   GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_send_message_on_complete,
+                          GRPC_ERROR_REF(error));
 }
 
 // Pulls a slice from the send_message byte stream, updating
@@ -302,7 +302,7 @@ static grpc_error* update_path_for_get(grpc_call_element* elem,
   size_t estimated_len = GRPC_SLICE_LENGTH(path_slice);
   estimated_len++; /* for the '?' */
   estimated_len += grpc_base64_estimate_encoded_size(
-      batch->payload->send_message.send_message->length(), true /* url_safe */,
+      batch->payload->send_message.send_message->length(),
       false /* multi_line */);
   grpc_core::UnmanagedMemorySlice path_with_query_slice(estimated_len);
   /* memcopy individual pieces into this slice */
@@ -473,8 +473,8 @@ static grpc_error* http_client_init_call_elem(
 
 /* Destructor for call_data */
 static void http_client_destroy_call_elem(
-    grpc_call_element* elem, const grpc_call_final_info* final_info,
-    grpc_closure* ignored) {
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
 }

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -80,9 +80,9 @@ grpc_error* client_authority_init_call_elem(
 }
 
 /* Destructor for call_data */
-void client_authority_destroy_call_elem(grpc_call_element* elem,
-                                        const grpc_call_final_info* final_info,
-                                        grpc_closure* ignored) {}
+void client_authority_destroy_call_elem(
+    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {}
 
 /* Constructor for channel_data */
 grpc_error* client_authority_init_channel_elem(

data/src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -227,8 +227,9 @@ static void send_message_on_complete(void* arg, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_slice_buffer_reset_and_unref_internal(&calld->slices);
-  GRPC_CLOSURE_RUN(calld->original_send_message_on_complete,
-                   GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_send_message_on_complete,
+                          GRPC_ERROR_REF(error));
 }
 
 static void send_message_batch_continue(grpc_call_element* elem) {
@@ -320,6 +321,11 @@ static grpc_error* pull_slice_from_send_message(call_data* calld) {
 // eventually result in calling on_send_message_next_done().
 static void continue_reading_send_message(grpc_call_element* elem) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
+  if (calld->slices.length ==
+      calld->send_message_batch->payload->send_message.send_message->length()) {
+    finish_send_message(elem);
+    return;
+  }
   while (calld->send_message_batch->payload->send_message.send_message->Next(
       ~static_cast<size_t>(0), &calld->on_send_message_next_done)) {
     grpc_error* error = pull_slice_from_send_message(calld);
@@ -361,7 +367,7 @@ static void on_send_message_next_done(void* arg, grpc_error* error) {
   }
 }
 
-static void start_send_message_batch(void* arg, grpc_error* unused) {
+static void start_send_message_batch(void* arg, grpc_error* /*unused*/) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   if (skip_message_compression(elem)) {
     send_message_batch_continue(elem);
@@ -448,9 +454,9 @@ static grpc_error* compress_init_call_elem(grpc_call_element* elem,
 }
 
 /* Destructor for call_data */
-static void compress_destroy_call_elem(grpc_call_element* elem,
-                                       const grpc_call_final_info* final_info,
-                                       grpc_closure* ignored) {
+static void compress_destroy_call_elem(
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
 }
@@ -487,7 +493,7 @@ static grpc_error* compress_init_channel_elem(grpc_channel_element* elem,
 }
 
 /* Destructor for channel data */
-static void compress_destroy_channel_elem(grpc_channel_element* elem) {}
+static void compress_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
 
 const grpc_channel_filter grpc_message_compress_filter = {
     compress_start_transport_stream_op_batch,