Yuchen Zeng
9 years ago
commit
c76e9d3062
358 changed files with 27228 additions and 2976 deletions
|
After Width: | Height: | Size: 62 KiB |
@ -0,0 +1,92 @@ |
||||
# Stress Test framework for gRPC |
||||
|
||||
(Sree Kuchibhotla - sreek@) |
||||
|
||||
> Status: This is implemented. More details at [README.md](https://github.com/grpc/grpc/blob/master/tools/run_tests/stress_test/README.md) |
||||
|
||||
|
||||
**I. GOALS** |
||||
|
||||
1) Build a stress test suite for gRPC: |
||||
|
||||
* Build a stress test suite that can Identify bugs by testing the system (gRPC server/client) under extreme conditions: |
||||
* High load |
||||
* High concurrency |
||||
* Limited resources |
||||
* Intermittent failures |
||||
* Should be integrated with Jenkins CI |
||||
|
||||
2) Make it generic enough (i.e build a generic test framework) that can be used for: |
||||
|
||||
* Executing M instances of a client against N instances of a server with an arbitrarily defined connection matrix |
||||
* Execute heterogenous test configurations - for example: Java stress test clients against C++ servers or Node clients against Python servers or TSAN C++ clients vs ASAN C++ Servers etc. |
||||
* Easy and Flexible enough that Devs can use it to recreate complex test scenarios |
||||
|
||||
The implementation effort is divided into two parts: |
||||
|
||||
* Building a "Stress Test Framework" to run the stress test suites- More details in **Section II** (The idea is that the Stress Test framework is generic enough that it would be easier to modify it to run other suites like interop-tests or custom test scenarios) |
||||
* Building a 'Stress test suite' - More details in **section III** |
||||
|
||||
**Terminology:** |
||||
|
||||
GCE - Google compute engine |
||||
GKE - Google Container engine |
||||
Kubernetes - Google's open source service scheduler / orchestrator. |
||||
|
||||
**Note:** The terms GKE and Kubernetes are used interchangeably in this document |
||||
|
||||
# II. STRESS TEST FRAMEWORK |
||||
|
||||
(The details of each step are explained below)) |
||||
 |
