Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Get the code to stop crashing by fixing bugs

Browse Source
pull/1948/head
Vijay Pai 10 years ago
parent dc0615fa87
commit 7b172b2411
1 changed files with 72 additions and 47 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 97
      test/cpp/qps/client_async.cc

97
test/cpp/qps/client_async.cc
Unescape View File

@ -34,6 +34,7 @@
#include <cassert> #include <cassert>
#include <forward_list> #include <forward_list>
#include <functional> #include <functional>
#include <list>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
@ -57,7 +58,7 @@
namespace grpc { namespace grpc {
namespace testing { namespace testing {
typedef std::forward_list<grpc_time> deadline_list; typedef std::list<grpc_time> deadline_list;
class ClientRpcContext { class ClientRpcContext {
public: public:
@ -72,8 +73,8 @@ class ClientRpcContext {
} }
deadline_list::iterator deadline_posn() const {return deadline_posn_;} deadline_list::iterator deadline_posn() const {return deadline_posn_;}
void set_deadline_posn(deadline_list::iterator&& it) {deadline_posn_ = it;} void set_deadline_posn(const deadline_list::iterator& it) {deadline_posn_ = it;}
virtual void Start() = 0; virtual void Start(CompletionQueue *cq) = 0;
int channel_id() const {return channel_id_;} int channel_id() const {return channel_id_;}
protected: protected:
int channel_id_; int channel_id_;
@ -88,7 +89,8 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
TestService::Stub* stub, const RequestType& req, TestService::Stub* stub, const RequestType& req,
std::function< std::function<
std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>( std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
TestService::Stub*, grpc::ClientContext*, const RequestType&)> TestService::Stub*, grpc::ClientContext*, const RequestType&,
CompletionQueue*)>
start_req, start_req,
std::function<void(grpc::Status, ResponseType*)> on_done) std::function<void(grpc::Status, ResponseType*)> on_done)
: ClientRpcContext(channel_id), context_(), : ClientRpcContext(channel_id), context_(),
@ -99,9 +101,9 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
callback_(on_done), callback_(on_done),
start_req_(start_req) { start_req_(start_req) {
} }
void Start() GRPC_OVERRIDE { void Start(CompletionQueue *cq) GRPC_OVERRIDE {
start_ = Timer::Now(); start_ = Timer::Now();
response_reader_ = start_req_(stub_, &context_, req_); response_reader_ = start_req_(stub_, &context_, req_, cq);
response_reader_->Finish(&response_, &status_, ClientRpcContext::tag(this)); response_reader_->Finish(&response_, &status_, ClientRpcContext::tag(this));
} }
~ClientRpcContextUnaryImpl() GRPC_OVERRIDE {} ~ClientRpcContextUnaryImpl() GRPC_OVERRIDE {}
@ -125,7 +127,7 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
} }
bool DoCallBack (bool) { bool DoCallBack (bool) {
callback_(status_, &response_); callback_(status_, &response_);
return false; return true; // we're done, this'll be ignored
} }
grpc::ClientContext context_; grpc::ClientContext context_;
TestService::Stub* stub_; TestService::Stub* stub_;
@ -134,7 +136,8 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext {
bool (ClientRpcContextUnaryImpl::*next_state_)(bool); bool (ClientRpcContextUnaryImpl::*next_state_)(bool);
std::function<void(grpc::Status, ResponseType*)> callback_; std::function<void(grpc::Status, ResponseType*)> callback_;
std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>( std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
TestService::Stub*, grpc::ClientContext*, const RequestType&)> start_req_; TestService::Stub*, grpc::ClientContext*,
const RequestType&, CompletionQueue *)> start_req_;
grpc::Status status_; grpc::Status status_;
double start_; double start_;
std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>> std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>
@ -146,11 +149,11 @@ typedef std::forward_list<ClientRpcContext *> context_list;
class AsyncClient : public Client { class AsyncClient : public Client {
public: public:
explicit AsyncClient(const ClientConfig& config, explicit AsyncClient(const ClientConfig& config,
std::function<ClientRpcContext*(int, CompletionQueue*, TestService::Stub*, std::function<ClientRpcContext*(int, TestService::Stub*,
const SimpleRequest&)> setup_ctx) : const SimpleRequest&)> setup_ctx) :
Client(config), channel_lock_(config.client_channels()), Client(config), channel_lock_(config.client_channels()),
max_outstanding_per_channel_(config.outstanding_rpcs_per_channel()),
contexts_(config.client_channels()), contexts_(config.client_channels()),
max_outstanding_per_channel_(config.outstanding_rpcs_per_channel()),
channel_count_(config.client_channels()) { channel_count_(config.client_channels()) {
SetupLoadTest(config, config.async_client_threads()); SetupLoadTest(config, config.async_client_threads());
@ -180,11 +183,9 @@ class AsyncClient : public Client {
auto& channel = channels_[ch]; auto& channel = channels_[ch];
auto* cq = cli_cqs_[t].get(); auto* cq = cli_cqs_[t].get();
t = (t + 1) % cli_cqs_.size(); t = (t + 1) % cli_cqs_.size();
auto ctx = setup_ctx(ch, cq, channel.get_stub(), request_); auto ctx = setup_ctx(ch, channel.get_stub(), request_);
if (closed_loop_) { if (closed_loop_) {
// only relevant for closed_loop unary, but harmless for ctx->Start(cq);
// closed_loop streaming
ctx->Start();
} }
else { else {
contexts_[ch].push_front(ctx); contexts_[ch].push_front(ctx);
@ -238,28 +239,36 @@ class AsyncClient : public Client {
} }
if ((closed_loop_ || !rpc_deadlines_[thread_idx].empty()) && if ((closed_loop_ || !rpc_deadlines_[thread_idx].empty()) &&
grpc_time_source::now() > deadline) { grpc_time_source::now() > deadline) {
// we have missed some 1-second deadline, which is too much gpr_log(GPR_INFO, "Missed an RPC deadline, giving up"); // we have missed some 1-second deadline, which is too much
gpr_log(GPR_INFO, "Missed an RPC deadline, giving up");
return false; return false;
} }
if (got_event) { if (got_event) {
ClientRpcContext* ctx = ClientRpcContext::detag(got_tag); ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
if (ctx->RunNextState(ok, histogram) == false) { if (ctx->RunNextState(ok, histogram) == false) {
// call the callback and then delete it // call the callback and then clone the ctx
rpc_deadlines_[thread_idx].erase_after(ctx->deadline_posn());
ctx->RunNextState(ok, histogram); ctx->RunNextState(ok, histogram);
ClientRpcContext *clone_ctx = ctx->StartNewClone(); ClientRpcContext *clone_ctx = ctx->StartNewClone();
delete ctx; if (closed_loop_) {
if (!closed_loop_) { clone_ctx->Start(cli_cqs_[thread_idx].get());
// Put this in the list of idle contexts for this channel }
else {
// Remove the entry from the rpc deadlines list
rpc_deadlines_[thread_idx].erase(ctx->deadline_posn());
// Put the clone_ctx in the list of idle contexts for this channel
// Under lock // Under lock
int ch = clone_ctx->channel_id(); int ch = clone_ctx->channel_id();
std::lock_guard<std::mutex> g(channel_lock_[ch]); std::lock_guard<std::mutex> g(channel_lock_[ch]);
contexts_[ch].push_front(ctx); rpcs_outstanding_[ch]--;
contexts_[ch].push_front(clone_ctx);
} }
// delete the old version
delete ctx;
} }
if (!closed_loop_)
issue_allowed_[thread_idx] = true; // may be ok now even if it hadn't been issue_allowed_[thread_idx] = true; // may be ok now even if it hadn't been
} }
if (issue_allowed_[thread_idx] && if (!closed_loop_ && issue_allowed_[thread_idx] &&
grpc_time_source::now() >= next_issue_[thread_idx]) { grpc_time_source::now() >= next_issue_[thread_idx]) {
// Attempt to issue // Attempt to issue
bool issued = false; bool issued = false;
@ -273,17 +282,28 @@ class AsyncClient : public Client {
max_outstanding_per_channel_) && max_outstanding_per_channel_) &&
!contexts_[next_channel_[thread_idx]].empty()) { !contexts_[next_channel_[thread_idx]].empty()) {
// Get an idle context from the front of the list // Get an idle context from the front of the list
auto ctx = contexts_[next_channel_[thread_idx]].begin(); auto ctx = *(contexts_[next_channel_[thread_idx]].begin());
contexts_[next_channel_[thread_idx]].pop_front(); contexts_[next_channel_[thread_idx]].pop_front();
// do the work to issue // do the work to issue
(*ctx)->Start(); rpc_deadlines_[thread_idx].emplace_back(
grpc_time_source::now() + std::chrono::seconds(1));
auto it = rpc_deadlines_[thread_idx].end();
--it;
ctx->set_deadline_posn(it);
ctx->Start(cli_cqs_[thread_idx].get());
rpcs_outstanding_[next_channel_[thread_idx]]++; rpcs_outstanding_[next_channel_[thread_idx]]++;
issued = true; issued = true;
} }
} }
if (!issued) if (issued) {
grpc_time next_issue;
NextIssueTime(thread_idx, &next_issue);
next_issue_[thread_idx]=next_issue;
}
else {
issue_allowed_[thread_idx] = false; issue_allowed_[thread_idx] = false;
} }
}
return true; return true;
} }
@ -311,12 +331,11 @@ class AsyncUnaryClient GRPC_FINAL : public AsyncClient {
~AsyncUnaryClient() GRPC_OVERRIDE { EndThreads(); } ~AsyncUnaryClient() GRPC_OVERRIDE { EndThreads(); }
private: private:
static ClientRpcContext *SetupCtx(int channel_id, static ClientRpcContext *SetupCtx(int channel_id,
CompletionQueue* cq,
TestService::Stub* stub, TestService::Stub* stub,
const SimpleRequest& req) { const SimpleRequest& req) {
auto check_done = [](grpc::Status s, SimpleResponse* response) {}; auto check_done = [](grpc::Status s, SimpleResponse* response) {};
auto start_req = [cq](TestService::Stub* stub, grpc::ClientContext* ctx, auto start_req = [](TestService::Stub* stub, grpc::ClientContext* ctx,
const SimpleRequest& request) { const SimpleRequest& request, CompletionQueue* cq) {
return stub->AsyncUnaryCall(ctx, request, cq); return stub->AsyncUnaryCall(ctx, request, cq);
}; };
return new ClientRpcContextUnaryImpl<SimpleRequest, return new ClientRpcContextUnaryImpl<SimpleRequest,
@ -333,7 +352,8 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
TestService::Stub* stub, const RequestType& req, TestService::Stub* stub, const RequestType& req,
std::function<std::unique_ptr< std::function<std::unique_ptr<
grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>( grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
TestService::Stub*, grpc::ClientContext*, void*)> start_req, TestService::Stub*, grpc::ClientContext*, CompletionQueue*,
void*)> start_req,
std::function<void(grpc::Status, ResponseType*)> on_done) std::function<void(grpc::Status, ResponseType*)> on_done)
: ClientRpcContext(channel_id), : ClientRpcContext(channel_id),
context_(), context_(),
@ -343,8 +363,7 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
next_state_(&ClientRpcContextStreamingImpl::ReqSent), next_state_(&ClientRpcContextStreamingImpl::ReqSent),
callback_(on_done), callback_(on_done),
start_req_(start_req), start_req_(start_req),
start_(Timer::Now()), start_(Timer::Now()) {}
stream_(start_req_(stub_, &context_, ClientRpcContext::tag(this))) {}
~ClientRpcContextStreamingImpl() GRPC_OVERRIDE {} ~ClientRpcContextStreamingImpl() GRPC_OVERRIDE {}
bool RunNextState(bool ok, Histogram* hist) GRPC_OVERRIDE { bool RunNextState(bool ok, Histogram* hist) GRPC_OVERRIDE {
return (this->*next_state_)(ok, hist); return (this->*next_state_)(ok, hist);
@ -353,7 +372,9 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
return new ClientRpcContextStreamingImpl(channel_id_, return new ClientRpcContextStreamingImpl(channel_id_,
stub_, req_, start_req_, callback_); stub_, req_, start_req_, callback_);
} }
void Start() GRPC_OVERRIDE {} void Start(CompletionQueue *cq) GRPC_OVERRIDE {
stream_ = start_req_(stub_, &context_, cq, ClientRpcContext::tag(this));
}
private: private:
bool ReqSent(bool ok, Histogram*) { return StartWrite(ok); } bool ReqSent(bool ok, Histogram*) { return StartWrite(ok); }
bool StartWrite(bool ok) { bool StartWrite(bool ok) {
@ -385,7 +406,8 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext {
std::function<void(grpc::Status, ResponseType*)> callback_; std::function<void(grpc::Status, ResponseType*)> callback_;
std::function< std::function<
std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>( std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>(
TestService::Stub*, grpc::ClientContext*, void*)> start_req_; TestService::Stub*, grpc::ClientContext*,
CompletionQueue *, void*)> start_req_;
grpc::Status status_; grpc::Status status_;
double start_; double start_;
std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>> std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>
@ -396,17 +418,20 @@ class AsyncStreamingClient GRPC_FINAL : public AsyncClient {
public: public:
explicit AsyncStreamingClient(const ClientConfig& config) explicit AsyncStreamingClient(const ClientConfig& config)
: AsyncClient(config, SetupCtx) { : AsyncClient(config, SetupCtx) {
// async streaming currently only supported closed loop
GPR_ASSERT(config.load_type() == CLOSED_LOOP);
StartThreads(config.async_client_threads()); StartThreads(config.async_client_threads());
} }
~AsyncStreamingClient() GRPC_OVERRIDE { EndThreads(); } ~AsyncStreamingClient() GRPC_OVERRIDE { EndThreads(); }
private: private:
static ClientRpcContext *SetupCtx(int channel_id, static ClientRpcContext *SetupCtx(int channel_id,
CompletionQueue* cq, TestService::Stub* stub, TestService::Stub* stub,
const SimpleRequest& req) { const SimpleRequest& req) {
auto check_done = [](grpc::Status s, SimpleResponse* response) {}; auto check_done = [](grpc::Status s, SimpleResponse* response) {};
auto start_req = [cq](TestService::Stub* stub, grpc::ClientContext* ctx, auto start_req = [](TestService::Stub* stub, grpc::ClientContext* ctx,
void* tag) { CompletionQueue *cq, void* tag) {
auto stream = stub->AsyncStreamingCall(ctx, cq, tag); auto stream = stub->AsyncStreamingCall(ctx, cq, tag);
return stream; return stream;
}; };

Write Preview
Loading…
Cancel
Save