1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to
5 * deal in the Software without restriction, including without limitation the
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 * sell copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 * IN THE SOFTWARE.
20 */
21
22 #include "task.h"
23 #include "uv.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #define EXPECTED "RANG TANG DING DONG I AM THE JAPANESE SANDMAN"
30
31 #define TEST_DURATION 5000 /* ms */
32
33 #define BASE_PORT 12345
34
35 struct sender_state {
36 struct sockaddr_in addr;
37 uv_udp_send_t send_req;
38 uv_udp_t udp_handle;
39 };
40
41 struct receiver_state {
42 struct sockaddr_in addr;
43 uv_udp_t udp_handle;
44 };
45
46 /* not used in timed mode */
47 static unsigned int packet_counter = (unsigned int) 1e6;
48
49 static int n_senders_;
50 static int n_receivers_;
51 static uv_buf_t bufs[5];
52 static struct sender_state senders[1024];
53 static struct receiver_state receivers[1024];
54
55 static unsigned int send_cb_called;
56 static unsigned int recv_cb_called;
57 static unsigned int close_cb_called;
58 static int timed;
59 static int exiting;
60
61
alloc_cb(uv_handle_t * handle,size_t suggested_size,uv_buf_t * buf)62 static void alloc_cb(uv_handle_t* handle,
63 size_t suggested_size,
64 uv_buf_t* buf) {
65 static char slab[65536];
66 ASSERT_LE(suggested_size, sizeof(slab));
67 buf->base = slab;
68 buf->len = sizeof(slab);
69 }
70
71
send_cb(uv_udp_send_t * req,int status)72 static void send_cb(uv_udp_send_t* req, int status) {
73 struct sender_state* s;
74
75 ASSERT_NOT_NULL(req);
76
77 if (status != 0) {
78 ASSERT_EQ(status, UV_ECANCELED);
79 return;
80 }
81
82 if (exiting)
83 return;
84
85 s = container_of(req, struct sender_state, send_req);
86 ASSERT_PTR_EQ(req->handle, &s->udp_handle);
87
88 if (timed)
89 goto send;
90
91 if (packet_counter == 0) {
92 uv_close((uv_handle_t*)&s->udp_handle, NULL);
93 return;
94 }
95
96 packet_counter--;
97
98 send:
99 ASSERT_OK(uv_udp_send(&s->send_req,
100 &s->udp_handle,
101 bufs,
102 ARRAY_SIZE(bufs),
103 (const struct sockaddr*) &s->addr,
104 send_cb));
105 send_cb_called++;
106 }
107
108
recv_cb(uv_udp_t * handle,ssize_t nread,const uv_buf_t * buf,const struct sockaddr * addr,unsigned flags)109 static void recv_cb(uv_udp_t* handle,
110 ssize_t nread,
111 const uv_buf_t* buf,
112 const struct sockaddr* addr,
113 unsigned flags) {
114 if (nread == 0)
115 return;
116
117 if (nread < 0) {
118 ASSERT_EQ(nread, UV_ECANCELED);
119 return;
120 }
121
122 ASSERT_EQ(addr->sa_family, AF_INET);
123 ASSERT(!memcmp(buf->base, EXPECTED, nread));
124
125 recv_cb_called++;
126 }
127
128
close_cb(uv_handle_t * handle)129 static void close_cb(uv_handle_t* handle) {
130 ASSERT_NOT_NULL(handle);
131 close_cb_called++;
132 }
133
134
timeout_cb(uv_timer_t * timer)135 static void timeout_cb(uv_timer_t* timer) {
136 int i;
137
138 exiting = 1;
139
140 for (i = 0; i < n_senders_; i++)
141 uv_close((uv_handle_t*)&senders[i].udp_handle, close_cb);
142
143 for (i = 0; i < n_receivers_; i++)
144 uv_close((uv_handle_t*)&receivers[i].udp_handle, close_cb);
145 }
146
147
pummel(unsigned int n_senders,unsigned int n_receivers,unsigned long timeout)148 static int pummel(unsigned int n_senders,
149 unsigned int n_receivers,
150 unsigned long timeout) {
151 uv_timer_t timer_handle;
152 uint64_t duration;
153 uv_loop_t* loop;
154 unsigned int i;
155
156 ASSERT_LE(n_senders, ARRAY_SIZE(senders));
157 ASSERT_LE(n_receivers, ARRAY_SIZE(receivers));
158
159 loop = uv_default_loop();
160
161 n_senders_ = n_senders;
162 n_receivers_ = n_receivers;
163
164 if (timeout) {
165 ASSERT_OK(uv_timer_init(loop, &timer_handle));
166 ASSERT_OK(uv_timer_start(&timer_handle, timeout_cb, timeout, 0));
167 /* Timer should not keep loop alive. */
168 uv_unref((uv_handle_t*)&timer_handle);
169 timed = 1;
170 }
171
172 for (i = 0; i < n_receivers; i++) {
173 struct receiver_state* s = receivers + i;
174 struct sockaddr_in addr;
175 ASSERT_OK(uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr));
176 ASSERT_OK(uv_udp_init(loop, &s->udp_handle));
177 ASSERT_OK(uv_udp_bind(&s->udp_handle, (const struct sockaddr*) &addr, 0));
178 ASSERT_OK(uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb));
179 uv_unref((uv_handle_t*)&s->udp_handle);
180 }
181
182 bufs[0] = uv_buf_init(&EXPECTED[0], 10);
183 bufs[1] = uv_buf_init(&EXPECTED[10], 10);
184 bufs[2] = uv_buf_init(&EXPECTED[20], 10);
185 bufs[3] = uv_buf_init(&EXPECTED[30], 10);
186 bufs[4] = uv_buf_init(&EXPECTED[40], 5);
187
188 for (i = 0; i < n_senders; i++) {
189 struct sender_state* s = senders + i;
190 ASSERT_OK(uv_ip4_addr("127.0.0.1",
191 BASE_PORT + (i % n_receivers),
192 &s->addr));
193 ASSERT_OK(uv_udp_init(loop, &s->udp_handle));
194 ASSERT_OK(uv_udp_send(&s->send_req,
195 &s->udp_handle,
196 bufs,
197 ARRAY_SIZE(bufs),
198 (const struct sockaddr*) &s->addr,
199 send_cb));
200 }
201
202 duration = uv_hrtime();
203 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
204 duration = uv_hrtime() - duration;
205 /* convert from nanoseconds to milliseconds */
206 duration = duration / (uint64_t) 1e6;
207
208 printf("udp_pummel_%dv%d: %.0f/s received, %.0f/s sent. "
209 "%u received, %u sent in %.1f seconds.\n",
210 n_receivers,
211 n_senders,
212 recv_cb_called / (duration / 1000.0),
213 send_cb_called / (duration / 1000.0),
214 recv_cb_called,
215 send_cb_called,
216 duration / 1000.0);
217
218 MAKE_VALGRIND_HAPPY(loop);
219 return 0;
220 }
221
222
223 #define X(a, b) \
224 BENCHMARK_IMPL(udp_pummel_##a##v##b) { \
225 return pummel(a, b, 0); \
226 } \
227 BENCHMARK_IMPL(udp_timed_pummel_##a##v##b) { \
228 return pummel(a, b, TEST_DURATION); \
229 }
230
231 X(1, 1)
232 X(1, 10)
233 X(1, 100)
234 X(1, 1000)
235 X(10, 10)
236 X(10, 100)
237 X(10, 1000)
238 X(100, 10)
239 X(100, 100)
240 X(100, 1000)
241 X(1000, 1000)
242
243 #undef X
244
