Schooner memslap changes

[awesomized/libmemcached] / clients / ms_setting.c

/*
 * File:   ms_setting.c
 * Author: Mingqiang Zhuang
 *
 * Created on February 10, 2009
 *
 * (c) Copyright 2009, Schooner Information Technology, Inc.
 * http://www.schoonerinfotech.com/
 *
 */
#include <ctype.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_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_t ms_setting;       /* store the settings specified by user */


/* read setting from configuration file */
static void ms_get_serverlist(char *str);
static int 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);


/**
 * 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)
{
    char *string;
    int64_t port;
    char *begin_ptr;
    char *end_ptr = str + strlen(str);
    ms_mcd_server_t *srvs = NULL;
    char buffer[512];
    char *ptr = NULL;

    /**
     * Servers list format is like this. For example:
     * "localhost:11108, localhost:11109"
     */
    for (begin_ptr = str, string = index(str, ',');
        begin_ptr != end_ptr;
        string = index(begin_ptr, ',')) {
        port = 0;

        if (string) {
            memcpy(buffer, begin_ptr, (size_t)(string - begin_ptr));
            buffer[(unsigned int)(string - begin_ptr)]= '\0';
            begin_ptr = string+1;
        } else {
            size_t length= strlen(begin_ptr);
            memcpy(buffer, begin_ptr, length);
            buffer[length] = '\0';
            begin_ptr = end_ptr;
        }

        ptr = index(buffer, ':');

        if (ptr != NULL) {
            ptr[0] = '\0';
            ptr++;
            port = strtol(ptr, (char **)NULL, 10);
        }

        assert(ms_setting.srv_cnt < ms_setting.total_srv_cnt);
        strcpy(ms_setting.servers[ms_setting.srv_cnt].srv_host_name, buffer);
        ms_setting.servers[ms_setting.srv_cnt].srv_port = (int)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,
                   (uint64_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;
        }

        if (isspace(*begin_ptr))
            begin_ptr++;
    }
}

/**
 * used to get the CPU count of the current system
 *
 * @return return the cpu count if get, else return 1
 */
static int 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 1;
}

/**
 * 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;
    }
}

/**
 * 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 1, else return 0
 */
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 0;
    return 1;
}

/**
 * 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 0, else return 1
 */
static int  ms_read_is_data(char* line, ssize_t nread)
{
    if (nread == EOF || !ms_is_line_data(line))
        return 0;
    return 1;
}

/**
 *  if no configuration file, use this function to create the default
 *  configuration file.
 */
static void ms_no_config_file()
{
    FILE *fd = fopen("config", "w+");
    fprintf(fd, "%s", DEFAULT_CONGIF_STR);
    fclose(fd);

    ms_setting.cfg_file = strdup("config");
}

/**
 * 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;
    size_t frequence;
    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;
    bool no_cfg = false;

    if (cfg_file == NULL) {
        ms_no_config_file();
        cfg_file = ms_setting.cfg_file;
        no_cfg = true;
    }

    /*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, "%lu %lu %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,
                                    (uint64_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, "%lu %lu %lf %lu", &start_len, &end_len,
                               &proportion, &frequence) !=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,
                                                                (uint64_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\n", &cmd_type, &proportion) != 2) {
                        conf_type = ms_get_conf_type(line);
                        break;
                    }
                    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;
        }
    }

    fclose(f);

    if (no_cfg) {
        remove(ms_setting.cfg_file);
    }

    if (line != NULL)
        free(line);
}

/* 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;
}

/**
 * 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 0
 */
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;
        }
    }
    
    return 0;
}

/**
 * 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);
        }
    }
}

/**
 * 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];
    }
}

/**
 * after initialization, call this function to output the main
 * configuration user specified.
 */
static void ms_print_setting()
{
    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: %ld\n", ms_setting.exec_num);
    }
    fprintf(stdout, "windows size: %ldk\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);
}

/**
 * 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;
}

/**
 * previous part of initialization of setting structure
 */
void ms_setting_init_pre()
{
    memset(&ms_setting, 0, sizeof(ms_setting_t));

    /* 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((uint64_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();
}

/**
 * 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((uint64_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((uint64_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.udp || ms_setting.facebook_test) && ms_setting.binary_prot) {
        fprintf(stderr, "Binary protocol doesn't support UDP now.\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.rep_write_srv > 0 && ms_setting.sock_per_conn > 1) {
        fprintf(stderr, "Replication doesn't support multi-socks "
                        "in one connection structure.\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);
    }

    if (ms_setting.reconnect && ms_setting.sock_per_conn > 1) {
        fprintf(stderr, "Reconnection doesn't support multi-socks "
                        "in one connection structure.\n");
        exit(1);
    }

    ms_build_distr();

    /* initialize global character block */
    ms_init_random_block();
    ms_print_setting();
}

/**
 * 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);
    }
}