grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -31,7 +31,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_core {
 
@@ -52,7 +51,7 @@ void SliceBuffer::Prepend(Slice slice) {
 }
 
 Slice SliceBuffer::RefSlice(size_t index) const {
-  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+  return Slice(CSliceRef(slice_buffer_.slices[index]));
 }
 
 std::string SliceBuffer::JoinIntoString() const {
@@ -120,12 +119,12 @@ void grpc_slice_buffer_init(grpc_slice_buffer* sb) {
   sb->base_slices = sb->slices = sb->inlined;
 }
 
-void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb) {
-  grpc_slice_buffer_reset_and_unref_internal(sb);
+void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
+  grpc_slice_buffer_reset_and_unref(sb);
   if (sb->base_slices != sb->inlined) {
     gpr_free(sb->base_slices);
     // As a precaution, set sb->base_slices to equal sb->inlined
-    // to prevent a double free attempt if grpc_slice_buffer_destroy_internal
+    // to prevent a double free attempt if grpc_slice_buffer_destroy
     // is invoked two times on the same slice buffer.
     sb->base_slices = sb->slices = sb->inlined;
   }
@@ -181,7 +180,7 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
     back->data.refcounted.length += GRPC_SLICE_LENGTH(s);
     sb->length += GRPC_SLICE_LENGTH(s);
     // Unref the merged slice.
-    grpc_slice_unref_internal(s);
+    grpc_core::CSliceUnref(s);
     // early out
     return;
   }
@@ -235,10 +234,10 @@ void grpc_slice_buffer_pop(grpc_slice_buffer* sb) {
   }
 }
 
-void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb) {
+void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
   size_t i;
   for (i = 0; i < sb->count; i++) {
-    grpc_slice_unref_internal(sb->slices[i]);
+    grpc_core::CSliceUnref(sb->slices[i]);
   }
 
   sb->count = 0;
@@ -370,13 +369,13 @@ void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
       n = 0;
     } else if (slice_len == n) {
       memcpy(dstp, GRPC_SLICE_START_PTR(slice), n);
-      grpc_slice_unref_internal(slice);
+      grpc_core::CSliceUnref(slice);
       n = 0;
     } else {
       memcpy(dstp, GRPC_SLICE_START_PTR(slice), slice_len);
       dstp += slice_len;
       n -= slice_len;
-      grpc_slice_unref_internal(slice);
+      grpc_core::CSliceUnref(slice);
     }
   }
 }
@@ -412,14 +411,14 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       return;
     } else if (slice_len == n) {
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       sb->count = idx;
       return;
@@ -427,7 +426,7 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       n -= slice_len;
       sb->count = idx;
@@ -449,7 +448,7 @@ grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb) {
 void grpc_slice_buffer_remove_first(grpc_slice_buffer* sb) {
   GPR_DEBUG_ASSERT(sb->count > 0);
   sb->length -= GRPC_SLICE_LENGTH(sb->slices[0]);
-  grpc_slice_unref_internal(sb->slices[0]);
+  grpc_core::CSliceUnref(sb->slices[0]);
   sb->slices++;
   if (--sb->count == 0) {
     sb->slices = sb->base_slices;

data/src/core/lib/slice/slice_internal.h

@@ -26,19 +26,13 @@
 #include <cstddef>
 #include <string>
 
+#include "absl/hash/hash.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/slice/slice_refcount.h"
-
-void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb);
-void grpc_slice_buffer_partial_unref_internal(grpc_slice_buffer* sb,
-                                              size_t idx);
-void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb);
 
 // Returns a pointer to the first slice in the slice buffer without giving
 // ownership to or a reference count on that slice.
@@ -54,7 +48,6 @@ void grpc_slice_buffer_remove_first(grpc_slice_buffer* sb);
 void grpc_slice_buffer_sub_first(grpc_slice_buffer* sb, size_t begin,
                                  size_t end);
 
-void grpc_test_only_set_slice_hash_seed(uint32_t seed);
 // if slice matches a static slice, returns the static slice
 // otherwise returns the passed in slice (without reffing it)
 // used for surface boundaries where we might receive an un-interned static
@@ -64,11 +57,6 @@ grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
 uint32_t grpc_static_slice_hash(grpc_slice s);
 int grpc_static_slice_eq(grpc_slice a, grpc_slice b);
 
-inline uint32_t grpc_slice_hash_internal(const grpc_slice& s) {
-  return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
-                          grpc_core::g_hash_seed);
-}
-
 grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
                                         size_t len);
 grpc_slice grpc_slice_from_moved_string(grpc_core::UniquePtr<char> p);
