mirror of https://github.com/grpc/grpc.git
Merge branch 'bm_error' of https://github.com/ctiller/grpc into to-grpc-err-is-human
ncteisen
8 years ago
commit
54edf009ec
25 changed files with 1271 additions and 23 deletions
@ -0,0 +1,406 @@ |
||||
/*
|
||||
* |
||||
* 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. |
||||
* |
||||
*/ |
||||
|
||||
/* This benchmark exists to ensure that the benchmark integration is
|
||||
* working */ |
||||
|
||||
#include <string.h> |
||||
#include <sstream> |
||||
|
||||
#include <grpc++/support/channel_arguments.h> |
||||
#include <grpc/grpc.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/string_util.h> |
||||
|
||||
extern "C" { |
||||
#include "src/core/ext/client_channel/client_channel.h" |
||||
#include "src/core/ext/load_reporting/load_reporting_filter.h" |
||||
#include "src/core/lib/channel/channel_stack.h" |
||||
#include "src/core/lib/channel/compress_filter.h" |
||||
#include "src/core/lib/channel/connected_channel.h" |
||||
#include "src/core/lib/channel/deadline_filter.h" |
||||
#include "src/core/lib/channel/http_client_filter.h" |
||||
#include "src/core/lib/channel/http_server_filter.h" |
||||
#include "src/core/lib/channel/message_size_filter.h" |
||||
#include "src/core/lib/transport/transport_impl.h" |
||||
} |
||||
|
||||
#include "third_party/benchmark/include/benchmark/benchmark.h" |
||||
|
||||
static struct Init { |
||||
Init() { grpc_init(); } |
||||
~Init() { grpc_shutdown(); } |
||||
} g_init; |
||||
|
||||
static void BM_InsecureChannelWithDefaults(benchmark::State &state) { |
||||
grpc_channel *channel = |
||||
grpc_insecure_channel_create("localhost:12345", NULL, NULL); |
||||
grpc_completion_queue *cq = grpc_completion_queue_create(NULL); |
||||
grpc_slice method = grpc_slice_from_static_string("/foo/bar"); |
||||
gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
while (state.KeepRunning()) { |
||||
grpc_call_destroy(grpc_channel_create_call(channel, NULL, |
||||
GRPC_PROPAGATE_DEFAULTS, cq, |
||||
method, NULL, deadline, NULL)); |
||||
} |
||||
grpc_channel_destroy(channel); |
||||
} |
||||
BENCHMARK(BM_InsecureChannelWithDefaults); |
||||
|
||||
static void FilterDestroy(grpc_exec_ctx *exec_ctx, void *arg, |
||||
grpc_error *error) { |
||||
gpr_free(arg); |
||||
} |
||||
|
||||
static void DoNothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {} |
||||
|
||||
class FakeClientChannelFactory : public grpc_client_channel_factory { |
||||
public: |
||||
FakeClientChannelFactory() { vtable = &vtable_; } |
||||
|
||||
private: |
||||
static void NoRef(grpc_client_channel_factory *factory) {} |
||||
static void NoUnref(grpc_exec_ctx *exec_ctx, |
||||
grpc_client_channel_factory *factory) {} |
||||
static grpc_subchannel *CreateSubchannel(grpc_exec_ctx *exec_ctx, |
||||
grpc_client_channel_factory *factory, |
||||
const grpc_subchannel_args *args) { |
||||
return nullptr; |
||||
} |
||||
static grpc_channel *CreateClientChannel(grpc_exec_ctx *exec_ctx, |
||||
grpc_client_channel_factory *factory, |
||||
const char *target, |
||||
grpc_client_channel_type type, |
||||
const grpc_channel_args *args) { |
||||
return nullptr; |
||||
} |
||||
|
||||
static const grpc_client_channel_factory_vtable vtable_; |
||||
}; |
||||
|
||||
const grpc_client_channel_factory_vtable FakeClientChannelFactory::vtable_ = { |
||||
NoRef, NoUnref, CreateSubchannel, CreateClientChannel}; |
||||
|
||||
static grpc_arg StringArg(const char *key, const char *value) { |
||||
grpc_arg a; |
||||
a.type = GRPC_ARG_STRING; |
||||
a.key = const_cast<char *>(key); |
||||
a.value.string = const_cast<char *>(value); |
||||
return a; |
||||
} |
||||
|
||||
enum FixtureFlags : uint32_t { |
||||
CHECKS_NOT_LAST = 1, |
||||
REQUIRES_TRANSPORT = 2, |
||||
}; |
||||
|
||||
template <const grpc_channel_filter *kFilter, uint32_t kFlags> |
||||
struct Fixture { |
||||
const grpc_channel_filter *filter = kFilter; |
||||
const uint32_t flags = kFlags; |
||||
}; |
||||
|
||||
namespace dummy_filter { |
||||
|
||||
static void StartTransportStreamOp(grpc_exec_ctx *exec_ctx, |
||||
grpc_call_element *elem, |
||||
grpc_transport_stream_op *op) {} |
||||
|
||||
static void StartTransportOp(grpc_exec_ctx *exec_ctx, |
||||
grpc_channel_element *elem, |
||||
grpc_transport_op *op) {} |
||||
|
||||
static grpc_error *InitCallElem(grpc_exec_ctx *exec_ctx, |
||||
grpc_call_element *elem, |
||||
const grpc_call_element_args *args) { |
||||
return GRPC_ERROR_NONE; |
||||
} |
||||
|
||||
static void SetPollsetOrPollsetSet(grpc_exec_ctx *exec_ctx, |
||||
grpc_call_element *elem, |
||||
grpc_polling_entity *pollent) {} |
||||
|
||||
static void DestroyCallElem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, |
||||
const grpc_call_final_info *final_info, |
||||
void *and_free_memory) {} |
||||
|
||||
grpc_error *InitChannelElem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, |
||||
grpc_channel_element_args *args) { |
||||
return GRPC_ERROR_NONE; |
||||
} |
||||
|
||||
void DestroyChannelElem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem) {} |
||||
|
||||
char *GetPeer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) { |
||||
return gpr_strdup("peer"); |
||||
} |
||||
|
||||
void GetChannelInfo(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, |
||||
const grpc_channel_info *channel_info) {} |
||||
|
||||
static const grpc_channel_filter dummy_filter = {StartTransportStreamOp, |
||||
StartTransportOp, |
||||
0, |
||||
InitCallElem, |
||||
SetPollsetOrPollsetSet, |
||||
DestroyCallElem, |
||||
0, |
||||
InitChannelElem, |
||||
DestroyChannelElem, |
||||
GetPeer, |
||||
GetChannelInfo, |
||||
"dummy_filter"}; |
||||
|
||||
} // namespace dummy_filter
|
||||
|
||||
namespace dummy_transport { |
||||
|
||||
/* Memory required for a single stream element - this is allocated by upper
|
||||
layers and initialized by the transport */ |
||||
size_t sizeof_stream; /* = sizeof(transport stream) */ |
||||
|
||||
/* name of this transport implementation */ |
||||
const char *name; |
||||
|
||||
/* implementation of grpc_transport_init_stream */ |
||||
int InitStream(grpc_exec_ctx *exec_ctx, grpc_transport *self, |
||||
grpc_stream *stream, grpc_stream_refcount *refcount, |
||||
const void *server_data) { |
||||
return 0; |
||||
} |
||||
|
||||
/* implementation of grpc_transport_set_pollset */ |
||||
void SetPollset(grpc_exec_ctx *exec_ctx, grpc_transport *self, |
||||
grpc_stream *stream, grpc_pollset *pollset) {} |
||||
|
||||
/* implementation of grpc_transport_set_pollset */ |
||||
void SetPollsetSet(grpc_exec_ctx *exec_ctx, grpc_transport *self, |
||||
grpc_stream *stream, grpc_pollset_set *pollset_set) {} |
||||
|
||||
/* implementation of grpc_transport_perform_stream_op */ |
||||
void PerformStreamOp(grpc_exec_ctx *exec_ctx, grpc_transport *self, |
||||
grpc_stream *stream, grpc_transport_stream_op *op) { |
||||
grpc_closure_sched(exec_ctx, op->on_complete, GRPC_ERROR_NONE); |
||||
} |
||||
|
||||
/* implementation of grpc_transport_perform_op */ |
||||
void PerformOp(grpc_exec_ctx *exec_ctx, grpc_transport *self, |
||||
grpc_transport_op *op) {} |
||||
|
||||
/* implementation of grpc_transport_destroy_stream */ |
||||
void DestroyStream(grpc_exec_ctx *exec_ctx, grpc_transport *self, |
||||
grpc_stream *stream, void *and_free_memory) {} |
||||
|
||||
/* implementation of grpc_transport_destroy */ |
||||
void Destroy(grpc_exec_ctx *exec_ctx, grpc_transport *self) {} |
||||
|
||||
/* implementation of grpc_transport_get_peer */ |
||||
char *GetPeer(grpc_exec_ctx *exec_ctx, grpc_transport *self) { |
||||
return gpr_strdup("transport_peer"); |
||||
} |
||||
|
||||
/* implementation of grpc_transport_get_endpoint */ |
||||
grpc_endpoint *GetEndpoint(grpc_exec_ctx *exec_ctx, grpc_transport *self) { |
||||
return nullptr; |
||||
} |
||||
|
||||
static const grpc_transport_vtable dummy_transport_vtable = { |
||||
0, "dummy_http2", InitStream, |
||||
SetPollset, SetPollsetSet, PerformStreamOp, |
||||
PerformOp, DestroyStream, Destroy, |
||||
GetPeer, GetEndpoint}; |
||||
|
||||
static grpc_transport dummy_transport = {&dummy_transport_vtable}; |
||||
|
||||
} // namespace dummy_transport
|
||||
|
||||
template <class Fixture> |
||||
static void BM_FilterInitDestroy(benchmark::State &state) { |
||||
Fixture fixture; |
||||
std::ostringstream label; |
||||
|
||||
std::vector<grpc_arg> args; |
||||
FakeClientChannelFactory fake_client_channel_factory; |
||||
args.push_back(grpc_client_channel_factory_create_channel_arg( |
||||
&fake_client_channel_factory)); |
||||
args.push_back(StringArg(GRPC_ARG_SERVER_URI, "localhost")); |
||||
|
||||
grpc_channel_args channel_args = {args.size(), &args[0]}; |
||||
|
||||
std::vector<const grpc_channel_filter *> filters; |
||||
if (fixture.filter != nullptr) { |
||||
filters.push_back(fixture.filter); |
||||
} |
||||
if (fixture.flags & CHECKS_NOT_LAST) { |
||||
filters.push_back(&dummy_filter::dummy_filter); |
||||
label << " has_dummy_filter"; |
||||
} |
||||
|
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
size_t channel_size = grpc_channel_stack_size(&filters[0], filters.size()); |
||||
grpc_channel_stack *channel_stack = |
||||
static_cast<grpc_channel_stack *>(gpr_malloc(channel_size)); |
||||
GPR_ASSERT(GRPC_LOG_IF_ERROR( |
||||
"call_stack_init", |
||||
grpc_channel_stack_init(&exec_ctx, 1, FilterDestroy, channel_stack, |
||||
&filters[0], filters.size(), &channel_args, |
||||
fixture.flags & REQUIRES_TRANSPORT |
||||
? &dummy_transport::dummy_transport |
||||
: nullptr, |
||||
"CHANNEL", channel_stack))); |
||||
grpc_exec_ctx_flush(&exec_ctx); |
||||
grpc_call_stack *call_stack = static_cast<grpc_call_stack *>( |
||||
gpr_malloc(channel_stack->call_stack_size)); |
||||
gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
gpr_timespec start_time = gpr_now(GPR_CLOCK_MONOTONIC); |
||||
grpc_slice method = grpc_slice_from_static_string("/foo/bar"); |
||||
grpc_call_final_info final_info; |
||||
while (state.KeepRunning()) { |
||||
GRPC_ERROR_UNREF(grpc_call_stack_init(&exec_ctx, channel_stack, 1, |
||||
DoNothing, NULL, NULL, NULL, method, |
||||
start_time, deadline, call_stack)); |
||||
grpc_call_stack_destroy(&exec_ctx, call_stack, &final_info, NULL); |
||||
grpc_exec_ctx_flush(&exec_ctx); |
||||
} |
||||
grpc_channel_stack_destroy(&exec_ctx, channel_stack); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
|
||||
state.SetLabel(label.str()); |
||||
} |
||||
|
||||
template <class Fixture> |
||||
static void BM_FilterInitSendInitialMetadataThenDestroy( |
||||
benchmark::State &state) { |
||||
Fixture fixture; |
||||
std::ostringstream label; |
||||
|
||||
std::vector<grpc_arg> args; |
||||
FakeClientChannelFactory fake_client_channel_factory; |
||||
args.push_back(grpc_client_channel_factory_create_channel_arg( |
||||
&fake_client_channel_factory)); |
||||
args.push_back(StringArg(GRPC_ARG_SERVER_URI, "localhost")); |
||||
|
||||
grpc_channel_args channel_args = {args.size(), &args[0]}; |
||||
|
||||
std::vector<const grpc_channel_filter *> filters; |
||||
if (fixture.filter != nullptr) { |
||||
filters.push_back(fixture.filter); |
||||
} |
||||
if (fixture.flags & CHECKS_NOT_LAST) { |
||||
filters.push_back(&dummy_filter::dummy_filter); |
||||
label << " has_dummy_filter"; |
||||
} |
||||
|
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
size_t channel_size = grpc_channel_stack_size(&filters[0], filters.size()); |
||||
grpc_channel_stack *channel_stack = |
||||
static_cast<grpc_channel_stack *>(gpr_malloc(channel_size)); |
||||
GPR_ASSERT(GRPC_LOG_IF_ERROR( |
||||
"call_stack_init", |
||||
grpc_channel_stack_init(&exec_ctx, 1, FilterDestroy, channel_stack, |
||||
&filters[0], filters.size(), &channel_args, |
||||
fixture.flags & REQUIRES_TRANSPORT |
||||
? &dummy_transport::dummy_transport |
||||
: nullptr, |
||||
"CHANNEL", channel_stack))); |
||||
grpc_exec_ctx_flush(&exec_ctx); |
||||
grpc_call_stack *call_stack = static_cast<grpc_call_stack *>( |
||||
gpr_malloc(channel_stack->call_stack_size)); |
||||
gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
gpr_timespec start_time = gpr_now(GPR_CLOCK_MONOTONIC); |
||||
grpc_slice method = grpc_slice_from_static_string("/foo/bar"); |
||||
grpc_call_final_info final_info; |
||||
grpc_transport_stream_op op; |
||||
memset(&op, 0, sizeof(op)); |
||||
grpc_closure closure; |
||||
op.on_complete = grpc_closure_init(&closure, DoNothing, nullptr, |
||||
grpc_schedule_on_exec_ctx); |
||||
while (state.KeepRunning()) { |
||||
grpc_metadata_batch batch; |
||||
grpc_metadata_batch_init(&batch); |
||||
op.send_initial_metadata = &batch; |
||||
GRPC_ERROR_UNREF(grpc_call_stack_init(&exec_ctx, channel_stack, 1, |
||||
DoNothing, NULL, NULL, NULL, method, |
||||
start_time, deadline, call_stack)); |
||||
auto elem = grpc_call_stack_element(call_stack, 0); |
||||
elem->filter->start_transport_stream_op(&exec_ctx, elem, &op); |
||||
grpc_call_stack_destroy(&exec_ctx, call_stack, &final_info, NULL); |
||||
grpc_metadata_batch_destroy(&exec_ctx, &batch); |
||||
grpc_exec_ctx_flush(&exec_ctx); |
||||
} |
||||
grpc_channel_stack_destroy(&exec_ctx, channel_stack); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
|
||||
state.SetLabel(label.str()); |
||||
} |
||||
|
||||
typedef Fixture<nullptr, 0> NoFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, NoFilter); |
||||
typedef Fixture<&dummy_filter::dummy_filter, 0> DummyFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, DummyFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, DummyFilter); |
||||
typedef Fixture<&grpc_client_channel_filter, 0> ClientChannelFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, ClientChannelFilter); |
||||
typedef Fixture<&grpc_compress_filter, CHECKS_NOT_LAST> CompressFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, CompressFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, CompressFilter); |
||||
typedef Fixture<&grpc_client_deadline_filter, CHECKS_NOT_LAST> |
||||
ClientDeadlineFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, ClientDeadlineFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, |
||||
ClientDeadlineFilter); |
||||
typedef Fixture<&grpc_server_deadline_filter, CHECKS_NOT_LAST> |
||||
ServerDeadlineFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, ServerDeadlineFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, |
||||
ServerDeadlineFilter); |
||||
typedef Fixture<&grpc_http_client_filter, CHECKS_NOT_LAST | REQUIRES_TRANSPORT> |
||||
HttpClientFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, HttpClientFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, |
||||
HttpClientFilter); |
||||
typedef Fixture<&grpc_http_server_filter, CHECKS_NOT_LAST> HttpServerFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, HttpServerFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, |
||||
HttpServerFilter); |
||||
typedef Fixture<&grpc_message_size_filter, CHECKS_NOT_LAST> MessageSizeFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, MessageSizeFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, |
||||
MessageSizeFilter); |
||||
typedef Fixture<&grpc_load_reporting_filter, CHECKS_NOT_LAST> |
||||
LoadReportingFilter; |
||||
BENCHMARK_TEMPLATE(BM_FilterInitDestroy, LoadReportingFilter); |
||||
BENCHMARK_TEMPLATE(BM_FilterInitSendInitialMetadataThenDestroy, |
||||
LoadReportingFilter); |
||||
|
||||
BENCHMARK_MAIN(); |
||||
@ -0,0 +1,119 @@ |
||||
/*
|
||||
* |
||||
* 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. |
||||
* |
||||
*/ |
||||
|
||||
/* This benchmark exists to ensure that the benchmark integration is
|
||||
* working */ |
||||
|
||||
#include <grpc++/completion_queue.h> |
||||
#include <grpc++/impl/grpc_library.h> |
||||
#include <grpc/grpc.h> |
||||
|
||||
#include "third_party/benchmark/include/benchmark/benchmark.h" |
||||
|
||||
extern "C" { |
||||
#include "src/core/lib/surface/completion_queue.h" |
||||
} |
||||
|
||||
namespace grpc { |
||||
namespace testing { |
||||
|
||||
static class InitializeStuff { |
||||
public: |
||||
InitializeStuff() { init_lib_.init(); } |
||||
~InitializeStuff() { init_lib_.shutdown(); } |
||||
|
||||
private: |
||||
internal::GrpcLibrary init_lib_; |
||||
internal::GrpcLibraryInitializer init_; |
||||
} initialize_stuff; |
||||
|
||||
static void BM_CreateDestroyCpp(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
CompletionQueue cq; |
||||
} |
||||
} |
||||
BENCHMARK(BM_CreateDestroyCpp); |
||||
|
||||
static void BM_CreateDestroyCore(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
grpc_completion_queue_destroy(grpc_completion_queue_create(NULL)); |
||||
} |
||||
} |
||||
BENCHMARK(BM_CreateDestroyCore); |
||||
|
||||
static void DoneWithCompletionOnStack(grpc_exec_ctx* exec_ctx, void* arg, |
||||
grpc_cq_completion* completion) {} |
||||
|
||||
class DummyTag final : public CompletionQueueTag { |
||||
public: |
||||
bool FinalizeResult(void** tag, bool* status) override { return true; } |
||||
}; |
||||
|
||||
static void BM_Pass1Cpp(benchmark::State& state) { |
||||
CompletionQueue cq; |
||||
grpc_completion_queue* c_cq = cq.cq(); |
||||
while (state.KeepRunning()) { |
||||
grpc_cq_completion completion; |
||||
DummyTag dummy_tag; |
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
grpc_cq_begin_op(c_cq, &dummy_tag); |
||||
grpc_cq_end_op(&exec_ctx, c_cq, &dummy_tag, GRPC_ERROR_NONE, |
||||
DoneWithCompletionOnStack, NULL, &completion); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
void* tag; |
||||
bool ok; |
||||
cq.Next(&tag, &ok); |
||||
} |
||||
} |
||||
BENCHMARK(BM_Pass1Cpp); |
||||
|
||||
static void BM_Pass1Core(benchmark::State& state) { |
||||
grpc_completion_queue* cq = grpc_completion_queue_create(NULL); |
||||
gpr_timespec deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
while (state.KeepRunning()) { |
||||
grpc_cq_completion completion; |
||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
||||
grpc_cq_begin_op(cq, NULL); |
||||
grpc_cq_end_op(&exec_ctx, cq, NULL, GRPC_ERROR_NONE, |
||||
DoneWithCompletionOnStack, NULL, &completion); |
||||
grpc_exec_ctx_finish(&exec_ctx); |
||||
grpc_completion_queue_next(cq, deadline, NULL); |
||||
} |
||||
grpc_completion_queue_destroy(cq); |
||||
} |
||||
BENCHMARK(BM_Pass1Core); |
||||
|
||||
} // namespace testing
|
||||
} // namespace grpc
|
||||
|
||||
BENCHMARK_MAIN(); |
||||
@ -0,0 +1,248 @@ |
||||
/*
|
||||
* |
||||
* 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. |
||||
* |
||||
*/ |
||||
|
||||
/* Test various operations on grpc_error */ |
||||
|
||||
#include <memory> |
||||
|
||||
extern "C" { |
||||
#include "src/core/lib/iomgr/error.h" |
||||
#include "src/core/lib/transport/error_utils.h" |
||||
} |
||||
|
||||
#include "third_party/benchmark/include/benchmark/benchmark.h" |
||||
|
||||
class ErrorDeleter { |
||||
public: |
||||
void operator()(grpc_error* error) { GRPC_ERROR_UNREF(error); } |
||||
}; |
||||
typedef std::unique_ptr<grpc_error, ErrorDeleter> ErrorPtr; |
||||
|
||||
static void BM_ErrorCreate(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
GRPC_ERROR_UNREF(GRPC_ERROR_CREATE("Error")); |
||||
} |
||||
} |
||||
BENCHMARK(BM_ErrorCreate); |
||||
|
||||
static void BM_ErrorCreateAndSetStatus(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
GRPC_ERROR_UNREF(grpc_error_set_int(GRPC_ERROR_CREATE("Error"), |
||||
GRPC_ERROR_INT_GRPC_STATUS, |
||||
GRPC_STATUS_ABORTED)); |
||||
} |
||||
} |
||||
BENCHMARK(BM_ErrorCreateAndSetStatus); |
||||
|
||||
static void BM_ErrorRefUnref(benchmark::State& state) { |
||||
grpc_error* error = GRPC_ERROR_CREATE("Error"); |
||||
while (state.KeepRunning()) { |
||||
GRPC_ERROR_UNREF(GRPC_ERROR_REF(error)); |
||||
} |
||||
GRPC_ERROR_UNREF(error); |
||||
} |
||||
BENCHMARK(BM_ErrorRefUnref); |
||||
|
||||
static void BM_ErrorUnrefNone(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
GRPC_ERROR_UNREF(GRPC_ERROR_NONE); |
||||
} |
||||
} |
||||
BENCHMARK(BM_ErrorUnrefNone); |
||||
|
||||
static void BM_ErrorGetIntFromNoError(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
intptr_t value; |
||||
grpc_error_get_int(GRPC_ERROR_NONE, GRPC_ERROR_INT_GRPC_STATUS, &value); |
||||
} |
||||
} |
||||
BENCHMARK(BM_ErrorGetIntFromNoError); |
||||
|
||||
static void BM_ErrorGetMissingInt(benchmark::State& state) { |
||||
ErrorPtr error( |
||||
grpc_error_set_int(GRPC_ERROR_CREATE("Error"), GRPC_ERROR_INT_INDEX, 1)); |
||||
while (state.KeepRunning()) { |
||||
intptr_t value; |
||||
grpc_error_get_int(error.get(), GRPC_ERROR_INT_OFFSET, &value); |
||||
} |
||||
} |
||||
BENCHMARK(BM_ErrorGetMissingInt); |
||||
|
||||
static void BM_ErrorGetPresentInt(benchmark::State& state) { |
||||
ErrorPtr error( |
||||
grpc_error_set_int(GRPC_ERROR_CREATE("Error"), GRPC_ERROR_INT_OFFSET, 1)); |
||||
while (state.KeepRunning()) { |
||||
intptr_t value; |
||||
grpc_error_get_int(error.get(), GRPC_ERROR_INT_OFFSET, &value); |
||||
} |
||||
} |
||||
BENCHMARK(BM_ErrorGetPresentInt); |
||||
|
||||
// Fixtures for tests: generate different kinds of errors
|
||||
class ErrorNone { |
||||
public: |
||||
gpr_timespec deadline() const { return deadline_; } |
||||
grpc_error* error() const { return GRPC_ERROR_NONE; } |
||||
|
||||
private: |
||||
const gpr_timespec deadline_ = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
}; |
||||
|
||||
class ErrorCancelled { |
||||
public: |
||||
gpr_timespec deadline() const { return deadline_; } |
||||
grpc_error* error() const { return GRPC_ERROR_CANCELLED; } |
||||
|
||||
private: |
||||
const gpr_timespec deadline_ = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
}; |
||||
|
||||
class SimpleError { |
||||
public: |
||||
gpr_timespec deadline() const { return deadline_; } |
||||
grpc_error* error() const { return error_.get(); } |
||||
|
||||
private: |
||||
const gpr_timespec deadline_ = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
ErrorPtr error_{GRPC_ERROR_CREATE("Error")}; |
||||
}; |
||||
|
||||
class ErrorWithGrpcStatus { |
||||
public: |
||||
gpr_timespec deadline() const { return deadline_; } |
||||
grpc_error* error() const { return error_.get(); } |
||||
|
||||
private: |
||||
const gpr_timespec deadline_ = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
ErrorPtr error_{grpc_error_set_int(GRPC_ERROR_CREATE("Error"), |
||||
GRPC_ERROR_INT_GRPC_STATUS, |
||||
GRPC_STATUS_UNIMPLEMENTED)}; |
||||
}; |
||||
|
||||
class ErrorWithHttpError { |
||||
public: |
||||
gpr_timespec deadline() const { return deadline_; } |
||||
grpc_error* error() const { return error_.get(); } |
||||
|
||||
private: |
||||
const gpr_timespec deadline_ = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
ErrorPtr error_{grpc_error_set_int(GRPC_ERROR_CREATE("Error"), |
||||
GRPC_ERROR_INT_HTTP2_ERROR, |
||||
GRPC_HTTP2_COMPRESSION_ERROR)}; |
||||
}; |
||||
|
||||
class ErrorWithNestedGrpcStatus { |
||||
public: |
||||
gpr_timespec deadline() const { return deadline_; } |
||||
grpc_error* error() const { return error_.get(); } |
||||
|
||||
private: |
||||
const gpr_timespec deadline_ = gpr_inf_future(GPR_CLOCK_MONOTONIC); |
||||
ErrorPtr nested_error_{grpc_error_set_int(GRPC_ERROR_CREATE("Error"), |
||||
GRPC_ERROR_INT_GRPC_STATUS, |
||||
GRPC_STATUS_UNIMPLEMENTED)}; |
||||
grpc_error* nested_errors_[1] = {nested_error_.get()}; |
||||
ErrorPtr error_{GRPC_ERROR_CREATE_REFERENCING("Error", nested_errors_, 1)}; |
||||
}; |
||||
|
||||
template <class Fixture> |
||||
static void BM_ErrorStringOnNewError(benchmark::State& state) { |
||||
while (state.KeepRunning()) { |
||||
Fixture fixture; |
||||
grpc_error_string(fixture.error()); |
||||
} |
||||
} |
||||
|
||||
template <class Fixture> |
||||
static void BM_ErrorStringRepeatedly(benchmark::State& state) { |
||||
Fixture fixture; |
||||
while (state.KeepRunning()) { |
||||
grpc_error_string(fixture.error()); |
||||
} |
||||
} |
||||
|
||||
template <class Fixture> |
||||
static void BM_ErrorGetStatus(benchmark::State& state) { |
||||
Fixture fixture; |
||||
while (state.KeepRunning()) { |
||||
grpc_status_code status; |
||||
const char* msg; |
||||
grpc_error_get_status(fixture.error(), fixture.deadline(), &status, &msg, |
||||
NULL); |
||||
} |
||||
} |
||||
|
||||
template <class Fixture> |
||||
static void BM_ErrorGetStatusCode(benchmark::State& state) { |
||||
Fixture fixture; |
||||
while (state.KeepRunning()) { |
||||
grpc_status_code status; |
||||
grpc_error_get_status(fixture.error(), fixture.deadline(), &status, NULL, |
||||
NULL); |
||||
} |
||||
} |
||||
|
||||
template <class Fixture> |
||||
static void BM_ErrorHttpError(benchmark::State& state) { |
||||
Fixture fixture; |
||||
while (state.KeepRunning()) { |
||||
grpc_http2_error_code error; |
||||
grpc_error_get_status(fixture.error(), fixture.deadline(), NULL, NULL, |
||||
&error); |
||||
} |
||||
} |
||||
|
||||
template <class Fixture> |
||||
static void BM_HasClearGrpcStatus(benchmark::State& state) { |
||||
Fixture fixture; |
||||
while (state.KeepRunning()) { |
||||
grpc_error_has_clear_grpc_status(fixture.error()); |
||||
} |
||||
} |
||||
|
||||
#define BENCHMARK_SUITE(fixture) \ |
||||
BENCHMARK_TEMPLATE(BM_ErrorStringOnNewError, fixture); \
|
||||
BENCHMARK_TEMPLATE(BM_ErrorStringRepeatedly, fixture); \
|
||||
BENCHMARK_TEMPLATE(BM_ErrorGetStatus, fixture); \
|
||||
BENCHMARK_TEMPLATE(BM_ErrorGetStatusCode, fixture); \
|
||||
BENCHMARK_TEMPLATE(BM_ErrorHttpError, fixture); \
|
||||
BENCHMARK_TEMPLATE(BM_HasClearGrpcStatus, fixture) |
||||
|
||||
BENCHMARK_SUITE(ErrorNone); |
||||
BENCHMARK_SUITE(ErrorCancelled); |
||||
BENCHMARK_SUITE(SimpleError); |
||||
BENCHMARK_SUITE(ErrorWithGrpcStatus); |
||||
BENCHMARK_SUITE(ErrorWithHttpError); |
||||
BENCHMARK_SUITE(ErrorWithNestedGrpcStatus); |
||||
|
||||
BENCHMARK_MAIN(); |
||||
Loading…
Reference in new issue