couchbase-memcached 1.2.8

data/ext/libmemcached-0.50/clients/ms_conn.h

@@ -0,0 +1,241 @@
+/*
+ * File:   ms_conn.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+#ifndef MS_CONN_H
+#define MS_CONN_H
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <event.h>
+#include <netdb.h>
+
+#include "ms_task.h"
+#include <libmemcached/memcached/protocol_binary.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DATA_BUFFER_SIZE             (1024 * 1024 + 2048) /* read buffer, 1M + 2k, enough for the max value(1M) */
+#define WRITE_BUFFER_SIZE            (32 * 1024)          /* write buffer, 32k */
+#define UDP_DATA_BUFFER_SIZE         (1 * 1024 * 1024)    /* read buffer for UDP, 1M */
+#define UDP_MAX_PAYLOAD_SIZE         1400                 /* server limit UDP payload size */
+#define UDP_MAX_SEND_PAYLOAD_SIZE    1400                 /* mtu size is 1500 */
+#define UDP_HEADER_SIZE              8                    /* UDP header size */
+#define MAX_SENDBUF_SIZE             (256 * 1024 * 1024)  /* Maximum socket buffer size */
+#define SOCK_WAIT_TIMEOUT            30                   /* maximum waiting time of UDP, 30s */
+#define MAX_UDP_PACKET               (1 << 16)            /* maximum UDP packets, 65536 */
+
+/* Initial size of the sendmsg() scatter/gather array. */
+#define IOV_LIST_INITIAL             400
+
+/* Initial number of sendmsg() argument structures to allocate. */
+#define MSG_LIST_INITIAL             10
+
+/* High water marks for buffer shrinking */
+#define READ_BUFFER_HIGHWAT          (2 * DATA_BUFFER_SIZE)
+#define UDP_DATA_BUFFER_HIGHWAT      (4 * UDP_DATA_BUFFER_SIZE)
+#define IOV_LIST_HIGHWAT             600
+#define MSG_LIST_HIGHWAT             100
+
+/* parse udp header */
+#define HEADER_TO_REQID(ptr)      ((uint16_t)*ptr * 256 \
+                                   + (uint16_t)*(ptr + 1))
+#define HEADER_TO_SEQNUM(ptr)     ((uint16_t)*(ptr        \
+                                               + 2) * 256 \
+                                   + (uint16_t)*(ptr + 3))
+#define HEADER_TO_PACKETS(ptr)    ((uint16_t)*(ptr        \
+                                               + 4) * 256 \
+                                   + (uint16_t)*(ptr + 5))
+
+/* states of connection */
+enum conn_states
+{
+  conn_read,         /* reading in a command line */
+  conn_write,        /* writing out a simple response */
+  conn_closing      /* closing this connection */
+};
+
+/* returned states of memcached command */
+enum mcd_ret
+{
+  MCD_SUCCESS,                      /* command success */
+  MCD_FAILURE,                      /* command failure */
+  MCD_UNKNOWN_READ_FAILURE,         /* unknown read failure */
+  MCD_PROTOCOL_ERROR,               /* protocol error */
+  MCD_CLIENT_ERROR,                 /* client error, wrong command */
+  MCD_SERVER_ERROR,                 /* server error, server run command failed */
+  MCD_DATA_EXISTS,                  /* object is existent in server */
+  MCD_NOTSTORED,                    /* server doesn't set the object successfully */
+  MCD_STORED,                       /* server set the object successfully */
+  MCD_NOTFOUND,                     /* server not find the object */
+  MCD_END,                          /* end of the response of get command */
+  MCD_DELETED,                      /* server delete the object successfully */
+  MCD_STAT                         /* response of stats command */
+};
+
+/* used to store the current or previous running command state */
+typedef struct cmdstat
+{
+  int cmd;                  /* command name */
+  int retstat;              /* return state of this command */
+  bool isfinish;            /* if it read all the response data */
+  uint64_t key_prefix;      /* key prefix */
+} ms_cmdstat_t;
+
+/* udp packet structure */
+typedef struct udppkt
+{
+  uint8_t *header;          /* udp header of the packet */
+  char *data;               /* udp data of the packet */
+  int rbytes;               /* number of data in the packet */
+  int copybytes;            /* number of copied data in the packet */
+} ms_udppkt_t;
+
+/* three protocols supported */
+enum protocol
+{
+  ascii_prot = 3,           /* ASCII protocol */
+  binary_prot              /* binary protocol */
+};
+
+/**
+ *  concurrency structure
+ *
+ *  Each thread has a libevent to manage the events of network.
+ *  Each thread has one or more self-governed concurrencies;
+ *  each concurrency has one or more socket connections. This
+ *  concurrency structure includes all the private variables of
+ *  the concurrency.
+ */
+typedef struct conn
+{
+  uint32_t conn_idx;             /* connection index in the thread */
+  int sfd;                  /* current tcp sock handler of the connection structure */
+  int udpsfd;               /* current udp sock handler of the connection structure*/
+  int state;                /* state of the connection */
+  struct event event;       /* event for libevent */
+  short ev_flags;           /* event flag for libevent */
+  short which;              /* which events were just triggered */
+  bool change_sfd;          /* whether change sfd */
+
+  int *tcpsfd;              /* TCP sock array */
+  uint32_t total_sfds;           /* how many socks in the tcpsfd array */
+  uint32_t alive_sfds;           /* alive socks */
+  uint32_t cur_idx;              /* current sock index in tcpsfd array */
+
+  ms_cmdstat_t precmd;      /* previous command state */
+  ms_cmdstat_t currcmd;     /* current command state */
+
+  char *rbuf;               /* buffer to read commands into */
+  char *rcurr;              /* but if we parsed some already, this is where we stopped */
+  int rsize;                /* total allocated size of rbuf */
+  int rbytes;               /* how much data, starting from rcur, do we have unparsed */
+
+  bool readval;             /* read value state, read known data size */
+  int rvbytes;              /* total value size need to read */
+
+  char *wbuf;               /* buffer to write commands out */
+  char *wcurr;              /* for multi-get, where we stopped */
+  int wsize;                /* total allocated size of wbuf */
+  bool ctnwrite;            /* continue to write */
+
+  /* data for the mwrite state */
+  struct iovec *iov;
+  int iovsize;              /* number of elements allocated in iov[] */
+  int iovused;              /* number of elements used in iov[] */
+
+  struct msghdr *msglist;
+  int msgsize;              /* number of elements allocated in msglist[] */
+  int msgused;              /* number of elements used in msglist[] */
+  int msgcurr;              /* element in msglist[] being transmitted now */
+  int msgbytes;             /* number of bytes in current msg */
+
+  /* data for UDP clients */
+  bool udp;                          /* is this is a UDP "connection" */
+  uint32_t request_id;                   /* UDP request ID of current operation, if this is a UDP "connection" */
+  uint8_t *hdrbuf;                  /* udp packet headers */
+  int hdrsize;                      /* number of headers' worth of space is allocated */
+  struct  sockaddr srv_recv_addr;   /* Sent the most recent request to which server */
+  socklen_t srv_recv_addr_size;
+
+  /* udp read buffer */
+  char *rudpbuf;                    /* buffer to read commands into for udp */
+  int rudpsize;                     /* total allocated size of rudpbuf */
+  int rudpbytes;                    /* how much data, starting from rudpbuf */
+
+  /* order udp packet */
+  ms_udppkt_t *udppkt;              /* the offset of udp packet in rudpbuf */
+  int packets;                      /* number of total packets need to read */
+  int recvpkt;                      /* number of received packets */
+  int pktcurr;                      /* current packet in rudpbuf being ordered */
+  int ordcurr;                      /* current ordered packet */
+
+  ms_task_item_t *item_win;         /* task sequence */
+  int win_size;                     /* current task window size */
+  uint64_t set_cursor;              /* current set item index in the item window */
+  ms_task_t curr_task;              /* current running task */
+  ms_mlget_task_t mlget_task;       /* multi-get task */
+
+  int warmup_num;                   /* to run how many warm up operations*/
+  int remain_warmup_num;            /* left how many warm up operations to run */
+  int64_t exec_num;                 /* to run how many task operations */
+  int64_t remain_exec_num;          /* how many remained task operations to run */
+
+  /* response time statistic and time out control */
+  struct timeval start_time;        /* start time of current operation(s) */
+  struct timeval end_time;          /* end time of current operation(s) */
+
+  /* Binary protocol stuff */
+  protocol_binary_response_header binary_header;    /* local temporary binary header */
+  enum protocol protocol;                           /* which protocol this connection speaks */
+} ms_conn_t;
+
+/* used to generate the key prefix */
+uint64_t ms_get_key_prefix(void);
+
+
+/**
+ * setup a connection, each connection structure of each
+ * thread must call this function to initialize.
+ */
+int ms_setup_conn(ms_conn_t *c);
+
+
+/* after one operation completes, reset the connection */
+void ms_reset_conn(ms_conn_t *c, bool timeout);
+
+
+/**
+ *  reconnect several disconnected socks in the connection
+ *  structure, the ever-1-second timer of the thread will check
+ *  whether some socks in the connections disconnect. if
+ *  disconnect, reconnect the sock.
+ */
+int ms_reconn_socks(ms_conn_t *c);
+
+
+/* used to send set command to server */
+int ms_mcd_set(ms_conn_t *c, ms_task_item_t *item);
+
+
+/* used to send the get command to server */
+int ms_mcd_get(ms_conn_t *c, ms_task_item_t *item);
+
+
+/* used to send the multi-get command to server */
+int ms_mcd_mlget(ms_conn_t *c);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of MS_CONN_H */

data/ext/libmemcached-0.50/clients/ms_memslap.h

@@ -0,0 +1,132 @@
+/*
+ * File:   ms_memslap.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+#ifndef MS_MEMSLAP_H
+#define MS_MEMSLAP_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <assert.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <pthread.h>
+#if !defined(__cplusplus)
+# include <stdbool.h>
+#endif
+#include <math.h>
+
+#include "ms_stats.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* command line option  */
+typedef enum
+{
+  OPT_VERSION= 'V',
+  OPT_HELP= 'h',
+  OPT_UDP= 'U',
+  OPT_SERVERS= 's',
+  OPT_EXECUTE_NUMBER= 'x',
+  OPT_THREAD_NUMBER= 'T',
+  OPT_CONCURRENCY= 'c',
+  OPT_FIXED_LTH= 'X',
+  OPT_VERIFY= 'v',
+  OPT_GETS_DIVISION= 'd',
+  OPT_TIME= 't',
+  OPT_CONFIG_CMD= 'F',
+  OPT_WINDOW_SIZE= 'w',
+  OPT_EXPIRE= 'e',
+  OPT_STAT_FREQ= 'S',
+  OPT_RECONNECT= 'R',
+  OPT_VERBOSE= 'b',
+  OPT_FACEBOOK_TEST= 'a',
+  OPT_SOCK_PER_CONN= 'n',
+  OPT_BINARY_PROTOCOL= 'B',
+  OPT_OVERWRITE= 'o',
+  OPT_TPS= 'P',
+  OPT_REP_WRITE_SRV= 'p'
+} ms_options_t;
+
+/* global statistic of response time */
+typedef struct statistic
+{
+  pthread_mutex_t stat_mutex;       /* synchronize the following members */
+
+  ms_stat_t get_stat;               /* statistics of get command */
+  ms_stat_t set_stat;               /* statistics of set command */
+  ms_stat_t total_stat;             /* statistics of both get and set commands */
+} ms_statistic_t;
+
+/* global status statistic structure */
+typedef struct stats
+{
+  volatile uint32_t active_conns;   /* active connections */
+  size_t bytes_read;              /* read bytes */
+  size_t bytes_written;           /* written bytes */
+  size_t obj_bytes;               /* object bytes */
+  size_t pre_cmd_get;             /* previous total get command count */
+  size_t pre_cmd_set;             /* previous total set command count */
+  size_t cmd_get;                 /* current total get command count */
+  size_t cmd_set;                 /* current total set command count */
+  size_t get_misses;              /* total objects of get miss */
+  size_t vef_miss;                /* total objects of verification miss  */
+  size_t vef_failed;              /* total objects of verification failed  */
+  size_t unexp_unget;             /* total objects which is unexpired but not get */
+  size_t exp_get;                 /* total objects which is expired but get  */
+  volatile size_t pkt_disorder;            /* disorder packages of UDP */
+  size_t pkt_drop;                /* packages dropped of UDP */
+  size_t udp_timeout;             /* how many times timeout of UDP happens */
+} ms_stats_t;
+
+/* lock adapter */
+typedef struct sync_lock
+{
+  uint32_t count;
+  pthread_mutex_t lock;
+  pthread_cond_t cond;
+} ms_sync_lock_t;
+
+/* global variable structure */
+typedef struct global
+{
+  /* synchronize lock */
+  ms_sync_lock_t init_lock;
+  ms_sync_lock_t warmup_lock;
+  ms_sync_lock_t run_lock;
+
+  /* mutex for outputing error log synchronously when memslap crashes */
+  pthread_mutex_t quit_mutex;
+
+  /* mutex for generating key prefix */
+  pthread_mutex_t seq_mutex;
+
+  /* global synchronous flags for slap mode */
+  bool finish_warmup;
+  bool time_out;
+} ms_global_t;
+
+/* global structure */
+ms_global_t ms_global;
+
+/* global stats information structure */
+ms_stats_t ms_stats;
+
+/* global statistic structure */
+ms_statistic_t ms_statistic;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of MS_MEMSLAP_H */

