libuv-svace-build

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

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

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

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

129
static void close_cb(uv_handle_t* handle) {
130
  ASSERT_NOT_NULL(handle);
131
  close_cb_called++;
132
}
133

134

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

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