grpc 1.70.1 → 1.71.0

data/src/core/channelz/channelz.h

@@ -28,13 +28,13 @@
 #include <atomic>
 #include <cstdint>
 #include <map>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/per_cpu.h"
@@ -152,31 +152,12 @@ class PerCpuCallCountingHelper final {
 
   // We want to ensure that this per-cpu data structure lands on different
   // cachelines per cpu.
-  // With C++17 we can do so explicitly with an `alignas` specifier.
-  // Prior versions we can at best approximate it by padding the structure.
-  // It'll probably work out ok, but it's not guaranteed across allocators.
-  // (in the bad case where this gets split across cachelines we'll just have
-  // two cpus fighting over the same cacheline with a slight performance
-  // degregation).
-  // TODO(ctiller): When we move to C++17 delete the duplicate definition.
-#if __cplusplus >= 201703L
   struct alignas(GPR_CACHELINE_SIZE) PerCpuData {
     std::atomic<int64_t> calls_started{0};
     std::atomic<int64_t> calls_succeeded{0};
     std::atomic<int64_t> calls_failed{0};
     std::atomic<gpr_cycle_counter> last_call_started_cycle{0};
   };
-#else
-  struct PerCpuDataHeader {
-    std::atomic<int64_t> calls_started{0};
-    std::atomic<int64_t> calls_succeeded{0};
-    std::atomic<int64_t> calls_failed{0};
-    std::atomic<gpr_cycle_counter> last_call_started_cycle{0};
-  };
-  struct PerCpuData : public PerCpuDataHeader {
-    uint8_t padding[GPR_CACHELINE_SIZE - sizeof(PerCpuDataHeader)];
-  };
-#endif
   PerCpu<PerCpuData> per_cpu_data_{PerCpuOptions().SetCpusPerShard(4)};
 };
 
@@ -346,8 +327,8 @@ class SocketNode final : public BaseNode {
     };
     enum class ModelType { kUnset = 0, kTls = 1, kOther = 2 };
     ModelType type = ModelType::kUnset;
-    absl::optional<Tls> tls;
-    absl::optional<Json> other;
+    std::optional<Tls> tls;
+    std::optional<Json> other;
 
     Json RenderJson();
 

data/src/core/channelz/channelz_registry.cc

@@ -178,7 +178,6 @@ void ChannelzRegistry::InternalLogAllEntities() {
 }  // namespace grpc_core
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   return gpr_strdup(
       grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id)
@@ -186,7 +185,6 @@ char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
 }
 
 char* grpc_channelz_get_servers(intptr_t start_server_id) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   return gpr_strdup(
       grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id)
@@ -194,7 +192,6 @@ char* grpc_channelz_get_servers(intptr_t start_server_id) {
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> server_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
@@ -212,7 +209,6 @@ char* grpc_channelz_get_server(intptr_t server_id) {
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
                                        intptr_t start_socket_id,
                                        intptr_t max_results) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   // Validate inputs before handing them of to the renderer.
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> base_node =
@@ -231,7 +227,6 @@ char* grpc_channelz_get_server_sockets(intptr_t server_id,
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> channel_node =
       grpc_core::channelz::ChannelzRegistry::Get(channel_id);
@@ -249,7 +244,6 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> subchannel_node =
       grpc_core::channelz::ChannelzRegistry::Get(subchannel_id);
@@ -265,7 +259,6 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> socket_node =
       grpc_core::channelz::ChannelzRegistry::Get(socket_id);

data/src/core/client_channel/client_channel.cc

@@ -29,9 +29,11 @@
 #include <algorithm>
 #include <functional>
 #include <new>
+#include <optional>
 #include <set>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/cleanup/cleanup.h"
@@ -43,8 +45,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/client_channel/config_selector.h"
@@ -243,8 +243,7 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
             *subchannel_wrapper_->client_channel_->work_serializer_) {
           ApplyUpdateInControlPlaneWorkSerializer(state, status);
           Unref();
-        },
-        DEBUG_LOCATION);
+        });
   }
 
   grpc_pollset_set* interested_parties() override { return nullptr; }
@@ -262,8 +261,7 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
         << subchannel_wrapper_->subchannel_.get()
         << " watcher=" << watcher_.get()
         << " state=" << ConnectivityStateName(state) << " status=" << status;
