grpc 1.26.0 → 1.27.0.pre1

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

@@ -27,6 +27,7 @@
 #include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
 #include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/optional.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -85,9 +86,9 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // keep a raw pointer to the watcher, which may be used only for
   // cancellation.  (Because the caller does not own the watcher, the
   // pointer must not be used for any other purpose.)
-  void WatchClusterData(StringView cluster,
+  void WatchClusterData(StringView cluster_name,
                         std::unique_ptr<ClusterWatcherInterface> watcher);
-  void CancelClusterDataWatch(StringView cluster,
+  void CancelClusterDataWatch(StringView cluster_name,
                               ClusterWatcherInterface* watcher);
 
   // Start and cancel endpoint data watch for a cluster.
@@ -95,15 +96,15 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // keep a raw pointer to the watcher, which may be used only for
   // cancellation.  (Because the caller does not own the watcher, the
   // pointer must not be used for any other purpose.)
-  void WatchEndpointData(StringView cluster,
+  void WatchEndpointData(StringView eds_service_name,
                          std::unique_ptr<EndpointWatcherInterface> watcher);
-  void CancelEndpointDataWatch(StringView cluster,
+  void CancelEndpointDataWatch(StringView eds_service_name,
                                EndpointWatcherInterface* watcher);
 
-  // Adds and removes client stats for cluster.
-  void AddClientStats(StringView lrs_server, StringView cluster,
+  // Adds and removes client stats for \a cluster_name.
+  void AddClientStats(StringView /*lrs_server*/, StringView cluster_name,
                       XdsClientStats* client_stats);
-  void RemoveClientStats(StringView lrs_server, StringView cluster,
+  void RemoveClientStats(StringView /*lrs_server*/, StringView cluster_name,
                          XdsClientStats* client_stats);
 
   // Resets connection backoff state.
@@ -115,6 +116,8 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
       const grpc_channel_args& args);
 
  private:
+  static const grpc_arg_pointer_vtable kXdsClientVtable;
+
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
   // TODO(roth): This is separate from the XdsClient object because it was
@@ -144,9 +147,6 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     AdsCallState* ads_calld() const;
     LrsCallState* lrs_calld() const;
 
-    void MaybeStartAdsCall();
-    void StopAdsCall();
-
     void MaybeStartLrsCall();
     void StopLrsCall();
 
@@ -155,6 +155,9 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     void StartConnectivityWatchLocked();
     void CancelConnectivityWatchLocked();
 
+    void OnResourceNamesChanged(const std::string& type_url);
+    void OnWatcherRemoved();
+
    private:
     class StateWatcher;
 
@@ -173,13 +176,18 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
 
   struct ClusterState {
     std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
-        cluster_watchers;
+        watchers;
+    // The latest data seen from CDS.
+    Optional<CdsUpdate> update;
+  };
+
+  struct EndpointState {
     std::map<EndpointWatcherInterface*,
              std::unique_ptr<EndpointWatcherInterface>>
-        endpoint_watchers;
+        watchers;
     std::set<XdsClientStats*> client_stats;
     // The latest data seen from EDS.
-    EdsUpdate eds_update;
+    EdsUpdate update;
   };
 
   // Sends an error notification to all watchers.
@@ -189,12 +197,22 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // normal method instead of a closure callback.
   static void NotifyOnServiceConfig(void* arg, grpc_error* error);
 
+  std::set<StringView> WatchedClusterNames() const;
+
+  std::set<StringView> EdsServiceNames() const;
+
+  std::map<StringView, std::set<XdsClientStats*>> ClientStatsMap() const;
+
   // Channel arg vtable functions.
   static void* ChannelArgCopy(void* p);
   static void ChannelArgDestroy(void* p);
   static int ChannelArgCmp(void* p, void* q);
 
-  static const grpc_arg_pointer_vtable kXdsClientVtable;
+  // All the received clusters are cached, no matter they are watched or not.
+  std::map<StringView /*cluster_name*/, ClusterState, StringLess> cluster_map_;
+  // Only the watched EDS service names are stored.
+  std::map<StringView /*eds_service_name*/, EndpointState, StringLess>
+      endpoint_map_;
 
   grpc_core::UniquePtr<char> build_version_;
 
@@ -203,7 +221,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
 
   std::unique_ptr<XdsBootstrap> bootstrap_;
 
-  grpc_core::UniquePtr<char> server_name_;
+  std::string server_name_;
   std::unique_ptr<ServiceConfigWatcherInterface> service_config_watcher_;
   // TODO(juanlishen): Once we implement LDS support, this will no
   // longer be needed.
@@ -212,12 +230,6 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // The channel for communicating with the xds server.
   OrphanablePtr<ChannelState> chand_;
 
-  // 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_;
-
   bool shutting_down_ = false;
 };
 

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

@@ -87,11 +87,10 @@ XdsClientStats::LocalityStats::GetSnapshotAndReset() {
   {
     MutexLock lock(&load_metric_stats_mu_);
     for (auto& p : load_metric_stats_) {
-      const char* metric_name = p.first.get();
+      const std::string& metric_name = p.first;
       LoadMetric& metric_value = p.second;
-      snapshot.load_metric_stats.emplace(
-          grpc_core::UniquePtr<char>(gpr_strdup(metric_name)),
-          metric_value.GetSnapshotAndReset());
+      snapshot.load_metric_stats.emplace(metric_name,
+                                         metric_value.GetSnapshotAndReset());
     }
   }
   return snapshot;
@@ -178,14 +177,12 @@ void XdsClientStats::PruneLocalityStats() {
   }
 }
 
-void XdsClientStats::AddCallDropped(
-    const grpc_core::UniquePtr<char>& category) {
+void XdsClientStats::AddCallDropped(const std::string& 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(
-        grpc_core::UniquePtr<char>(gpr_strdup(category.get())), 1);
+    dropped_requests_.emplace(category, 1);
   } else {
     ++iter->second;
   }

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

@@ -38,46 +38,43 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
   struct Less {
     bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
                     const RefCountedPtr<XdsLocalityName>& rhs) const {
-      int cmp_result = strcmp(lhs->region_.get(), rhs->region_.get());
+      int cmp_result = lhs->region_.compare(rhs->region_);
       if (cmp_result != 0) return cmp_result < 0;
-      cmp_result = strcmp(lhs->zone_.get(), rhs->zone_.get());
+      cmp_result = lhs->zone_.compare(rhs->zone_);
       if (cmp_result != 0) return cmp_result < 0;
-      return strcmp(lhs->sub_zone_.get(), rhs->sub_zone_.get()) < 0;
+      return lhs->sub_zone_.compare(rhs->sub_zone_) < 0;
     }
   };
 
-  XdsLocalityName(grpc_core::UniquePtr<char> region,
-                  grpc_core::UniquePtr<char> zone,
-                  grpc_core::UniquePtr<char> subzone)
+  XdsLocalityName(std::string region, std::string zone, std::string subzone)
       : region_(std::move(region)),
         zone_(std::move(zone)),
         sub_zone_(std::move(subzone)) {}
 
   bool operator==(const XdsLocalityName& other) const {
-    return strcmp(region_.get(), other.region_.get()) == 0 &&
-           strcmp(zone_.get(), other.zone_.get()) == 0 &&
-           strcmp(sub_zone_.get(), other.sub_zone_.get()) == 0;
+    return region_ == other.region_ && zone_ == other.zone_ &&
+           sub_zone_ == other.sub_zone_;
   }
 
-  const char* region() const { return region_.get(); }
-  const char* zone() const { return zone_.get(); }
-  const char* sub_zone() const { return sub_zone_.get(); }
+  const std::string& region() const { return region_; }
+  const std::string& zone() const { return zone_; }
+  const std::string& sub_zone() const { return sub_zone_; }
 
   const char* AsHumanReadableString() {
     if (human_readable_string_ == nullptr) {
       char* tmp;
       gpr_asprintf(&tmp, "{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
-                   region_.get(), zone_.get(), sub_zone_.get());
+                   region_.c_str(), zone_.c_str(), sub_zone_.c_str());
       human_readable_string_.reset(tmp);
     }
     return human_readable_string_.get();
   }
 
  private:
-  grpc_core::UniquePtr<char> region_;
-  grpc_core::UniquePtr<char> zone_;
-  grpc_core::UniquePtr<char> sub_zone_;
-  grpc_core::UniquePtr<char> human_readable_string_;
+  std::string region_;
+  std::string zone_;
+  std::string sub_zone_;
+  UniquePtr<char> human_readable_string_;
 };
 
 // The stats classes (i.e., XdsClientStats, LocalityStats, and LoadMetric) can
@@ -112,10 +109,8 @@ class XdsClientStats {
       double total_metric_value_{0};
     };
 
-    using LoadMetricMap =
-        std::map<grpc_core::UniquePtr<char>, LoadMetric, StringLess>;
-    using LoadMetricSnapshotMap =
-        std::map<grpc_core::UniquePtr<char>, LoadMetric::Snapshot, StringLess>;
+    using LoadMetricMap = std::map<std::string, LoadMetric>;
+    using LoadMetricSnapshotMap = std::map<std::string, LoadMetric::Snapshot>;
 
     struct Snapshot {
       // TODO(juanlishen): Change this to const method when const_iterator is
@@ -187,8 +182,7 @@ class XdsClientStats {
   using LocalityStatsSnapshotMap =
       std::map<RefCountedPtr<XdsLocalityName>, LocalityStats::Snapshot,
                XdsLocalityName::Less>;
-  using DroppedRequestsMap =
-      std::map<grpc_core::UniquePtr<char>, uint64_t, StringLess>;
+  using DroppedRequestsMap = std::map<std::string, uint64_t>;
   using DroppedRequestsSnapshotMap = DroppedRequestsMap;
 
   struct Snapshot {
@@ -211,7 +205,7 @@ class XdsClientStats {
   RefCountedPtr<LocalityStats> FindLocalityStats(
       const RefCountedPtr<XdsLocalityName>& locality_name);
   void PruneLocalityStats();
-  void AddCallDropped(const grpc_core::UniquePtr<char>& category);
+  void AddCallDropped(const std::string& category);
 
  private:
   // The stats for each locality.

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

@@ -3008,8 +3008,8 @@ void Chttp2IncomingByteStream::NextLocked(void* arg,
     }
   } else if (s->read_closed) {
     if (bs->remaining_bytes_ != 0) {
-      s->byte_stream_error =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Truncated message");
+      s->byte_stream_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+          "Truncated message", &s->read_closed_error, 1);
       grpc_core::ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete,
                               GRPC_ERROR_REF(s->byte_stream_error));
       if (s->data_parser.parsing_frame != nullptr) {

data/src/core/ext/upb-generated/src/proto/grpc/lb/v1/load_balancer.upb.c

@@ -71,20 +71,22 @@ const upb_msglayout grpc_lb_v1_ClientStats_msginit = {
   UPB_SIZE(40, 48), 6, false,
 };
 
-static const upb_msglayout *const grpc_lb_v1_LoadBalanceResponse_submsgs[2] = {
+static const upb_msglayout *const grpc_lb_v1_LoadBalanceResponse_submsgs[3] = {
+  &grpc_lb_v1_FallbackResponse_msginit,
   &grpc_lb_v1_InitialLoadBalanceResponse_msginit,
   &grpc_lb_v1_ServerList_msginit,
 };
 
-static const upb_msglayout_field grpc_lb_v1_LoadBalanceResponse__fields[2] = {
-  {1, UPB_SIZE(0, 0), UPB_SIZE(-5, -9), 0, 11, 1},
-  {2, UPB_SIZE(0, 0), UPB_SIZE(-5, -9), 1, 11, 1},
+static const upb_msglayout_field grpc_lb_v1_LoadBalanceResponse__fields[3] = {
+  {1, UPB_SIZE(0, 0), UPB_SIZE(-5, -9), 1, 11, 1},
+  {2, UPB_SIZE(0, 0), UPB_SIZE(-5, -9), 2, 11, 1},
+  {3, UPB_SIZE(0, 0), UPB_SIZE(-5, -9), 0, 11, 1},
 };
 
 const upb_msglayout grpc_lb_v1_LoadBalanceResponse_msginit = {
   &grpc_lb_v1_LoadBalanceResponse_submsgs[0],
   &grpc_lb_v1_LoadBalanceResponse__fields[0],
-  UPB_SIZE(8, 16), 2, false,
+  UPB_SIZE(8, 16), 3, false,
 };
 
 static const upb_msglayout *const grpc_lb_v1_InitialLoadBalanceResponse_submsgs[1] = {
@@ -129,5 +131,11 @@ const upb_msglayout grpc_lb_v1_Server_msginit = {
   UPB_SIZE(24, 48), 4, false,
 };
 
+const upb_msglayout grpc_lb_v1_FallbackResponse_msginit = {
+  NULL,
+  NULL,
+  UPB_SIZE(0, 0), 0, false,
+};
+
 #include "upb/port_undef.inc"
 

data/src/core/ext/upb-generated/src/proto/grpc/lb/v1/load_balancer.upb.h

@@ -28,6 +28,7 @@ struct grpc_lb_v1_LoadBalanceResponse;
 struct grpc_lb_v1_InitialLoadBalanceResponse;
 struct grpc_lb_v1_ServerList;
 struct grpc_lb_v1_Server;
+struct grpc_lb_v1_FallbackResponse;
 typedef struct grpc_lb_v1_LoadBalanceRequest grpc_lb_v1_LoadBalanceRequest;
 typedef struct grpc_lb_v1_InitialLoadBalanceRequest grpc_lb_v1_InitialLoadBalanceRequest;
 typedef struct grpc_lb_v1_ClientStatsPerToken grpc_lb_v1_ClientStatsPerToken;
@@ -36,6 +37,7 @@ typedef struct grpc_lb_v1_LoadBalanceResponse grpc_lb_v1_LoadBalanceResponse;
 typedef struct grpc_lb_v1_InitialLoadBalanceResponse grpc_lb_v1_InitialLoadBalanceResponse;
 typedef struct grpc_lb_v1_ServerList grpc_lb_v1_ServerList;
 typedef struct grpc_lb_v1_Server grpc_lb_v1_Server;
+typedef struct grpc_lb_v1_FallbackResponse grpc_lb_v1_FallbackResponse;
 extern const upb_msglayout grpc_lb_v1_LoadBalanceRequest_msginit;
 extern const upb_msglayout grpc_lb_v1_InitialLoadBalanceRequest_msginit;
 extern const upb_msglayout grpc_lb_v1_ClientStatsPerToken_msginit;
@@ -44,6 +46,7 @@ extern const upb_msglayout grpc_lb_v1_LoadBalanceResponse_msginit;
 extern const upb_msglayout grpc_lb_v1_InitialLoadBalanceResponse_msginit;
 extern const upb_msglayout grpc_lb_v1_ServerList_msginit;
 extern const upb_msglayout grpc_lb_v1_Server_msginit;
+extern const upb_msglayout grpc_lb_v1_FallbackResponse_msginit;
 struct google_protobuf_Duration;
 struct google_protobuf_Timestamp;
 extern const upb_msglayout google_protobuf_Duration_msginit;
@@ -221,6 +224,7 @@ UPB_INLINE char *grpc_lb_v1_LoadBalanceResponse_serialize(const grpc_lb_v1_LoadB
 typedef enum {
   grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_initial_response = 1,
   grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_server_list = 2,
+  grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_fallback_response = 3,
   grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_NOT_SET = 0
 } grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_oneofcases;
 UPB_INLINE grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_oneofcases grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_case(const grpc_lb_v1_LoadBalanceResponse* msg) { return (grpc_lb_v1_LoadBalanceResponse_load_balance_response_type_oneofcases)UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 8)); }
@@ -229,6 +233,8 @@ UPB_INLINE bool grpc_lb_v1_LoadBalanceResponse_has_initial_response(const grpc_l
 UPB_INLINE const grpc_lb_v1_InitialLoadBalanceResponse* grpc_lb_v1_LoadBalanceResponse_initial_response(const grpc_lb_v1_LoadBalanceResponse *msg) { return UPB_READ_ONEOF(msg, const grpc_lb_v1_InitialLoadBalanceResponse*, UPB_SIZE(0, 0), UPB_SIZE(4, 8), 1, NULL); }
 UPB_INLINE bool grpc_lb_v1_LoadBalanceResponse_has_server_list(const grpc_lb_v1_LoadBalanceResponse *msg) { return _upb_has_oneof_field(msg, UPB_SIZE(4, 8), 2); }
 UPB_INLINE const grpc_lb_v1_ServerList* grpc_lb_v1_LoadBalanceResponse_server_list(const grpc_lb_v1_LoadBalanceResponse *msg) { return UPB_READ_ONEOF(msg, const grpc_lb_v1_ServerList*, UPB_SIZE(0, 0), UPB_SIZE(4, 8), 2, NULL); }
+UPB_INLINE bool grpc_lb_v1_LoadBalanceResponse_has_fallback_response(const grpc_lb_v1_LoadBalanceResponse *msg) { return _upb_has_oneof_field(msg, UPB_SIZE(4, 8), 3); }
+UPB_INLINE const grpc_lb_v1_FallbackResponse* grpc_lb_v1_LoadBalanceResponse_fallback_response(const grpc_lb_v1_LoadBalanceResponse *msg) { return UPB_READ_ONEOF(msg, const grpc_lb_v1_FallbackResponse*, UPB_SIZE(0, 0), UPB_SIZE(4, 8), 3, NULL); }
 
 UPB_INLINE void grpc_lb_v1_LoadBalanceResponse_set_initial_response(grpc_lb_v1_LoadBalanceResponse *msg, grpc_lb_v1_InitialLoadBalanceResponse* value) {
   UPB_WRITE_ONEOF(msg, grpc_lb_v1_InitialLoadBalanceResponse*, UPB_SIZE(0, 0), value, UPB_SIZE(4, 8), 1);
@@ -254,6 +260,18 @@ UPB_INLINE struct grpc_lb_v1_ServerList* grpc_lb_v1_LoadBalanceResponse_mutable_
   }
   return sub;
 }
+UPB_INLINE void grpc_lb_v1_LoadBalanceResponse_set_fallback_response(grpc_lb_v1_LoadBalanceResponse *msg, grpc_lb_v1_FallbackResponse* value) {
+  UPB_WRITE_ONEOF(msg, grpc_lb_v1_FallbackResponse*, UPB_SIZE(0, 0), value, UPB_SIZE(4, 8), 3);
+}
+UPB_INLINE struct grpc_lb_v1_FallbackResponse* grpc_lb_v1_LoadBalanceResponse_mutable_fallback_response(grpc_lb_v1_LoadBalanceResponse *msg, upb_arena *arena) {
+  struct grpc_lb_v1_FallbackResponse* sub = (struct grpc_lb_v1_FallbackResponse*)grpc_lb_v1_LoadBalanceResponse_fallback_response(msg);
+  if (sub == NULL) {
+    sub = (struct grpc_lb_v1_FallbackResponse*)upb_msg_new(&grpc_lb_v1_FallbackResponse_msginit, arena);
+    if (!sub) return NULL;
+    grpc_lb_v1_LoadBalanceResponse_set_fallback_response(msg, sub);
+  }
+  return sub;
+}
 
 /* grpc.lb.v1.InitialLoadBalanceResponse */
 
@@ -350,6 +368,22 @@ UPB_INLINE void grpc_lb_v1_Server_set_drop(grpc_lb_v1_Server *msg, bool value) {
   UPB_FIELD_AT(msg, bool, UPB_SIZE(4, 4)) = value;
 }
 
+/* grpc.lb.v1.FallbackResponse */
+
+UPB_INLINE grpc_lb_v1_FallbackResponse *grpc_lb_v1_FallbackResponse_new(upb_arena *arena) {
+  return (grpc_lb_v1_FallbackResponse *)upb_msg_new(&grpc_lb_v1_FallbackResponse_msginit, arena);
+}
+UPB_INLINE grpc_lb_v1_FallbackResponse *grpc_lb_v1_FallbackResponse_parse(const char *buf, size_t size,
+                        upb_arena *arena) {
+  grpc_lb_v1_FallbackResponse *ret = grpc_lb_v1_FallbackResponse_new(arena);
+  return (ret && upb_decode(buf, size, ret, &grpc_lb_v1_FallbackResponse_msginit, arena)) ? ret : NULL;
+}
+UPB_INLINE char *grpc_lb_v1_FallbackResponse_serialize(const grpc_lb_v1_FallbackResponse *msg, upb_arena *arena, size_t *len) {
+  return upb_encode(msg, &grpc_lb_v1_FallbackResponse_msginit, arena, len);
+}
+
+
+
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif

data/src/core/lib/channel/channelz.h

@@ -148,7 +148,17 @@ class CallCountingHelper {
     // Make sure the size is exactly one cache line.
     uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(Atomic<intptr_t>) -
                     sizeof(Atomic<gpr_cycle_counter>)];
-  } GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
+  }
+#if GRPC_USE_ABSL
+  // TODO(soheilhy,veblush): Revist this after abseil integration.
+  // This has a problem when using abseil inlined_vector because it
+  // carries an alignment attribute properly but our allocator doesn't
+  // respect this. To avoid UBSAN errors, this should be removed with
+  // abseil inlined_vector.
+  ;
+#else
+  GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
+#endif
 
   struct CounterData {
     int64_t calls_started = 0;

data/src/core/lib/gpr/time_precise.cc

@@ -31,7 +31,7 @@
 
 #include "src/core/lib/gpr/time_precise.h"
 
-#if GPR_CYCLE_COUNTER_RDTSC_32 or GPR_CYCLE_COUNTER_RDTSC_64
+#if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64
 #if GPR_LINUX
 static bool read_freq_from_kernel(double* freq) {
   // Google production kernel export the frequency for us in kHz.

data/src/core/lib/gprpp/optional.h

@@ -19,6 +19,24 @@
 #ifndef GRPC_CORE_LIB_GPRPP_OPTIONAL_H
 #define GRPC_CORE_LIB_GPRPP_OPTIONAL_H
 
+#include <grpc/support/port_platform.h>
+
+// TODO(yashykt): Remove false once migration to abseil is done.
+#if false && GRPC_USE_ABSL
+
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+template <typename T>
+using Optional = absl::optional<T>;
+
+}  // namespace grpc_core
+
+#else
+
+#include <utility>
+
 namespace grpc_core {
 
 /* A make-shift alternative for absl::Optional. This can be removed in favor of
@@ -27,11 +45,17 @@ template <typename T>
 class Optional {
  public:
   Optional() : value_() {}
+
   void set(const T& val) {
     value_ = val;
     set_ = true;
   }
 
+  void set(T&& val) {
+    value_ = std::move(val);
+    set_ = true;
+  }
+
   bool has_value() const { return set_; }
 
   void reset() { set_ = false; }
@@ -45,4 +69,6 @@ class Optional {
 
 } /* namespace grpc_core */
 
+#endif
+
 #endif /* GRPC_CORE_LIB_GPRPP_OPTIONAL_H */