data/ext/libmemcached-0.50/clients/ms_setting.c

@@ -0,0 +1,1068 @@
+/*
+ * File:   ms_setting.c
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+
+#include "config.h"
+
+#include <libmemcached/memcached.h>
+
+#include <ctype.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <pwd.h>
+#include <strings.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+
+
+#include "ms_setting.h"
+#include "ms_conn.h"
+
+#define MAX_EXEC_NUM               0x4000000000000000      /* 1 << 62 */
+#define ADDR_ALIGN(addr)    ((addr + 15) & ~(16 - 1))      /* 16 bytes aligned */
+#define RAND_CHAR_SIZE             (10 * 1024 * 1024)      /* 10M character table */
+#define RESERVED_RAND_CHAR_SIZE    (2 * 1024 * 1024)       /* reserved 2M to avoid pointer sloping over */
+
+#define DEFAULT_CONFIG_NAME ".memslap.cnf"
+
+#define DEFAULT_THREADS_NUM        1                       /* default start one thread */
+#define DEFAULT_CONNS_NUM          16                      /* default each thread with 16 connections */
+#define DEFAULT_EXE_NUM            0                       /* default execute number is 0 */
+#define DEFAULT_VERIFY_RATE        0.0                     /* default it doesn't do data verification */
+#define DEFAULT_OVERWRITE_RATE     0.0                     /* default it doesn't do overwrite */
+#define DEFAULT_DIV                1                       /* default it runs single get */
+#define DEFAULT_RUN_TIME           600                     /* default run time 10 minutes */
+#define DEFAULT_WINDOW_SIZE        (10 * UNIT_ITEMS_COUNT) /* default window size is 10k */
+#define DEFAULT_SOCK_PER_CONN      1                       /* default socks per connection is 1 */
+
+/* Use this for string generation */
+#define CHAR_COUNT                 64 /* number of characters used to generate character table */
+const char ALPHANUMBERICS[]=
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-";
+
+ms_setting_st ms_setting;       /* store the settings specified by user */
+
+
+/* read setting from configuration file */
+static void ms_get_serverlist(char *str);
+static uint32_t ms_get_cpu_count(void);
+ms_conf_type_t ms_get_conf_type(char *line);
+static int ms_is_line_data(char *line);
+static int ms_read_is_data(char *line, ssize_t nread);
+static void ms_no_config_file(void);
+static void ms_parse_cfg_file(char *cfg_file);
+
+
+/* initialize setting structure */
+static void ms_init_random_block(void);
+static void ms_calc_avg_size(void);
+static int ms_shuffle_distr(ms_distr_t *distr, int length);
+static void ms_build_distr(void);
+static void ms_print_setting(void);
+static void ms_setting_slapmode_init_pre(void);
+static void ms_setting_slapmode_init_post(void);
+
+#if !defined(HAVE_GETLINE)
+#include <limits.h>
+static ssize_t getline (char **line, size_t *line_size, FILE *fp)
+{
+  char delim= '\n';
+  ssize_t result= 0;
+  size_t cur_len= 0;
+
+  if (line == NULL || line_size == NULL || fp == NULL)
+  {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (*line == NULL || *line_size == 0)
+  {
+    char *new_line;
+    *line_size = 120;
+    new_line= (char *) realloc (*line, *line_size);
+    if (new_line == NULL)
+    {
+      result= -1;
+      return result;
+    }
+    *line= new_line;
+  }
+
+  for (;;)
+  {
+    int i= getc(fp);
+    if (i == EOF)
+    {
+      result = -1;
+      break;
+    }
+
+    /* Make enough space for len+1 (for final NUL) bytes.  */
+    if (cur_len + 1 >= *line_size)
+    {
+      size_t needed_max=
+        SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX;
+      size_t needed= (2 * (*line_size)) + 1;
+      char *new_line;
+
+      if (needed_max < needed)
+        needed= needed_max;
+      if (cur_len + 1 >= needed)
+      {
+        result= -1;
+        errno= EOVERFLOW;
+        return result;
+      }
+
+      new_line= (char *)realloc(*line, needed);
+      if (new_line == NULL)
+      {
+        result= -1;
+        return result;
+      }
+
+      *line= new_line;
+      *line_size= needed;
+    }
+
+    (*line)[cur_len]= (char)i;
+    cur_len++;
+
+    if (i == delim)
+      break;
+  }
+  (*line)[cur_len] = '\0';
+  if (cur_len != 0)
+    return (ssize_t)cur_len;
+  return result;
+}
+#endif
+
+/**
+ * parse the server list string, and build the servers
+ * information structure array. this function is used to parse
+ * the command line options specified by user.
+ *
+ * @param str, the string of server list
+ */
+static void ms_get_serverlist(char *str)
+{
+  ms_mcd_server_t *srvs= NULL;
+
+  /**
+   * Servers list format is like this. For example:
+   * "localhost:11108, localhost:11109"
+   */
+  memcached_server_st *server_pool;
+  server_pool = memcached_servers_parse(str);
+
+  for (uint32_t loop= 0; loop < memcached_server_list_count(server_pool); loop++)
+  {
+    assert(ms_setting.srv_cnt < ms_setting.total_srv_cnt);
+    strcpy(ms_setting.servers[ms_setting.srv_cnt].srv_host_name, server_pool[loop].hostname);
+    ms_setting.servers[ms_setting.srv_cnt].srv_port= server_pool[loop].port;
+    ms_setting.servers[ms_setting.srv_cnt].disconn_cnt= 0;
+    ms_setting.servers[ms_setting.srv_cnt].reconn_cnt= 0;
+    ms_setting.srv_cnt++;
+
+    if (ms_setting.srv_cnt >= ms_setting.total_srv_cnt)
+    {
+      srvs= (ms_mcd_server_t *)realloc( ms_setting.servers,
+                                        (size_t)ms_setting.total_srv_cnt * sizeof(ms_mcd_server_t) * 2);
+      if (srvs == NULL)
+      {
+        fprintf(stderr, "Can't reallocate servers structure.\n");
+        exit(1);
+      }
+      ms_setting.servers= srvs;
+      ms_setting.total_srv_cnt*= 2;
+    }
+  }
+
+  memcached_server_free(server_pool);
+} /* ms_get_serverlist */
+
+
+/**
+ * used to get the CPU count of the current system
+ *
+ * @return return the cpu count if get, else return EXIT_FAILURE
+ */
+static uint32_t ms_get_cpu_count()
+{
+#ifdef HAVE__SC_NPROCESSORS_ONLN
+  return sysconf(_SC_NPROCESSORS_CONF);
+
+#else
+# ifdef HAVE_CPU_SET_T
+  int cpu_count= 0;
+  cpu_set_t cpu_set;
+
+  sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set);
+
+  for (int i= 0; i < (sizeof(cpu_set_t) * 8); i++)
+  {
+    if (CPU_ISSET(i, &cpu_set))
+    {
+      cpu_count++;
+    }
+  }
+
+  return cpu_count;
+
+# endif
+#endif
+
+  /* the system with one cpu at least */
+  return EXIT_FAILURE;
+} /* ms_get_cpu_count */
+
+
+/**
+ * used to get the configure type based on the type string read
+ * from the configuration file.
+ *
+ * @param line, string of one line
+ *
+ * @return ms_conf_type_t
+ */
+ms_conf_type_t ms_get_conf_type(char *line)
+{
+  if (! memcmp(line, "key", strlen("key")))
+  {
+    return CONF_KEY;
+  }
+  else if (! memcmp(line, "value", strlen("value")))
+  {
+    return CONF_VALUE;
+  }
+  else if (! memcmp(line, "cmd", strlen("cmd")))
+  {
+    return CONF_CMD;
+  }
+  else
+  {
+    return CONF_NULL;
+  }
+} /* ms_get_conf_type */
+
+
+/**
+ * judge whether the line is a line with useful data. used to
+ * parse the configuration file.
+ *
+ * @param line, string of one line
+ *
+ * @return if success, return EXIT_FAILURE, else return EXIT_SUCCESS
+ */
+static int ms_is_line_data(char *line)
+{
+  assert(line != NULL);
+
+  char *begin_ptr= line;
+
+  while (isspace(*begin_ptr))
+  {
+    begin_ptr++;
+  }
+  if ((begin_ptr[0] == '\0') || (begin_ptr[0] == '#'))
+    return EXIT_SUCCESS;
+
+  return EXIT_FAILURE;
+} /* ms_is_line_data */
+
+
+/**
+ * function to bypass blank line and comments
+ *
+ * @param line, string of one line
+ * @param nread, length of the line
+ *
+ * @return if it's EOF or not line data, return EXIT_SUCCESS, else return EXIT_FAILURE
+ */
+static int ms_read_is_data(char *line, ssize_t nread)
+{
+  if ((nread == EOF) || ! ms_is_line_data(line))
+    return EXIT_SUCCESS;
+
+  return EXIT_FAILURE;
+} /* ms_read_is_data */
+
+
+/**
+ *  if no configuration file, use this function to create the default
+ *  configuration file.
+ */
+static void ms_no_config_file()
+{
+  char userpath[PATH_MAX];
+  struct passwd *usr= NULL;
+  FILE *fd;
+
+  usr= getpwuid(getuid());
+
+  snprintf(userpath, PATH_MAX, "%s/%s", usr->pw_dir, DEFAULT_CONFIG_NAME);
+
+  if (access (userpath, F_OK | R_OK) == 0)
+    goto exit;
+
+  fd= fopen(userpath, "w+");
+
+  if (fd == NULL)
+  {
+    fprintf(stderr, "Could not create default configure file %s\n", userpath);
+    perror(strerror(errno));
+    exit(1);
+  }
+  fprintf(fd, "%s", DEFAULT_CONGIF_STR);
+  fclose(fd);
+
+exit:
+  ms_setting.cfg_file= strdup(userpath);
+} /* ms_no_config_file */
+
+
+/**
+ * parse the configuration file
+ *
+ * @param cfg_file, the configuration file name
+ */
+static void ms_parse_cfg_file(char *cfg_file)
+{
+  FILE *f;
+  size_t start_len, end_len;
+  double proportion;
+  char *line= NULL;
+  size_t  read_len;
+  ssize_t nread;
+  int cmd_type;
+  ms_conf_type_t conf_type;
+  int end_of_file= 0;
+  ms_key_distr_t *key_distr= NULL;
+  ms_value_distr_t *val_distr= NULL;
+
+  if (cfg_file == NULL)
+  {
+    ms_no_config_file();
+    cfg_file= ms_setting.cfg_file;
+  }
+
+  /*read key value configure file*/
+  if ((f= fopen(cfg_file, "r")) == NULL)
+  {
+    fprintf(stderr, "Can not open file: '%s'.\n", cfg_file);
+    exit(1);
+  }
+
+  while (1)
+  {
+    if ((((nread= getline(&line, &read_len, f)) == 1)
+         || ! ms_read_is_data(line, nread)) && (nread != EOF)) /* bypass blank line */
+      continue;
+
+    if (nread == EOF)
+    {
+      fprintf(stderr, "Bad configuration file, no configuration find.\n");
+      exit(1);
+    }
+    conf_type= ms_get_conf_type(line);
+    break;
+  }
+
+  while (! end_of_file)
+  {
+    switch (conf_type)
+    {
+    case CONF_KEY:
+      while (1)
+      {
+        if ((((nread= getline(&line, &read_len, f)) == 1)
+             || ! ms_read_is_data(line, nread)) && (nread != EOF))     /* bypass blank line */
+          continue;
+
+        if (nread != EOF)
+        {
+          if (sscanf(line, "%zu %zu %lf ", &start_len,
+                     &end_len, &proportion) != 3)
+          {
+            conf_type= ms_get_conf_type(line);
+            break;
+          }
+          ms_setting.key_distr[ms_setting.key_rng_cnt].start_len= start_len;
+          ms_setting.key_distr[ms_setting.key_rng_cnt].end_len= end_len;
+          ms_setting.key_distr[ms_setting.key_rng_cnt].key_prop= proportion;
+          ms_setting.key_rng_cnt++;
+
+          if (ms_setting.key_rng_cnt >= ms_setting.total_key_rng_cnt)
+          {
+            key_distr= (ms_key_distr_t *)realloc(
+              ms_setting.key_distr,
+              (size_t)ms_setting.
+                 total_key_rng_cnt * sizeof(ms_key_distr_t) * 2);
+            if (key_distr == NULL)
+            {
+              fprintf(stderr,
+                      "Can't reallocate key distribution structure.\n");
+              exit(1);
+            }
+            ms_setting.key_distr= key_distr;
+            ms_setting.total_key_rng_cnt*= 2;
+          }
+          continue;
+        }
+        end_of_file= 1;
+        break;
+      }
+      break;
+
+    case CONF_VALUE:
+      while (1)
+      {
+        if ((((nread= getline(&line, &read_len, f)) == 1)
+             || ! ms_read_is_data(line, nread)) && (nread != EOF))     /* bypass blank line */
+          continue;
+
+        if (nread != EOF)
+        {
+          if (sscanf(line, "%zu %zu %lf", &start_len, &end_len,
+                     &proportion) != 3)
+          {
+            conf_type= ms_get_conf_type(line);
+            break;
+          }
+          ms_setting.value_distr[ms_setting.val_rng_cnt].start_len=
+            start_len;
+          ms_setting.value_distr[ms_setting.val_rng_cnt].end_len= end_len;
+          ms_setting.value_distr[ms_setting.val_rng_cnt].value_prop=
+            proportion;
+          ms_setting.val_rng_cnt++;
+
+          if (ms_setting.val_rng_cnt >= ms_setting.total_val_rng_cnt)
+          {
+            val_distr= (ms_value_distr_t *)realloc(
+              ms_setting.value_distr,
+              (size_t)ms_setting.
+                 total_val_rng_cnt * sizeof(ms_value_distr_t) * 2);
+            if (val_distr == NULL)
+            {
+              fprintf(stderr,
+                      "Can't reallocate key distribution structure.\n");
+              exit(1);
+            }
+            ms_setting.value_distr= val_distr;
+            ms_setting.total_val_rng_cnt*= 2;
+          }
+          continue;
+        }
+        end_of_file= 1;
+        break;
+      }
+      break;
+
+    case CONF_CMD:
+      while (1)
+      {
+        if ((((nread= getline(&line, &read_len, f)) == 1)
+             || ! ms_read_is_data(line, nread)) && (nread != EOF))     /* bypass blank line */
+          continue;
+
+        if (nread != EOF)
+        {
+          if (sscanf(line, "%d %lf", &cmd_type, &proportion) != 2)
+          {
+            conf_type= ms_get_conf_type(line);
+            break;
+          }
+          if (cmd_type >= CMD_NULL)
+          {
+            continue;
+          }
+          ms_setting.cmd_distr[ms_setting.cmd_used_count].cmd_type=
+            cmd_type;
+          ms_setting.cmd_distr[ms_setting.cmd_used_count].cmd_prop=
+            proportion;
+          ms_setting.cmd_used_count++;
+          continue;
+        }
+        end_of_file= 1;
+        break;
+      }
+
+    case CONF_NULL:
+      while (1)
+      {
+        if ((((nread= getline(&line, &read_len, f)) == 1)
+             || ! ms_read_is_data(line, nread)) && (nread != EOF))     /* bypass blank line */
+          continue;
+
+        if (nread != EOF)
+        {
+          if ((conf_type= ms_get_conf_type(line)) != CONF_NULL)
+          {
+            break;
+          }
+          continue;
+        }
+        end_of_file= 1;
+        break;
+      }
+      break;
+
+    default:
+      assert(0);
+      break;
+    } /* switch */
+  }
+
+  fclose(f);
+
+  if (line != NULL)
+  {
+    free(line);
+  }
+} /* ms_parse_cfg_file */
+
+
+/* calculate the average size of key and value */
+static void ms_calc_avg_size()
+{
+  double avg_val_size= 0.0;
+  double avg_key_size= 0.0;
+  double val_pro= 0.0;
+  double key_pro= 0.0;
+  double averge_len= 0.0;
+  size_t start_len= 0;
+  size_t end_len= 0;
+
+  for (int j= 0; j < ms_setting.val_rng_cnt; j++)
+  {
+    val_pro= ms_setting.value_distr[j].value_prop;
+    start_len= ms_setting.value_distr[j].start_len;
+    end_len= ms_setting.value_distr[j].end_len;
+
+    averge_len= val_pro * ((double)(start_len + end_len)) / 2;
+    avg_val_size+= averge_len;
+  }
+
+  for (int j= 0; j < ms_setting.key_rng_cnt; j++)
+  {
+    key_pro= ms_setting.key_distr[j].key_prop;
+    start_len= ms_setting.key_distr[j].start_len;
+    end_len= ms_setting.key_distr[j].end_len;
+
+    averge_len= key_pro * ((double)(start_len + end_len)) / 2;
+    avg_key_size+= averge_len;
+  }
+
+  ms_setting.avg_val_size= (size_t)avg_val_size;
+  ms_setting.avg_key_size= (size_t)avg_key_size;
+} /* ms_calc_avg_size */
+
+
+/**
+ * used to shuffle key and value distribution array to ensure
+ * (key, value) pair with different set.
+ *
+ * @param distr, pointer of distribution structure array
+ * @param length, length of the array
+ *
+ * @return always return EXIT_SUCCESS
+ */
+static int ms_shuffle_distr(ms_distr_t *distr, int length)
+{
+  int i, j;
+  int tmp_offset;
+  size_t  tmp_size;
+  int64_t rnd;
+
+  for (i= 0; i < length; i++)
+  {
+    rnd= random();
+    j= (int)(rnd % (length - i)) + i;
+
+    switch (rnd % 3)
+    {
+    case 0:
+      tmp_size= distr[j].key_size;
+      distr[j].key_size= distr[i].key_size;
+      distr[i].key_size= tmp_size;
+      break;
+
+    case 1:
+      tmp_offset= distr[j].key_offset;
+      distr[j].key_offset= distr[i].key_offset;
+      distr[i].key_offset= tmp_offset;
+      break;
+
+    case 2:
+      tmp_size= distr[j].value_size;
+      distr[j].value_size= distr[i].value_size;
+      distr[i].value_size= tmp_size;
+      break;
+
+    default:
+      break;
+    } /* switch */
+  }
+
+  return EXIT_SUCCESS;
+} /* ms_shuffle_distr */
+
+
+/**
+ * according to the key and value distribution, to build the
+ * (key, value) pair distribution. the (key, value) pair
+ * distribution array is global, each connection set or get
+ * object keeping this distribution, for the final result, we
+ * can reach the expected key and value distribution.
+ */
+static void ms_build_distr()
+{
+  int offset= 0;
+  int end= 0;
+  int key_cnt= 0;
+  int value_cnt= 0;
+  size_t average_len= 0;
+  size_t diff_len= 0;
+  size_t start_len= 0;
+  size_t end_len= 0;
+  int rnd= 0;
+  ms_distr_t *distr= NULL;
+  int units= (int)ms_setting.win_size / UNIT_ITEMS_COUNT;
+
+  /* calculate average value size and key size */
+  ms_calc_avg_size();
+
+  ms_setting.char_blk_size= RAND_CHAR_SIZE;
+  int key_scope_size=
+    (int)((ms_setting.char_blk_size - RESERVED_RAND_CHAR_SIZE)
+          / UNIT_ITEMS_COUNT);
+
+  ms_setting.distr= (ms_distr_t *)malloc(
+    sizeof(ms_distr_t) * ms_setting.win_size);
+  if (ms_setting.distr == NULL)
+  {
+    fprintf(stderr, "Can't allocate distribution array.");
+    exit(1);
+  }
+
+  /**
+   *  character block is divided by how many different key
+   *  size, each different key size has the same size character
+   *  range.
+   */
+  for (int m= 0; m < units; m++)
+  {
+    for (int i= 0; i < UNIT_ITEMS_COUNT; i++)
+    {
+      ms_setting.distr[m * UNIT_ITEMS_COUNT + i].key_offset=
+        ADDR_ALIGN(key_scope_size * i);
+    }
+  }
+
+  /* initialize key size distribution */
+  for (int m= 0; m < units; m++)
+  {
+    for (int j= 0; j < ms_setting.key_rng_cnt; j++)
+    {
+      key_cnt= (int)(UNIT_ITEMS_COUNT * ms_setting.key_distr[j].key_prop);
+      start_len= ms_setting.key_distr[j].start_len;
+      end_len= ms_setting.key_distr[j].end_len;
+      if ((start_len < MIN_KEY_SIZE) || (end_len < MIN_KEY_SIZE))
+      {
+        fprintf(stderr, "key length must be greater than 16 bytes.\n");
+        exit(1);
+      }
+
+      if (! ms_setting.binary_prot
+          && ((start_len > MAX_KEY_SIZE) || (end_len > MAX_KEY_SIZE)))
+      {
+        fprintf(stderr, "key length must be less than 250 bytes.\n");
+        exit(1);
+      }
+
+      average_len= (start_len + end_len) / 2;
+      diff_len= (end_len - start_len) / 2;
+      for (int k= 0; k < key_cnt; k++)
+      {
+        if (offset >= (m + 1) * UNIT_ITEMS_COUNT)
+        {
+          break;
+        }
+        rnd= (int)random();
+        if (k % 2 == 0)
+        {
+          ms_setting.distr[offset].key_size=
+            (diff_len == 0) ? average_len :
+            average_len + (size_t)rnd
+            % diff_len;
+        }
+        else
+        {
+          ms_setting.distr[offset].key_size=
+            (diff_len == 0) ? average_len :
+            average_len - (size_t)rnd
+            % diff_len;
+        }
+        offset++;
+      }
+    }
+
+    if (offset < (m + 1) * UNIT_ITEMS_COUNT)
+    {
+      end= (m + 1) * UNIT_ITEMS_COUNT - offset;
+      for (int i= 0; i < end; i++)
+      {
+        ms_setting.distr[offset].key_size= ms_setting.avg_key_size;
+        offset++;
+      }
+    }
+  }
+  offset= 0;
+
+  /* initialize value distribution */
+  if (ms_setting.fixed_value_size != 0)
+  {
+    for (int i= 0; i < units * UNIT_ITEMS_COUNT; i++)
+    {
+      ms_setting.distr[i].value_size= ms_setting.fixed_value_size;
+    }
+  }
+  else
+  {
+    for (int m= 0; m < units; m++)
+    {
+      for (int j= 0; j < ms_setting.val_rng_cnt; j++)
+      {
+        value_cnt=
+          (int)(UNIT_ITEMS_COUNT * ms_setting.value_distr[j].value_prop);
+        start_len= ms_setting.value_distr[j].start_len;
+        end_len= ms_setting.value_distr[j].end_len;
+        if ((start_len <= 0) || (end_len <= 0))
+        {
+          fprintf(stderr, "value length must be greater than 0 bytes.\n");
+          exit(1);
+        }
+
+        if ((start_len > MAX_VALUE_SIZE) || (end_len > MAX_VALUE_SIZE))
+        {
+          fprintf(stderr, "key length must be less than or equal to 1M.\n");
+          exit(1);
+        }
+
+        average_len= (start_len + end_len) / 2;
+        diff_len= (end_len - start_len) / 2;
+        for (int k= 0; k < value_cnt; k++)
+        {
+          if (offset >= (m + 1) * UNIT_ITEMS_COUNT)
+          {
+            break;
+          }
+          rnd= (int)random();
+          if (k % 2 == 0)
+          {
+            ms_setting.distr[offset].value_size=
+              (diff_len == 0) ? average_len :
+              average_len
+              + (size_t)rnd % diff_len;
+          }
+          else
+          {
+            ms_setting.distr[offset].value_size=
+              (diff_len == 0) ? average_len :
+              average_len
+              - (size_t)rnd % diff_len;
+          }
+          offset++;
+        }
+      }
+
+      if (offset < (m + 1) * UNIT_ITEMS_COUNT)
+      {
+        end= (m + 1) * UNIT_ITEMS_COUNT - offset;
+        for (int i= 0; i < end; i++)
+        {
+          ms_setting.distr[offset++].value_size= ms_setting.avg_val_size;
+        }
+      }
+    }
+  }
+
+  /* shuffle distribution */
+  for (int i= 0; i < units; i++)
+  {
+    distr= &ms_setting.distr[i * UNIT_ITEMS_COUNT];
+    for (int j= 0; j < 4; j++)
+    {
+      ms_shuffle_distr(distr, UNIT_ITEMS_COUNT);
+    }
+  }
+} /* ms_build_distr */
+
+
+/**
+ * used to initialize the global character block. The character
+ * block is used to generate the suffix of the key and value. we
+ * only store a pointer in the character block for each key
+ * suffix or value string. It can save much memory to store key
+ * or value string.
+ */
+static void ms_init_random_block()
+{
+  char *ptr= NULL;
+
+  assert(ms_setting.char_blk_size > 0);
+
+  ms_setting.char_block= (char *)malloc(ms_setting.char_blk_size);
+  if (ms_setting.char_block == NULL)
+  {
+    fprintf(stderr, "Can't allocate global char block.");
+    exit(1);
+  }
+  ptr= ms_setting.char_block;
+
+  for (int i= 0; (size_t)i < ms_setting.char_blk_size; i++)
+  {
+    *(ptr++)= ALPHANUMBERICS[random() % CHAR_COUNT];
+  }
+} /* ms_init_random_block */
+
+
+/**
+ * after initialization, call this function to output the main
+ * configuration user specified.
+ */
+static void ms_print_setting()
+{
+  fprintf(stdout, "servers : %s\n", ms_setting.srv_str);
+  fprintf(stdout, "threads count: %d\n", ms_setting.nthreads);
+  fprintf(stdout, "concurrency: %d\n", ms_setting.nconns);
+  if (ms_setting.run_time > 0)
+  {
+    fprintf(stdout, "run time: %ds\n", ms_setting.run_time);
+  }
+  else
+  {
+    fprintf(stdout, "execute number: %" PRId64 "\n", ms_setting.exec_num);
+  }
+  fprintf(stdout, "windows size: %" PRId64 "k\n",
+          (int64_t)(ms_setting.win_size / 1024));
+  fprintf(stdout, "set proportion: set_prop=%.2f\n",
+          ms_setting.cmd_distr[CMD_SET].cmd_prop);
+  fprintf(stdout, "get proportion: get_prop=%.2f\n",
+          ms_setting.cmd_distr[CMD_GET].cmd_prop);
+  fflush(stdout);
+} /* ms_print_setting */
+
+
+/**
+ * previous part of slap mode initialization of setting structure
+ */
+static void ms_setting_slapmode_init_pre()
+{
+  ms_setting.exec_num= DEFAULT_EXE_NUM;
+  ms_setting.verify_percent= DEFAULT_VERIFY_RATE;
+  ms_setting.exp_ver_per= DEFAULT_VERIFY_RATE;
+  ms_setting.overwrite_percent= DEFAULT_OVERWRITE_RATE;
+  ms_setting.mult_key_num= DEFAULT_DIV;
+  ms_setting.fixed_value_size= 0;
+  ms_setting.win_size= DEFAULT_WINDOW_SIZE;
+  ms_setting.udp= false;
+  ms_setting.reconnect= false;
+  ms_setting.verbose= false;
+  ms_setting.facebook_test= false;
+  ms_setting.binary_prot= false;
+  ms_setting.stat_freq= 0;
+  ms_setting.srv_str= NULL;
+  ms_setting.cfg_file= NULL;
+  ms_setting.sock_per_conn= DEFAULT_SOCK_PER_CONN;
+  ms_setting.expected_tps= 0;
+  ms_setting.rep_write_srv= 0;
+} /* ms_setting_slapmode_init_pre */
+
+
+/**
+ * previous part of initialization of setting structure
+ */
+void ms_setting_init_pre()
+{
+  memset(&ms_setting, 0, sizeof(ms_setting));
+
+  /* common initialize */
+  ms_setting.ncpu= ms_get_cpu_count();
+  ms_setting.nthreads= DEFAULT_THREADS_NUM;
+  ms_setting.nconns= DEFAULT_CONNS_NUM;
+  ms_setting.run_time= DEFAULT_RUN_TIME;
+  ms_setting.total_srv_cnt= MCD_SRVS_NUM_INIT;
+  ms_setting.servers= (ms_mcd_server_t *)malloc(
+    (size_t)ms_setting.total_srv_cnt
+    * sizeof(ms_mcd_server_t));
+  if (ms_setting.servers == NULL)
+  {
+    fprintf(stderr, "Can't allocate servers structure.\n");
+    exit(1);
+  }
+
+  ms_setting_slapmode_init_pre();
+} /* ms_setting_init_pre */
+
+
+/**
+ * post part of slap mode initialization of setting structure
+ */
+static void ms_setting_slapmode_init_post()
+{
+  ms_setting.total_key_rng_cnt= KEY_RANGE_COUNT_INIT;
+  ms_setting.key_distr=
+    (ms_key_distr_t *)malloc((size_t)ms_setting.total_key_rng_cnt * sizeof(ms_key_distr_t));
+
+  if (ms_setting.key_distr == NULL)
+  {
+    fprintf(stderr, "Can't allocate key distribution structure.\n");
+    exit(1);
+  }
+
+  ms_setting.total_val_rng_cnt= VALUE_RANGE_COUNT_INIT;
+
+  ms_setting.value_distr=
+    (ms_value_distr_t *)malloc((size_t)ms_setting.total_val_rng_cnt * sizeof( ms_value_distr_t));
+
+  if (ms_setting.value_distr == NULL)
+  {
+    fprintf(stderr, "Can't allocate value distribution structure.\n");
+    exit(1);
+  }
+
+  ms_parse_cfg_file(ms_setting.cfg_file);
+
+  /* run time mode */
+  if ((ms_setting.exec_num == 0) && (ms_setting.run_time != 0))
+  {
+    ms_setting.exec_num= (int64_t)MAX_EXEC_NUM;
+  }
+  else
+  {
+    /* execute number mode */
+    ms_setting.run_time= 0;
+  }
+
+  if (ms_setting.rep_write_srv > 0)
+  {
+    /* for replication test, need enable reconnect feature */
+    ms_setting.reconnect= true;
+  }
+
+  if (ms_setting.facebook_test && (ms_setting.mult_key_num < 2))
+  {
+    fprintf(stderr, "facebook test must work with multi-get, "
+                    "please specify multi-get key number "
+                    "with '--division' option.\n");
+    exit(1);
+  }
+
+  if (ms_setting.facebook_test && ms_setting.udp)
+  {
+    fprintf(stderr, "facebook test couldn't work with UDP.\n");
+    exit(1);
+  }
+
+  if (ms_setting.udp && (ms_setting.sock_per_conn > 1))
+  {
+    fprintf(stderr, "UDP doesn't support multi-socks "
+                    "in one connection structure.\n");
+    exit(1);
+  }
+
+  if ((ms_setting.rep_write_srv > 0) && (ms_setting.srv_cnt < 2))
+  {
+    fprintf(stderr, "Please specify 2 servers at least for replication\n");
+    exit(1);
+  }
+
+  if ((ms_setting.rep_write_srv > 0)
+      && (ms_setting.srv_cnt < ms_setting.rep_write_srv))
+  {
+    fprintf(stderr, "Servers to do replication writing "
+                    "is larger than the total servers\n");
+    exit(1);
+  }
+
+  if (ms_setting.udp && (ms_setting.rep_write_srv > 0))
+  {
+    fprintf(stderr, "UDP doesn't support replication.\n");
+    exit(1);
+  }
+
+  if (ms_setting.facebook_test && (ms_setting.rep_write_srv > 0))
+  {
+    fprintf(stderr, "facebook test couldn't work with replication.\n");
+    exit(1);
+  }
+
+  ms_build_distr();
+
+  /* initialize global character block */
+  ms_init_random_block();
+  ms_print_setting();
+} /* ms_setting_slapmode_init_post */
+
+
+/**
+ * post part of initialization of setting structure
+ */
+void ms_setting_init_post()
+{
+  ms_get_serverlist(ms_setting.srv_str);
+  ms_setting_slapmode_init_post();
+}
+
+
+/**
+ * clean up the global setting structure
+ */
+void ms_setting_cleanup()
+{
+  if (ms_setting.distr != NULL)
+  {
+    free(ms_setting.distr);
+  }
+
+  if (ms_setting.char_block != NULL)
+  {
+    free(ms_setting.char_block);
+  }
+
+  if (ms_setting.srv_str != NULL)
+  {
+    free(ms_setting.srv_str);
+  }
+
+  if (ms_setting.cfg_file != NULL)
+  {
+    free(ms_setting.cfg_file);
+  }
+
+  if (ms_setting.servers != NULL)
+  {
+    free(ms_setting.servers);
+  }
+
+  if (ms_setting.key_distr != NULL)
+  {
+    free(ms_setting.key_distr);
+  }
+
+  if (ms_setting.value_distr != NULL)
+  {
+    free(ms_setting.value_distr);
+  }
+} /* ms_setting_cleanup */