-    absl::optional<absl::Cord> keepalive_throttling =
-        status.GetPayload(kKeepaliveThrottlingKey);
+    auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
     if (keepalive_throttling.has_value()) {
       int new_keepalive_time = -1;
       if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
@@ -368,8 +366,7 @@ void ClientChannel::SubchannelWrapper::Orphaned() {
             }
           }
         }
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 void ClientChannel::SubchannelWrapper::WatchConnectivityState(
@@ -557,7 +554,7 @@ absl::StatusOr<RefCountedPtr<Channel>> ClientChannel::Create(
   }
   // Get default service config.  If none is specified via the client API,
   // we use an empty config.
-  absl::optional<absl::string_view> service_config_json =
+  std::optional<absl::string_view> service_config_json =
       channel_args.GetString(GRPC_ARG_SERVICE_CONFIG);
   if (!service_config_json.has_value()) service_config_json = "{}";
   auto default_service_config =
@@ -592,7 +589,7 @@ absl::StatusOr<RefCountedPtr<Channel>> ClientChannel::Create(
 namespace {
 std::string GetDefaultAuthorityFromChannelArgs(const ChannelArgs& channel_args,
                                                absl::string_view target) {
-  absl::optional<std::string> default_authority =
+  std::optional<std::string> default_authority =
       channel_args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY);
   if (!default_authority.has_value()) {
     return CoreConfiguration::Get().resolver_registry().GetDefaultAuthority(
@@ -661,8 +658,7 @@ void ClientChannel::Orphaned() {
   work_serializer_->Run(
       [self]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*self->work_serializer_) {
         self->DestroyResolverAndLbPolicyLocked();
-      },
-      DEBUG_LOCATION);
+      });
   // IncreaseCallCount() introduces a phony call and prevents the idle
   // timer from being reset by other threads.
   idle_state_.IncreaseCallCount();
@@ -682,8 +678,7 @@ grpc_connectivity_state ClientChannel::CheckConnectivityState(
     work_serializer_->Run(
         [self]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*self->work_serializer_) {
           self->TryToConnectLocked();
-        },
-        DEBUG_LOCATION);
+        });
   }
   return state;
 }
@@ -708,7 +703,6 @@ class ExternalStateWatcher : public RefCounted<ExternalStateWatcher> {
     const Duration timeout = deadline - Timestamp::Now();
     timer_handle_ =
         channel_->event_engine()->RunAfter(timeout, [self = Ref()]() mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->MaybeStartCompletion(absl::DeadlineExceededError(
               "Timed out waiting for connection state change"));
@@ -788,8 +782,7 @@ void ClientChannel::AddConnectivityWatcher(
   //       watcher = std::move(watcher)]()
   //            ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_) {
   //        self->state_tracker_.AddWatcher(initial_state, std::move(watcher));
-  //      },
-  //      DEBUG_LOCATION);
+  //      });
 }
 
 void ClientChannel::RemoveConnectivityWatcher(
@@ -798,8 +791,7 @@ void ClientChannel::RemoveConnectivityWatcher(
   work_serializer_->Run(
       [self, watcher]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*self->work_serializer_) {
         self->state_tracker_.RemoveWatcher(watcher);
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 void ClientChannel::GetInfo(const grpc_channel_info* info) {
@@ -817,8 +809,7 @@ void ClientChannel::ResetConnectionBackoff() {
   work_serializer_->Run(
       [self]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*self->work_serializer_) {
         if (self->lb_policy_ != nullptr) self->lb_policy_->ResetBackoffLocked();
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 namespace {
@@ -855,7 +846,7 @@ void ClientChannel::Ping(grpc_completion_queue*, void*) {
 grpc_call* ClientChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
-    Slice path, absl::optional<Slice> authority, Timestamp deadline, bool) {
+    Slice path, std::optional<Slice> authority, Timestamp deadline, bool) {
   auto arena = call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       event_engine());
@@ -985,7 +976,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   }
   // Try the deprecated LB policy name from the service config.
   // If not, try the setting from channel args.
-  absl::optional<absl::string_view> policy_name;
+  std::optional<absl::string_view> policy_name;
   if (!parsed_service_config->parsed_deprecated_lb_policy().empty()) {
     policy_name = parsed_service_config->parsed_deprecated_lb_policy();
   } else {
@@ -1189,7 +1180,7 @@ void ClientChannel::OnResolverErrorLocked(absl::Status status) {
 
 absl::Status ClientChannel::CreateOrUpdateLbPolicyLocked(
     RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
-    const absl::optional<std::string>& health_check_service_name,
+    const std::optional<std::string>& health_check_service_name,
     Resolver::Result result) {
   // Construct update.
   LoadBalancingPolicy::UpdateArgs update_args;
@@ -1368,8 +1359,7 @@ void ClientChannel::StartIdleTimer() {
                 // might need to check for any calls that are
                 // queued waiting for a resolver result or an LB
                 // pick.
-              },
-              DEBUG_LOCATION);
+              });
         }
       },
       std::move(arena)));

data/src/core/client_channel/client_channel.h

@@ -74,7 +74,7 @@ class ClientChannel : public Channel {
   grpc_call* CreateCall(grpc_call* parent_call, uint32_t propagation_mask,
                         grpc_completion_queue* cq,
                         grpc_pollset_set* /*pollset_set_alternative*/,
-                        Slice path, absl::optional<Slice> authority,
+                        Slice path, std::optional<Slice> authority,
                         Timestamp deadline, bool registered_method) override;
 
   void StartCall(UnstartedCallHandler unstarted_handler) override;
@@ -139,7 +139,7 @@ class ClientChannel : public Channel {
 
   absl::Status CreateOrUpdateLbPolicyLocked(
       RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
-      const absl::optional<std::string>& health_check_service_name,
+      const std::optional<std::string>& health_check_service_name,
       Resolver::Result result) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);
   OrphanablePtr<LoadBalancingPolicy> CreateLbPolicyLocked(
       const ChannelArgs& args) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);