projects / m6w6 / libmemcached / blob
? search:


764707b5ab2b88b4a6e2084f64828a158fdeaada
[m6w6/libmemcached] / clients / memaslap.c
1 /*
2 * memslap
3 *
4 * (c) Copyright 2009, Schooner Information Technology, Inc.
5 * All rights reserved.
6 * http://www.schoonerinfotech.com/
7 *
8 * Use and distribution licensed under the BSD license. See
9 * the COPYING file for full text.
10 *
11 * Authors:
12 * Brian Aker
13 * Mingqiang Zhuang <mingqiangzhuang@hengtiansoft.com>
14 *
15 */
16 #include "config.h"
17
18 #include <stdlib.h>
19 #include <getopt.h>
20 #include <limits.h>
21
22 #if defined(HAVE_SYS_TIME_H)
23 # include <sys/time.h>
24 #endif
25
26 #if defined(HAVE_TIME_H)
27 # include <time.h>
28 #endif
29
30
31 #include "ms_sigsegv.h"
32 #include "ms_setting.h"
33 #include "ms_thread.h"
34
35 #define PROGRAM_NAME "memslap"
36 #define PROGRAM_DESCRIPTION \
37 "Generates workload against memcached servers."
38
39 #ifdef __sun
40 /* For some odd reason the option struct on solaris defines the argument
41 * as char* and not const char*
42 */
43 #define OPTIONSTRING char*
44 #else
45 #define OPTIONSTRING const char*
46 #endif
47
48 /* options */
49 static struct option long_options[]=
50 {
51 { (OPTIONSTRING)"servers", required_argument, NULL,
52 OPT_SERVERS },
53 { (OPTIONSTRING)"threads", required_argument, NULL,
54 OPT_THREAD_NUMBER },
55 { (OPTIONSTRING)"concurrency", required_argument, NULL,
56 OPT_CONCURRENCY },
57 { (OPTIONSTRING)"conn_sock", required_argument, NULL,
58 OPT_SOCK_PER_CONN },
59 { (OPTIONSTRING)"execute_number", required_argument, NULL,
60 OPT_EXECUTE_NUMBER },
61 { (OPTIONSTRING)"time", required_argument, NULL,
62 OPT_TIME },
63 { (OPTIONSTRING)"cfg_cmd", required_argument, NULL,
64 OPT_CONFIG_CMD },
65 { (OPTIONSTRING)"win_size", required_argument, NULL,
66 OPT_WINDOW_SIZE },
67 { (OPTIONSTRING)"fixed_size", required_argument, NULL,
68 OPT_FIXED_LTH },
69 { (OPTIONSTRING)"verify", required_argument, NULL,
70 OPT_VERIFY },
71 { (OPTIONSTRING)"division", required_argument, NULL,
72 OPT_GETS_DIVISION },
73 { (OPTIONSTRING)"stat_freq", required_argument, NULL,
74 OPT_STAT_FREQ },
75 { (OPTIONSTRING)"exp_verify", required_argument, NULL,
76 OPT_EXPIRE },
77 { (OPTIONSTRING)"overwrite", required_argument, NULL,
78 OPT_OVERWRITE },
79 { (OPTIONSTRING)"reconnect", no_argument, NULL,
80 OPT_RECONNECT },
81 { (OPTIONSTRING)"udp", no_argument, NULL,
82 OPT_UDP },
83 { (OPTIONSTRING)"facebook", no_argument, NULL,
84 OPT_FACEBOOK_TEST },
85 { (OPTIONSTRING)"binary", no_argument, NULL,
86 OPT_BINARY_PROTOCOL },
87 { (OPTIONSTRING)"tps", required_argument, NULL,
88 OPT_TPS },
89 { (OPTIONSTRING)"rep_write", required_argument, NULL,
90 OPT_REP_WRITE_SRV },
91 { (OPTIONSTRING)"verbose", no_argument, NULL,
92 OPT_VERBOSE },
93 { (OPTIONSTRING)"help", no_argument, NULL,
94 OPT_HELP },
95 { (OPTIONSTRING)"version", no_argument, NULL,
96 OPT_VERSION },
97 { 0, 0, 0, 0 },
98 };
99
100 /* Prototypes */
101 static void ms_sync_lock_init(void);
102 static void ms_sync_lock_destroy(void);
103 static void ms_global_struct_init(void);
104 static void ms_global_struct_destroy(void);
105 static void ms_version_command(const char *command_name);
106 static const char *ms_lookup_help(ms_options_t option);
107 static int64_t ms_parse_time(void);
108 static int64_t ms_parse_size(void);
109 static void ms_options_parse(int argc, char *argv[]);
110 static int ms_check_para(void);
111 static void ms_statistic_init(void);
112 static void ms_stats_init(void);
113 static void ms_print_statistics(int in_time);
114 static void ms_print_memslap_stats(struct timeval *start_time,
115 struct timeval *end_time);
116 static void ms_monitor_slap_mode(void);
117 void ms_help_command(const char *command_name, const char *description);
118
119
120 /* initialize the global locks */
121 static void ms_sync_lock_init()
122 {
123 ms_global.init_lock.count= 0;
124 pthread_mutex_init(&ms_global.init_lock.lock, NULL);
125 pthread_cond_init(&ms_global.init_lock.cond, NULL);
126
127 ms_global.warmup_lock.count = 0;
128 pthread_mutex_init(&ms_global.warmup_lock.lock, NULL);
129 pthread_cond_init(&ms_global.warmup_lock.cond, NULL);
130
131 ms_global.run_lock.count= 0;
132 pthread_mutex_init(&ms_global.run_lock.lock, NULL);
133 pthread_cond_init(&ms_global.run_lock.cond, NULL);
134
135 pthread_mutex_init(&ms_global.quit_mutex, NULL);
136 pthread_mutex_init(&ms_global.seq_mutex, NULL);
137 } /* ms_sync_lock_init */
138
139
140 /* destroy the global locks */
141 static void ms_sync_lock_destroy()
142 {
143 pthread_mutex_destroy(&ms_global.init_lock.lock);
144 pthread_cond_destroy(&ms_global.init_lock.cond);
145
146 pthread_mutex_destroy(&ms_global.warmup_lock.lock);
147 pthread_cond_destroy(&ms_global.warmup_lock.cond);
148
149 pthread_mutex_destroy(&ms_global.run_lock.lock);
150 pthread_cond_destroy(&ms_global.run_lock.cond);
151
152 pthread_mutex_destroy(&ms_global.quit_mutex);
153 pthread_mutex_destroy(&ms_global.seq_mutex);
154
155 if (ms_setting.stat_freq > 0)
156 {
157 pthread_mutex_destroy(&ms_statistic.stat_mutex);
158 }
159 } /* ms_sync_lock_destroy */
160
161
162 /* initialize the global structure */
163 static void ms_global_struct_init()
164 {
165 ms_sync_lock_init();
166 ms_global.finish_warmup= false;
167 ms_global.time_out= false;
168 }
169
170
171 /* destroy the global structure */
172 static void ms_global_struct_destroy()
173 {
174 ms_sync_lock_destroy();
175 }
176
177
178 /**
179 * output the version information
180 *
181 * @param command_name, the string of this process
182 */
183 static void ms_version_command(const char *command_name)
184 {
185 printf("%s v%u.%u\n", command_name, 1U, 0U);
186 exit(0);
187 }
188
189
190 /**
191 * get the description of the option
192 *
193 * @param option, option of command line
194 *
195 * @return char*, description of the command option
196 */
197 static const char *ms_lookup_help(ms_options_t option)
198 {
199 switch (option)
200 {
201 case OPT_SERVERS:
202 return
203 "List one or more servers to connect. Servers count must be less than\n"
204 " threads count. e.g.: --servers=localhost:1234,localhost:11211";
205
206 case OPT_VERSION:
207 return "Display the version of the application and then exit.";
208
209 case OPT_HELP:
210 return "Display this message and then exit.";
211
212 case OPT_EXECUTE_NUMBER:
213 return "Number of operations(get and set) to execute for the\n"
214 " given test. Default 1000000.";
215
216 case OPT_THREAD_NUMBER:
217 return
218 "Number of threads to startup, better equal to CPU numbers. Default 8.";
219
220 case OPT_CONCURRENCY:
221 return "Number of concurrency to simulate with load. Default 128.";
222
223 case OPT_FIXED_LTH:
224 return "Fixed length of value.";
225
226 case OPT_VERIFY:
227 return "The proportion of date verification, e.g.: --verify=0.01";
228
229 case OPT_GETS_DIVISION:
230 return "Number of keys to multi-get once. Default 1, means single get.";
231
232 case OPT_TIME:
233 return
234 "How long the test to run, suffix: s-seconds, m-minutes, h-hours,\n"
235 " d-days e.g.: --time=2h.";
236
237 case OPT_CONFIG_CMD:
238 return
239 "Load the configure file to get command,key and value distribution list.";
240
241 case OPT_WINDOW_SIZE:
242 return
243 "Task window size of each concurrency, suffix: K, M e.g.: --win_size=10k.\n"
244 " Default 10k.";
245
246 case OPT_UDP:
247 return
248 "UDP support, default memslap uses TCP, TCP port and UDP port of\n"
249 " server must be same.";
250
251 case OPT_EXPIRE:
252 return
253 "The proportion of objects with expire time, e.g.: --exp_verify=0.01.\n"
254 " Default no object with expire time";
255
256 case OPT_OVERWRITE:
257 return
258 "The proportion of objects need overwrite, e.g.: --overwrite=0.01.\n"
259 " Default never overwrite object.";
260
261 case OPT_STAT_FREQ:
262 return
263 "Frequency of dumping statistic information. suffix: s-seconds,\n"
264 " m-minutes, e.g.: --resp_freq=10s.";
265
266 case OPT_SOCK_PER_CONN:
267 return "Number of TCP socks per concurrency. Default 1.";
268
269 case OPT_RECONNECT:
270 return
271 "Reconnect support, when connection is closed it will be reconnected.";
272
273 case OPT_VERBOSE:
274 return
275 "Whether it outputs detailed information when verification fails.";
276
277 case OPT_FACEBOOK_TEST:
278 return
279 "Whether it enables facebook test feature, set with TCP and multi-get with UDP.";
280
281 case OPT_BINARY_PROTOCOL:
282 return
283 "Whether it enables binary protocol. Default with ASCII protocol.";
284
285 case OPT_TPS:
286 return "Expected throughput, suffix: K, e.g.: --tps=10k.";
287
288 case OPT_REP_WRITE_SRV:
289 return "The first nth servers can write data, e.g.: --rep_write=2.";
290
291 default:
292 return "Forgot to document this option :)";
293 } /* switch */
294 } /* ms_lookup_help */
295
296
297 /**
298 * output the help information
299 *
300 * @param command_name, the string of this process
301 * @param description, description of this process
302 * @param long_options, global options array
303 */
304 void ms_help_command(const char *command_name, const char *description)
305 {
306 char *help_message= NULL;
307
308 printf("%s v%u.%u\n", command_name, 1U, 0U);
309 printf(" %s\n\n", description);
310 printf(
311 "Usage:\n"
312 " memslap -hV | -s servers [-F config_file] [-t time | -x exe_num] [...]\n\n"
313 "Options:\n");
314
315 for (int x= 0; long_options[x].name; x++)
316 {
317 printf(" -%c, --%s%c\n", long_options[x].val, long_options[x].name,
318 long_options[x].has_arg ? '=' : ' ');
319
320 if ((help_message= (char *)ms_lookup_help(long_options[x].val)) != NULL)
321 {
322 printf(" %s\n", help_message);
323 }
324 }
325
326 printf(
327 "\nExamples:\n"
328 " memslap -s 127.0.0.1:11211 -S 5s\n"
329 " memslap -s 127.0.0.1:11211 -t 2m -v 0.2 -e 0.05 -b\n"
330 " memslap -s 127.0.0.1:11211 -F config -t 2m -w 40k -S 20s -o 0.2\n"
331 " memslap -s 127.0.0.1:11211 -F config -t 2m -T 4 -c 128 -d 20 -P 40k\n"
332 " memslap -s 127.0.0.1:11211 -F config -t 2m -d 50 -a -n 40\n"
333 " memslap -s 127.0.0.1:11211,127.0.0.1:11212 -F config -t 2m\n"
334 " memslap -s 127.0.0.1:11211,127.0.0.1:11212 -F config -t 2m -p 2\n\n");
335
336 exit(0);
337 } /* ms_help_command */
338
339
340 /* used to parse the time string */
341 static int64_t ms_parse_time()
342 {
343 int64_t ret= 0;
344 char unit= optarg[strlen(optarg) - 1];
345
346 optarg[strlen(optarg) - 1]= '\0';
347 ret= atoi(optarg);
348
349 switch (unit)
350 {
351 case 'd':
352 case 'D':
353 ret*= 24;
354
355 case 'h':
356 case 'H':
357 ret*= 60;
358
359 case 'm':
360 case 'M':
361 ret*= 60;
362
363 case 's':
364 case 'S':
365 break;
366
367 default:
368 ret= -1;
369 break;
370 } /* switch */
371
372 return ret;
373 } /* ms_parse_time */
374
375
376 /* used to parse the size string */
377 static int64_t ms_parse_size()
378 {
379 int64_t ret= -1;
380 char unit= optarg[strlen(optarg) - 1];
381
382 optarg[strlen(optarg) - 1]= '\0';
383 ret= strtoll(optarg, (char **)NULL, 10);
384
385 switch (unit)
386 {
387 case 'k':
388 case 'K':
389 ret*= 1024;
390 break;
391
392 case 'm':
393 case 'M':
394 ret*= 1024 * 1024;
395 break;
396
397 case 'g':
398 case 'G':
399 ret*= 1024 * 1024 * 1024;
400 break;
401
402 default:
403 ret= -1;
404 break;
405 } /* switch */
406
407 return ret;
408 } /* ms_parse_size */
409
410
411 /* used to parse the options of command line */
412 static void ms_options_parse(int argc, char *argv[])
413 {
414 int option_index= 0;
415 int option_rv;
416
417 while ((option_rv= getopt_long(argc, argv, "VhURbaBs:x:T:c:X:v:d:"
418 "t:S:F:w:e:o:n:P:p:",
419 long_options, &option_index)) != -1)
420 {
421 switch (option_rv)
422 {
423 case 0:
424 break;
425
426 case OPT_VERSION: /* --version or -V */
427 ms_version_command(PROGRAM_NAME);
428 break;
429
430 case OPT_HELP: /* --help or -h */
431 ms_help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION);
432 break;
433
434 case OPT_SERVERS: /* --servers or -s */
435 ms_setting.srv_str= strdup(optarg);
436 break;
437
438 case OPT_CONCURRENCY: /* --concurrency or -c */
439 ms_setting.nconns= (uint32_t)strtoul(optarg, (char **) NULL, 10);
440 if (ms_setting.nconns <= 0)
441 {
442 fprintf(stderr, "Concurrency must be greater than 0.:-)\n");
443 exit(1);
444 }
445 break;
446
447 case OPT_EXECUTE_NUMBER: /* --execute_number or -x */
448 ms_setting.exec_num= (int)strtol(optarg, (char **) NULL, 10);
449 if (ms_setting.exec_num <= 0)
450 {
451 fprintf(stderr, "Execute number must be greater than 0.:-)\n");
452 exit(1);
453 }
454 break;
455
456 case OPT_THREAD_NUMBER: /* --threads or -T */
457 ms_setting.nthreads= (uint32_t)strtoul(optarg, (char **) NULL, 10);
458 if (ms_setting.nthreads <= 0)
459 {
460 fprintf(stderr, "Threads number must be greater than 0.:-)\n");
461 exit(1);
462 }
463 break;
464
465 case OPT_FIXED_LTH: /* --fixed_size or -X */
466 ms_setting.fixed_value_size= (size_t)strtoull(optarg, (char **) NULL, 10);
467 if ((ms_setting.fixed_value_size <= 0)
468 || (ms_setting.fixed_value_size > MAX_VALUE_SIZE))
469 {
470 fprintf(stderr, "Value size must be between 0 and 1M.:-)\n");
471 exit(1);
472 }
473 break;
474
475 case OPT_VERIFY: /* --verify or -v */
476 ms_setting.verify_percent= atof(optarg);
477 if ((ms_setting.verify_percent <= 0)
478 || (ms_setting.verify_percent > 1.0))
479 {
480 fprintf(stderr, "Data verification rate must be "
481 "greater than 0 and less than 1.0. :-)\n");
482 exit(1);
483 }
484 break;
485
486 case OPT_GETS_DIVISION: /* --division or -d */
487 ms_setting.mult_key_num= (int)strtol(optarg, (char **) NULL, 10);
488 if (ms_setting.mult_key_num <= 0)
489 {
490 fprintf(stderr, "Multi-get key number must be greater than 0.:-)\n");
491 exit(1);
492 }
493 break;
494
495 case OPT_TIME: /* --time or -t */
496 ms_setting.run_time= (int)ms_parse_time();
497 if (ms_setting.run_time == -1)
498 {
499 fprintf(stderr, "Please specify the run time. :-)\n"
500 "'s' for second, 'm' for minute, 'h' for hour, "
501 "'d' for day. e.g.: --time=24h (means 24 hours).\n");
502 exit(1);
503 }
504
505 if (ms_setting.run_time == 0)
506 {
507 fprintf(stderr, "Running time can not be 0. :-)\n");
508 exit(1);
509 }
510 break;
511
512 case OPT_CONFIG_CMD: /* --cfg_cmd or -F */
513 ms_setting.cfg_file= strdup(optarg);
514 break;
515
516 case OPT_WINDOW_SIZE: /* --win_size or -w */
517 ms_setting.win_size= (size_t)ms_parse_size();
518 if (ms_setting.win_size == (size_t)-1)
519 {
520 fprintf(
521 stderr,
522 "Please specify the item window size. :-)\n"
523 "e.g.: --win_size=10k (means 10k task window size).\n");
524 exit(1);
525 }
526 break;
527
528 case OPT_UDP: /* --udp or -U*/
529 ms_setting.udp= true;
530 break;
531
532 case OPT_EXPIRE: /* --exp_verify or -e */
533 ms_setting.exp_ver_per= atof(optarg);
534 if ((ms_setting.exp_ver_per <= 0) || (ms_setting.exp_ver_per > 1.0))
535 {
536 fprintf(stderr, "Expire time verification rate must be "
537 "greater than 0 and less than 1.0. :-)\n");
538 exit(1);
539 }
540 break;
541
542 case OPT_OVERWRITE: /* --overwrite or -o */
543 ms_setting.overwrite_percent= atof(optarg);
544 if ((ms_setting.overwrite_percent <= 0)
545 || (ms_setting.overwrite_percent > 1.0))
546 {
547 fprintf(stderr, "Objects overwrite rate must be "
548 "greater than 0 and less than 1.0. :-)\n");
549 exit(1);
550 }
551 break;
552
553 case OPT_STAT_FREQ: /* --stat_freq or -S */
554 ms_setting.stat_freq= (int)ms_parse_time();
555 if (ms_setting.stat_freq == -1)
556 {
557 fprintf(stderr, "Please specify the frequency of dumping "
558 "statistic information. :-)\n"
559 "'s' for second, 'm' for minute, 'h' for hour, "
560 "'d' for day. e.g.: --time=24h (means 24 hours).\n");
561 exit(1);
562 }
563
564 if (ms_setting.stat_freq == 0)
565 {
566 fprintf(stderr, "The frequency of dumping statistic information "
567 "can not be 0. :-)\n");
568 exit(1);
569 }
570 break;
571
572 case OPT_SOCK_PER_CONN: /* --conn_sock or -n */
573 ms_setting.sock_per_conn= (uint32_t)strtoul(optarg, (char **) NULL, 10);
574 if (ms_setting.sock_per_conn <= 0)
575 {
576 fprintf(stderr, "Number of socks of each concurrency "
577 "must be greater than 0.:-)\n");
578 exit(1);
579 }
580 break;
581
582 case OPT_RECONNECT: /* --reconnect or -R */
583 ms_setting.reconnect= true;
584 break;
585
586 case OPT_VERBOSE: /* --verbose or -b */
587 ms_setting.verbose= true;
588 break;
589
590 case OPT_FACEBOOK_TEST: /* --facebook or -a */
591 ms_setting.facebook_test= true;
592 break;
593
594 case OPT_BINARY_PROTOCOL: /* --binary or -B */
595 ms_setting.binary_prot_= true;
596 break;
597
598 case OPT_TPS: /* --tps or -P */
599 ms_setting.expected_tps= (int)ms_parse_size();
600 if (ms_setting.expected_tps == -1)
601 {
602 fprintf(stderr,
603 "Please specify the item expected throughput. :-)\n"
604 "e.g.: --tps=10k (means 10k throughput).\n");
605 exit(1);
606 }
607 break;
608
609 case OPT_REP_WRITE_SRV: /* --rep_write or -p */
610 ms_setting.rep_write_srv= (uint32_t)strtoul(optarg, (char **) NULL, 10);
611 if (ms_setting.rep_write_srv <= 0)
612 {
613 fprintf(stderr,
614 "Number of replication writing server must be greater "
615 "than 0.:-)\n");
616 exit(1);
617 }
618 break;
619
620 case '?':
621 /* getopt_long already printed an error message. */
622 exit(1);
623
624 default:
625 abort();
626 } /* switch */
627 }
628 } /* ms_options_parse */
629
630
631 static int ms_check_para()
632 {
633 if (ms_setting.srv_str == NULL)
634 {
635 char *temp;
636
637 if ((temp= getenv("MEMCACHED_SERVERS")))
638 {
639 ms_setting.srv_str= strdup(temp);
640 }
641 else
642 {
643 fprintf(stderr, "No Servers provided\n\n");
644 return -1;
645 }
646 }
647
648 if (ms_setting.nconns % (uint32_t)ms_setting.nthreads != 0)
649 {
650 fprintf(stderr, "Concurrency must be the multiples of threads count.\n");
651 return -1;
652 }
653
654 if (ms_setting.win_size % UNIT_ITEMS_COUNT != 0)
655 {
656 fprintf(stderr, "Window size must be the multiples of 1024.\n\n");
657 return -1;
658 }
659
660 return EXIT_SUCCESS;
661 } /* ms_check_para */
662
663
664 /* initialize the statistic structure */
665 static void ms_statistic_init()
666 {
667 pthread_mutex_init(&ms_statistic.stat_mutex, NULL);
668 ms_init_stats(&ms_statistic.get_stat, "Get");
669 ms_init_stats(&ms_statistic.set_stat, "Set");
670 ms_init_stats(&ms_statistic.total_stat, "Total");
671 } /* ms_statistic_init */
672
673
674 /* initialize the global state structure */
675 static void ms_stats_init()
676 {
677 memset(&ms_stats, 0, sizeof(ms_stats_t));
678 if (ms_setting.stat_freq > 0)
679 {
680 ms_statistic_init();
681 }
682 } /* ms_stats_init */
683
684
685 /* use to output the statistic */
686 static void ms_print_statistics(int in_time)
687 {
688 int obj_size= (int)(ms_setting.avg_key_size + ms_setting.avg_val_size);
689
690 printf("\033[1;1H\033[2J\n");
691 ms_dump_format_stats(&ms_statistic.get_stat, in_time,
692 ms_setting.stat_freq, obj_size);
693 ms_dump_format_stats(&ms_statistic.set_stat, in_time,
694 ms_setting.stat_freq, obj_size);
695 ms_dump_format_stats(&ms_statistic.total_stat, in_time,
696 ms_setting.stat_freq, obj_size);
697 } /* ms_print_statistics */
698
699
700 /* used to print the states of memslap */
701 static void ms_print_memslap_stats(struct timeval *start_time,
702 struct timeval *end_time)
703 {
704 char buf[1024];
705 char *pos= buf;
706
707 pos+= snprintf(pos,
708 sizeof(buf), "cmd_get: %lu\n",
709 (unsigned long) ms_stats.cmd_get);
710 pos+= snprintf(pos,
711 sizeof(buf) - (size_t)(pos -buf),
712 "cmd_set: %lu\n",
713 (unsigned long) ms_stats.cmd_set);
714 pos+= snprintf(pos,
715 sizeof(buf) - (size_t)(pos -buf),
716 "get_misses: %lu\n",
717 (unsigned long) ms_stats.get_misses);
718
719 if (ms_setting.verify_percent > 0)
720 {
721 pos+= snprintf(pos,
722 sizeof(buf) - (size_t)(pos -buf),
723 "verify_misses: %lu\n",
724 (unsigned long) ms_stats.vef_miss);
725 pos+= snprintf(pos,
726 sizeof(buf) - (size_t)(pos -buf),
727 "verify_failed: %lu\n",
728 (unsigned long) ms_stats.vef_failed);
729 }
730
731 if (ms_setting.exp_ver_per > 0)
732 {
733 pos+= snprintf(pos,
734 sizeof(buf) - (size_t)(pos -buf),
735 "expired_get: %lu\n",
736 (unsigned long) ms_stats.exp_get);
737 pos+= snprintf(pos,
738 sizeof(buf) - (size_t)(pos -buf),
739 "unexpired_unget: %lu\n",
740 (unsigned long) ms_stats.unexp_unget);
741 }
742
743 pos+= snprintf(pos,
744 sizeof(buf) - (size_t)(pos -buf),
745 "written_bytes: %lu\n",
746 (unsigned long) ms_stats.bytes_written);
747 pos+= snprintf(pos,
748 sizeof(buf) - (size_t)(pos -buf),
749 "read_bytes: %lu\n",
750 (unsigned long) ms_stats.bytes_read);
751 pos+= snprintf(pos,
752 sizeof(buf) - (size_t)(pos -buf),
753 "object_bytes: %lu\n",
754 (unsigned long) ms_stats.obj_bytes);
755
756 if (ms_setting.udp || ms_setting.facebook_test)
757 {
758 pos+= snprintf(pos,
759 sizeof(buf) - (size_t)(pos -buf),
760 "packet_disorder: %lu\n",
761 (unsigned long) ms_stats.pkt_disorder);
762 pos+= snprintf(pos,
763 sizeof(buf) - (size_t)(pos -buf),
764 "packet_drop: %lu\n",
765 (unsigned long)ms_stats.pkt_drop);
766 pos+= snprintf(pos,
767 sizeof(buf) - (size_t)(pos -buf),
768 "udp_timeout: %lu\n",
769 (unsigned long)ms_stats.udp_timeout);
770 }
771
772 if (ms_setting.stat_freq > 0)
773 {
774 ms_dump_stats(&ms_statistic.get_stat);
775 ms_dump_stats(&ms_statistic.set_stat);
776 ms_dump_stats(&ms_statistic.total_stat);
777 }
778
779 int64_t time_diff= ms_time_diff(start_time, end_time);
780 pos+= snprintf(pos,
781 sizeof(buf) - (size_t)(pos -buf),
782 "\nRun time: %.1fs Ops: %llu TPS: %.0Lf Net_rate: %.1fM/s\n",
783 (double)time_diff / 1000000,
784 (unsigned long long)(ms_stats.cmd_get + ms_stats.cmd_set),
785 (ms_stats.cmd_get
786 + ms_stats.cmd_set) / ((long double)time_diff / 1000000),
787 (double)(
788 ms_stats.bytes_written
789 + ms_stats.bytes_read) / 1024 / 1024
790 / ((double)time_diff / 1000000));
791 assert(pos <= buf);
792
793 fprintf(stdout, "%s", buf);
794 fflush(stdout);
795 } /* ms_print_memslap_stats */
796
797
798 /* the loop of the main thread, wait the work threads to complete */
799 static void ms_monitor_slap_mode()
800 {
801 struct timeval start_time, end_time;
802
803 /* Wait all the threads complete initialization. */
804 pthread_mutex_lock(&ms_global.init_lock.lock);
805 while (ms_global.init_lock.count < ms_setting.nthreads)
806 {
807 pthread_cond_wait(&ms_global.init_lock.cond,
808 &ms_global.init_lock.lock);
809 }
810 pthread_mutex_unlock(&ms_global.init_lock.lock);
811
812 /* only when there is no set operation it need warm up */
813 if (ms_setting.cmd_distr[CMD_SET].cmd_prop < PROP_ERROR)
814 {
815 /* Wait all the connects complete warm up. */
816 pthread_mutex_lock(&ms_global.warmup_lock.lock);
817 while (ms_global.warmup_lock.count < ms_setting.nconns)
818 {
819 pthread_cond_wait(&ms_global.warmup_lock.cond, &ms_global.warmup_lock.lock);
820 }
821 pthread_mutex_unlock(&ms_global.warmup_lock.lock);
822 }
823 ms_global.finish_warmup= true;
824
825 /* running in "run time" mode, user specify run time */
826 if (ms_setting.run_time > 0)
827 {
828 int second= 0;
829 gettimeofday(&start_time, NULL);
830 while (1)
831 {
832 sleep(1);
833 second++;
834
835 if ((ms_setting.stat_freq > 0) && (second % ms_setting.stat_freq == 0)
836 && (ms_stats.active_conns >= ms_setting.nconns)
837 && (ms_stats.active_conns <= INT_MAX))
838 {
839 ms_print_statistics(second);
840 }
841
842 if (ms_setting.run_time <= second)
843 {
844 ms_global.time_out= true;
845 break;
846 }
847
848 /* all connections disconnect */
849 if ((second > 5) && (ms_stats.active_conns == 0))
850 {
851 break;
852 }
853 }
854 gettimeofday(&end_time, NULL);
855 sleep(1); /* wait all threads clean up */
856 }
857 else
858 {
859 /* running in "execute number" mode, user specify execute number */
860 gettimeofday(&start_time, NULL);
861
862 /*
863 * We loop until we know that all connects have cleaned up.
864 */
865 pthread_mutex_lock(&ms_global.run_lock.lock);
866 while (ms_global.run_lock.count < ms_setting.nconns)
867 {
868 pthread_cond_wait(&ms_global.run_lock.cond, &ms_global.run_lock.lock);
869 }
870 pthread_mutex_unlock(&ms_global.run_lock.lock);
871
872 gettimeofday(&end_time, NULL);
873 }
874
875 ms_print_memslap_stats(&start_time, &end_time);
876 } /* ms_monitor_slap_mode */
877
878
879 /* the main function */
880 int main(int argc, char *argv[])
881 {
882 srandom((unsigned int)time(NULL));
883 ms_global_struct_init();
884
885 /* initialization */
886 ms_setting_init_pre();
887 ms_options_parse(argc, argv);
888 if (ms_check_para())
889 {
890 ms_help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION);
891 exit(1);
892 }
893 ms_setting_init_post();
894 ms_stats_init();
895 ms_thread_init();
896
897 /* waiting work thread complete its task */
898 ms_monitor_slap_mode();
899
900 /* clean up */
901 ms_thread_cleanup();
902 ms_global_struct_destroy();
903 ms_setting_cleanup();
904
905 return EXIT_SUCCESS;
906 } /* main */
Resurrection of libmemcached https://launchpad.net/libmemcached