||||
**Figure 1** |
||||
|
||||
### Step 1 Read the test config, generate base docker images |
||||
|
||||
**_Test Config:_** The test configuration contains the following information: |
||||
|
||||
* _GKE info:_ GKE project and cluster info |
||||
* _Docker images:_ Instructions to build docker images |
||||
* _Client templates:_ One or more client templates each containing the following information: |
||||
* Which docker image to use |
||||
* Path to the client program to launch (within the docker image) |
||||
* Parameters to the client program |
||||
* _Server templates:_ Similar to Client templates - except that these are for servers |
||||
* Test matrix containing the following: |
||||
* _Server groups:_ One or more groups of servers containing the following info for each group |
||||
* Which server template to use |
||||
* How many instances to launch |
||||
* _Client groups:_ One or more groups of clients containing the following (for each group): |
||||
* Which client template to use |
||||
* How many instances to launch |
||||
* Which server group to talk to (all clients in this group will talk to all servers in the server group) |
||||
|
||||
The first step is to read the test config and build the docker images |
||||
|
||||
**_Stress server docker image:_** The following are the main files in the server docker images |
||||
|
||||
* _Interop_server:_ The server program |
||||
* `run_server.py`: This is a python script which is the entry point of the docker image (i.e this is the script that is called when the docker image is run in GKE). This script launches the interop server and also updates the status in BigQuery. If the interop_server fails for whatever reason, the script launch_server.py logs that status in BigQuery |
||||
|
||||
**_Stress client docker image:_** |
||||
|
||||
* Stress client: The stress test client. In addition to talking to the interop_server, the stress client also exports metrics (which can be queried by the metrics_client described below) |
||||
* Metrics client: Metrics client connects to the stress_client to get the current qps metrics. |
||||
* `run_client.py`: This is a python script which is the entry point of the docker image (i.e this is the script that is called when the docker image is run in GKE). This script launches the stress client and also updates the status in BigQuery. The script then periodically launches metrics client to query the qps from the stress client and then uploads the qps to BigQuery. |
||||
|
||||
### Step 2) Upload the docker images to GKE |
||||
The docker images are uploaded to the GKE registry |
||||
|
||||
### Step 3) Launch the tests in GKE |
||||
The test driver reads the test matrix (described in step 1) and creates the necessary server and client pods in GKE. |
||||
|
||||
### Step 4) Tests are run in GKE |
||||
GKE starts running the tests by calling the entry points in *each* docker image (i.e `run_server.py` or `run_client.py` depending on whcih docker image it is) |
||||
|
||||
### Step 5) Upload the status to GKE and Monitor the status in GKE |
||||
* 5.1 The tests periodically update their status in BigQuery |
||||
* 5.2 The test driver periodically checks the status in Bigquery to see if any tests failed. If any tests failed, the driver immediately stops the tests. If not, the driver continues to run the tests for a configurable amount of time. |
||||
|
||||
### Step 6) Create a summary report |
||||
The test driver creates a final summary report containing details about any test failures and information about how to connect the failed pods in GKE for debugging. |
||||
|
||||
@ -0,0 +1,70 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPCXX_RESOURCE_QUOTA_H |
||||
#define GRPCXX_RESOURCE_QUOTA_H |
||||
|
||||
struct grpc_resource_quota; |
||||
|
||||
#include <grpc++/impl/codegen/config.h> |
||||
|
||||
namespace grpc { |
||||
|
||||
/// ResourceQuota represents a bound on memory usage by the gRPC library.
|
||||
/// A ResourceQuota can be attached to a server (via ServerBuilder), or a client
|
||||
/// channel (via ChannelArguments). gRPC will attempt to keep memory used by
|
||||
/// all attached entities below the ResourceQuota bound.
|
||||
class ResourceQuota GRPC_FINAL { |
||||
public: |
||||
explicit ResourceQuota(const grpc::string& name); |
||||
ResourceQuota(); |
||||
~ResourceQuota(); |
||||
|
||||
/// Resize this ResourceQuota to a new size. If new_size is smaller than the
|
||||
/// current size of the pool, memory usage will be monotonically decreased
|
||||
/// until it falls under new_size. No time bound is given for this to occur
|
||||
/// however.
|
||||
ResourceQuota& Resize(size_t new_size); |
||||
|
||||
grpc_resource_quota* c_resource_quota() const { return impl_; } |
||||
|
||||
private: |
||||
ResourceQuota(const ResourceQuota& rhs); |
||||
ResourceQuota& operator=(const ResourceQuota& rhs); |
||||
|
||||
grpc_resource_quota* const impl_; |
||||
}; |
||||
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCXX_RESOURCE_QUOTA_H
|
||||
@ -1,94 +0,0 @@ |
||||
//
|
||||
// Copyright 2015, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
|
||||
#include "src/core/ext/client_channel/resolver_result.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/string_util.h> |
||||
|
||||
#include "src/core/lib/channel/channel_args.h" |
||||
|
||||
struct grpc_resolver_result { |
||||
gpr_refcount refs; |
||||
char* server_name; |
||||
grpc_lb_addresses* addresses; |
||||
char* lb_policy_name; |
||||
grpc_channel_args* lb_policy_args; |
||||
}; |
||||
|
||||
grpc_resolver_result* grpc_resolver_result_create( |
||||
const char* server_name, grpc_lb_addresses* addresses, |
||||
const char* lb_policy_name, grpc_channel_args* lb_policy_args) { |
||||
grpc_resolver_result* result = gpr_malloc(sizeof(*result)); |
||||
memset(result, 0, sizeof(*result)); |
||||
gpr_ref_init(&result->refs, 1); |
||||
result->server_name = gpr_strdup(server_name); |
||||
result->addresses = addresses; |
||||
result->lb_policy_name = gpr_strdup(lb_policy_name); |
||||
result->lb_policy_args = lb_policy_args; |
||||
return result; |
||||
} |
||||
|
||||
void grpc_resolver_result_ref(grpc_resolver_result* result) { |
||||
gpr_ref(&result->refs); |
||||
} |
||||
|
||||
void grpc_resolver_result_unref(grpc_exec_ctx* exec_ctx, |
||||
grpc_resolver_result* result) { |
||||
if (gpr_unref(&result->refs)) { |
||||
gpr_free(result->server_name); |
||||
grpc_lb_addresses_destroy(result->addresses, NULL /* user_data_destroy */); |
||||
gpr_free(result->lb_policy_name); |
||||
grpc_channel_args_destroy(result->lb_policy_args); |
||||
gpr_free(result); |
||||
} |
||||
} |
||||
|
||||
const char* grpc_resolver_result_get_server_name(grpc_resolver_result* result) { |
||||
return result->server_name; |
||||
} |
||||
|
||||
grpc_lb_addresses* grpc_resolver_result_get_addresses( |
||||
grpc_resolver_result* result) { |
||||
return result->addresses; |
||||
} |
||||
|
||||
const char* grpc_resolver_result_get_lb_policy_name( |
||||
grpc_resolver_result* result) { |
||||
return result->lb_policy_name; |
||||
} |
||||
|
||||
grpc_channel_args* grpc_resolver_result_get_lb_policy_args( |
||||
grpc_resolver_result* result) { |
||||
return result->lb_policy_args; |
||||
} |
||||
@ -1,68 +0,0 @@ |
||||
//
|
||||
// Copyright 2015, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
|
||||
#ifndef GRPC_CORE_EXT_CLIENT_CHANNEL_RESOLVER_RESULT_H |
||||
#define GRPC_CORE_EXT_CLIENT_CHANNEL_RESOLVER_RESULT_H |
||||
|
||||
#include "src/core/ext/client_channel/lb_policy_factory.h" |
||||
|
||||
// TODO(roth, ctiller): In the long term, we are considering replacing
|
||||
// the resolver_result data structure with grpc_channel_args. The idea is
|
||||
// that the resolver will return a set of channel args that contains the
|
||||
// information that is currently in the resolver_result struct. For
|
||||
// example, there will be specific args indicating the set of addresses
|
||||
// and the name of the LB policy to instantiate. Note that if we did
|
||||
// this, we would probably want to change the data structure of
|
||||
// grpc_channel_args such to a hash table or AVL or some other data
|
||||
// structure that does not require linear search to find keys.
|
||||
|
||||
/// Results reported from a grpc_resolver.
|
||||
typedef struct grpc_resolver_result grpc_resolver_result; |
||||
|
||||
/// Takes ownership of \a addresses and \a lb_policy_args.
|
||||
grpc_resolver_result* grpc_resolver_result_create( |
||||
const char* server_name, grpc_lb_addresses* addresses, |
||||
const char* lb_policy_name, grpc_channel_args* lb_policy_args); |
||||
|
||||
void grpc_resolver_result_ref(grpc_resolver_result* result); |
||||
void grpc_resolver_result_unref(grpc_exec_ctx* exec_ctx, |
||||
grpc_resolver_result* result); |
||||
|
||||
/// Accessors. Caller does NOT take ownership of results.
|
||||
const char* grpc_resolver_result_get_server_name(grpc_resolver_result* result); |
||||
grpc_lb_addresses* grpc_resolver_result_get_addresses( |
||||
grpc_resolver_result* result); |
||||
const char* grpc_resolver_result_get_lb_policy_name( |
||||
grpc_resolver_result* result); |
||||
grpc_channel_args* grpc_resolver_result_get_lb_policy_args( |
||||
grpc_resolver_result* result); |
||||
|
||||
#endif /* GRPC_CORE_EXT_CLIENT_CHANNEL_RESOLVER_RESULT_H */ |
||||
@ -0,0 +1,49 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "src/core/lib/iomgr/port.h" |
||||
|
||||
#ifdef GRPC_UV |
||||
|
||||
#include "src/core/lib/debug/trace.h" |
||||
#include "src/core/lib/iomgr/pollset_uv.h" |
||||
#include "src/core/lib/iomgr/tcp_uv.h" |
||||
|
||||
void grpc_iomgr_platform_init(void) { |
||||
grpc_pollset_global_init(); |
||||
grpc_register_tracer("tcp", &grpc_tcp_trace); |
||||
} |
||||
void grpc_iomgr_platform_flush(void) {} |
||||
void grpc_iomgr_platform_shutdown(void) { grpc_pollset_global_shutdown(); } |
||||
|
||||
#endif /* GRPC_UV */ |
||||
@ -0,0 +1,62 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "src/core/lib/iomgr/port.h" |
||||
|
||||
#ifdef GRPC_UV |
||||
|
||||
#include "src/core/lib/iomgr/pollset_set.h" |
||||
|
||||
grpc_pollset_set* grpc_pollset_set_create(void) { |
||||
return (grpc_pollset_set*)((intptr_t)0xdeafbeef); |
||||
} |
||||
|
||||
void grpc_pollset_set_destroy(grpc_pollset_set* pollset_set) {} |
||||
|
||||
void grpc_pollset_set_add_pollset(grpc_exec_ctx* exec_ctx, |
||||
grpc_pollset_set* pollset_set, |
||||
grpc_pollset* pollset) {} |
||||
|
||||
void grpc_pollset_set_del_pollset(grpc_exec_ctx* exec_ctx, |
||||
grpc_pollset_set* pollset_set, |
||||
grpc_pollset* pollset) {} |
||||
|
||||
void grpc_pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx, |
||||
grpc_pollset_set* bag, |
||||
grpc_pollset_set* item) {} |
||||
|
||||
void grpc_pollset_set_del_pollset_set(grpc_exec_ctx* exec_ctx, |
||||
grpc_pollset_set* bag, |
||||
grpc_pollset_set* item) {} |
||||
|
||||
#endif /* GRPC_UV */ |
||||
@ -0,0 +1,142 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "src/core/lib/iomgr/port.h" |
||||
|
||||
#ifdef GRPC_UV |
||||
|
||||
#include <uv.h> |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/sync.h> |
||||
|
||||
#include "src/core/lib/iomgr/pollset.h" |
||||
#include "src/core/lib/iomgr/pollset_uv.h" |
||||
|
||||
struct grpc_pollset { |
||||
uv_timer_t timer; |
||||
int shutting_down; |
||||
}; |
||||
|
||||
/* Indicates that grpc_pollset_work should run an iteration of the UV loop
|
||||
before running callbacks. This defaults to 1, and should be disabled if |
||||
grpc_pollset_work will be called within the callstack of uv_run */ |
||||
int grpc_pollset_work_run_loop; |
||||
|
||||
gpr_mu grpc_polling_mu; |
||||
|
||||
size_t grpc_pollset_size() { return sizeof(grpc_pollset); } |
||||
|
||||
void grpc_pollset_global_init(void) { |
||||
gpr_mu_init(&grpc_polling_mu); |
||||
grpc_pollset_work_run_loop = 1; |
||||
} |
||||
|
||||
void grpc_pollset_global_shutdown(void) { gpr_mu_destroy(&grpc_polling_mu); } |
||||
|
||||
void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu) { |
||||
*mu = &grpc_polling_mu; |
||||
memset(pollset, 0, sizeof(grpc_pollset)); |
||||
uv_timer_init(uv_default_loop(), &pollset->timer); |
||||
pollset->shutting_down = 0; |
||||
} |
||||
|
||||
static void timer_close_cb(uv_handle_t *handle) { handle->data = (void *)1; } |
||||
|
||||
void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset, |
||||
grpc_closure *closure) { |
||||
GPR_ASSERT(!pollset->shutting_down); |
||||
pollset->shutting_down = 1; |
||||
if (grpc_pollset_work_run_loop) { |
||||
// Drain any pending UV callbacks without blocking
|
||||
uv_run(uv_default_loop(), UV_RUN_NOWAIT); |
||||
} |
||||
grpc_exec_ctx_sched(exec_ctx, closure, GRPC_ERROR_NONE, NULL); |
||||
} |
||||
|
||||
void grpc_pollset_destroy(grpc_pollset *pollset) { |
||||
uv_close((uv_handle_t *)&pollset->timer, timer_close_cb); |
||||
// timer.data is a boolean indicating that the timer has finished closing
|
||||
pollset->timer.data = (void *)0; |
||||
if (grpc_pollset_work_run_loop) { |
||||
while (!pollset->timer.data) { |
||||
uv_run(uv_default_loop(), UV_RUN_NOWAIT); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void grpc_pollset_reset(grpc_pollset *pollset) { |
||||
GPR_ASSERT(pollset->shutting_down); |
||||
pollset->shutting_down = 0; |
||||
} |
||||
|
||||
static void timer_run_cb(uv_timer_t *timer) {} |
||||
|
||||
grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset, |
||||
grpc_pollset_worker **worker_hdl, |
||||
gpr_timespec now, gpr_timespec deadline) { |
||||
uint64_t timeout; |
||||
gpr_mu_unlock(&grpc_polling_mu); |
||||
if (grpc_pollset_work_run_loop) { |
||||
if (gpr_time_cmp(deadline, now) >= 0) { |
||||
timeout = (uint64_t)gpr_time_to_millis(gpr_time_sub(deadline, now)); |
||||
} else { |
||||
timeout = 0; |
||||
} |
||||
/* We special-case timeout=0 so that we don't bother with the timer when
|
||||
the loop won't block anyway */ |
||||
if (timeout > 0) { |
||||
uv_timer_start(&pollset->timer, timer_run_cb, timeout, 0); |
||||
/* Run until there is some I/O activity or the timer triggers. It doesn't
|
||||
matter which happens */ |
||||
uv_run(uv_default_loop(), UV_RUN_ONCE); |
||||
uv_timer_stop(&pollset->timer); |
||||
} else { |
||||
uv_run(uv_default_loop(), UV_RUN_NOWAIT); |
||||
} |
||||
} |
||||
if (!grpc_closure_list_empty(exec_ctx->closure_list)) { |
||||
grpc_exec_ctx_flush(exec_ctx); |
||||
} |
||||
gpr_mu_lock(&grpc_polling_mu); |
||||
return GRPC_ERROR_NONE; |
||||
} |
||||
|
||||
grpc_error *grpc_pollset_kick(grpc_pollset *pollset, |
||||
grpc_pollset_worker *specific_worker) { |
||||
return GRPC_ERROR_NONE; |
||||
} |
||||
|
||||
#endif /* GRPC_UV */ |
||||
@ -0,0 +1,42 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_UV_H |
||||
#define GRPC_CORE_LIB_IOMGR_POLLSET_UV_H |
||||
|
||||
extern int grpc_pollset_work_run_loop; |
||||
|
||||
void grpc_pollset_global_init(void); |
||||
void grpc_pollset_global_shutdown(void); |
||||
|
||||
#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_UV_H */ |
||||
@ -0,0 +1,131 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#ifndef GRPC_CORE_LIB_IOMGR_PORT_H |
||||
#define GRPC_CORE_LIB_IOMGR_PORT_H |
||||
|
||||
#if defined(GRPC_UV) |
||||
// Do nothing
|
||||
#elif defined(GPR_MANYLINUX1) |
||||
#define GRPC_HAVE_IPV6_RECVPKTINFO 1 |
||||
#define GRPC_HAVE_IP_PKTINFO 1 |
||||
#define GRPC_HAVE_MSG_NOSIGNAL 1 |
||||
#define GRPC_HAVE_UNIX_SOCKET 1 |
||||
#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#define GRPC_POSIX_SOCKET 1 |
||||
#define GRPC_POSIX_SOCKETADDR 1 |
||||
#define GRPC_POSIX_SOCKETUTILS 1 |
||||
#define GRPC_POSIX_WAKEUP_FD 1 |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#elif defined(GPR_WINDOWS) |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#define GRPC_WINSOCK_SOCKET 1 |
||||
#define GRPC_WINDOWS_SOCKETUTILS 1 |
||||
#elif defined(GPR_ANDROID) |
||||
#define GRPC_HAVE_IPV6_RECVPKTINFO 1 |
||||
#define GRPC_HAVE_IP_PKTINFO 1 |
||||
#define GRPC_HAVE_MSG_NOSIGNAL 1 |
||||
#define GRPC_HAVE_UNIX_SOCKET 1 |
||||
#define GRPC_LINUX_EVENTFD 1 |
||||
#define GRPC_POSIX_SOCKET 1 |
||||
#define GRPC_POSIX_SOCKETADDR 1 |
||||
#define GRPC_POSIX_SOCKETUTILS 1 |
||||
#define GRPC_POSIX_WAKEUP_FD 1 |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#elif defined(GPR_LINUX) |
||||
#define GRPC_HAVE_IPV6_RECVPKTINFO 1 |
||||
#define GRPC_HAVE_IP_PKTINFO 1 |
||||
#define GRPC_HAVE_MSG_NOSIGNAL 1 |
||||
#define GRPC_HAVE_UNIX_SOCKET 1 |
||||
#define GRPC_LINUX_MULTIPOLL_WITH_EPOLL 1 |
||||
#define GRPC_POSIX_SOCKET 1 |
||||
#define GRPC_POSIX_SOCKETADDR 1 |
||||
#define GRPC_POSIX_WAKEUP_FD 1 |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#ifdef __GLIBC_PREREQ |
||||
#if __GLIBC_PREREQ(2, 9) |
||||
#define GRPC_LINUX_EPOLL 1 |
||||
#define GRPC_LINUX_EVENTFD 1 |
||||
#endif |
||||
#if __GLIBC_PREREQ(2, 10) |
||||
#define GRPC_LINUX_SOCKETUTILS 1 |
||||
#endif |
||||
#endif |
||||
#ifndef GRPC_LINUX_EVENTFD |
||||
#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#endif |
||||
#ifndef GRPC_LINUX_SOCKETUTILS |
||||
#define GRPC_POSIX_SOCKETUTILS |
||||
#endif |
||||
#elif defined(GPR_APPLE) |
||||
#define GRPC_HAVE_IP_PKTINFO 1 |
||||
#define GRPC_HAVE_SO_NOSIGPIPE 1 |
||||
#define GRPC_HAVE_UNIX_SOCKET 1 |
||||
#define GRPC_MSG_IOVLEN_TYPE int |
||||
#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#define GRPC_POSIX_SOCKET 1 |
||||
#define GRPC_POSIX_SOCKETADDR 1 |
||||
#define GRPC_POSIX_SOCKETUTILS 1 |
||||
#define GRPC_POSIX_WAKEUP_FD 1 |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#elif defined(GPR_FREEBSD) |
||||
#define GRPC_HAVE_IPV6_RECVPKTINFO 1 |
||||
#define GRPC_HAVE_IP_PKTINFO 1 |
||||
#define GRPC_HAVE_SO_NOSIGPIPE 1 |
||||
#define GRPC_HAVE_UNIX_SOCKET 1 |
||||
#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#define GRPC_POSIX_SOCKET 1 |
||||
#define GRPC_POSIX_SOCKETADDR 1 |
||||
#define GRPC_POSIX_SOCKETUTILS 1 |
||||
#define GRPC_POSIX_WAKEUP_FD 1 |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#elif defined(GPR_NACL) |
||||
#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 |
||||
#define GRPC_POSIX_SOCKET 1 |
||||
#define GRPC_POSIX_SOCKETADDR 1 |
||||
#define GRPC_POSIX_SOCKETUTILS 1 |
||||
#define GRPC_POSIX_WAKEUP_FD 1 |
||||
#define GRPC_TIMER_USE_GENERIC 1 |
||||
#elif !defined(GPR_NO_AUTODETECT_PLATFORM) |
||||
#error "Platform not recognized" |
||||
#endif |
||||
|
||||
#if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) + \ |
||||
defined(GRPC_CUSTOM_SOCKET) + defined(GRPC_UV) != \
|
||||
1 |
||||
#error Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GPR_CUSTOM_SOCKET |
||||
#endif |
||||
|
||||
#endif /* GRPC_CORE_LIB_IOMGR_PORT_H */ |
||||
@ -0,0 +1,231 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "src/core/lib/iomgr/port.h" |
||||
#ifdef GRPC_UV |
||||
|
||||
#include <uv.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/host_port.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/string_util.h> |
||||
|
||||
#include "src/core/lib/iomgr/closure.h" |
||||
#include "src/core/lib/iomgr/error.h" |
||||
#include "src/core/lib/iomgr/exec_ctx.h" |
||||
#include "src/core/lib/iomgr/resolve_address.h" |
||||
#include "src/core/lib/iomgr/sockaddr.h" |
||||
#include "src/core/lib/iomgr/sockaddr_utils.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
typedef struct request { |
||||
grpc_closure *on_done; |
||||
grpc_resolved_addresses **addresses; |
||||
struct addrinfo *hints; |
||||
} request; |
||||
|
||||
static grpc_error *handle_addrinfo_result(int status, struct addrinfo *result, |
||||
grpc_resolved_addresses **addresses) { |
||||
struct addrinfo *resp; |
||||
size_t i; |
||||
if (status != 0) { |
||||
grpc_error *error; |
||||
*addresses = NULL; |
||||
error = GRPC_ERROR_CREATE("getaddrinfo failed"); |
||||
error = |
||||
grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, uv_strerror(status)); |
||||
return error; |
||||
} |
||||
(*addresses) = gpr_malloc(sizeof(grpc_resolved_addresses)); |
||||
(*addresses)->naddrs = 0; |
||||
for (resp = result; resp != NULL; resp = resp->ai_next) { |
||||
(*addresses)->naddrs++; |
||||
} |
||||
(*addresses)->addrs = |
||||
gpr_malloc(sizeof(grpc_resolved_address) * (*addresses)->naddrs); |
||||
i = 0; |
||||
for (resp = result; resp != NULL; resp = resp->ai_next) { |
||||
memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen); |
||||
(*addresses)->addrs[i].len = resp->ai_addrlen; |
||||
i++; |
||||
} |
||||
|
||||
{ |
||||
for (i = 0; i < (*addresses)->naddrs; i++) { |
||||
char *buf; |
||||
grpc_sockaddr_to_string(&buf, &(*addresses)->addrs[i], 0); |
||||
gpr_free(buf); |
||||
} |
||||
} |
||||
return GRPC_ERROR_NONE; |
||||
} |
||||
|
||||
static void getaddrinfo_callback(uv_getaddrinfo_t *req, int status, |
||||
struct addrinfo *res) { |
||||
request *r = (request *)req->data; |
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
grpc_error *error; |
||||
error = handle_addrinfo_result(status, res, r->addresses); |
||||
grpc_exec_ctx_sched(&exec_ctx, r->on_done, error, NULL); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
|
||||
gpr_free(r->hints); |
||||
gpr_free(r); |
||||
gpr_free(req); |
||||
uv_freeaddrinfo(res); |
||||
} |
||||
|
||||
static grpc_error *try_split_host_port(const char *name, |
||||
const char *default_port, char **host, |
||||
char **port) { |
||||
/* parse name, splitting it into host and port parts */ |
||||
grpc_error *error; |
||||
gpr_split_host_port(name, host, port); |
||||
if (host == NULL) { |
||||
char *msg; |
||||
gpr_asprintf(&msg, "unparseable host:port: '%s'", name); |
||||
error = GRPC_ERROR_CREATE(msg); |
||||
gpr_free(msg); |
||||
return error; |
||||
} |
||||
if (port == NULL) { |
||||
if (default_port == NULL) { |
||||
char *msg; |
||||
gpr_asprintf(&msg, "no port in name '%s'", name); |
||||
error = GRPC_ERROR_CREATE(msg); |
||||
gpr_free(msg); |
||||
return error; |
||||
} |
||||
*port = gpr_strdup(default_port); |
||||
} |
||||
return GRPC_ERROR_NONE; |
||||
} |
||||
|
||||
static grpc_error *blocking_resolve_address_impl( |
||||
const char *name, const char *default_port, |
||||
grpc_resolved_addresses **addresses) { |
||||
char *host; |
||||
char *port; |
||||
struct addrinfo hints; |
||||
uv_getaddrinfo_t req; |
||||
int s; |
||||
grpc_error *err; |
||||
|
||||
req.addrinfo = NULL; |
||||
|
||||
err = try_split_host_port(name, default_port, &host, &port); |
||||
if (err != GRPC_ERROR_NONE) { |
||||
goto done; |
||||
} |
||||
|
||||
/* Call getaddrinfo */ |
||||
memset(&hints, 0, sizeof(hints)); |
||||
hints.ai_family = AF_UNSPEC; /* ipv4 or ipv6 */ |
||||
hints.ai_socktype = SOCK_STREAM; /* stream socket */ |
||||
hints.ai_flags = AI_PASSIVE; /* for wildcard IP address */ |
||||
|
||||
s = uv_getaddrinfo(uv_default_loop(), &req, NULL, host, port, &hints); |
||||
err = handle_addrinfo_result(s, req.addrinfo, addresses); |
||||
|
||||
done: |
||||
gpr_free(host); |
||||
gpr_free(port); |
||||
if (req.addrinfo) { |
||||
uv_freeaddrinfo(req.addrinfo); |
||||
} |
||||
return err; |
||||
} |
||||
|
||||
grpc_error *(*grpc_blocking_resolve_address)( |
||||
const char *name, const char *default_port, |
||||
grpc_resolved_addresses **addresses) = blocking_resolve_address_impl; |
||||
|
||||
void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addrs) { |
||||
if (addrs != NULL) { |
||||
gpr_free(addrs->addrs); |
||||
} |
||||
gpr_free(addrs); |
||||
} |
||||
|
||||
static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name, |
||||
const char *default_port, |
||||
grpc_closure *on_done, |
||||
grpc_resolved_addresses **addrs) { |
||||
uv_getaddrinfo_t *req; |
||||
request *r; |
||||
struct addrinfo *hints; |
||||
char *host; |
||||
char *port; |
||||
grpc_error *err; |
||||
int s; |
||||
err = try_split_host_port(name, default_port, &host, &port); |
||||
if (err != GRPC_ERROR_NONE) { |
||||
grpc_exec_ctx_sched(exec_ctx, on_done, err, NULL); |
||||
return; |
||||
} |
||||
r = gpr_malloc(sizeof(request)); |
||||
r->on_done = on_done; |
||||
r->addresses = addrs; |
||||
req = gpr_malloc(sizeof(uv_getaddrinfo_t)); |
||||
req->data = r; |
||||
|
||||
/* Call getaddrinfo */ |
||||
hints = gpr_malloc(sizeof(struct addrinfo)); |
||||
memset(hints, 0, sizeof(struct addrinfo)); |
||||
hints->ai_family = AF_UNSPEC; /* ipv4 or ipv6 */ |
||||
hints->ai_socktype = SOCK_STREAM; /* stream socket */ |
||||
hints->ai_flags = AI_PASSIVE; /* for wildcard IP address */ |
||||
r->hints = hints; |
||||
|
||||
s = uv_getaddrinfo(uv_default_loop(), req, getaddrinfo_callback, host, port, |
||||
hints); |
||||
|
||||
if (s != 0) { |
||||
*addrs = NULL; |
||||
err = GRPC_ERROR_CREATE("getaddrinfo failed"); |
||||
err = grpc_error_set_str(err, GRPC_ERROR_STR_OS_ERROR, uv_strerror(s)); |
||||
grpc_exec_ctx_sched(exec_ctx, on_done, err, NULL); |
||||
gpr_free(r); |
||||
gpr_free(req); |
||||
gpr_free(hints); |
||||
} |
||||
} |
||||
|
||||
void (*grpc_resolve_address)(grpc_exec_ctx *exec_ctx, const char *name, |
||||
const char *default_port, grpc_closure *on_done, |
||||
grpc_resolved_addresses **addrs) = |
||||
resolve_address_impl; |
||||
|
||||
#endif /* GRPC_UV */ |
||||
@ -0,0 +1,714 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include "src/core/lib/iomgr/resource_quota.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/string_util.h> |
||||
#include <grpc/support/useful.h> |
||||
|
||||
#include "src/core/lib/iomgr/combiner.h" |
||||
|
||||
int grpc_resource_quota_trace = 0; |
||||
|
||||
struct grpc_resource_quota { |
||||
/* refcount */ |
||||
gpr_refcount refs; |
||||
|
||||
/* Master combiner lock: all activity on a quota executes under this combiner
|
||||
* (so no mutex is needed for this data structure) |
||||
*/ |
||||
grpc_combiner *combiner; |
||||
/* Size of the resource quota */ |
||||
int64_t size; |
||||
/* Amount of free memory in the resource quota */ |
||||
int64_t free_pool; |
||||
|
||||
/* Has rq_step been scheduled to occur? */ |
||||
bool step_scheduled; |
||||
/* Are we currently reclaiming memory */ |
||||
bool reclaiming; |
||||
/* Closure around rq_step */ |
||||
grpc_closure rq_step_closure; |
||||
/* Closure around rq_reclamation_done */ |
||||
grpc_closure rq_reclamation_done_closure; |
||||
|
||||
/* Roots of all resource user lists */ |
||||
grpc_resource_user *roots[GRPC_RULIST_COUNT]; |
||||
|
||||
char *name; |
||||
}; |
||||
|
||||
/*******************************************************************************
|
||||
* list management |
||||
*/ |
||||
|
||||
static void rulist_add_head(grpc_resource_user *resource_user, |
||||
grpc_rulist list) { |
||||
grpc_resource_quota *resource_quota = resource_user->resource_quota; |
||||
grpc_resource_user **root = &resource_quota->roots[list]; |
||||
if (*root == NULL) { |
||||
*root = resource_user; |
||||
resource_user->links[list].next = resource_user->links[list].prev = |
||||
resource_user; |
||||
} else { |
||||
resource_user->links[list].next = *root; |
||||
resource_user->links[list].prev = (*root)->links[list].prev; |
||||
resource_user->links[list].next->links[list].prev = |
||||
resource_user->links[list].prev->links[list].next = resource_user; |
||||
*root = resource_user; |
||||
} |
||||
} |
||||
|
||||
static void rulist_add_tail(grpc_resource_user *resource_user, |
||||
grpc_rulist list) { |
||||
grpc_resource_quota *resource_quota = resource_user->resource_quota; |
||||
grpc_resource_user **root = &resource_quota->roots[list]; |
||||
if (*root == NULL) { |
||||
*root = resource_user; |
||||
resource_user->links[list].next = resource_user->links[list].prev = |
||||
resource_user; |
||||
} else { |
||||
resource_user->links[list].next = (*root)->links[list].next; |
||||
resource_user->links[list].prev = *root; |
||||
resource_user->links[list].next->links[list].prev = |
||||
resource_user->links[list].prev->links[list].next = resource_user; |
||||
} |
||||
} |
||||
|
||||
static bool rulist_empty(grpc_resource_quota *resource_quota, |
||||
grpc_rulist list) { |
||||
return resource_quota->roots[list] == NULL; |
||||
} |
||||
|
||||
static grpc_resource_user *rulist_pop_head(grpc_resource_quota *resource_quota, |
||||
grpc_rulist list) { |
||||
grpc_resource_user **root = &resource_quota->roots[list]; |
||||
grpc_resource_user *resource_user = *root; |
||||
if (resource_user == NULL) { |
||||
return NULL; |
||||
} |
||||
if (resource_user->links[list].next == resource_user) { |
||||
*root = NULL; |
||||
} else { |
||||
resource_user->links[list].next->links[list].prev = |
||||
resource_user->links[list].prev; |
||||
resource_user->links[list].prev->links[list].next = |
||||
resource_user->links[list].next; |
||||
*root = resource_user->links[list].next; |
||||
} |
||||
resource_user->links[list].next = resource_user->links[list].prev = NULL; |
||||
return resource_user; |
||||
} |
||||
|
||||
static void rulist_remove(grpc_resource_user *resource_user, grpc_rulist list) { |
||||
if (resource_user->links[list].next == NULL) return; |
||||
grpc_resource_quota *resource_quota = resource_user->resource_quota; |
||||
if (resource_quota->roots[list] == resource_user) { |
||||
resource_quota->roots[list] = resource_user->links[list].next; |
||||
if (resource_quota->roots[list] == resource_user) { |
||||
resource_quota->roots[list] = NULL; |
||||
} |
||||
} |
||||
resource_user->links[list].next->links[list].prev = |
||||
resource_user->links[list].prev; |
||||
resource_user->links[list].prev->links[list].next = |
||||
resource_user->links[list].next; |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* resource quota state machine |
||||
*/ |
||||
|
||||
static bool rq_alloc(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota); |
||||
static bool rq_reclaim_from_per_user_free_pool( |
||||
grpc_exec_ctx *exec_ctx, grpc_resource_quota *resource_quota); |
||||
static bool rq_reclaim(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota, bool destructive); |
||||
|
||||
static void rq_step(grpc_exec_ctx *exec_ctx, void *rq, grpc_error *error) { |
||||
grpc_resource_quota *resource_quota = rq; |
||||
resource_quota->step_scheduled = false; |
||||
do { |
||||
if (rq_alloc(exec_ctx, resource_quota)) goto done; |
||||
} while (rq_reclaim_from_per_user_free_pool(exec_ctx, resource_quota)); |
||||
rq_reclaim(exec_ctx, resource_quota, false) || |
||||
rq_reclaim(exec_ctx, resource_quota, true); |
||||
done: |
||||
grpc_resource_quota_internal_unref(exec_ctx, resource_quota); |
||||
} |
||||
|
||||
static void rq_step_sched(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota) { |
||||
if (resource_quota->step_scheduled) return; |
||||
resource_quota->step_scheduled = true; |
||||
grpc_resource_quota_internal_ref(resource_quota); |
||||
grpc_combiner_execute_finally(exec_ctx, resource_quota->combiner, |
||||
&resource_quota->rq_step_closure, |
||||
GRPC_ERROR_NONE, false); |
||||
} |
||||
|
||||
/* returns true if all allocations are completed */ |
||||
static bool rq_alloc(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota) { |
||||
grpc_resource_user *resource_user; |
||||
while ((resource_user = rulist_pop_head(resource_quota, |
||||
GRPC_RULIST_AWAITING_ALLOCATION))) { |
||||
gpr_mu_lock(&resource_user->mu); |
||||
if (resource_user->free_pool < 0 && |
||||
-resource_user->free_pool <= resource_quota->free_pool) { |
||||
int64_t amt = -resource_user->free_pool; |
||||
resource_user->free_pool = 0; |
||||
resource_quota->free_pool -= amt; |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: grant alloc %" PRId64 |
||||
" bytes; rq_free_pool -> %" PRId64, |
||||
resource_quota->name, resource_user->name, amt, |
||||
resource_quota->free_pool); |
||||
} |
||||
} else if (grpc_resource_quota_trace && resource_user->free_pool >= 0) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: discard already satisfied alloc request", |
||||
resource_quota->name, resource_user->name); |
||||
} |
||||
if (resource_user->free_pool >= 0) { |
||||
resource_user->allocating = false; |
||||
grpc_exec_ctx_enqueue_list(exec_ctx, &resource_user->on_allocated, NULL); |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
} else { |
||||
rulist_add_head(resource_user, GRPC_RULIST_AWAITING_ALLOCATION); |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
/* returns true if any memory could be reclaimed from buffers */ |
||||
static bool rq_reclaim_from_per_user_free_pool( |
||||
grpc_exec_ctx *exec_ctx, grpc_resource_quota *resource_quota) { |
||||
grpc_resource_user *resource_user; |
||||
while ((resource_user = rulist_pop_head(resource_quota, |
||||
GRPC_RULIST_NON_EMPTY_FREE_POOL))) { |
||||
gpr_mu_lock(&resource_user->mu); |
||||
if (resource_user->free_pool > 0) { |
||||
int64_t amt = resource_user->free_pool; |
||||
resource_user->free_pool = 0; |
||||
resource_quota->free_pool += amt; |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: reclaim_from_per_user_free_pool %" PRId64 |
||||
" bytes; rq_free_pool -> %" PRId64, |
||||
resource_quota->name, resource_user->name, amt, |
||||
resource_quota->free_pool); |
||||
} |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
return true; |
||||
} else { |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/* returns true if reclamation is proceeding */ |
||||
static bool rq_reclaim(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota, bool destructive) { |
||||
if (resource_quota->reclaiming) return true; |
||||
grpc_rulist list = destructive ? GRPC_RULIST_RECLAIMER_DESTRUCTIVE |
||||
: GRPC_RULIST_RECLAIMER_BENIGN; |
||||
grpc_resource_user *resource_user = rulist_pop_head(resource_quota, list); |
||||
if (resource_user == NULL) return false; |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: initiate %s reclamation", |
||||
resource_quota->name, resource_user->name, |
||||
destructive ? "destructive" : "benign"); |
||||
} |
||||
resource_quota->reclaiming = true; |
||||
grpc_resource_quota_internal_ref(resource_quota); |
||||
grpc_closure *c = resource_user->reclaimers[destructive]; |
||||
resource_user->reclaimers[destructive] = NULL; |
||||
grpc_closure_run(exec_ctx, c, GRPC_ERROR_NONE); |
||||
return true; |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* ru_slice: a slice implementation that is backed by a grpc_resource_user |
||||
*/ |
||||
|
||||
typedef struct { |
||||
gpr_slice_refcount base; |
||||
gpr_refcount refs; |
||||
grpc_resource_user *resource_user; |
||||
size_t size; |
||||
} ru_slice_refcount; |
||||
|
||||
static void ru_slice_ref(void *p) { |
||||
ru_slice_refcount *rc = p; |
||||
gpr_ref(&rc->refs); |
||||
} |
||||
|
||||
static void ru_slice_unref(void *p) { |
||||
ru_slice_refcount *rc = p; |
||||
if (gpr_unref(&rc->refs)) { |
||||
/* TODO(ctiller): this is dangerous, but I think safe for now:
|
||||
we have no guarantee here that we're at a safe point for creating an |
||||
execution context, but we have no way of writing this code otherwise. |
||||
In the future: consider lifting gpr_slice to grpc, and offering an |
||||
internal_{ref,unref} pair that is execution context aware. |
||||
Alternatively, |
||||
make exec_ctx be thread local and 'do the right thing' (whatever that |
||||
is) |
||||
if NULL */ |
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
grpc_resource_user_free(&exec_ctx, rc->resource_user, rc->size); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
gpr_free(rc); |
||||
} |
||||
} |
||||
|
||||
static gpr_slice ru_slice_create(grpc_resource_user *resource_user, |
||||
size_t size) { |
||||
ru_slice_refcount *rc = gpr_malloc(sizeof(ru_slice_refcount) + size); |
||||
rc->base.ref = ru_slice_ref; |
||||
rc->base.unref = ru_slice_unref; |
||||
gpr_ref_init(&rc->refs, 1); |
||||
rc->resource_user = resource_user; |
||||
rc->size = size; |
||||
gpr_slice slice; |
||||
slice.refcount = &rc->base; |
||||
slice.data.refcounted.bytes = (uint8_t *)(rc + 1); |
||||
slice.data.refcounted.length = size; |
||||
return slice; |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* grpc_resource_quota internal implementation: resource user manipulation under |
||||
* the combiner |
||||
*/ |
||||
|
||||
static void ru_allocate(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) { |
||||
grpc_resource_user *resource_user = ru; |
||||
if (rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_AWAITING_ALLOCATION)) { |
||||
rq_step_sched(exec_ctx, resource_user->resource_quota); |
||||
} |
||||
rulist_add_tail(resource_user, GRPC_RULIST_AWAITING_ALLOCATION); |
||||
} |
||||
|
||||
static void ru_add_to_free_pool(grpc_exec_ctx *exec_ctx, void *ru, |
||||
grpc_error *error) { |
||||
grpc_resource_user *resource_user = ru; |
||||
if (!rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_AWAITING_ALLOCATION) && |
||||
rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_NON_EMPTY_FREE_POOL)) { |
||||
rq_step_sched(exec_ctx, resource_user->resource_quota); |
||||
} |
||||
rulist_add_tail(resource_user, GRPC_RULIST_NON_EMPTY_FREE_POOL); |
||||
} |
||||
|
||||
static void ru_post_benign_reclaimer(grpc_exec_ctx *exec_ctx, void *ru, |
||||
grpc_error *error) { |
||||
grpc_resource_user *resource_user = ru; |
||||
if (!rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_AWAITING_ALLOCATION) && |
||||
rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_NON_EMPTY_FREE_POOL) && |
||||
rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_RECLAIMER_BENIGN)) { |
||||
rq_step_sched(exec_ctx, resource_user->resource_quota); |
||||
} |
||||
rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_BENIGN); |
||||
} |
||||
|
||||
static void ru_post_destructive_reclaimer(grpc_exec_ctx *exec_ctx, void *ru, |
||||
grpc_error *error) { |
||||
grpc_resource_user *resource_user = ru; |
||||
if (!rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_AWAITING_ALLOCATION) && |
||||
rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_NON_EMPTY_FREE_POOL) && |
||||
rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_RECLAIMER_BENIGN) && |
||||
rulist_empty(resource_user->resource_quota, |
||||
GRPC_RULIST_RECLAIMER_DESTRUCTIVE)) { |
||||
rq_step_sched(exec_ctx, resource_user->resource_quota); |
||||
} |
||||
rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_DESTRUCTIVE); |
||||
} |
||||
|
||||
static void ru_destroy(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) { |
||||
grpc_resource_user *resource_user = ru; |
||||
GPR_ASSERT(resource_user->allocated == 0); |
||||
for (int i = 0; i < GRPC_RULIST_COUNT; i++) { |
||||
rulist_remove(resource_user, (grpc_rulist)i); |
||||
} |
||||
grpc_exec_ctx_sched(exec_ctx, resource_user->reclaimers[0], |
||||
GRPC_ERROR_CANCELLED, NULL); |
||||
grpc_exec_ctx_sched(exec_ctx, resource_user->reclaimers[1], |
||||
GRPC_ERROR_CANCELLED, NULL); |
||||
grpc_exec_ctx_sched(exec_ctx, (grpc_closure *)gpr_atm_no_barrier_load( |
||||
&resource_user->on_done_destroy_closure), |
||||
GRPC_ERROR_NONE, NULL); |
||||
if (resource_user->free_pool != 0) { |
||||
resource_user->resource_quota->free_pool += resource_user->free_pool; |
||||
rq_step_sched(exec_ctx, resource_user->resource_quota); |
||||
} |
||||
} |
||||
|
||||
static void ru_allocated_slices(grpc_exec_ctx *exec_ctx, void *arg, |
||||
grpc_error *error) { |
||||
grpc_resource_user_slice_allocator *slice_allocator = arg; |
||||
if (error == GRPC_ERROR_NONE) { |
||||
for (size_t i = 0; i < slice_allocator->count; i++) { |
||||
gpr_slice_buffer_add_indexed( |
||||
slice_allocator->dest, ru_slice_create(slice_allocator->resource_user, |
||||
slice_allocator->length)); |
||||
} |
||||
} |
||||
grpc_closure_run(exec_ctx, &slice_allocator->on_done, GRPC_ERROR_REF(error)); |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* grpc_resource_quota internal implementation: quota manipulation under the |
||||
* combiner |
||||
*/ |
||||
|
||||
typedef struct { |
||||
int64_t size; |
||||
grpc_resource_quota *resource_quota; |
||||
grpc_closure closure; |
||||
} rq_resize_args; |
||||
|
||||
static void rq_resize(grpc_exec_ctx *exec_ctx, void *args, grpc_error *error) { |
||||
rq_resize_args *a = args; |
||||
int64_t delta = a->size - a->resource_quota->size; |
||||
a->resource_quota->size += delta; |
||||
a->resource_quota->free_pool += delta; |
||||
rq_step_sched(exec_ctx, a->resource_quota); |
||||
grpc_resource_quota_internal_unref(exec_ctx, a->resource_quota); |
||||
gpr_free(a); |
||||
} |
||||
|
||||
static void rq_reclamation_done(grpc_exec_ctx *exec_ctx, void *rq, |
||||
grpc_error *error) { |
||||
grpc_resource_quota *resource_quota = rq; |
||||
resource_quota->reclaiming = false; |
||||
rq_step_sched(exec_ctx, resource_quota); |
||||
grpc_resource_quota_internal_unref(exec_ctx, resource_quota); |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* grpc_resource_quota api |
||||
*/ |
||||
|
||||
/* Public API */ |
||||
grpc_resource_quota *grpc_resource_quota_create(const char *name) { |
||||
grpc_resource_quota *resource_quota = gpr_malloc(sizeof(*resource_quota)); |
||||
gpr_ref_init(&resource_quota->refs, 1); |
||||
resource_quota->combiner = grpc_combiner_create(NULL); |
||||
resource_quota->free_pool = INT64_MAX; |
||||
resource_quota->size = INT64_MAX; |
||||
resource_quota->step_scheduled = false; |
||||
resource_quota->reclaiming = false; |
||||
if (name != NULL) { |
||||
resource_quota->name = gpr_strdup(name); |
||||
} else { |
||||
gpr_asprintf(&resource_quota->name, "anonymous_pool_%" PRIxPTR, |
||||
(intptr_t)resource_quota); |
||||
} |
||||
grpc_closure_init(&resource_quota->rq_step_closure, rq_step, resource_quota); |
||||
grpc_closure_init(&resource_quota->rq_reclamation_done_closure, |
||||
rq_reclamation_done, resource_quota); |
||||
for (int i = 0; i < GRPC_RULIST_COUNT; i++) { |
||||
resource_quota->roots[i] = NULL; |
||||
} |
||||
return resource_quota; |
||||
} |
||||
|
||||
void grpc_resource_quota_internal_unref(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota) { |
||||
if (gpr_unref(&resource_quota->refs)) { |
||||
grpc_combiner_destroy(exec_ctx, resource_quota->combiner); |
||||
gpr_free(resource_quota->name); |
||||
gpr_free(resource_quota); |
||||
} |
||||
} |
||||
|
||||
/* Public API */ |
||||
void grpc_resource_quota_unref(grpc_resource_quota *resource_quota) { |
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
grpc_resource_quota_internal_unref(&exec_ctx, resource_quota); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
} |
||||
|
||||
grpc_resource_quota *grpc_resource_quota_internal_ref( |
||||
grpc_resource_quota *resource_quota) { |
||||
gpr_ref(&resource_quota->refs); |
||||
return resource_quota; |
||||
} |
||||
|
||||
/* Public API */ |
||||
void grpc_resource_quota_ref(grpc_resource_quota *resource_quota) { |
||||
grpc_resource_quota_internal_ref(resource_quota); |
||||
} |
||||
|
||||
/* Public API */ |
||||
void grpc_resource_quota_resize(grpc_resource_quota *resource_quota, |
||||
size_t size) { |
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
rq_resize_args *a = gpr_malloc(sizeof(*a)); |
||||
a->resource_quota = grpc_resource_quota_internal_ref(resource_quota); |
||||
a->size = (int64_t)size; |
||||
grpc_closure_init(&a->closure, rq_resize, a); |
||||
grpc_combiner_execute(&exec_ctx, resource_quota->combiner, &a->closure, |
||||
GRPC_ERROR_NONE, false); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* grpc_resource_user channel args api |
||||
*/ |
||||
|
||||
grpc_resource_quota *grpc_resource_quota_from_channel_args( |
||||
const grpc_channel_args *channel_args) { |
||||
for (size_t i = 0; i < channel_args->num_args; i++) { |
||||
if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) { |
||||
if (channel_args->args[i].type == GRPC_ARG_POINTER) { |
||||
return grpc_resource_quota_internal_ref( |
||||
channel_args->args[i].value.pointer.p); |
||||
} else { |
||||
gpr_log(GPR_DEBUG, GRPC_ARG_RESOURCE_QUOTA " should be a pointer"); |
||||
} |
||||
} |
||||
} |
||||
return grpc_resource_quota_create(NULL); |
||||
} |
||||
|
||||
static void *rq_copy(void *rq) { |
||||
grpc_resource_quota_ref(rq); |
||||
return rq; |
||||
} |
||||
|
||||
static void rq_destroy(void *rq) { grpc_resource_quota_unref(rq); } |
||||
|
||||
static int rq_cmp(void *a, void *b) { return GPR_ICMP(a, b); } |
||||
|
||||
const grpc_arg_pointer_vtable *grpc_resource_quota_arg_vtable(void) { |
||||
static const grpc_arg_pointer_vtable vtable = {rq_copy, rq_destroy, rq_cmp}; |
||||
return &vtable; |
||||
} |
||||
|
||||
/*******************************************************************************
|
||||
* grpc_resource_user api |
||||
*/ |
||||
|
||||
void grpc_resource_user_init(grpc_resource_user *resource_user, |
||||
grpc_resource_quota *resource_quota, |
||||
const char *name) { |
||||
resource_user->resource_quota = |
||||
grpc_resource_quota_internal_ref(resource_quota); |
||||
grpc_closure_init(&resource_user->allocate_closure, &ru_allocate, |
||||
resource_user); |
||||
grpc_closure_init(&resource_user->add_to_free_pool_closure, |
||||
&ru_add_to_free_pool, resource_user); |
||||
grpc_closure_init(&resource_user->post_reclaimer_closure[0], |
||||
&ru_post_benign_reclaimer, resource_user); |
||||
grpc_closure_init(&resource_user->post_reclaimer_closure[1], |
||||
&ru_post_destructive_reclaimer, resource_user); |
||||
grpc_closure_init(&resource_user->destroy_closure, &ru_destroy, |
||||
resource_user); |
||||
gpr_mu_init(&resource_user->mu); |
||||
resource_user->allocated = 0; |
||||
resource_user->free_pool = 0; |
||||
grpc_closure_list_init(&resource_user->on_allocated); |
||||
resource_user->allocating = false; |
||||
resource_user->added_to_free_pool = false; |
||||
gpr_atm_no_barrier_store(&resource_user->on_done_destroy_closure, 0); |
||||
resource_user->reclaimers[0] = NULL; |
||||
resource_user->reclaimers[1] = NULL; |
||||
for (int i = 0; i < GRPC_RULIST_COUNT; i++) { |
||||
resource_user->links[i].next = resource_user->links[i].prev = NULL; |
||||
} |
||||
if (name != NULL) { |
||||
resource_user->name = gpr_strdup(name); |
||||
} else { |
||||
gpr_asprintf(&resource_user->name, "anonymous_resource_user_%" PRIxPTR, |
||||
(intptr_t)resource_user); |
||||
} |
||||
} |
||||
|
||||
void grpc_resource_user_shutdown(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, |
||||
grpc_closure *on_done) { |
||||
gpr_mu_lock(&resource_user->mu); |
||||
GPR_ASSERT(gpr_atm_no_barrier_load(&resource_user->on_done_destroy_closure) == |
||||
0); |
||||
gpr_atm_no_barrier_store(&resource_user->on_done_destroy_closure, |
||||
(gpr_atm)on_done); |
||||
if (resource_user->allocated == 0) { |
||||
grpc_combiner_execute(exec_ctx, resource_user->resource_quota->combiner, |
||||
&resource_user->destroy_closure, GRPC_ERROR_NONE, |
||||
false); |
||||
} |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
} |
||||
|
||||
void grpc_resource_user_destroy(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user) { |
||||
grpc_resource_quota_internal_unref(exec_ctx, resource_user->resource_quota); |
||||
gpr_mu_destroy(&resource_user->mu); |
||||
gpr_free(resource_user->name); |
||||
} |
||||
|
||||
void grpc_resource_user_alloc(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, size_t size, |
||||
grpc_closure *optional_on_done) { |
||||
gpr_mu_lock(&resource_user->mu); |
||||
grpc_closure *on_done_destroy = (grpc_closure *)gpr_atm_no_barrier_load( |
||||
&resource_user->on_done_destroy_closure); |
||||
if (on_done_destroy != NULL) { |
||||
/* already shutdown */ |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: alloc %" PRIdPTR " after shutdown", |
||||
resource_user->resource_quota->name, resource_user->name, size); |
||||
} |
||||
grpc_exec_ctx_sched( |
||||
exec_ctx, optional_on_done, |
||||
GRPC_ERROR_CREATE("Buffer pool user is already shutdown"), NULL); |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
return; |
||||
} |
||||
resource_user->allocated += (int64_t)size; |
||||
resource_user->free_pool -= (int64_t)size; |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: alloc %" PRIdPTR "; allocated -> %" PRId64 |
||||
", free_pool -> %" PRId64, |
||||
resource_user->resource_quota->name, resource_user->name, size, |
||||
resource_user->allocated, resource_user->free_pool); |
||||
} |
||||
if (resource_user->free_pool < 0) { |
||||
grpc_closure_list_append(&resource_user->on_allocated, optional_on_done, |
||||
GRPC_ERROR_NONE); |
||||
if (!resource_user->allocating) { |
||||
resource_user->allocating = true; |
||||
grpc_combiner_execute(exec_ctx, resource_user->resource_quota->combiner, |
||||
&resource_user->allocate_closure, GRPC_ERROR_NONE, |
||||
false); |
||||
} |
||||
} else { |
||||
grpc_exec_ctx_sched(exec_ctx, optional_on_done, GRPC_ERROR_NONE, NULL); |
||||
} |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
} |
||||
|
||||
void grpc_resource_user_free(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, size_t size) { |
||||
gpr_mu_lock(&resource_user->mu); |
||||
GPR_ASSERT(resource_user->allocated >= (int64_t)size); |
||||
bool was_zero_or_negative = resource_user->free_pool <= 0; |
||||
resource_user->free_pool += (int64_t)size; |
||||
resource_user->allocated -= (int64_t)size; |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: free %" PRIdPTR "; allocated -> %" PRId64 |
||||
", free_pool -> %" PRId64, |
||||
resource_user->resource_quota->name, resource_user->name, size, |
||||
resource_user->allocated, resource_user->free_pool); |
||||
} |
||||
bool is_bigger_than_zero = resource_user->free_pool > 0; |
||||
if (is_bigger_than_zero && was_zero_or_negative && |
||||
!resource_user->added_to_free_pool) { |
||||
resource_user->added_to_free_pool = true; |
||||
grpc_combiner_execute(exec_ctx, resource_user->resource_quota->combiner, |
||||
&resource_user->add_to_free_pool_closure, |
||||
GRPC_ERROR_NONE, false); |
||||
} |
||||
grpc_closure *on_done_destroy = (grpc_closure *)gpr_atm_no_barrier_load( |
||||
&resource_user->on_done_destroy_closure); |
||||
if (on_done_destroy != NULL && resource_user->allocated == 0) { |
||||
grpc_combiner_execute(exec_ctx, resource_user->resource_quota->combiner, |
||||
&resource_user->destroy_closure, GRPC_ERROR_NONE, |
||||
false); |
||||
} |
||||
gpr_mu_unlock(&resource_user->mu); |
||||
} |
||||
|
||||
void grpc_resource_user_post_reclaimer(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, |
||||
bool destructive, |
||||
grpc_closure *closure) { |
||||
if (gpr_atm_acq_load(&resource_user->on_done_destroy_closure) == 0) { |
||||
GPR_ASSERT(resource_user->reclaimers[destructive] == NULL); |
||||
resource_user->reclaimers[destructive] = closure; |
||||
grpc_combiner_execute(exec_ctx, resource_user->resource_quota->combiner, |
||||
&resource_user->post_reclaimer_closure[destructive], |
||||
GRPC_ERROR_NONE, false); |
||||
} else { |
||||
grpc_exec_ctx_sched(exec_ctx, closure, GRPC_ERROR_CANCELLED, NULL); |
||||
} |
||||
} |
||||
|
||||
void grpc_resource_user_finish_reclamation(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user) { |
||||
if (grpc_resource_quota_trace) { |
||||
gpr_log(GPR_DEBUG, "RQ %s %s: reclamation complete", |
||||
resource_user->resource_quota->name, resource_user->name); |
||||
} |
||||
grpc_combiner_execute( |
||||
exec_ctx, resource_user->resource_quota->combiner, |
||||
&resource_user->resource_quota->rq_reclamation_done_closure, |
||||
GRPC_ERROR_NONE, false); |
||||
} |
||||
|
||||
void grpc_resource_user_slice_allocator_init( |
||||
grpc_resource_user_slice_allocator *slice_allocator, |
||||
grpc_resource_user *resource_user, grpc_iomgr_cb_func cb, void *p) { |
||||
grpc_closure_init(&slice_allocator->on_allocated, ru_allocated_slices, |
||||
slice_allocator); |
||||
grpc_closure_init(&slice_allocator->on_done, cb, p); |
||||
slice_allocator->resource_user = resource_user; |
||||
} |
||||
|
||||
void grpc_resource_user_alloc_slices( |
||||
grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user_slice_allocator *slice_allocator, size_t length, |
||||
size_t count, gpr_slice_buffer *dest) { |
||||
slice_allocator->length = length; |
||||
slice_allocator->count = count; |
||||
slice_allocator->dest = dest; |
||||
grpc_resource_user_alloc(exec_ctx, slice_allocator->resource_user, |
||||
count * length, &slice_allocator->on_allocated); |
||||
} |
||||
@ -0,0 +1,224 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2016, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H |
||||
#define GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H |
||||
|
||||
#include <grpc/grpc.h> |
||||
|
||||
#include "src/core/lib/iomgr/exec_ctx.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 int grpc_resource_quota_trace; |
||||
|
||||
grpc_resource_quota *grpc_resource_quota_internal_ref( |
||||
grpc_resource_quota *resource_quota); |
||||
void grpc_resource_quota_internal_unref(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_quota *resource_quota); |
||||
grpc_resource_quota *grpc_resource_quota_from_channel_args( |
||||
const grpc_channel_args *channel_args); |
||||
|
||||
/* Resource users are kept in (potentially) several intrusive linked lists
|
||||
at once. These are the list names. */ |
||||
typedef enum { |
||||
/* Resource users that are waiting for an allocation */ |
||||
GRPC_RULIST_AWAITING_ALLOCATION, |
||||
/* Resource users that have free memory available for internal reclamation */ |
||||
GRPC_RULIST_NON_EMPTY_FREE_POOL, |
||||
/* Resource users that have published a benign reclamation is available */ |
||||
GRPC_RULIST_RECLAIMER_BENIGN, |
||||
/* Resource users that have published a destructive reclamation is
|
||||
available */ |
||||
GRPC_RULIST_RECLAIMER_DESTRUCTIVE, |
||||
/* Number of lists: must be last */ |
||||
GRPC_RULIST_COUNT |
||||
} grpc_rulist; |
||||
|
||||
typedef struct grpc_resource_user grpc_resource_user; |
||||
|
||||
/* Internal linked list pointers for a resource user */ |
||||
typedef struct { |
||||
grpc_resource_user *next; |
||||
grpc_resource_user *prev; |
||||
} grpc_resource_user_link; |
||||
|
||||
struct grpc_resource_user { |
||||
/* The quota this resource user consumes from */ |
||||
grpc_resource_quota *resource_quota; |
||||
|
||||
/* Closure to schedule an allocation under the resource quota combiner lock */ |
||||
grpc_closure allocate_closure; |
||||
/* Closure to publish a non empty free pool under the resource quota combiner
|
||||
lock */ |
||||
grpc_closure add_to_free_pool_closure; |
||||
|
||||
gpr_mu mu; |
||||
/* Total allocated memory outstanding by this resource user in bytes;
|
||||
always positive */ |
||||
int64_t allocated; |
||||
/* The amount of memory (in bytes) this user has cached for its own use: to
|
||||
avoid quota contention, each resource user can keep some memory in |
||||
addition to what it is immediately using (e.g., for caching), and the quota |
||||
can pull it back under memory pressure. |
||||
This value can become negative if more memory has been requested than |
||||
existed in the free pool, at which point the quota is consulted to bring |
||||
this value non-negative (asynchronously). */ |
||||
int64_t free_pool; |
||||
/* A list of closures to call once free_pool becomes non-negative - ie when
|
||||
all outstanding allocations have been granted. */ |
||||
grpc_closure_list on_allocated; |
||||
/* True if we are currently trying to allocate from the quota, false if not */ |
||||
bool allocating; |
||||
/* True if we are currently trying to add ourselves to the non-free quota
|
||||
list, false otherwise */ |
||||
bool added_to_free_pool; |
||||
|
||||
/* Reclaimers: index 0 is the benign reclaimer, 1 is the destructive reclaimer
|
||||
*/ |
||||
grpc_closure *reclaimers[2]; |
||||
/* Trampoline closures to finish reclamation and re-enter the quota combiner
|
||||
lock */ |
||||
grpc_closure post_reclaimer_closure[2]; |
||||
|
||||
/* Closure to execute under the quota combiner to de-register and shutdown the
|
||||
resource user */ |
||||
grpc_closure destroy_closure; |
||||
/* User supplied closure to call once the user has finished shutting down AND
|
||||
all outstanding allocations have been freed. Real type is grpc_closure*, |
||||
but it's stored as an atomic to avoid a mutex on some fast paths. */ |
||||
gpr_atm on_done_destroy_closure; |
||||
|
||||
/* Links in the various grpc_rulist lists */ |
||||
grpc_resource_user_link links[GRPC_RULIST_COUNT]; |
||||
|
||||
/* The name of this resource user, for debugging/tracing */ |
||||
char *name; |
||||
}; |
||||
|
||||
void grpc_resource_user_init(grpc_resource_user *resource_user, |
||||
grpc_resource_quota *resource_quota, |
||||
const char *name); |
||||
void grpc_resource_user_shutdown(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, |
||||
grpc_closure *on_done); |
||||
void grpc_resource_user_destroy(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user); |
||||
|
||||
/* Allocate from the resource user (and its quota).
|
||||
If optional_on_done is NULL, then allocate immediately. This may push the |
||||
quota over-limit, at which point reclamation will kick in. |
||||
If optional_on_done is non-NULL, it will be scheduled when the allocation has |
||||
been granted by the quota. */ |
||||
void grpc_resource_user_alloc(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, size_t size, |
||||
grpc_closure *optional_on_done); |
||||
/* Release memory back to the quota */ |
||||
void grpc_resource_user_free(grpc_exec_ctx *exec_ctx, |
||||
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_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user, |
||||
bool destructive, grpc_closure *closure); |
||||
/* Finish a reclamation step */ |
||||
void grpc_resource_user_finish_reclamation(grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user *resource_user); |
||||
|
||||
/* Helper to allocate slices from a resource user */ |
||||
typedef struct grpc_resource_user_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; |
||||
/* Destination for slices to allocate on the current request */ |
||||
gpr_slice_buffer *dest; |
||||
/* Parent resource user */ |
||||
grpc_resource_user *resource_user; |
||||
} grpc_resource_user_slice_allocator; |
||||
|
||||
/* Initialize a slice allocator.
|
||||
When an allocation is completed, calls \a cb with arg \p. */ |
||||
void grpc_resource_user_slice_allocator_init( |
||||
grpc_resource_user_slice_allocator *slice_allocator, |
||||
grpc_resource_user *resource_user, grpc_iomgr_cb_func cb, void *p); |
||||
|
||||
/* Allocate \a count slices of length \a length into \a dest. Only one request
|
||||
can be outstanding at a time. */ |
||||
void grpc_resource_user_alloc_slices( |
||||
grpc_exec_ctx *exec_ctx, |
||||
grpc_resource_user_slice_allocator *slice_allocator, size_t length, |
||||
size_t count, gpr_slice_buffer *dest); |
||||
|
||||
#endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */ |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue