mirror of https://github.com/grpc/grpc.git
A starter slice buffer implementation to unblock event engine endpoints (#29367)
* A starter SliceBuffer implementation * Add comments and fix sanity checks * Minor fixes * more minor fixes * Addressing review comments and adding a slice_buffer_test * fix sanity checks * regenerate projects * fixing undefined function error * reverting changes from memory_allocator.cc and adding them to src/core/lib/slice/slice_buffer.cc to allow memory allocator lib to build correctly * fix sanity checks * adding an open source slice definition * regnerate projects * fix asan error * Automated change: Fix sanity tests * addressing review comments * fix sanity checks * regenerate projects * update * fix sanity checks * Converting slice buffer to retarin ownership of the underlying ctype * fix nits Co-authored-by: Vignesh2208 <Vignesh2208@users.noreply.github.com>pull/29647/head
Vignesh Babu
3 years ago
committed by
GitHub
parent
4ab3103293
commit
1494b1ef26
26 changed files with 841 additions and 77 deletions
@ -0,0 +1,286 @@ |
|||||||
|
// 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.
|
||||||
|
|
||||||
|
#ifndef GRPC_EVENT_ENGINE_SLICE_H |
||||||
|
#define GRPC_EVENT_ENGINE_SLICE_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include <cstdint> |
||||||
|
#include <string> |
||||||
|
#include <utility> |
||||||
|
|
||||||
|
#include "absl/strings/string_view.h" |
||||||
|
|
||||||
|
#include <grpc/slice.h> |
||||||
|
#include <grpc/support/log.h> |
||||||
|
|
||||||
|
// This public slice definition largely based of the internal grpc_core::Slice
|
||||||
|
// implementation. Changes to this implementation might warrant changes to the
|
||||||
|
// internal grpc_core::Slice type as well.
|
||||||
|
|
||||||
|
namespace grpc_event_engine { |
||||||
|
namespace experimental { |
||||||
|
|
||||||
|
// Forward declarations
|
||||||
|
class Slice; |
||||||
|
class MutableSlice; |
||||||
|
|
||||||
|
namespace slice_detail { |
||||||
|
|
||||||
|
// Returns an empty slice.
|
||||||
|
static constexpr grpc_slice EmptySlice() { return {nullptr, {}}; } |
||||||
|
|
||||||
|
// BaseSlice holds the grpc_slice object, but does not apply refcounting policy.
|
||||||
|
// It does export immutable access into the slice, such that this can be shared
|
||||||
|
// by all storage policies.
|
||||||
|
class BaseSlice { |
||||||
|
public: |
||||||
|
BaseSlice(const BaseSlice&) = delete; |
||||||
|
BaseSlice& operator=(const BaseSlice&) = delete; |
||||||
|
BaseSlice(BaseSlice&& other) = delete; |
||||||
|
BaseSlice& operator=(BaseSlice&& other) = delete; |
||||||
|
|
||||||
|
// Iterator access to the underlying bytes
|
||||||
|
const uint8_t* begin() const { return GRPC_SLICE_START_PTR(c_slice()); } |
||||||
|
const uint8_t* end() const { return GRPC_SLICE_END_PTR(c_slice()); } |
||||||
|
const uint8_t* cbegin() const { return GRPC_SLICE_START_PTR(c_slice()); } |
||||||
|
const uint8_t* cend() const { return GRPC_SLICE_END_PTR(c_slice()); } |
||||||
|
|
||||||
|
// Retrieve a borrowed reference to the underlying grpc_slice.
|
||||||
|
const grpc_slice& c_slice() const { return slice_; } |
||||||
|
|
||||||
|
// Retrieve the underlying grpc_slice, and replace the one in this object with
|
||||||
|
// EmptySlice().
|
||||||
|
grpc_slice TakeCSlice() { |
||||||
|
grpc_slice out = slice_; |
||||||
|
slice_ = EmptySlice(); |
||||||
|
return out; |
||||||
|
} |
||||||
|
|
||||||
|
// As other things... borrowed references.
|
||||||
|
absl::string_view as_string_view() const { |
||||||
|
return absl::string_view(reinterpret_cast<const char*>(data()), size()); |
||||||
|
} |
||||||
|
|
||||||
|
// Array access
|
||||||
|
uint8_t operator[](size_t i) const { |
||||||
|
return GRPC_SLICE_START_PTR(c_slice())[i]; |
||||||
|
} |
||||||
|
|
||||||
|
// Access underlying data
|
||||||
|
const uint8_t* data() const { return GRPC_SLICE_START_PTR(c_slice()); } |
||||||
|
|
||||||
|
// Size of the slice
|
||||||
|
size_t size() const { return GRPC_SLICE_LENGTH(c_slice()); } |
||||||
|
size_t length() const { return size(); } |
||||||
|
bool empty() const { return size() == 0; } |
||||||
|
|
||||||
|
// For inlined slices - are these two slices equal?
|
||||||
|
// For non-inlined slices - do these two slices refer to the same block of
|
||||||
|
// memory?
|
||||||
|
bool is_equivalent(const BaseSlice& other) const { |
||||||
|
return grpc_slice_is_equivalent(slice_, other.slice_); |
||||||
|
} |
||||||
|
|
||||||
|
uint32_t Hash() const; |
||||||
|
|
||||||
|
protected: |
||||||
|
BaseSlice() : slice_(EmptySlice()) {} |
||||||
|
explicit BaseSlice(const grpc_slice& slice) : slice_(slice) {} |
||||||
|
~BaseSlice() = default; |
||||||
|
|
||||||
|
void Swap(BaseSlice* other) { std::swap(slice_, other->slice_); } |
||||||
|
void SetCSlice(const grpc_slice& slice) { slice_ = slice; } |
||||||
|
|
||||||
|
uint8_t* mutable_data() { return GRPC_SLICE_START_PTR(slice_); } |
||||||
|
|
||||||
|
grpc_slice* c_slice_ptr() { return &slice_; } |
||||||
|
|
||||||
|
private: |
||||||
|
grpc_slice slice_; |
||||||
|
}; |
||||||
|
|
||||||
|
inline bool operator==(const BaseSlice& a, const BaseSlice& b) { |
||||||
|
return grpc_slice_eq(a.c_slice(), b.c_slice()) != 0; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator!=(const BaseSlice& a, const BaseSlice& b) { |
||||||
|
return grpc_slice_eq(a.c_slice(), b.c_slice()) == 0; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator==(const BaseSlice& a, absl::string_view b) { |
||||||
|
return a.as_string_view() == b; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator!=(const BaseSlice& a, absl::string_view b) { |
||||||
|
return a.as_string_view() != b; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator==(absl::string_view a, const BaseSlice& b) { |
||||||
|
return a == b.as_string_view(); |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator!=(absl::string_view a, const BaseSlice& b) { |
||||||
|
return a != b.as_string_view(); |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator==(const BaseSlice& a, const grpc_slice& b) { |
||||||
|
return grpc_slice_eq(a.c_slice(), b) != 0; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator!=(const BaseSlice& a, const grpc_slice& b) { |
||||||
|
return grpc_slice_eq(a.c_slice(), b) == 0; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator==(const grpc_slice& a, const BaseSlice& b) { |
||||||
|
return grpc_slice_eq(a, b.c_slice()) != 0; |
||||||
|
} |
||||||
|
|
||||||
|
inline bool operator!=(const grpc_slice& a, const BaseSlice& b) { |
||||||
|
return grpc_slice_eq(a, b.c_slice()) == 0; |
||||||
|
} |
||||||
|
|
||||||
|
template <typename Out> |
||||||
|
struct CopyConstructors { |
||||||
|
static Out FromCopiedString(const char* s) { |
||||||
|
return FromCopiedBuffer(s, strlen(s)); |
||||||
|
} |
||||||
|
static Out FromCopiedString(absl::string_view s) { |
||||||
|
return FromCopiedBuffer(s.data(), s.size()); |
||||||
|
} |
||||||
|
static Out FromCopiedString(std::string s); |
||||||
|
|
||||||
|
static Out FromCopiedBuffer(const char* p, size_t len) { |
||||||
|
return Out(grpc_slice_from_copied_buffer(p, len)); |
||||||
|
} |
||||||
|
|
||||||
|
template <typename Buffer> |
||||||
|
static Out FromCopiedBuffer(const Buffer& buffer) { |
||||||
|
return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()), |
||||||
|
buffer.size()); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace slice_detail
|
||||||
|
|
||||||
|
class MutableSlice : public slice_detail::BaseSlice, |
||||||
|
public slice_detail::CopyConstructors<MutableSlice> { |
||||||
|
public: |
||||||
|
MutableSlice() = default; |
||||||
|
explicit MutableSlice(const grpc_slice& slice); |
||||||
|
~MutableSlice(); |
||||||
|
|
||||||
|
MutableSlice(const MutableSlice&) = delete; |
||||||
|
MutableSlice& operator=(const MutableSlice&) = delete; |
||||||
|
MutableSlice(MutableSlice&& other) noexcept |
||||||
|
: slice_detail::BaseSlice(other.TakeCSlice()) {} |
||||||
|
MutableSlice& operator=(MutableSlice&& other) noexcept { |
||||||
|
Swap(&other); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
static MutableSlice CreateUninitialized(size_t length) { |
||||||
|
return MutableSlice(grpc_slice_malloc(length)); |
||||||
|
} |
||||||
|
|
||||||
|
// Return a sub slice of this one. Leaves this slice in an indeterminate but
|
||||||
|
// valid state.
|
||||||
|
MutableSlice TakeSubSlice(size_t pos, size_t n) { |
||||||
|
return MutableSlice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n)); |
||||||
|
} |
||||||
|
|
||||||
|
// Iterator access to the underlying bytes
|
||||||
|
uint8_t* begin() { return mutable_data(); } |
||||||
|
uint8_t* end() { return mutable_data() + size(); } |
||||||
|
uint8_t* data() { return mutable_data(); } |
||||||
|
|
||||||
|
// Array access
|
||||||
|
uint8_t& operator[](size_t i) { return mutable_data()[i]; } |
||||||
|
}; |
||||||
|
|
||||||
|
class Slice : public slice_detail::BaseSlice, |
||||||
|
public slice_detail::CopyConstructors<Slice> { |
||||||
|
public: |
||||||
|
Slice() = default; |
||||||
|
~Slice(); |
||||||
|
explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {} |
||||||
|
explicit Slice(slice_detail::BaseSlice&& other) |
||||||
|
: slice_detail::BaseSlice(other.TakeCSlice()) {} |
||||||
|
|
||||||
|
Slice(const Slice&) = delete; |
||||||
|
Slice& operator=(const Slice&) = delete; |
||||||
|
Slice(Slice&& other) noexcept : slice_detail::BaseSlice(other.TakeCSlice()) {} |
||||||
|
Slice& operator=(Slice&& other) noexcept { |
||||||
|
Swap(&other); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
// A slice might refer to some memory that we keep a refcount to (this is
|
||||||
|
// owned), or some memory that's inlined into the slice (also owned), or some
|
||||||
|
// other block of memory that we know will be available for the lifetime of
|
||||||
|
// some operation in the common case (not owned). In the *less common* case
|
||||||
|
// that we need to keep that slice text for longer than our API's guarantee us
|
||||||
|
// access, we need to take a copy and turn this into something that we do own.
|
||||||
|
|
||||||
|
// TakeOwned returns an owned slice regardless of current ownership, and
|
||||||
|
// leaves the current slice in a valid but externally unpredictable state - in
|
||||||
|
// doing so it can avoid adding a ref to the underlying slice.
|
||||||
|
Slice TakeOwned(); |
||||||
|
|
||||||
|
// AsOwned returns an owned slice but does not mutate the current slice,
|
||||||
|
// meaning that it may add a reference to the underlying slice.
|
||||||
|
Slice AsOwned() const; |
||||||
|
|
||||||
|
// TakeMutable returns a MutableSlice, and leaves the current slice in an
|
||||||
|
// indeterminate but valid state.
|
||||||
|
// A mutable slice requires only one reference to the bytes of the slice -
|
||||||
|
// this can be achieved either with inlined storage or with a single
|
||||||
|
// reference.
|
||||||
|
// If the current slice is refcounted and there are more than one references
|
||||||
|
// to that slice, then the slice is copied in order to achieve a mutable
|
||||||
|
// version.
|
||||||
|
MutableSlice TakeMutable(); |
||||||
|
|
||||||
|
// Return a sub slice of this one. Leaves this slice in an indeterminate but
|
||||||
|
// valid state.
|
||||||
|
Slice TakeSubSlice(size_t pos, size_t n) { |
||||||
|
return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n)); |
||||||
|
} |
||||||
|
|
||||||
|
// Return a sub slice of this one. Adds a reference to the underlying slice.
|
||||||
|
Slice RefSubSlice(size_t pos, size_t n) const { |
||||||
|
return Slice(grpc_slice_sub(c_slice(), pos, pos + n)); |
||||||
|
} |
||||||
|
|
||||||
|
// Split this slice, returning a new slice containing (split:end] and
|
||||||
|
// leaving this slice with [begin:split).
|
||||||
|
Slice Split(size_t split) { |
||||||
|
return Slice(grpc_slice_split_tail(c_slice_ptr(), split)); |
||||||
|
} |
||||||
|
|
||||||
|
Slice Ref() const; |
||||||
|
|
||||||
|
Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); } |
||||||
|
|
||||||
|
static Slice FromRefcountAndBytes(grpc_slice_refcount* r, |
||||||
|
const uint8_t* begin, const uint8_t* end); |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace experimental
|
||||||
|
} // namespace grpc_event_engine
|
||||||
|
|
||||||
|
#endif // GRPC_EVENT_ENGINE_SLICE_H
|
||||||
@ -0,0 +1,112 @@ |
|||||||
|
// 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.
|
||||||
|
|
||||||
|
#ifndef GRPC_EVENT_ENGINE_SLICE_BUFFER_H |
||||||
|
#define GRPC_EVENT_ENGINE_SLICE_BUFFER_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include <cstdint> |
||||||
|
#include <string> |
||||||
|
|
||||||
|
#include "absl/strings/string_view.h" |
||||||
|
#include "absl/utility/utility.h" |
||||||
|
|
||||||
|
#include <grpc/event_engine/slice.h> |
||||||
|
#include <grpc/slice.h> |
||||||
|
#include <grpc/slice_buffer.h> |
||||||
|
#include <grpc/support/log.h> |
||||||
|
|
||||||
|
namespace grpc_event_engine { |
||||||
|
namespace experimental { |
||||||
|
|
||||||
|
/// A Wrapper around \a grpc_slice_buffer pointer.
|
||||||
|
///
|
||||||
|
/// A slice buffer holds the memory for a collection of slices.
|
||||||
|
/// The SliceBuffer object itself is meant to only hide the C-style API,
|
||||||
|
/// and won't hold the data itself. In terms of lifespan, the
|
||||||
|
/// grpc_slice_buffer ought to be kept somewhere inside the caller's objects,
|
||||||
|
/// like a transport or an endpoint.
|
||||||
|
///
|
||||||
|
/// This lifespan rule is likely to change in the future, as we may
|
||||||
|
/// collapse the grpc_slice_buffer structure straight into this class.
|
||||||
|
///
|
||||||
|
/// The SliceBuffer API is basically a replica of the grpc_slice_buffer's,
|
||||||
|
/// and its documentation will move here once we remove the C structure,
|
||||||
|
/// which should happen before the Event Engine's API is no longer
|
||||||
|
/// an experimental API.
|
||||||
|
class SliceBuffer { |
||||||
|
public: |
||||||
|
explicit SliceBuffer() { grpc_slice_buffer_init(&slice_buffer_); } |
||||||
|
SliceBuffer(const SliceBuffer& other) = delete; |
||||||
|
SliceBuffer(SliceBuffer&& other) noexcept |
||||||
|
: slice_buffer_(other.slice_buffer_) { |
||||||
|
grpc_slice_buffer_reset_and_unref(&slice_buffer_); |
||||||
|
grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_); |
||||||
|
} |
||||||
|
/// Upon destruction, the underlying raw slice buffer is cleaned out and all
|
||||||
|
/// slices are unreffed.
|
||||||
|
~SliceBuffer() { grpc_slice_buffer_destroy(&slice_buffer_); } |
||||||
|
|
||||||
|
/// Appends a new slice into the SliceBuffer and makes an attempt to merge
|
||||||
|
/// this slice with the last slice in the SliceBuffer.
|
||||||
|
void Append(Slice slice); |
||||||
|
|
||||||
|
/// Adds a new slice into the SliceBuffer at the next available index.
|
||||||
|
/// Returns the index at which the new slice is added.
|
||||||
|
size_t AppendIndexed(Slice slice); |
||||||
|
|
||||||
|
/// Returns the number of slices held by the SliceBuffer.
|
||||||
|
size_t Count() { return slice_buffer_.count; } |
||||||
|
|
||||||
|
/// Removes/deletes the last n bytes in the SliceBuffer.
|
||||||
|
void RemoveLastNBytes(size_t n) { |
||||||
|
grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr); |
||||||
|
} |
||||||
|
|
||||||
|
/// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
|
||||||
|
void MoveFirstNBytesIntoBuffer(size_t n, void* dst) { |
||||||
|
grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst); |
||||||
|
} |
||||||
|
|
||||||
|
/// Removes and unrefs all slices in the SliceBuffer.
|
||||||
|
void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); } |
||||||
|
|
||||||
|
/// Removes the first slice in the SliceBuffer and returns it.
|
||||||
|
Slice TakeFirst(); |
||||||
|
|
||||||
|
/// Prepends the slice to the the front of the SliceBuffer.
|
||||||
|
void Prepend(Slice slice); |
||||||
|
|
||||||
|
/// Increased the ref-count of slice at the specified index and returns the
|
||||||
|
/// associated slice.
|
||||||
|
Slice RefSlice(size_t index); |
||||||
|
|
||||||
|
/// The total number of bytes held by the SliceBuffer
|
||||||
|
size_t Length() { return slice_buffer_.length; } |
||||||
|
|
||||||
|
/// Return a pointer to the back raw grpc_slice_buffer
|
||||||
|
grpc_slice_buffer* RawSliceBuffer() { return &slice_buffer_; } |
||||||
|
|
||||||
|
private: |
||||||
|
/// The backing raw slice buffer.
|
||||||
|
grpc_slice_buffer slice_buffer_; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace experimental
|
||||||
|
} // namespace grpc_event_engine
|
||||||
|
|
||||||
|
#endif // GRPC_EVENT_ENGINE_SLICE_BUFFER_H
|
||||||
@ -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 <stddef.h> |
||||||
|
#include <stdint.h> |
||||||
|
|
||||||
|
#include <string> |
||||||
|
#include <utility> |
||||||
|
|
||||||
|
#include <grpc/event_engine/slice.h> |
||||||
|
#include <grpc/slice.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
|
||||||
@ -0,0 +1,49 @@ |
|||||||
|
// 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 <grpc/event_engine/slice_buffer.h> |
||||||
|
#include <grpc/slice.h> |
||||||
|
#include <grpc/slice_buffer.h> |
||||||
|
|
||||||
|
#include "src/core/lib/slice/slice.h" |
||||||
|
#include "src/core/lib/slice/slice_internal.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
|
||||||
@ -0,0 +1,79 @@ |
|||||||
|
// 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.
|
||||||
|
// 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 <gmock/gmock.h> |
||||||
|
#include <gtest/gtest.h> |
||||||
|
|
||||||
|
#include <grpc/event_engine/slice_buffer.h> |
||||||
|
#include <grpc/grpc.h> |
||||||
|
|
||||||
|
#include "src/core/lib/slice/slice.h" |
||||||
|
#include "test/core/util/test_config.h" |
||||||
|
|
||||||
|
using ::grpc_event_engine::experimental::Slice; |
||||||
|
using ::grpc_event_engine::experimental::SliceBuffer; |
||||||
|
|
||||||
|
static constexpr int kNewSliceLength = 100; |
||||||
|
|
||||||
|
Slice MakeSlice(size_t len) { |
||||||
|
GPR_ASSERT(len > 0); |
||||||
|
unsigned char* contents = reinterpret_cast<unsigned char*>(new char[len]); |
||||||
|
memset(contents, 'a', len); |
||||||
|
return Slice(grpc_slice_new(contents, len, gpr_free)); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(SliceBufferTest, AddAndRemoveTest) { |
||||||
|
SliceBuffer sb; |
||||||
|
Slice first_slice = MakeSlice(kNewSliceLength); |
||||||
|
Slice second_slice = MakeSlice(kNewSliceLength); |
||||||
|
Slice first_slice_copy = first_slice.Copy(); |
||||||
|
sb.Append(std::move(first_slice)); |
||||||
|
sb.Append(std::move(second_slice)); |
||||||
|
ASSERT_EQ(sb.Count(), 2); |
||||||
|
ASSERT_EQ(sb.Length(), 2 * kNewSliceLength); |
||||||
|
Slice popped = sb.TakeFirst(); |
||||||
|
ASSERT_EQ(popped, first_slice_copy); |
||||||
|
ASSERT_EQ(sb.Count(), 1); |
||||||
|
ASSERT_EQ(sb.Length(), kNewSliceLength); |
||||||
|
sb.Prepend(std::move(popped)); |
||||||
|
ASSERT_EQ(sb.Count(), 2); |
||||||
|
ASSERT_EQ(sb.Length(), 2 * kNewSliceLength); |
||||||
|
sb.Clear(); |
||||||
|
ASSERT_EQ(sb.Count(), 0); |
||||||
|
ASSERT_EQ(sb.Length(), 0); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(SliceBufferTest, SliceRefTest) { |
||||||
|
SliceBuffer sb; |
||||||
|
Slice first_slice = MakeSlice(kNewSliceLength); |
||||||
|
Slice second_slice = MakeSlice(kNewSliceLength + 1); |
||||||
|
Slice first_slice_copy = first_slice.Copy(); |
||||||
|
Slice second_slice_copy = second_slice.Copy(); |
||||||
|
ASSERT_EQ(sb.AppendIndexed(std::move(first_slice)), 0); |
||||||
|
ASSERT_EQ(sb.AppendIndexed(std::move(second_slice)), 1); |
||||||
|
Slice first_reffed = sb.RefSlice(0); |
||||||
|
Slice second_reffed = sb.RefSlice(1); |
||||||
|
ASSERT_EQ(first_reffed, first_slice_copy); |
||||||
|
ASSERT_EQ(second_reffed, second_slice_copy); |
||||||
|
ASSERT_EQ(sb.Count(), 2); |
||||||
|
ASSERT_EQ(sb.Length(), 2 * kNewSliceLength + 1); |
||||||
|
sb.Clear(); |
||||||
|
} |
||||||
|
|
||||||
|
int main(int argc, char** argv) { |
||||||
|
testing::InitGoogleTest(&argc, argv); |
||||||
|
return RUN_ALL_TESTS(); |
||||||
|
} |
||||||
Loading…
Reference in new issue