1 /*
2 *
3 * Copyright 2015 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <grpc/grpc.h>
20
21 #include <stdio.h>
22 #include <string.h>
23
24 #include <grpc/support/log.h>
25 #include <grpc/support/time.h>
26
27 #include "src/core/lib/gpr/useful.h"
28 #include "src/core/lib/profiling/timers.h"
29 #include "test/core/util/cmdline.h"
30 #include "test/core/util/grpc_profiler.h"
31 #include "test/core/util/histogram.h"
32 #include "test/core/util/test_config.h"
33
34 static grpc_histogram* histogram;
35 static grpc_byte_buffer* the_buffer;
36 static grpc_channel* channel;
37 static grpc_completion_queue* cq;
38 static grpc_call* call;
39 static grpc_op ops[6];
40 static grpc_op stream_init_ops[2];
41 static grpc_op stream_step_ops[2];
42 static grpc_metadata_array initial_metadata_recv;
43 static grpc_metadata_array trailing_metadata_recv;
44 static grpc_byte_buffer* response_payload_recv = nullptr;
45 static grpc_status_code status;
46 static grpc_slice details;
47 static grpc_op* op;
48
init_ping_pong_request(void)49 static void init_ping_pong_request(void) {
50 grpc_metadata_array_init(&initial_metadata_recv);
51 grpc_metadata_array_init(&trailing_metadata_recv);
52
53 memset(ops, 0, sizeof(ops));
54 op = ops;
55
56 op->op = GRPC_OP_SEND_INITIAL_METADATA;
57 op->data.send_initial_metadata.count = 0;
58 op++;
59 op->op = GRPC_OP_SEND_MESSAGE;
60 op->data.send_message.send_message = the_buffer;
61 op++;
62 op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
63 op++;
64 op->op = GRPC_OP_RECV_INITIAL_METADATA;
65 op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
66 op++;
67 op->op = GRPC_OP_RECV_MESSAGE;
68 op->data.recv_message.recv_message = &response_payload_recv;
69 op++;
70 op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
71 op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
72 op->data.recv_status_on_client.status = &status;
73 op->data.recv_status_on_client.status_details = &details;
74 op++;
75 }
76
step_ping_pong_request(void)77 static void step_ping_pong_request(void) {
78 GPR_TIMER_SCOPE("ping_pong", 1);
79 grpc_slice host = grpc_slice_from_static_string("localhost");
80 call = grpc_channel_create_call(
81 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
82 grpc_slice_from_static_string("/Reflector/reflectUnary"), &host,
83 gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
84 GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
85 (size_t)(op - ops), (void*)1,
86 nullptr));
87 grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
88 grpc_call_unref(call);
89 grpc_byte_buffer_destroy(response_payload_recv);
90 call = nullptr;
91 }
92
init_ping_pong_stream(void)93 static void init_ping_pong_stream(void) {
94 grpc_metadata_array_init(&initial_metadata_recv);
95
96 grpc_call_error error;
97 grpc_slice host = grpc_slice_from_static_string("localhost");
98 call = grpc_channel_create_call(
99 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
100 grpc_slice_from_static_string("/Reflector/reflectStream"), &host,
101 gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
102 stream_init_ops[0].op = GRPC_OP_SEND_INITIAL_METADATA;
103 stream_init_ops[0].data.send_initial_metadata.count = 0;
104 stream_init_ops[1].op = GRPC_OP_RECV_INITIAL_METADATA;
105 stream_init_ops[1].data.recv_initial_metadata.recv_initial_metadata =
106 &initial_metadata_recv;
107 error = grpc_call_start_batch(call, stream_init_ops, 2, (void*)1, nullptr);
108 GPR_ASSERT(GRPC_CALL_OK == error);
109 grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
110
111 grpc_metadata_array_init(&initial_metadata_recv);
112
113 stream_step_ops[0].op = GRPC_OP_SEND_MESSAGE;
114 stream_step_ops[0].data.send_message.send_message = the_buffer;
115 stream_step_ops[1].op = GRPC_OP_RECV_MESSAGE;
116 stream_step_ops[1].data.recv_message.recv_message = &response_payload_recv;
117 }
118
step_ping_pong_stream(void)119 static void step_ping_pong_stream(void) {
120 GPR_TIMER_SCOPE("ping_pong", 1);
121 grpc_call_error error;
122 error = grpc_call_start_batch(call, stream_step_ops, 2, (void*)1, nullptr);
123 GPR_ASSERT(GRPC_CALL_OK == error);
124 grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
125 grpc_byte_buffer_destroy(response_payload_recv);
126 }
127
now(void)128 static double now(void) {
129 gpr_timespec tv = gpr_now(GPR_CLOCK_REALTIME);
130 return 1e9 * static_cast<double>(tv.tv_sec) + tv.tv_nsec;
131 }
132
133 typedef struct {
134 const char* name;
135 void (*init)();
136 void (*do_one_step)();
137 } scenario;
138
139 static const scenario scenarios[] = {
140 {"ping-pong-request", init_ping_pong_request, step_ping_pong_request},
141 {"ping-pong-stream", init_ping_pong_stream, step_ping_pong_stream},
142 };
143
main(int argc,char ** argv)144 int main(int argc, char** argv) {
145 grpc_slice slice = grpc_slice_from_copied_string("x");
146 double start, stop;
147 unsigned i;
148
149 char* fake_argv[1];
150
151 int payload_size = 1;
152 int secure = 0;
153 const char* target = "localhost:443";
154 gpr_cmdline* cl;
155 grpc_event event;
156 const char* scenario_name = "ping-pong-request";
157 scenario sc = {nullptr, nullptr, nullptr};
158
159 gpr_timers_set_log_filename("latency_trace.fling_client.txt");
160
161 grpc_init();
162
163 GPR_ASSERT(argc >= 1);
164 fake_argv[0] = argv[0];
165 grpc_test_init(1, fake_argv);
166
167 int warmup_seconds = 1;
168 int benchmark_seconds = 5;
169
170 cl = gpr_cmdline_create("fling client");
171 gpr_cmdline_add_int(cl, "payload_size", "Size of the payload to send",
172 &payload_size);
173 gpr_cmdline_add_string(cl, "target", "Target host:port", &target);
174 gpr_cmdline_add_flag(cl, "secure", "Run with security?", &secure);
175 gpr_cmdline_add_string(cl, "scenario", "Scenario", &scenario_name);
176 gpr_cmdline_add_int(cl, "warmup", "Warmup seconds", &warmup_seconds);
177 gpr_cmdline_add_int(cl, "benchmark", "Benchmark seconds", &benchmark_seconds);
178 gpr_cmdline_parse(cl, argc, argv);
179 gpr_cmdline_destroy(cl);
180
181 for (i = 0; i < GPR_ARRAY_SIZE(scenarios); i++) {
182 if (0 == strcmp(scenarios[i].name, scenario_name)) {
183 sc = scenarios[i];
184 }
185 }
186 if (!sc.name) {
187 fprintf(stderr, "unsupported scenario '%s'. Valid are:", scenario_name);
188 fflush(stderr);
189 for (i = 0; i < GPR_ARRAY_SIZE(scenarios); i++) {
190 fprintf(stderr, " %s", scenarios[i].name);
191 fflush(stderr);
192 }
193 return 1;
194 }
195
196 channel = grpc_insecure_channel_create(target, nullptr, nullptr);
197 cq = grpc_completion_queue_create_for_next(nullptr);
198 the_buffer =
199 grpc_raw_byte_buffer_create(&slice, static_cast<size_t>(payload_size));
200 histogram = grpc_histogram_create(0.01, 60e9);
201
202 sc.init();
203
204 gpr_timespec end_warmup = grpc_timeout_seconds_to_deadline(warmup_seconds);
205 gpr_timespec end_profiling =
206 grpc_timeout_seconds_to_deadline(warmup_seconds + benchmark_seconds);
207
208 while (gpr_time_cmp(gpr_now(end_warmup.clock_type), end_warmup) < 0) {
209 sc.do_one_step();
210 }
211
212 gpr_log(GPR_INFO, "start profiling");
213 grpc_profiler_start("client.prof");
214 while (gpr_time_cmp(gpr_now(end_profiling.clock_type), end_profiling) < 0) {
215 start = now();
216 sc.do_one_step();
217 stop = now();
218 grpc_histogram_add(histogram, stop - start);
219 }
220 grpc_profiler_stop();
221
222 if (call) {
223 grpc_call_unref(call);
224 }
225
226 grpc_channel_destroy(channel);
227 grpc_completion_queue_shutdown(cq);
228 do {
229 event = grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
230 nullptr);
231 } while (event.type != GRPC_QUEUE_SHUTDOWN);
232 grpc_completion_queue_destroy(cq);
233 grpc_byte_buffer_destroy(the_buffer);
234 grpc_slice_unref(slice);
235
236 gpr_log(GPR_INFO, "latency (50/95/99/99.9): %f/%f/%f/%f",
237 grpc_histogram_percentile(histogram, 50),
238 grpc_histogram_percentile(histogram, 95),
239 grpc_histogram_percentile(histogram, 99),
240 grpc_histogram_percentile(histogram, 99.9));
241 grpc_histogram_destroy(histogram);
242
243 grpc_shutdown();
244
245 return 0;
246 }
247