grpc 1.45.0 → 1.47.0

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

@@ -14,10 +14,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <memory>
+#include <new>
+#include <utility>
+
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/memory_request.h>
+#include <grpc/slice.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -41,7 +49,7 @@ class SliceRefCount : public grpc_slice_refcount {
   static void Destroy(grpc_slice_refcount* p) {
     auto* rc = static_cast<SliceRefCount*>(p);
     rc->~SliceRefCount();
-    gpr_free(rc);
+    free(rc);
   }
 
   std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
@@ -52,7 +60,7 @@ class SliceRefCount : public grpc_slice_refcount {
 
 grpc_slice MemoryAllocator::MakeSlice(MemoryRequest request) {
   auto size = Reserve(request.Increase(sizeof(SliceRefCount)));
-  void* p = gpr_malloc(size);
+  void* p = malloc(size);
   new (p) SliceRefCount(allocator_, size);
   grpc_slice slice;
   slice.refcount = static_cast<SliceRefCount*>(p);

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

@@ -11,13 +11,15 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/event_engine/port.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/sync.h"
+// IWYU pragma: no_include <sys/socket.h>
 
 namespace grpc_event_engine {
 namespace experimental {

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

@@ -0,0 +1,102 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <string>
+#include <utility>
+
+#include <grpc/event_engine/slice.h>
+#include <grpc/slice.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace slice_detail {
+
+uint32_t BaseSlice::Hash() const { return grpc_slice_hash_internal(slice_); }
+
+template <>
+MutableSlice CopyConstructors<MutableSlice>::FromCopiedString(std::string s) {
+  return MutableSlice(grpc_slice_from_cpp_string(std::move(s)));
+}
+
+template <>
+Slice CopyConstructors<Slice>::FromCopiedString(std::string s) {
+  return Slice(grpc_slice_from_cpp_string(std::move(s)));
+}
+
+}  // namespace slice_detail
+
+MutableSlice::MutableSlice(const grpc_slice& slice)
+    : slice_detail::BaseSlice(slice) {
+  GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
+}
+
+MutableSlice::~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
+
+Slice Slice::TakeOwned() {
+  if (c_slice().refcount == nullptr) {
+    return Slice(c_slice());
+  }
+  if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
+    return Slice(grpc_slice_copy(c_slice()));
+  }
+  return Slice(TakeCSlice());
+}
+
+Slice Slice::AsOwned() const {
+  if (c_slice().refcount == nullptr) {
+    return Slice(c_slice());
+  }
+  if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
+    return Slice(grpc_slice_copy(c_slice()));
+  }
+  return Slice(grpc_slice_ref_internal(c_slice()));
+}
+
+MutableSlice Slice::TakeMutable() {
+  if (c_slice().refcount == nullptr) {
+    return MutableSlice(c_slice());
+  }
+  if (c_slice().refcount != grpc_slice_refcount::NoopRefcount() &&
+      c_slice().refcount->IsUnique()) {
+    return MutableSlice(TakeCSlice());
+  }
+  return MutableSlice(grpc_slice_copy(c_slice()));
+}
+
+Slice::~Slice() { grpc_slice_unref_internal(c_slice()); }
+
+Slice Slice::Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
+
+Slice Slice::FromRefcountAndBytes(grpc_slice_refcount* r, const uint8_t* begin,
+                                  const uint8_t* end) {
+  grpc_slice out;
+  out.refcount = r;
+  if (r != grpc_slice_refcount::NoopRefcount()) r->Ref();
+  out.data.refcounted.bytes = const_cast<uint8_t*>(begin);
+  out.data.refcounted.length = end - begin;
+  return Slice(out);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,50 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/event_engine/slice.h>
+#include <grpc/event_engine/slice_buffer.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+
+#include "src/core/lib/slice/slice_refcount.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+void SliceBuffer::Append(Slice slice) {
+  grpc_slice_buffer_add(&slice_buffer_, slice.TakeCSlice());
+}
+
+size_t SliceBuffer::AppendIndexed(Slice slice) {
+  return grpc_slice_buffer_add_indexed(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::TakeFirst() {
+  return Slice(grpc_slice_buffer_take_first(&slice_buffer_));
+}
+
+void SliceBuffer::Prepend(Slice slice) {
+  grpc_slice_buffer_undo_take_first(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::RefSlice(size_t index) {
+  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/{ext/filters/max_age/max_age_filter.h → lib/event_engine/trace.cc}

@@ -1,5 +1,4 @@
-//
-// Copyright 2017 gRPC authors.
+// Copyright 2022 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,15 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-//
-
-#ifndef GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H
-
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack.h"
-
-extern const grpc_channel_filter grpc_max_age_filter;
+#include "src/core/lib/debug/trace.h"
 
-#endif /* GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H */
+grpc_core::TraceFlag grpc_event_engine_trace(false, "event_engine");

data/src/core/lib/{iomgr/endpoint_pair_event_engine.cc → event_engine/trace.h}

@@ -1,4 +1,4 @@
-// Copyright 2021 The gRPC Authors
+// Copyright 2022 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,22 +11,20 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H
 
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <stdlib.h>
+#include <grpc/support/port_platform.h>
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/iomgr/endpoint_pair.h"
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/debug/trace.h"
+
+extern grpc_core::TraceFlag grpc_event_engine_trace;
 
-grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
-    const char* /* name */, grpc_channel_args* /* args */) {
-  // TODO(hork): determine what's needed here in the long run
-  GPR_ASSERT(
-      false &&
-      "grpc_iomgr_create_endpoint_pair is not suppoted with event_engine");
-}
+#define GRPC_EVENT_ENGINE_TRACE(format, ...)                   \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {      \
+    gpr_log(GPR_DEBUG, "(event_engine) " format, __VA_ARGS__); \
+  }
 
-#endif  // GRPC_USE_EVENT_ENGINE
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H

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

@@ -47,6 +47,11 @@ static gpr_atm g_log_func = reinterpret_cast<gpr_atm>(gpr_default_log);
 static gpr_atm g_min_severity_to_print = GPR_LOG_SEVERITY_UNSET;
 static gpr_atm g_min_severity_to_print_stacktrace = GPR_LOG_SEVERITY_UNSET;
 
+void gpr_unreachable_code(const char* reason, const char* file, int line) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "UNREACHABLE CODE: %s", reason);
+  abort();
+}
+
 const char* gpr_log_severity_string(gpr_log_severity severity) {
   switch (severity) {
     case GPR_LOG_SEVERITY_DEBUG:

data/src/core/lib/gpr/tls.h

@@ -50,11 +50,10 @@ class TlsTypeConstrainer {
 
 #include <pthread.h>
 
+#include <algorithm>
 #include <array>
 #include <cstring>
 
-#include <grpc/support/log.h> /* for GPR_ASSERT */
-
 namespace grpc_core {
 
 template <typename T>
@@ -94,14 +93,14 @@ class PthreadTlsImpl : TlsTypeConstrainer<T> {
           typename std::remove_const<decltype(PthreadTlsImpl::keys_)>::type
               keys;
           for (pthread_key_t& key : keys) {
-            GPR_ASSERT(0 == pthread_key_create(&key, nullptr));
+            if (0 != pthread_key_create(&key, nullptr)) abort();
           }
           return keys;
         }()) {}
   PthreadTlsImpl(T t) : PthreadTlsImpl() { *this = t; }
   ~PthreadTlsImpl() {
     for (pthread_key_t key : keys_) {
-      GPR_ASSERT(0 == pthread_key_delete(key));
+      if (0 != pthread_key_delete(key)) abort();
     }
   }
 
@@ -131,7 +130,7 @@ class PthreadTlsImpl : TlsTypeConstrainer<T> {
       size_t remaining = reinterpret_cast<char*>(&t + 1) - src;
       size_t step = std::min(sizeof(dst), remaining);
       memcpy(&dst, src, step);
-      GPR_ASSERT(0 == pthread_setspecific(key, reinterpret_cast<void*>(dst)));
+      if (0 != pthread_setspecific(key, reinterpret_cast<void*>(dst))) abort();
       src += step;
     }
     return t;

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

@@ -17,7 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <utility>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <type_traits>
 
 #include "src/core/lib/gpr/useful.h"
 
@@ -33,6 +36,7 @@ namespace grpc_core {
 // exactly that number of bits. Undefined if that bit count is not available.
 template <size_t kBits>
 struct UintSelector;
+
 template <>
 struct UintSelector<8> {
   typedef uint8_t Type;
@@ -153,6 +157,18 @@ class BitSet {
     return true;
   }
 
+  template <typename Int>
+  typename std::enable_if<std::is_unsigned<Int>::value &&
+                              (sizeof(Int) * 8 >= kTotalBits),
+                          Int>::type
+  ToInt() const {
+    Int result = 0;
+    for (size_t i = 0; i < kTotalBits; i++) {
+      if (is_set(i)) result |= (Int(1) << i);
+    }
+    return result;
+  }
+
  private:
   // Given a bit index, return which unit it's stored in.
   static constexpr size_t unit_for(size_t bit) { return bit / kUnitBits; }

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

@@ -18,6 +18,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <cstddef>
+#include <iterator>
+#include <utility>
+
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/resource_quota/arena.h"

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <new>
 #include <utility>
 
 namespace grpc_core {

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

@@ -31,6 +31,10 @@ class CppImplOf {
     return reinterpret_cast<CppType*>(c_type);
   }
 
+  static const CppType* FromC(const CType* c_type) {
+    return reinterpret_cast<const CppType*>(c_type);
+  }
+
   // Retrieve a c pointer (of the same ownership as this)
   CType* c_ptr() {
     return reinterpret_cast<CType*>(static_cast<CppType*>(this));

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

@@ -20,12 +20,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
-#include <cassert>
-#include <cinttypes>
+#include <cstdint>
 
-#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
-#include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"

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

@@ -21,7 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <functional>
 #include <string>
 
 #include "absl/types/optional.h"

data/src/core/lib/gprpp/fork.cc

@@ -20,15 +20,12 @@
 
 #include "src/core/lib/gprpp/fork.h"
 
-#include <string.h>
-
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/atm.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/global_config.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/global_config_env.h"
 
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK

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

@@ -21,8 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
 // --------------------------------------------------------------------
 // How to use global configuration variables:
 //
@@ -89,7 +87,7 @@
 //   bool gpr_global_config_get_test();
 //   void gpr_global_config_set_test(bool value);
 
-#include "src/core/lib/gprpp/global_config_custom.h"
-#include "src/core/lib/gprpp/global_config_env.h"
+#include "src/core/lib/gprpp/global_config_custom.h"  // IWYU pragma: export
+#include "src/core/lib/gprpp/global_config_env.h"     // IWYU pragma: export
 
 #endif /* GRPC_CORE_LIB_GPRPP_GLOBAL_CONFIG_H */

data/src/core/lib/gprpp/global_config_env.cc

@@ -21,13 +21,14 @@
 #include "src/core/lib/gprpp/global_config_env.h"
 
 #include <ctype.h>
-#include <string.h>
+#include <stdlib.h>
 
+#include <memory>
 #include <string>
+#include <type_traits>
 
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 

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

@@ -21,7 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/global_config_generic.h"
+#include <stdint.h>
+
+#include "src/core/lib/gprpp/global_config_generic.h"  // IWYU pragma: export
 #include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {

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

@@ -21,10 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
-#include "src/core/lib/gprpp/memory.h"
-
 #define GPR_GLOBAL_CONFIG_GET(name) gpr_global_config_get_##name()
 
 #define GPR_GLOBAL_CONFIG_SET(name, value) gpr_global_config_set_##name(value)

data/src/core/lib/gprpp/host_port.cc

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/gprpp/host_port.h"
 
+#include <stddef.h>
+
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 

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

@@ -24,7 +24,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
-#include <stdlib.h>
 
 #include <new>
 #include <type_traits>

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

@@ -0,0 +1,75 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_GPRPP_MATCH_H
+#define GRPC_CORE_LIB_GPRPP_MATCH_H
+
+#include <grpc/support/port_platform.h>
+
+#include <type_traits>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/gprpp/overload.h"
+
+namespace grpc_core {
+
+namespace detail {
+
+template <typename... Cases>
+struct MatchPointerExtractor {
+  OverloadType<Cases...> cases;
+  template <typename T>
+  auto operator()(T& value) -> decltype(cases(&value)) {
+    return cases(&value);
+  }
+};
+
+}  // namespace detail
+
+/// Match on a variant.
+/// Given variant \a value, and a set of callables \a fs, call the appropriate
+/// callable based on the type contained in \a value.
+///
+/// Example (prints "hoorah"):
+///   variant<int, string> v = 42;
+///   Match(v,
+///         [](int i) { puts("hoorah"); },
+///         [](string s) { puts("boo"); });
+template <typename... Fs, typename T0, typename... Ts>
+auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
+    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0>())) {
+  return absl::visit(Overload(std::move(fs)...), value);
+}
+
+/// A version of Match that takes a mutable pointer to a variant and calls its
+/// overload callables with a mutable pointer to the current variant value.
+///
+/// Example:
+///   variant<int, string> v = 42;
+///   MatchMutable(&v,
+///                [](int* i) { *i = 1; },
+///                [](string* s) { *s = "foo"; });
+///   // v now contains 1.
+template <typename... Fs, typename T0, typename... Ts>
+auto MatchMutable(absl::variant<T0, Ts...>* value, Fs... fs)
+    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0*>())) {
+  return absl::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
+                         std::move(fs)...)},
+                     *value);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_MATCH_H

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

@@ -21,14 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <limits>
 #include <memory>
-#include <utility>
-
-#include "absl/memory/memory.h"
+#include <type_traits>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 namespace grpc_core {
 

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

@@ -23,12 +23,9 @@
 
 #include <cinttypes>
 #include <memory>
-
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
+#include <utility>
 
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"