projects / m6w6 / libmemcached / blob
? search:


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