@@ -81,14 +69,6 @@ size_t grpc_slice_memory_usage(grpc_slice s);
 
 namespace grpc_core {
 
-struct SliceHash {
-  std::size_t operator()(const grpc_slice& slice) const {
-    return grpc_slice_hash_internal(slice);
-  }
-};
-
-extern uint32_t g_hash_seed;
-
 // Converts grpc_slice to absl::string_view.
 inline absl::string_view StringViewFromSlice(const grpc_slice& slice) {
   return absl::string_view(
@@ -98,6 +78,18 @@ inline absl::string_view StringViewFromSlice(const grpc_slice& slice) {
 
 }  // namespace grpc_core
 
+inline uint32_t grpc_slice_hash(const grpc_slice& s) {
+  return absl::HashOf(grpc_core::StringViewFromSlice(s));
+}
+
+namespace grpc_core {
+struct SliceHash {
+  std::size_t operator()(const grpc_slice& slice) const {
+    return grpc_slice_hash(slice);
+  }
+};
+}  // namespace grpc_core
+
 inline bool operator==(const grpc_slice& s1, const grpc_slice& s2) {
   return grpc_slice_eq(s1, s2);
 }

data/src/core/lib/slice/slice_refcount.h

@@ -17,29 +17,44 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <stddef.h>
 
-#include <grpc/slice.h>
+#include <atomic>
 
-#include "src/core/lib/slice/slice_refcount_base.h"
+// grpc_slice_refcount : A reference count for grpc_slice.
+struct grpc_slice_refcount {
+ public:
+  typedef void (*DestroyerFn)(grpc_slice_refcount*);
 
-namespace grpc_core {
-
-extern uint32_t g_hash_seed;
-
-}  // namespace grpc_core
-
-inline const grpc_slice& grpc_slice_ref_internal(const grpc_slice& slice) {
-  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
-    slice.refcount->Ref();
+  static grpc_slice_refcount* NoopRefcount() {
+    return reinterpret_cast<grpc_slice_refcount*>(1);
   }
-  return slice;
-}
 
-inline void grpc_slice_unref_internal(const grpc_slice& slice) {
-  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
-    slice.refcount->Unref();
+  grpc_slice_refcount() = default;
+
+  // Regular constructor for grpc_slice_refcount.
+  //
+  // Parameters:
+  //  1. DestroyerFn destroyer_fn
+  //  Called when the refcount goes to 0, with 'this' as parameter.
+  explicit grpc_slice_refcount(DestroyerFn destroyer_fn)
+      : destroyer_fn_(destroyer_fn) {}
+
+  void Ref() { ref_.fetch_add(1, std::memory_order_relaxed); }
+  void Unref() {
+    if (ref_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      destroyer_fn_(this);
+    }
   }
-}
 
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_REFCOUNT_H */
+  // Is this the only instance?
+  // For this to be useful the caller needs to ensure that if this is the only
+  // instance, no other instance could be created during this call.
+  bool IsUnique() const { return ref_.load(std::memory_order_relaxed) == 1; }
+
+ private:
+  std::atomic<size_t> ref_{1};
+  DestroyerFn destroyer_fn_ = nullptr;
+};
+
+#endif  // GRPC_CORE_LIB_SLICE_SLICE_REFCOUNT_H

data/src/core/lib/surface/byte_buffer.cc

@@ -28,8 +28,7 @@
 #include <grpc/support/alloc.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice.h"
 
 grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices,
                                               size_t nslices) {
@@ -47,7 +46,7 @@ grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
   bb->data.raw.compression = compression;
   grpc_slice_buffer_init(&bb->data.raw.slice_buffer);
   for (i = 0; i < nslices; i++) {
-    grpc_slice_ref_internal(slices[i]);
+    grpc_core::CSliceRef(slices[i]);
     grpc_slice_buffer_add(&bb->data.raw.slice_buffer, slices[i]);
   }
   return bb;
@@ -83,7 +82,7 @@ void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) {
   grpc_core::ExecCtx exec_ctx;
   switch (bb->type) {
     case GRPC_BB_RAW:
-      grpc_slice_buffer_destroy_internal(&bb->data.raw.slice_buffer);
+      grpc_slice_buffer_destroy(&bb->data.raw.slice_buffer);
       break;
   }
   gpr_free(bb);

data/src/core/lib/surface/byte_buffer_reader.cc

@@ -28,7 +28,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice.h"
 
 int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
                                  grpc_byte_buffer* buffer) {
@@ -70,8 +70,8 @@ int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
       grpc_slice_buffer* slice_buffer;
       slice_buffer = &reader->buffer_out->data.raw.slice_buffer;
       if (reader->current.index < slice_buffer->count) {
-        *slice = grpc_slice_ref_internal(
-            slice_buffer->slices[reader->current.index]);
+        *slice =
+            grpc_core::CSliceRef(slice_buffer->slices[reader->current.index]);
         reader->current.index += 1;
         return 1;
       }
@@ -93,7 +93,7 @@ grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader) {
     const size_t slice_length = GRPC_SLICE_LENGTH(in_slice);
     memcpy(&(outbuf[bytes_read]), GRPC_SLICE_START_PTR(in_slice), slice_length);
     bytes_read += slice_length;
-    grpc_slice_unref_internal(in_slice);
+    grpc_core::CSliceUnref(in_slice);
     GPR_ASSERT(bytes_read <= input_size);
   }