mirror of https://github.com/grpc/grpc.git
Integrate new resource quota, event engine (#27522)
* Integrate new resource quota, event engine * Automated change: Fix sanity tests * windows fix * Automated change: Fix sanity tests * Update memory_allocator.h * Automated change: Fix sanity tests * first round review feedback * review feedback * Automated change: Fix sanity tests * Update memory_quota.h * get re-export formatted right * Automated change: Fix sanity tests * Update memory_allocator.cc * Automated change: Fix sanity tests * MemoryOwner has-a MemoryAllocator * using fix * review feedback * Automated change: Fix sanity tests Co-authored-by: ctiller <ctiller@users.noreply.github.com>pull/27643/head
Craig Tiller
3 years ago
committed by
GitHub
parent
3d83dd3776
commit
79ef60f079
30 changed files with 737 additions and 649 deletions
@ -0,0 +1,98 @@ |
|||||||
|
// Copyright 2021 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.
|
||||||
|
#ifndef GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H |
||||||
|
#define GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H |
||||||
|
|
||||||
|
#include <grpc/impl/codegen/port_platform.h> |
||||||
|
|
||||||
|
#include <algorithm> |
||||||
|
#include <memory> |
||||||
|
#include <type_traits> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
#include <grpc/slice.h> |
||||||
|
|
||||||
|
// forward-declaring an internal struct, not used publicly.
|
||||||
|
struct grpc_slice_buffer; |
||||||
|
|
||||||
|
namespace grpc_event_engine { |
||||||
|
namespace experimental { |
||||||
|
|
||||||
|
/// Reservation request - how much memory do we want to allocate?
|
||||||
|
class MemoryRequest { |
||||||
|
public: |
||||||
|
/// Request a fixed amount of memory.
|
||||||
|
// NOLINTNEXTLINE(google-explicit-constructor)
|
||||||
|
MemoryRequest(size_t n) : min_(n), max_(n) {} |
||||||
|
/// Request a range of memory.
|
||||||
|
/// Requires: \a min <= \a max.
|
||||||
|
/// Requires: \a max <= max_size()
|
||||||
|
MemoryRequest(size_t min, size_t max) : min_(min), max_(max) {} |
||||||
|
|
||||||
|
/// Maximum allowable request size - hard coded to 1GB.
|
||||||
|
static constexpr size_t max_allowed_size() { return 1024 * 1024 * 1024; } |
||||||
|
|
||||||
|
/// Increase the size by \a amount.
|
||||||
|
/// Undefined behavior if min() + amount or max() + amount overflows.
|
||||||
|
MemoryRequest Increase(size_t amount) const { |
||||||
|
return MemoryRequest(min_ + amount, max_ + amount); |
||||||
|
} |
||||||
|
|
||||||
|
size_t min() const { return min_; } |
||||||
|
size_t max() const { return max_; } |
||||||
|
|
||||||
|
private: |
||||||
|
size_t min_; |
||||||
|
size_t max_; |
||||||
|
}; |
||||||
|
|
||||||
|
namespace internal { |
||||||
|
|
||||||
|
/// Underlying memory allocation interface.
|
||||||
|
/// This is an internal interface, not intended to be used by users.
|
||||||
|
/// Its interface is subject to change at any time.
|
||||||
|
class MemoryAllocatorImpl |
||||||
|
: public std::enable_shared_from_this<MemoryAllocatorImpl> { |
||||||
|
public: |
||||||
|
MemoryAllocatorImpl() {} |
||||||
|
virtual ~MemoryAllocatorImpl() {} |
||||||
|
|
||||||
|
MemoryAllocatorImpl(const MemoryAllocatorImpl&) = delete; |
||||||
|
MemoryAllocatorImpl& operator=(const MemoryAllocatorImpl&) = delete; |
||||||
|
|
||||||
|
/// Reserve bytes from the quota.
|
||||||
|
/// If we enter overcommit, reclamation will begin concurrently.
|
||||||
|
/// Returns the number of bytes reserved.
|
||||||
|
/// If MemoryRequest is invalid, this function will abort.
|
||||||
|
/// If MemoryRequest is valid, this function is infallible, and will always
|
||||||
|
/// succeed at reserving the some number of bytes between request.min() and
|
||||||
|
/// request.max() inclusively.
|
||||||
|
virtual size_t Reserve(MemoryRequest request) = 0; |
||||||
|
|
||||||
|
/// Release some bytes that were previously reserved.
|
||||||
|
/// If more bytes are released than were reserved, we will have undefined
|
||||||
|
/// behavior.
|
||||||
|
virtual void Release(size_t n) = 0; |
||||||
|
|
||||||
|
/// Shutdown this allocator.
|
||||||
|
/// Further usage of Reserve() is undefined behavior.
|
||||||
|
virtual void Shutdown() = 0; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace internal
|
||||||
|
|
||||||
|
} // namespace experimental
|
||||||
|
} // namespace grpc_event_engine
|
||||||
|
|
||||||
|
#endif // GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H
|
||||||
@ -0,0 +1,210 @@ |
|||||||
|
// Copyright 2021 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.
|
||||||
|
#ifndef GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H |
||||||
|
#define GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H |
||||||
|
|
||||||
|
#include <grpc/impl/codegen/port_platform.h> |
||||||
|
|
||||||
|
#include <algorithm> |
||||||
|
#include <memory> |
||||||
|
#include <type_traits> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
#include <grpc/event_engine/internal/memory_allocator_impl.h> |
||||||
|
#include <grpc/slice.h> |
||||||
|
|
||||||
|
// forward-declaring an internal struct, not used publicly.
|
||||||
|
struct grpc_slice_buffer; |
||||||
|
|
||||||
|
namespace grpc_event_engine { |
||||||
|
namespace experimental { |
||||||
|
|
||||||
|
// TODO(nnoble): needs implementation
|
||||||
|
class SliceBuffer { |
||||||
|
public: |
||||||
|
SliceBuffer() { abort(); } |
||||||
|
explicit SliceBuffer(grpc_slice_buffer*) { abort(); } |
||||||
|
|
||||||
|
grpc_slice_buffer* RawSliceBuffer() { return slice_buffer_; } |
||||||
|
|
||||||
|
private: |
||||||
|
grpc_slice_buffer* slice_buffer_; |
||||||
|
}; |
||||||
|
|
||||||
|
class MemoryAllocator { |
||||||
|
public: |
||||||
|
/// Construct a MemoryAllocator given an internal::MemoryAllocatorImpl
|
||||||
|
/// implementation. The constructed MemoryAllocator will call
|
||||||
|
/// MemoryAllocatorImpl::Shutdown() upon destruction.
|
||||||
|
explicit MemoryAllocator( |
||||||
|
std::shared_ptr<internal::MemoryAllocatorImpl> allocator) |
||||||
|
: allocator_(std::move(allocator)) {} |
||||||
|
~MemoryAllocator() { |
||||||
|
if (allocator_ != nullptr) allocator_->Shutdown(); |
||||||
|
} |
||||||
|
|
||||||
|
MemoryAllocator(const MemoryAllocator&) = delete; |
||||||
|
MemoryAllocator& operator=(const MemoryAllocator&) = delete; |
||||||
|
|
||||||
|
MemoryAllocator(MemoryAllocator&&) = default; |
||||||
|
MemoryAllocator& operator=(MemoryAllocator&&) = default; |
||||||
|
|
||||||
|
/// Reserve bytes from the quota.
|
||||||
|
/// If we enter overcommit, reclamation will begin concurrently.
|
||||||
|
/// Returns the number of bytes reserved.
|
||||||
|
size_t Reserve(MemoryRequest request) { return allocator_->Reserve(request); } |
||||||
|
|
||||||
|
/// Release some bytes that were previously reserved.
|
||||||
|
void Release(size_t n) { return allocator_->Release(n); } |
||||||
|
|
||||||
|
/// Return a pointer to the underlying implementation.
|
||||||
|
/// Note that the interface of said implementatoin is unstable and likely to
|
||||||
|
/// change at any time.
|
||||||
|
internal::MemoryAllocatorImpl* get_internal_impl_ptr() { |
||||||
|
return allocator_.get(); |
||||||
|
} |
||||||
|
|
||||||
|
//
|
||||||
|
// The remainder of this type are helper functions implemented in terms of
|
||||||
|
// Reserve/Release.
|
||||||
|
//
|
||||||
|
|
||||||
|
/// An automatic releasing reservation of memory.
|
||||||
|
class Reservation { |
||||||
|
public: |
||||||
|
Reservation() = default; |
||||||
|
Reservation(const Reservation&) = delete; |
||||||
|
Reservation& operator=(const Reservation&) = delete; |
||||||
|
Reservation(Reservation&&) = default; |
||||||
|
Reservation& operator=(Reservation&&) = default; |
||||||
|
~Reservation() { |
||||||
|
if (allocator_ != nullptr) allocator_->Release(size_); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
friend class MemoryAllocator; |
||||||
|
Reservation(std::shared_ptr<internal::MemoryAllocatorImpl> allocator, |
||||||
|
size_t size) |
||||||
|
: allocator_(std::move(allocator)), size_(size) {} |
||||||
|
|
||||||
|
std::shared_ptr<internal::MemoryAllocatorImpl> allocator_; |
||||||
|
size_t size_ = 0; |
||||||
|
}; |
||||||
|
|
||||||
|
/// Reserve bytes from the quota and automatically release them when
|
||||||
|
/// Reservation is destroyed.
|
||||||
|
Reservation MakeReservation(MemoryRequest request) { |
||||||
|
return Reservation(allocator_, Reserve(request)); |
||||||
|
} |
||||||
|
|
||||||
|
/// Allocate a new object of type T, with constructor arguments.
|
||||||
|
/// The returned type is wrapped, and upon destruction the reserved memory
|
||||||
|
/// will be released to the allocator automatically. As such, T must have a
|
||||||
|
/// virtual destructor so we can insert the necessary hook.
|
||||||
|
template <typename T, typename... Args> |
||||||
|
typename std::enable_if<std::has_virtual_destructor<T>::value, T*>::type New( |
||||||
|
Args&&... args) { |
||||||
|
// Wrap T such that when it's destroyed, we can release memory back to the
|
||||||
|
// allocator.
|
||||||
|
class Wrapper final : public T { |
||||||
|
public: |
||||||
|
explicit Wrapper(std::shared_ptr<internal::MemoryAllocatorImpl> allocator, |
||||||
|
Args&&... args) |
||||||
|
: T(std::forward<Args>(args)...), allocator_(std::move(allocator)) {} |
||||||
|
~Wrapper() override { allocator_->Release(sizeof(*this)); } |
||||||
|
|
||||||
|
private: |
||||||
|
const std::shared_ptr<internal::MemoryAllocatorImpl> allocator_; |
||||||
|
}; |
||||||
|
Reserve(sizeof(Wrapper)); |
||||||
|
return new Wrapper(allocator_, std::forward<Args>(args)...); |
||||||
|
} |
||||||
|
|
||||||
|
/// Construct a unique_ptr immediately.
|
||||||
|
template <typename T, typename... Args> |
||||||
|
std::unique_ptr<T> MakeUnique(Args&&... args) { |
||||||
|
return std::unique_ptr<T>(New<T>(std::forward<Args>(args)...)); |
||||||
|
} |
||||||
|
|
||||||
|
/// Allocate a slice, using MemoryRequest to size the number of returned
|
||||||
|
/// bytes. For a variable length request, check the returned slice length to
|
||||||
|
/// verify how much memory was allocated. Takes care of reserving memory for
|
||||||
|
/// any relevant control structures also.
|
||||||
|
grpc_slice MakeSlice(MemoryRequest request); |
||||||
|
|
||||||
|
/// A C++ allocator for containers of T.
|
||||||
|
template <typename T> |
||||||
|
class Container { |
||||||
|
public: |
||||||
|
using value_type = T; |
||||||
|
|
||||||
|
/// Construct the allocator: \a underlying_allocator is borrowed, and must
|
||||||
|
/// outlive this object.
|
||||||
|
explicit Container(MemoryAllocator* underlying_allocator) |
||||||
|
: underlying_allocator_(underlying_allocator) {} |
||||||
|
template <typename U> |
||||||
|
explicit Container(const Container<U>& other) |
||||||
|
: underlying_allocator_(other.underlying_allocator()) {} |
||||||
|
|
||||||
|
MemoryAllocator* underlying_allocator() const { |
||||||
|
return underlying_allocator_; |
||||||
|
} |
||||||
|
|
||||||
|
T* allocate(size_t n) { |
||||||
|
underlying_allocator_->Reserve(n * sizeof(T)); |
||||||
|
return static_cast<T*>(::operator new(n * sizeof(T))); |
||||||
|
} |
||||||
|
void deallocate(T* p, size_t n) { |
||||||
|
::operator delete(p); |
||||||
|
underlying_allocator_->Release(n * sizeof(T)); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
MemoryAllocator* underlying_allocator_; |
||||||
|
}; |
||||||
|
|
||||||
|
protected: |
||||||
|
const std::shared_ptr<internal::MemoryAllocatorImpl>& allocator() { |
||||||
|
return allocator_; |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
std::shared_ptr<internal::MemoryAllocatorImpl> allocator_; |
||||||
|
}; |
||||||
|
|
||||||
|
// Wrapper type around std::vector to make initialization against a
|
||||||
|
// MemoryAllocator based container allocator easy.
|
||||||
|
template <typename T> |
||||||
|
class Vector : public std::vector<T, MemoryAllocator::Container<T>> { |
||||||
|
public: |
||||||
|
explicit Vector(MemoryAllocator* allocator) |
||||||
|
: std::vector<T, MemoryAllocator::Container<T>>( |
||||||
|
MemoryAllocator::Container<T>(allocator)) {} |
||||||
|
}; |
||||||
|
|
||||||
|
class MemoryAllocatorFactory { |
||||||
|
public: |
||||||
|
virtual ~MemoryAllocatorFactory() = default; |
||||||
|
/// On Endpoint creation, call \a CreateMemoryAllocator to create a new
|
||||||
|
/// allocator for the endpoint.
|
||||||
|
/// Typically we'll want to:
|
||||||
|
/// auto allocator = factory->CreateMemoryAllocator();
|
||||||
|
/// auto* endpoint = allocator->New<MyEndpoint>(std::move(allocator), ...);
|
||||||
|
virtual MemoryAllocator CreateMemoryAllocator() = 0; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace experimental
|
||||||
|
} // namespace grpc_event_engine
|
||||||
|
|
||||||
|
#endif // GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H
|
||||||
@ -1,71 +0,0 @@ |
|||||||
// Copyright 2021 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.
|
|
||||||
#ifndef GRPC_EVENT_ENGINE_SLICE_ALLOCATOR_H |
|
||||||
#define GRPC_EVENT_ENGINE_SLICE_ALLOCATOR_H |
|
||||||
|
|
||||||
#include <grpc/support/port_platform.h> |
|
||||||
|
|
||||||
#include <functional> |
|
||||||
|
|
||||||
#include "absl/status/status.h" |
|
||||||
|
|
||||||
// forward-declaring an internal struct, not used publicly.
|
|
||||||
struct grpc_resource_quota; |
|
||||||
struct grpc_resource_user; |
|
||||||
struct grpc_slice_buffer; |
|
||||||
|
|
||||||
namespace grpc_event_engine { |
|
||||||
namespace experimental { |
|
||||||
|
|
||||||
// TODO(nnoble): needs implementation
|
|
||||||
class SliceBuffer { |
|
||||||
public: |
|
||||||
SliceBuffer() { abort(); } |
|
||||||
explicit SliceBuffer(grpc_slice_buffer*) { abort(); } |
|
||||||
|
|
||||||
grpc_slice_buffer* RawSliceBuffer() { return slice_buffer_; } |
|
||||||
|
|
||||||
private: |
|
||||||
grpc_slice_buffer* slice_buffer_; |
|
||||||
}; |
|
||||||
|
|
||||||
class SliceAllocator { |
|
||||||
public: |
|
||||||
using AllocateCallback = std::function<void(absl::Status)>; |
|
||||||
virtual ~SliceAllocator() = default; |
|
||||||
/// Requests \a size bytes from gRPC, and populates \a dest with the allocated
|
|
||||||
/// slices. Ownership of the \a SliceBuffer is not transferred.
|
|
||||||
///
|
|
||||||
/// gRPC provides a ResourceQuota system to cap the amount of memory used by
|
|
||||||
/// the library. When a memory limit has been reached, slice allocation is
|
|
||||||
/// interrupted to attempt to reclaim memory from participating gRPC
|
|
||||||
/// internals. When there is sufficient memory available, slice allocation
|
|
||||||
/// proceeds as normal.
|
|
||||||
virtual absl::Status Allocate(size_t size, SliceBuffer* dest, |
|
||||||
SliceAllocator::AllocateCallback cb) = 0; |
|
||||||
}; |
|
||||||
|
|
||||||
class SliceAllocatorFactory { |
|
||||||
public: |
|
||||||
virtual ~SliceAllocatorFactory() = default; |
|
||||||
/// On Endpoint creation, call \a CreateSliceAllocator with the name of the
|
|
||||||
/// endpoint peer (a URI string, most likely).
|
|
||||||
virtual std::unique_ptr<SliceAllocator> CreateSliceAllocator( |
|
||||||
absl::string_view peer_name) = 0; |
|
||||||
}; |
|
||||||
|
|
||||||
} // namespace experimental
|
|
||||||
} // namespace grpc_event_engine
|
|
||||||
|
|
||||||
#endif // GRPC_EVENT_ENGINE_SLICE_ALLOCATOR_H
|
|
||||||
@ -1,67 +0,0 @@ |
|||||||
// Copyright 2021 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 "src/core/ext/transport/chttp2/transport/chttp2_slice_allocator.h" |
|
||||||
|
|
||||||
#include <functional> |
|
||||||
|
|
||||||
#include "absl/memory/memory.h" |
|
||||||
#include "absl/status/status.h" |
|
||||||
|
|
||||||
#include <grpc/event_engine/slice_allocator.h> |
|
||||||
|
|
||||||
#include "src/core/lib/iomgr/resource_quota.h" |
|
||||||
|
|
||||||
namespace grpc_event_engine { |
|
||||||
namespace experimental { |
|
||||||
|
|
||||||
Chttp2SliceAllocator::Chttp2SliceAllocator(grpc_resource_user* user) |
|
||||||
: resource_user_(user) {} |
|
||||||
|
|
||||||
Chttp2SliceAllocator::~Chttp2SliceAllocator() { |
|
||||||
if (resource_user_ != nullptr) { |
|
||||||
grpc_resource_user_unref(resource_user_); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
absl::Status Chttp2SliceAllocator::Allocate( |
|
||||||
size_t size, SliceBuffer* dest, SliceAllocator::AllocateCallback cb) { |
|
||||||
// TODO(hork): merge the implementation from the uv-ee branch.
|
|
||||||
(void)size; |
|
||||||
(void)dest; |
|
||||||
(void)cb; |
|
||||||
return absl::OkStatus(); |
|
||||||
} |
|
||||||
|
|
||||||
Chttp2SliceAllocatorFactory::Chttp2SliceAllocatorFactory( |
|
||||||
grpc_resource_quota* quota) |
|
||||||
: resource_quota_(quota) { |
|
||||||
grpc_resource_quota_ref_internal(resource_quota_); |
|
||||||
} |
|
||||||
|
|
||||||
Chttp2SliceAllocatorFactory::~Chttp2SliceAllocatorFactory() { |
|
||||||
if (resource_quota_ != nullptr) { |
|
||||||
grpc_resource_quota_unref_internal(resource_quota_); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
std::unique_ptr<SliceAllocator> |
|
||||||
Chttp2SliceAllocatorFactory::CreateSliceAllocator(absl::string_view peer_name) { |
|
||||||
return absl::make_unique<Chttp2SliceAllocator>( |
|
||||||
grpc_resource_user_create(resource_quota_, peer_name)); |
|
||||||
} |
|
||||||
|
|
||||||
} // namespace experimental
|
|
||||||
} // namespace grpc_event_engine
|
|
||||||
@ -1,74 +0,0 @@ |
|||||||
// Copyright 2021 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.
|
|
||||||
#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_SLICE_ALLOCATOR_H |
|
||||||
#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_SLICE_ALLOCATOR_H |
|
||||||
|
|
||||||
#include <grpc/support/port_platform.h> |
|
||||||
|
|
||||||
#include <functional> |
|
||||||
|
|
||||||
#include "absl/status/status.h" |
|
||||||
|
|
||||||
#include <grpc/event_engine/slice_allocator.h> |
|
||||||
|
|
||||||
#include "src/core/lib/iomgr/resource_quota.h" |
|
||||||
|
|
||||||
namespace grpc_event_engine { |
|
||||||
namespace experimental { |
|
||||||
|
|
||||||
class Chttp2SliceAllocator |
|
||||||
: public grpc_event_engine::experimental::SliceAllocator { |
|
||||||
public: |
|
||||||
/// gRPC-internal constructor. Takes ownership of a resource_user ref from the
|
|
||||||
/// caller.
|
|
||||||
explicit Chttp2SliceAllocator(grpc_resource_user* user); |
|
||||||
// Not copyable
|
|
||||||
Chttp2SliceAllocator(Chttp2SliceAllocator& other) = delete; |
|
||||||
Chttp2SliceAllocator& operator=(const Chttp2SliceAllocator& other) = delete; |
|
||||||
// Not Moveable
|
|
||||||
Chttp2SliceAllocator(Chttp2SliceAllocator&& other) = delete; |
|
||||||
Chttp2SliceAllocator& operator=(Chttp2SliceAllocator&& other) = delete; |
|
||||||
~Chttp2SliceAllocator() override; |
|
||||||
absl::Status Allocate(size_t size, SliceBuffer* dest, |
|
||||||
SliceAllocator::AllocateCallback cb) override; |
|
||||||
|
|
||||||
private: |
|
||||||
grpc_resource_user* resource_user_; |
|
||||||
}; |
|
||||||
|
|
||||||
class Chttp2SliceAllocatorFactory |
|
||||||
: public grpc_event_engine::experimental::SliceAllocatorFactory { |
|
||||||
public: |
|
||||||
// gRPC-internal constructor
|
|
||||||
explicit Chttp2SliceAllocatorFactory(grpc_resource_quota* quota); |
|
||||||
// Not copyable
|
|
||||||
Chttp2SliceAllocatorFactory(Chttp2SliceAllocatorFactory& other) = delete; |
|
||||||
Chttp2SliceAllocatorFactory& operator=( |
|
||||||
const Chttp2SliceAllocatorFactory& other) = delete; |
|
||||||
// Not Moveable
|
|
||||||
Chttp2SliceAllocatorFactory(Chttp2SliceAllocatorFactory&& other) = delete; |
|
||||||
Chttp2SliceAllocatorFactory& operator=(Chttp2SliceAllocatorFactory&& other) = |
|
||||||
delete; |
|
||||||
~Chttp2SliceAllocatorFactory() override; |
|
||||||
std::unique_ptr<SliceAllocator> CreateSliceAllocator( |
|
||||||
absl::string_view peer_name) override; |
|
||||||
|
|
||||||
private: |
|
||||||
grpc_resource_quota* resource_quota_; |
|
||||||
}; |
|
||||||
|
|
||||||
} // namespace experimental
|
|
||||||
} // namespace grpc_event_engine
|
|
||||||
|
|
||||||
#endif // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_SLICE_ALLOCATOR_H
|
|
||||||
@ -0,0 +1,70 @@ |
|||||||
|
// 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.
|
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <grpc/event_engine/memory_allocator.h> |
||||||
|
|
||||||
|
#include "src/core/lib/gprpp/ref_counted.h" |
||||||
|
#include "src/core/lib/slice/slice_refcount.h" |
||||||
|
|
||||||
|
namespace grpc_event_engine { |
||||||
|
namespace experimental { |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
// Reference count for a slice allocated by MemoryAllocator::MakeSlice.
|
||||||
|
// Takes care of releasing memory back when the slice is destroyed.
|
||||||
|
class SliceRefCount { |
||||||
|
public: |
||||||
|
static void Destroy(void* p) { |
||||||
|
auto* rc = static_cast<SliceRefCount*>(p); |
||||||
|
rc->~SliceRefCount(); |
||||||
|
gpr_free(rc); |
||||||
|
} |
||||||
|
SliceRefCount(std::shared_ptr<internal::MemoryAllocatorImpl> allocator, |
||||||
|
size_t size) |
||||||
|
: base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this, |
||||||
|
&base_), |
||||||
|
allocator_(std::move(allocator)), |
||||||
|
size_(size) { |
||||||
|
// Nothing to do here.
|
||||||
|
} |
||||||
|
~SliceRefCount() { allocator_->Release(size_); } |
||||||
|
|
||||||
|
grpc_slice_refcount* base_refcount() { return &base_; } |
||||||
|
|
||||||
|
private: |
||||||
|
grpc_slice_refcount base_; |
||||||
|
grpc_core::RefCount refs_; |
||||||
|
std::shared_ptr<internal::MemoryAllocatorImpl> allocator_; |
||||||
|
size_t size_; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
grpc_slice MemoryAllocator::MakeSlice(MemoryRequest request) { |
||||||
|
auto size = Reserve(request.Increase(sizeof(SliceRefCount))); |
||||||
|
void* p = gpr_malloc(size); |
||||||
|
new (p) SliceRefCount(allocator_, size); |
||||||
|
grpc_slice slice; |
||||||
|
slice.refcount = static_cast<SliceRefCount*>(p)->base_refcount(); |
||||||
|
slice.data.refcounted.bytes = |
||||||
|
static_cast<uint8_t*>(p) + sizeof(SliceRefCount); |
||||||
|
slice.data.refcounted.length = size - sizeof(SliceRefCount); |
||||||
|
return slice; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace experimental
|
||||||
|
} // namespace grpc_event_engine
|
||||||
Loading…
Reference in new issue