1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/*
*
* Copyright 2018 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <cstdlib>
#include <string>
#include <thread> // NOLINT
#include "absl/base/call_once.h"
#include "absl/strings/str_cat.h"
#include "benchmark/benchmark.h"
#include "include/grpc++/grpc++.h"
#include "opencensus/stats/stats.h"
#include "src/cpp/ext/filters/census/grpc_plugin.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/cpp/microbenchmarks/helpers.h"
namespace grpc {
namespace {
absl::once_flag once;
void RegisterOnce() { absl::call_once(once, RegisterOpenCensusPlugin); }
class EchoServer final : public testing::EchoTestService::Service {
::grpc::Status Echo(::grpc::ServerContext* context,
const testing::EchoRequest* request,
testing::EchoResponse* response) override {
if (request->param().expected_error().code() == 0) {
response->set_message(request->message());
return ::grpc::Status::OK;
} else {
return ::grpc::Status(static_cast<::grpc::StatusCode>(
request->param().expected_error().code()),
"");
}
}
};
// An EchoServerThread object creates an EchoServer on a separate thread and
// shuts down the server and thread when it goes out of scope.
class EchoServerThread final {
public:
EchoServerThread() {
::grpc::ServerBuilder builder;
int port;
builder.AddListeningPort("[::]:0", ::grpc::InsecureServerCredentials(),
&port);
builder.RegisterService(&service_);
server_ = builder.BuildAndStart();
if (server_ == nullptr || port == 0) {
std::abort();
}
server_address_ = absl::StrCat("[::]:", port);
server_thread_ = std::thread(&EchoServerThread::RunServerLoop, this);
}
~EchoServerThread() {
server_->Shutdown();
server_thread_.join();
}
const std::string& address() { return server_address_; }
private:
void RunServerLoop() { server_->Wait(); }
std::string server_address_;
EchoServer service_;
std::unique_ptr<grpc::Server> server_;
std::thread server_thread_;
};
void BM_E2eLatencyCensusDisabled(benchmark::State& state) {
EchoServerThread server;
std::unique_ptr<testing::EchoTestService::Stub> stub =
testing::EchoTestService::NewStub(::grpc::CreateChannel(
server.address(), ::grpc::InsecureChannelCredentials()));
testing::EchoResponse response;
for (auto _ : state) {
testing::EchoRequest request;
::grpc::ClientContext context;
::grpc::Status status = stub->Echo(&context, request, &response);
}
}
BENCHMARK(BM_E2eLatencyCensusDisabled);
void BM_E2eLatencyCensusEnabled(benchmark::State& state) {
RegisterOnce();
// This we can safely repeat, and doing so clears accumulated data to avoid
// initialization costs varying between runs.
RegisterGrpcViewsForExport();
EchoServerThread server;
std::unique_ptr<testing::EchoTestService::Stub> stub =
testing::EchoTestService::NewStub(::grpc::CreateChannel(
server.address(), ::grpc::InsecureChannelCredentials()));
testing::EchoResponse response;
for (auto _ : state) {
testing::EchoRequest request;
::grpc::ClientContext context;
::grpc::Status status = stub->Echo(&context, request, &response);
}
}
BENCHMARK(BM_E2eLatencyCensusEnabled);
} // namespace
} // namespace grpc
BENCHMARK_MAIN();
|