File: | pr/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/pr/tests/../../../pr/tests/thruput.c |
Warning: | line 276, column 13 Value stored to 'rv' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ |
2 | /* This Source Code Form is subject to the terms of the Mozilla Public |
3 | * License, v. 2.0. If a copy of the MPL was not distributed with this |
4 | * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
5 | |
6 | /* |
7 | ** File: thruput.c |
8 | ** Description: Test server's throughput capability comparing various |
9 | ** implmentation strategies. |
10 | ** |
11 | ** Note: Requires a server machine and an aribitrary number of |
12 | ** clients to bang on it. Trust the numbers on the server |
13 | ** more than those being displayed by the various clients. |
14 | */ |
15 | |
16 | #include "prerror.h" |
17 | #include "prinrval.h" |
18 | #include "prinit.h" |
19 | #include "prio.h" |
20 | #include "prlock.h" |
21 | #include "prmem.h" |
22 | #include "prnetdb.h" |
23 | #include "prprf.h" |
24 | #include "prthread.h" |
25 | #include "pprio.h" |
26 | #include "plerror.h" |
27 | #include "plgetopt.h" |
28 | |
29 | #define ADDR_BUFFER100 100 |
30 | |
31 | #ifdef DEBUG1 |
32 | #define PORT_INC_DO+100 +100 |
33 | #else |
34 | #define PORT_INC_DO+100 |
35 | #endif |
36 | #ifdef IS_64 |
37 | #define PORT_INC_3264+200 +200 |
38 | #else |
39 | #define PORT_INC_3264+200 |
40 | #endif |
41 | |
42 | #define PORT_NUMBER51877 +100 +200 51877 PORT_INC_DO+100 PORT_INC_3264+200 |
43 | |
44 | #define SAMPLING_INTERVAL10 10 |
45 | #define BUFFER_SIZE(32 * 1024) (32 * 1024) |
46 | |
47 | static PRInt32 domain = PR_AF_INET2; |
48 | static PRInt32 protocol = 6; /* TCP */ |
49 | static PRFileDesc *err = NULL((void*)0); |
50 | static PRIntn concurrency = 1; |
51 | static PRInt32 xport_buffer = -1; |
52 | static PRUint32 initial_streams = 1; |
53 | static PRInt32 buffer_size = BUFFER_SIZE(32 * 1024); |
54 | static PRThreadScope thread_scope = PR_LOCAL_THREAD; |
55 | |
56 | typedef struct Shared |
57 | { |
58 | PRLock *ml; |
59 | PRUint32 sampled; |
60 | PRUint32 threads; |
61 | PRIntervalTime timein; |
62 | PRNetAddr server_address; |
63 | } Shared; |
64 | |
65 | static Shared *shared = NULL((void*)0); |
66 | |
67 | static PRStatus PrintAddress(const PRNetAddr* address) |
68 | { |
69 | char buffer[ADDR_BUFFER100]; |
70 | PRStatus rv = PR_NetAddrToString(address, buffer, sizeof(buffer)); |
71 | if (PR_SUCCESS == rv) { |
72 | PR_fprintf(err, "%s:%u\n", buffer, PR_ntohs(address->inet.port)); |
73 | } |
74 | else { |
75 | PL_FPrintError(err, "PR_NetAddrToString"); |
76 | } |
77 | return rv; |
78 | } /* PrintAddress */ |
79 | |
80 | |
81 | static void PR_CALLBACK Clientel(void *arg) |
82 | { |
83 | PRStatus rv; |
84 | PRFileDesc *xport; |
85 | PRInt32 bytes, sampled; |
86 | PRIntervalTime now, interval; |
87 | PRBool do_display = PR_FALSE0; |
88 | Shared *shared = (Shared*)arg; |
89 | char *buffer = (char*)PR_Malloc(buffer_size); |
90 | PRNetAddr *server_address = &shared->server_address; |
91 | PRIntervalTime connect_timeout = PR_SecondsToInterval(5); |
92 | PRIntervalTime sampling_interval = PR_SecondsToInterval(SAMPLING_INTERVAL10); |
93 | |
94 | PR_fprintf(err, "Client connecting to "); |
95 | (void)PrintAddress(server_address); |
96 | |
97 | do |
98 | { |
99 | xport = PR_Socket(domain, PR_SOCK_STREAMSOCK_STREAM, protocol); |
100 | if (NULL((void*)0) == xport) |
101 | { |
102 | PL_FPrintError(err, "PR_Socket"); |
103 | return; |
104 | } |
105 | |
106 | if (xport_buffer != -1) |
107 | { |
108 | PRSocketOptionData data; |
109 | data.option = PR_SockOpt_RecvBufferSize; |
110 | data.value.recv_buffer_size = (PRSize)xport_buffer; |
111 | rv = PR_SetSocketOption(xport, &data); |
112 | if (PR_FAILURE == rv) { |
113 | PL_FPrintError(err, "PR_SetSocketOption - ignored"); |
114 | } |
115 | data.option = PR_SockOpt_SendBufferSize; |
116 | data.value.send_buffer_size = (PRSize)xport_buffer; |
117 | rv = PR_SetSocketOption(xport, &data); |
118 | if (PR_FAILURE == rv) { |
119 | PL_FPrintError(err, "PR_SetSocketOption - ignored"); |
120 | } |
121 | } |
122 | |
123 | rv = PR_Connect(xport, server_address, connect_timeout); |
124 | if (PR_FAILURE == rv) |
125 | { |
126 | PL_FPrintError(err, "PR_Connect"); |
127 | if (PR_IO_TIMEOUT_ERROR(-5990L) != PR_GetError()) { |
128 | PR_Sleep(connect_timeout); |
129 | } |
130 | PR_Close(xport); /* delete it and start over */ |
131 | } |
132 | } while (PR_FAILURE == rv); |
133 | |
134 | do |
135 | { |
136 | bytes = PR_Recv( |
137 | xport, buffer, buffer_size, 0, PR_INTERVAL_NO_TIMEOUT0xffffffffUL); |
138 | PR_Lock(shared->ml); |
139 | now = PR_IntervalNow(); |
140 | shared->sampled += bytes; |
141 | interval = now - shared->timein; |
142 | if (interval > sampling_interval) |
143 | { |
144 | sampled = shared->sampled; |
145 | shared->timein = now; |
146 | shared->sampled = 0; |
147 | do_display = PR_TRUE1; |
148 | } |
149 | PR_Unlock(shared->ml); |
150 | |
151 | if (do_display) |
152 | { |
153 | PRUint32 rate = sampled / PR_IntervalToMilliseconds(interval); |
154 | PR_fprintf(err, "%u streams @ %u Kbytes/sec\n", shared->threads, rate); |
155 | do_display = PR_FALSE0; |
156 | } |
157 | |
158 | } while (bytes > 0); |
159 | } /* Clientel */ |
160 | |
161 | static void Client(const char *server_name) |
162 | { |
163 | PRStatus rv; |
164 | PRHostEnt host; |
165 | char buffer[PR_NETDB_BUF_SIZE2048]; |
166 | PRIntervalTime dally = PR_SecondsToInterval(60); |
167 | PR_fprintf(err, "Translating the name %s\n", server_name); |
168 | rv = PR_GetHostByName(server_name, buffer, sizeof(buffer), &host); |
169 | if (PR_FAILURE == rv) { |
170 | PL_FPrintError(err, "PR_GetHostByName"); |
171 | } |
172 | else |
173 | { |
174 | if (PR_EnumerateHostEnt( |
175 | 0, &host, PORT_NUMBER51877 +100 +200, &shared->server_address) < 0) { |
176 | PL_FPrintError(err, "PR_EnumerateHostEnt"); |
177 | } |
178 | else |
179 | { |
180 | do |
181 | { |
182 | shared->threads += 1; |
183 | (void)PR_CreateThread( |
184 | PR_USER_THREAD, Clientel, shared, |
185 | PR_PRIORITY_NORMAL, thread_scope, |
186 | PR_UNJOINABLE_THREAD, 8 * 1024); |
187 | if (shared->threads == initial_streams) |
188 | { |
189 | PR_Sleep(dally); |
190 | initial_streams += 1; |
191 | } |
192 | } while (PR_TRUE1); |
193 | } |
194 | } |
195 | } |
196 | |
197 | static void PR_CALLBACK Servette(void *arg) |
198 | { |
199 | PRInt32 bytes, sampled; |
200 | PRIntervalTime now, interval; |
201 | PRBool do_display = PR_FALSE0; |
202 | PRFileDesc *client = (PRFileDesc*)arg; |
203 | char *buffer = (char*)PR_Malloc(buffer_size); |
204 | PRIntervalTime sampling_interval = PR_SecondsToInterval(SAMPLING_INTERVAL10); |
205 | |
206 | if (xport_buffer != -1) |
207 | { |
208 | PRStatus rv; |
209 | PRSocketOptionData data; |
210 | data.option = PR_SockOpt_RecvBufferSize; |
211 | data.value.recv_buffer_size = (PRSize)xport_buffer; |
212 | rv = PR_SetSocketOption(client, &data); |
213 | if (PR_FAILURE == rv) { |
214 | PL_FPrintError(err, "PR_SetSocketOption - ignored"); |
215 | } |
216 | data.option = PR_SockOpt_SendBufferSize; |
217 | data.value.send_buffer_size = (PRSize)xport_buffer; |
218 | rv = PR_SetSocketOption(client, &data); |
219 | if (PR_FAILURE == rv) { |
220 | PL_FPrintError(err, "PR_SetSocketOption - ignored"); |
221 | } |
222 | } |
223 | |
224 | do |
225 | { |
226 | bytes = PR_Send( |
227 | client, buffer, buffer_size, 0, PR_INTERVAL_NO_TIMEOUT0xffffffffUL); |
228 | |
229 | PR_Lock(shared->ml); |
230 | now = PR_IntervalNow(); |
231 | shared->sampled += bytes; |
232 | interval = now - shared->timein; |
233 | if (interval > sampling_interval) |
234 | { |
235 | sampled = shared->sampled; |
236 | shared->timein = now; |
237 | shared->sampled = 0; |
238 | do_display = PR_TRUE1; |
239 | } |
240 | PR_Unlock(shared->ml); |
241 | |
242 | if (do_display) |
243 | { |
244 | PRUint32 rate = sampled / PR_IntervalToMilliseconds(interval); |
245 | PR_fprintf(err, "%u streams @ %u Kbytes/sec\n", shared->threads, rate); |
246 | do_display = PR_FALSE0; |
247 | } |
248 | } while (bytes > 0); |
249 | } /* Servette */ |
250 | |
251 | static void Server(void) |
252 | { |
253 | PRStatus rv; |
254 | PRNetAddr server_address, client_address; |
255 | PRFileDesc *xport = PR_Socket(domain, PR_SOCK_STREAMSOCK_STREAM, protocol); |
256 | |
257 | if (NULL((void*)0) == xport) |
258 | { |
259 | PL_FPrintError(err, "PR_Socket"); |
260 | return; |
261 | } |
262 | |
263 | rv = PR_InitializeNetAddr(PR_IpAddrAny, PORT_NUMBER51877 +100 +200, &server_address); |
264 | if (PR_FAILURE == rv) { |
265 | PL_FPrintError(err, "PR_InitializeNetAddr"); |
266 | } |
267 | else |
268 | { |
269 | rv = PR_Bind(xport, &server_address); |
270 | if (PR_FAILURE == rv) { |
271 | PL_FPrintError(err, "PR_Bind"); |
272 | } |
273 | else |
274 | { |
275 | PRFileDesc *client; |
276 | rv = PR_Listen(xport, 10); |
Value stored to 'rv' is never read | |
277 | PR_fprintf(err, "Server listening on "); |
278 | (void)PrintAddress(&server_address); |
279 | do |
280 | { |
281 | client = PR_Accept( |
282 | xport, &client_address, PR_INTERVAL_NO_TIMEOUT0xffffffffUL); |
283 | if (NULL((void*)0) == client) { |
284 | PL_FPrintError(err, "PR_Accept"); |
285 | } |
286 | else |
287 | { |
288 | PR_fprintf(err, "Server accepting from "); |
289 | (void)PrintAddress(&client_address); |
290 | shared->threads += 1; |
291 | (void)PR_CreateThread( |
292 | PR_USER_THREAD, Servette, client, |
293 | PR_PRIORITY_NORMAL, thread_scope, |
294 | PR_UNJOINABLE_THREAD, 8 * 1024); |
295 | } |
296 | } while (PR_TRUE1); |
297 | |
298 | } |
299 | } |
300 | } /* Server */ |
301 | |
302 | static void Help(void) |
303 | { |
304 | PR_fprintf(err, "Usage: [-h] [<server>]\n"); |
305 | PR_fprintf(err, "\t-s <n> Initial # of connections (default: 1)\n"); |
306 | PR_fprintf(err, "\t-C <n> Set 'concurrency' (default: 1)\n"); |
307 | PR_fprintf(err, "\t-b <nK> Client buffer size (default: 32k)\n"); |
308 | PR_fprintf(err, "\t-B <nK> Transport recv/send buffer size (default: sys)\n"); |
309 | PR_fprintf(err, "\t-G Use GLOBAL threads (default: LOCAL)\n"); |
310 | PR_fprintf(err, "\t-X Use XTP transport (default: TCP)\n"); |
311 | PR_fprintf(err, "\t-6 Use IPv6 (default: IPv4)\n"); |
312 | PR_fprintf(err, "\t-h This message and nothing else\n"); |
313 | PR_fprintf(err, "\t<server> DNS name of server\n"); |
314 | PR_fprintf(err, "\t\tIf <server> is not specified, this host will be\n"); |
315 | PR_fprintf(err, "\t\tthe server and not act as a client.\n"); |
316 | } /* Help */ |
317 | |
318 | int main(int argc, char **argv) |
319 | { |
320 | PLOptStatus os; |
321 | const char *server_name = NULL((void*)0); |
322 | PLOptState *opt = PL_CreateOptState(argc, argv, "hGX6C:b:s:B:"); |
323 | |
324 | err = PR_GetSpecialFD(PR_StandardError); |
325 | |
326 | while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) |
327 | { |
328 | if (PL_OPT_BAD == os) { |
329 | continue; |
330 | } |
331 | switch (opt->option) |
332 | { |
333 | case 0: /* Name of server */ |
334 | server_name = opt->value; |
335 | break; |
336 | case 'G': /* Globular threads */ |
337 | thread_scope = PR_GLOBAL_THREAD; |
338 | break; |
339 | case 'X': /* Use XTP as the transport */ |
340 | protocol = 36; |
341 | break; |
342 | case '6': /* Use IPv6 */ |
343 | domain = PR_AF_INET610; |
344 | break; |
345 | case 's': /* initial_streams */ |
346 | initial_streams = atoi(opt->value); |
347 | break; |
348 | case 'C': /* concurrency */ |
349 | concurrency = atoi(opt->value); |
350 | break; |
351 | case 'b': /* buffer size */ |
352 | buffer_size = 1024 * atoi(opt->value); |
353 | break; |
354 | case 'B': /* buffer size */ |
355 | xport_buffer = 1024 * atoi(opt->value); |
356 | break; |
357 | case 'h': /* user wants some guidance */ |
358 | default: |
359 | Help(); /* so give him an earful */ |
360 | return 2; /* but not a lot else */ |
361 | } |
362 | } |
363 | PL_DestroyOptState(opt); |
364 | |
365 | shared = PR_NEWZAP(Shared)((Shared*)PR_Calloc(1, sizeof(Shared))); |
366 | shared->ml = PR_NewLock(); |
367 | |
368 | PR_fprintf(err, |
369 | "This machine is %s\n", |
370 | (NULL((void*)0) == server_name) ? "the SERVER" : "a CLIENT"); |
371 | |
372 | PR_fprintf(err, |
373 | "Transport being used is %s\n", |
374 | (6 == protocol) ? "TCP" : "XTP"); |
375 | |
376 | if (PR_GLOBAL_THREAD == thread_scope) |
377 | { |
378 | if (1 != concurrency) |
379 | { |
380 | PR_fprintf(err, " **Concurrency > 1 and GLOBAL threads!?!?\n"); |
381 | PR_fprintf(err, " **Ignoring concurrency\n"); |
382 | concurrency = 1; |
383 | } |
384 | } |
385 | |
386 | if (1 != concurrency) |
387 | { |
388 | PR_SetConcurrency(concurrency); |
389 | PR_fprintf(err, "Concurrency set to %u\n", concurrency); |
390 | } |
391 | |
392 | PR_fprintf(err, |
393 | "All threads will be %s\n", |
394 | (PR_GLOBAL_THREAD == thread_scope) ? "GLOBAL" : "LOCAL"); |
395 | |
396 | PR_fprintf(err, "Client buffer size will be %u\n", buffer_size); |
397 | |
398 | if (-1 != xport_buffer) |
399 | PR_fprintf( |
400 | err, "Transport send & receive buffer size will be %u\n", xport_buffer); |
401 | |
402 | |
403 | if (NULL((void*)0) == server_name) { |
404 | Server(); |
405 | } |
406 | else { |
407 | Client(server_name); |
408 | } |
409 | |
410 | return 0; |
411 | } /* main */ |
412 | |
413 | /* thruput.c */ |
414 |