mirror of https://github.com/grpc/grpc.git
Reland resource quota work (#28017)
* Check if memory owner available prior to polling it
The transport may drop the memory owner during its destruction sequence
* tcp_fix
* Revert "Revert "New resource quota integration (#27643)" (#28014)"
This reverts commit 0ea2c37263.
* clang-format
* fix-path
* fix
pull/28030/head
Craig Tiller
3 years ago
committed by
GitHub
parent
901e72edc0
commit
a629c9a03e
141 changed files with 1790 additions and 3688 deletions
@ -0,0 +1,57 @@ |
|||||||
|
// 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_REQUEST_H |
||||||
|
#define GRPC_EVENT_ENGINE_MEMORY_REQUEST_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <stddef.h> |
||||||
|
|
||||||
|
#include "absl/strings/string_view.h" |
||||||
|
|
||||||
|
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 experimental
|
||||||
|
} // namespace grpc_event_engine
|
||||||
|
|
||||||
|
#endif // GRPC_EVENT_ENGINE_MEMORY_REQUEST_H
|
||||||
@ -0,0 +1,45 @@ |
|||||||
|
// 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_CPP_IMPL_OF_H |
||||||
|
#define GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
|
||||||
|
// Declares CppType to be the backing implementation of CType.
|
||||||
|
// Use via the curiously recursive template:
|
||||||
|
// class Foo : public CppImplOf<Foo, grpc_foo> {};
|
||||||
|
// Provides casting methods each way.
|
||||||
|
// grpc_foo should be `typedef struct grpc_foo grpc_foo` and otherwise
|
||||||
|
// not defined.
|
||||||
|
template <typename CppType, typename CType> |
||||||
|
class CppImplOf { |
||||||
|
public: |
||||||
|
// Convert the C struct to C++
|
||||||
|
static CppType* FromC(CType* c_type) { |
||||||
|
return reinterpret_cast<CppType*>(c_type); |
||||||
|
} |
||||||
|
|
||||||
|
// Retrieve a c pointer (of the same ownership as this)
|
||||||
|
CType* c_ptr() { |
||||||
|
return reinterpret_cast<CType*>(static_cast<CppType*>(this)); |
||||||
|
} |
||||||
|
|
||||||
|
protected: |
||||||
|
~CppImplOf() = default; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace grpc_core
|
||||||
|
|
||||||
|
#endif // GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,226 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2016 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_IOMGR_RESOURCE_QUOTA_H |
|
||||||
#define GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H |
|
||||||
|
|
||||||
#include <grpc/support/port_platform.h> |
|
||||||
|
|
||||||
#include <grpc/grpc.h> |
|
||||||
|
|
||||||
#include "src/core/lib/debug/trace.h" |
|
||||||
#include "src/core/lib/iomgr/closure.h" |
|
||||||
|
|
||||||
/** \file Tracks resource usage against a pool.
|
|
||||||
|
|
||||||
The current implementation tracks only memory usage, but in the future |
|
||||||
this may be extended to (for example) threads and file descriptors. |
|
||||||
|
|
||||||
A grpc_resource_quota represents the pooled resources, and |
|
||||||
grpc_resource_user instances attach to the quota and consume those |
|
||||||
resources. They also offer a vector for reclamation: if we become |
|
||||||
resource constrained, grpc_resource_user instances are asked (in turn) to |
|
||||||
free up whatever they can so that the system as a whole can make progress. |
|
||||||
|
|
||||||
There are three kinds of reclamation that take place, in order of increasing |
|
||||||
invasiveness: |
|
||||||
- an internal reclamation, where cached resource at the resource user level |
|
||||||
is returned to the quota |
|
||||||
- a benign reclamation phase, whereby resources that are in use but are not |
|
||||||
helping anything make progress are reclaimed |
|
||||||
- a destructive reclamation, whereby resources that are helping something |
|
||||||
make progress may be enacted so that at least one part of the system can |
|
||||||
complete. |
|
||||||
|
|
||||||
Only one reclamation will be outstanding for a given quota at a given time. |
|
||||||
On each reclamation attempt, the kinds of reclamation are tried in order of |
|
||||||
increasing invasiveness, stopping at the first one that succeeds. Thus, on a |
|
||||||
given reclamation attempt, if internal and benign reclamation both fail, it |
|
||||||
will wind up doing a destructive reclamation. However, the next reclamation |
|
||||||
attempt may then be able to get what it needs via internal or benign |
|
||||||
reclamation, due to resources that may have been freed up by the destructive |
|
||||||
reclamation in the previous attempt. |
|
||||||
|
|
||||||
Future work will be to expose the current resource pressure so that back |
|
||||||
pressure can be applied to avoid reclamation phases starting. |
|
||||||
|
|
||||||
Resource users own references to resource quotas, and resource quotas |
|
||||||
maintain lists of users (which users arrange to leave before they are |
|
||||||
destroyed) */ |
|
||||||
|
|
||||||
extern grpc_core::TraceFlag grpc_resource_quota_trace; |
|
||||||
|
|
||||||
// TODO(juanlishen): This is a hack. We need to do real accounting instead of
|
|
||||||
// hard coding.
|
|
||||||
constexpr size_t GRPC_RESOURCE_QUOTA_CALL_SIZE = 15 * 1024; |
|
||||||
constexpr size_t GRPC_RESOURCE_QUOTA_CHANNEL_SIZE = 50 * 1024; |
|
||||||
constexpr size_t GRPC_SLICE_ALLOCATOR_MIN_ALLOCATE_SIZE = 256; |
|
||||||
constexpr size_t GRPC_SLICE_ALLOCATOR_MAX_ALLOCATE_SIZE = 4 * 1024 * 1024; |
|
||||||
|
|
||||||
grpc_resource_quota* grpc_resource_quota_ref_internal( |
|
||||||
grpc_resource_quota* resource_quota); |
|
||||||
void grpc_resource_quota_unref_internal(grpc_resource_quota* resource_quota); |
|
||||||
grpc_resource_quota* grpc_resource_quota_from_channel_args( |
|
||||||
const grpc_channel_args* channel_args, bool create = true); |
|
||||||
|
|
||||||
/* Return a number indicating current memory pressure:
|
|
||||||
0.0 ==> no memory usage |
|
||||||
1.0 ==> maximum memory usage */ |
|
||||||
double grpc_resource_quota_get_memory_pressure( |
|
||||||
grpc_resource_quota* resource_quota); |
|
||||||
|
|
||||||
size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota); |
|
||||||
|
|
||||||
typedef struct grpc_resource_user grpc_resource_user; |
|
||||||
|
|
||||||
grpc_resource_user* grpc_resource_user_create( |
|
||||||
grpc_resource_quota* resource_quota, absl::string_view name); |
|
||||||
|
|
||||||
/* Returns a borrowed reference to the underlying resource quota for this
|
|
||||||
resource user. */ |
|
||||||
grpc_resource_quota* grpc_resource_user_quota( |
|
||||||
grpc_resource_user* resource_user); |
|
||||||
|
|
||||||
void grpc_resource_user_ref(grpc_resource_user* resource_user); |
|
||||||
void grpc_resource_user_unref(grpc_resource_user* resource_user); |
|
||||||
void grpc_resource_user_shutdown(grpc_resource_user* resource_user); |
|
||||||
|
|
||||||
/* Attempts to get quota from the resource_user to create 'thread_count' number
|
|
||||||
* of threads. Returns true if successful (i.e the caller is now free to create |
|
||||||
* 'thread_count' number of threads) or false if quota is not available */ |
|
||||||
bool grpc_resource_user_allocate_threads(grpc_resource_user* resource_user, |
|
||||||
int thread_count); |
|
||||||
/* Releases 'thread_count' worth of quota back to the resource user. The quota
|
|
||||||
* should have been previously obtained successfully by calling |
|
||||||
* grpc_resource_user_allocate_threads(). |
|
||||||
* |
|
||||||
* Note: There need not be an exact one-to-one correspondence between |
|
||||||
* grpc_resource_user_allocate_threads() and grpc_resource_user_free_threads() |
|
||||||
* calls. The only requirement is that the number of threads allocated should |
|
||||||
* all be eventually released */ |
|
||||||
void grpc_resource_user_free_threads(grpc_resource_user* resource_user, |
|
||||||
int thread_count); |
|
||||||
|
|
||||||
/* Allocates from the resource user 'size' worth of memory if this won't exceed
|
|
||||||
* the resource quota's total size. Returns whether the allocation is done |
|
||||||
* successfully. If allocated successfully, the memory should be freed by the |
|
||||||
* caller eventually. */ |
|
||||||
bool grpc_resource_user_safe_alloc(grpc_resource_user* resource_user, |
|
||||||
size_t size); |
|
||||||
/* Allocates from the resource user 'size' worth of memory.
|
|
||||||
* If optional_on_done is NULL, then allocate immediately. This may push the |
|
||||||
* quota over-limit, at which point reclamation will kick in. The caller is |
|
||||||
* always responsible to free the memory eventually. |
|
||||||
* Returns true if the allocation was successful. Otherwise, if optional_on_done |
|
||||||
* is non-NULL, it will be scheduled without error when the allocation has been |
|
||||||
* granted by the quota, and the caller is responsible to free the memory |
|
||||||
* eventually. Or it may be scheduled with an error, in which case the caller |
|
||||||
* fails to allocate the memory and shouldn't free the memory. |
|
||||||
*/ |
|
||||||
bool grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size, |
|
||||||
grpc_closure* optional_on_done) |
|
||||||
GRPC_MUST_USE_RESULT; |
|
||||||
/* Release memory back to the quota */ |
|
||||||
void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size); |
|
||||||
/* Post a memory reclaimer to the resource user. Only one benign and one
|
|
||||||
destructive reclaimer can be posted at once. When executed, the reclaimer |
|
||||||
MUST call grpc_resource_user_finish_reclamation before it completes, to |
|
||||||
return control to the resource quota. */ |
|
||||||
void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user, |
|
||||||
bool destructive, grpc_closure* closure); |
|
||||||
/* Finish a reclamation step */ |
|
||||||
void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user); |
|
||||||
|
|
||||||
/* Helper to allocate slices from a resource user */ |
|
||||||
typedef struct grpc_slice_allocator { |
|
||||||
/* Closure for when a resource user allocation completes */ |
|
||||||
grpc_closure on_allocated; |
|
||||||
/* Closure to call when slices have been allocated */ |
|
||||||
grpc_closure on_done; |
|
||||||
/* Length of slices to allocate on the current request */ |
|
||||||
size_t length; |
|
||||||
/* Number of slices to allocate on the current request */ |
|
||||||
size_t count; |
|
||||||
/* Minimum size to allocate under memory pressure. */ |
|
||||||
size_t min_length; |
|
||||||
/* Maximum size that can be allocated. */ |
|
||||||
size_t max_length; |
|
||||||
/* Destination for slices to allocate on the current request */ |
|
||||||
grpc_slice_buffer* dest; |
|
||||||
/* Parent resource user */ |
|
||||||
grpc_resource_user* resource_user; |
|
||||||
} grpc_slice_allocator; |
|
||||||
|
|
||||||
/// Constructs a slice allocator using configuration from \a args.
|
|
||||||
///
|
|
||||||
/// Minimum and maximum limits for memory allocation size can be defined in
|
|
||||||
/// \a args, and used to configure an allocator. See
|
|
||||||
/// \a grpc_slice_allocator_allocate for details on how those values are used.
|
|
||||||
///
|
|
||||||
/// Caller is responsible for calling \a grpc_slice_allocator_destroy.
|
|
||||||
grpc_slice_allocator* grpc_slice_allocator_create( |
|
||||||
grpc_resource_quota* resource_quota, absl::string_view name, |
|
||||||
const grpc_channel_args* args = nullptr); |
|
||||||
|
|
||||||
/* Cleans up after a slice_allocator. */ |
|
||||||
void grpc_slice_allocator_destroy(grpc_slice_allocator* slice_allocator); |
|
||||||
|
|
||||||
enum class grpc_slice_allocator_intent { |
|
||||||
kDefault, // Default intent allocates exactly the memory required.
|
|
||||||
kReadBuffer // ReadBuffer intent may return a smaller slice than requested if
|
|
||||||
// memory pressure is high.
|
|
||||||
}; |
|
||||||
|
|
||||||
/** Allocate \a count slices of length \a length into \a dest. Only one request
|
|
||||||
can be outstanding at a time. When an allocation is completed, calls \a cb |
|
||||||
with arg \a p. Returns whether the slice was allocated inline in the |
|
||||||
function. If true, the \a cb will not be called. The \a intent argument |
|
||||||
allows allocation of smaller slices if memory pressure is high; the size is |
|
||||||
implementation-dependent. */ |
|
||||||
bool grpc_slice_allocator_allocate(grpc_slice_allocator* slice_allocator, |
|
||||||
size_t length, size_t count, |
|
||||||
grpc_slice_allocator_intent intent, |
|
||||||
grpc_slice_buffer* dest, |
|
||||||
grpc_iomgr_cb_func cb, |
|
||||||
void* p) GRPC_MUST_USE_RESULT; |
|
||||||
|
|
||||||
/* Allows creation of slice_allocators (thus resource_users) without calling
|
|
||||||
* code having to understand resource_user concepts. */ |
|
||||||
typedef struct grpc_slice_allocator_factory { |
|
||||||
/* Parent resource quota */ |
|
||||||
grpc_resource_quota* resource_quota; |
|
||||||
} grpc_slice_allocator_factory; |
|
||||||
|
|
||||||
/* Constructs a slice allocator factory. Takes ownership of a ref on
|
|
||||||
* \a resource_quota from the caller. Caller is responsible for calling \a |
|
||||||
* grpc_slice_allocator_factory_destroy. */ |
|
||||||
grpc_slice_allocator_factory* grpc_slice_allocator_factory_create( |
|
||||||
grpc_resource_quota* resource_quota); |
|
||||||
|
|
||||||
/* Cleans up after a slice_allocator. */ |
|
||||||
void grpc_slice_allocator_factory_destroy( |
|
||||||
grpc_slice_allocator_factory* slice_allocator_factory); |
|
||||||
|
|
||||||
/** A factory method to create and initialize a slice_allocator using the
|
|
||||||
factory's resource quota. \a name is the resulting resource_user name. \a args |
|
||||||
are used to configure the \a slice_allocator */ |
|
||||||
grpc_slice_allocator* grpc_slice_allocator_factory_create_slice_allocator( |
|
||||||
grpc_slice_allocator_factory* slice_allocator_factory, |
|
||||||
absl::string_view name, grpc_channel_args* args = nullptr); |
|
||||||
|
|
||||||
#endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */ |
|
||||||
@ -0,0 +1,102 @@ |
|||||||
|
// 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 "src/core/lib/resource_quota/api.h" |
||||||
|
|
||||||
|
#include <grpc/grpc.h> |
||||||
|
|
||||||
|
#include "src/core/lib/gpr/useful.h" |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
|
||||||
|
ResourceQuotaRefPtr ResourceQuotaFromChannelArgs( |
||||||
|
const grpc_channel_args* args) { |
||||||
|
return grpc_channel_args_find_pointer<ResourceQuota>(args, |
||||||
|
GRPC_ARG_RESOURCE_QUOTA) |
||||||
|
->Ref(); |
||||||
|
} |
||||||
|
|
||||||
|
namespace { |
||||||
|
grpc_arg MakeArg(ResourceQuota* quota) { |
||||||
|
return grpc_channel_arg_pointer_create( |
||||||
|
const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA), quota, |
||||||
|
grpc_resource_quota_arg_vtable()); |
||||||
|
} |
||||||
|
} // namespace
|
||||||
|
|
||||||
|
grpc_channel_args* EnsureResourceQuotaInChannelArgs( |
||||||
|
const grpc_channel_args* args) { |
||||||
|
if (grpc_channel_args_find(args, GRPC_ARG_RESOURCE_QUOTA) != nullptr) { |
||||||
|
return grpc_channel_args_copy(args); |
||||||
|
} |
||||||
|
// If there's no existing quota, add it to the default one - shared between
|
||||||
|
// all channel args declared thusly. This prevents us from accidentally not
|
||||||
|
// sharing subchannels due to their channel args not specifying a quota.
|
||||||
|
auto new_arg = MakeArg(ResourceQuota::Default().get()); |
||||||
|
return grpc_channel_args_copy_and_add(args, &new_arg, 1); |
||||||
|
} |
||||||
|
|
||||||
|
grpc_channel_args* ChannelArgsWrappingResourceQuota( |
||||||
|
ResourceQuotaRefPtr resource_quota) { |
||||||
|
auto new_arg = MakeArg(resource_quota.get()); |
||||||
|
return grpc_channel_args_copy_and_add(nullptr, &new_arg, 1); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace grpc_core
|
||||||
|
|
||||||
|
extern "C" const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable() { |
||||||
|
static const grpc_arg_pointer_vtable vtable = { |
||||||
|
// copy
|
||||||
|
[](void* p) -> void* { |
||||||
|
return static_cast<grpc_core::ResourceQuota*>(p)->Ref().release(); |
||||||
|
}, |
||||||
|
// destroy
|
||||||
|
[](void* p) { static_cast<grpc_core::ResourceQuota*>(p)->Unref(); }, |
||||||
|
// compare
|
||||||
|
[](void* p, void* q) { return grpc_core::QsortCompare(p, q); }}; |
||||||
|
return &vtable; |
||||||
|
} |
||||||
|
|
||||||
|
extern "C" grpc_resource_quota* grpc_resource_quota_create(const char* name) { |
||||||
|
static std::atomic<uintptr_t> anonymous_counter{0}; |
||||||
|
std::string quota_name = |
||||||
|
name == nullptr |
||||||
|
? absl::StrCat("anonymous-quota-", anonymous_counter.fetch_add(1)) |
||||||
|
: name; |
||||||
|
return (new grpc_core::ResourceQuota(std::move(quota_name)))->c_ptr(); |
||||||
|
} |
||||||
|
|
||||||
|
extern "C" void grpc_resource_quota_ref(grpc_resource_quota* resource_quota) { |
||||||
|
grpc_core::ResourceQuota::FromC(resource_quota)->Ref().release(); |
||||||
|
} |
||||||
|
|
||||||
|
extern "C" void grpc_resource_quota_unref(grpc_resource_quota* resource_quota) { |
||||||
|
grpc_core::ResourceQuota::FromC(resource_quota)->Unref(); |
||||||
|
} |
||||||
|
|
||||||
|
extern "C" void grpc_resource_quota_resize(grpc_resource_quota* resource_quota, |
||||||
|
size_t new_size) { |
||||||
|
grpc_core::ResourceQuota::FromC(resource_quota) |
||||||
|
->memory_quota() |
||||||
|
->SetSize(new_size); |
||||||
|
} |
||||||
|
|
||||||
|
extern "C" void grpc_resource_quota_set_max_threads( |
||||||
|
grpc_resource_quota* resource_quota, int new_max_threads) { |
||||||
|
grpc_core::ResourceQuota::FromC(resource_quota) |
||||||
|
->thread_quota() |
||||||
|
->SetMax(new_max_threads); |
||||||
|
} |
||||||
@ -0,0 +1,52 @@ |
|||||||
|
// 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_RESOURCE_QUOTA_API_H |
||||||
|
#define GRPC_CORE_LIB_RESOURCE_QUOTA_API_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include "src/core/lib/channel/channel_args.h" |
||||||
|
#include "src/core/lib/resource_quota/resource_quota.h" |
||||||
|
|
||||||
|
typedef struct grpc_resource_quota grpc_resource_quota; |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
|
||||||
|
// TODO(ctiller): This is a hack. We need to do real accounting instead of
|
||||||
|
// hard coding.
|
||||||
|
constexpr size_t kResourceQuotaCallSize = 15 * 1024; |
||||||
|
constexpr size_t kResourceQuotaChannelSize = 50 * 1024; |
||||||
|
|
||||||
|
// Retrieve the resource quota from the channel args.
|
||||||
|
// UB if not set.
|
||||||
|
ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(const grpc_channel_args* args); |
||||||
|
|
||||||
|
// Take some channel args:
|
||||||
|
// If there is a resource quota set, copy args and return that.
|
||||||
|
// If there is no resource quota set, set a default, and return new
|
||||||
|
// channel args. Call grpc_channel_args_destroy on the input args.
|
||||||
|
grpc_channel_args* EnsureResourceQuotaInChannelArgs( |
||||||
|
const grpc_channel_args* args); |
||||||
|
|
||||||
|
// Create channel args with just the passed in resource quota
|
||||||
|
grpc_channel_args* ChannelArgsWrappingResourceQuota(ResourceQuotaRefPtr); |
||||||
|
|
||||||
|
inline ResourceQuota* ResourceQuotaFromC(grpc_resource_quota* quota) { |
||||||
|
return reinterpret_cast<ResourceQuota*>(quota); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace grpc_core
|
||||||
|
|
||||||
|
#endif // GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
|
||||||
@ -0,0 +1,19 @@ |
|||||||
|
// 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 "src/core/lib/resource_quota/trace.h" |
||||||
|
|
||||||
|
grpc_core::TraceFlag grpc_resource_quota_trace(false, "resource_quota"); |
||||||
@ -0,0 +1,33 @@ |
|||||||
|
// 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 "src/core/lib/gprpp/cpp_impl_of.h" |
||||||
|
|
||||||
|
#include <gtest/gtest.h> |
||||||
|
|
||||||
|
typedef struct grpc_foo grpc_foo; |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
namespace { |
||||||
|
class Foo : public CppImplOf<Foo, grpc_foo> {}; |
||||||
|
} // namespace
|
||||||
|
|
||||||
|
TEST(CppImplOfTest, CreateDestroy) { delete Foo::FromC((new Foo())->c_ptr()); } |
||||||
|
|
||||||
|
} // namespace grpc_core
|
||||||
|
|
||||||
|
int main(int argc, char** argv) { |
||||||
|
::testing::InitGoogleTest(&argc, argv); |
||||||
|
return RUN_ALL_TESTS(); |
||||||
|
} |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue