{
printf(" -%c, --%s%c\n", long_options[x].val, long_options[x].name,
long_options[x].has_arg ? '=' : ' ');
+
if ((help_message= (char *)ms_lookup_help(long_options[x].val)) != NULL)
{
printf(" %s\n", help_message);
break;
case OPT_CONCURRENCY: /* --concurrency or -c */
- ms_setting.nconns= atoi(optarg);
+ ms_setting.nconns= (int)strtol(optarg, (char **) NULL, 10);
if (ms_setting.nconns <= 0)
{
fprintf(stderr, "Concurrency must be greater than 0.:-)\n");
break;
case OPT_EXECUTE_NUMBER: /* --execute_number or -x */
- ms_setting.exec_num= atoll(optarg);
+ ms_setting.exec_num= (int)strtol(optarg, (char **) NULL, 10);
if (ms_setting.exec_num <= 0)
{
fprintf(stderr, "Execute number must be greater than 0.:-)\n");
break;
case OPT_THREAD_NUMBER: /* --threads or -T */
- ms_setting.nthreads= atoi(optarg);
+ ms_setting.nthreads= (int)strtol(optarg, (char **) NULL, 10);
if (ms_setting.nthreads <= 0)
{
fprintf(stderr, "Threads number must be greater than 0.:-)\n");
break;
case OPT_FIXED_LTH: /* --fixed_size or -X */
- ms_setting.fixed_value_size= (size_t)atoi(optarg);
+ ms_setting.fixed_value_size= (size_t)strtoull(optarg, (char **) NULL, 10);
if ((ms_setting.fixed_value_size <= 0)
|| (ms_setting.fixed_value_size > MAX_VALUE_SIZE))
{
break;
case OPT_GETS_DIVISION: /* --division or -d */
- ms_setting.mult_key_num= atoi(optarg);
+ ms_setting.mult_key_num= (int)strtol(optarg, (char **) NULL, 10);
if (ms_setting.mult_key_num <= 0)
{
fprintf(stderr, "Multi-get key number must be greater than 0.:-)\n");
break;
case OPT_SOCK_PER_CONN: /* --conn_sock or -n */
- ms_setting.sock_per_conn= atoi(optarg);
+ ms_setting.sock_per_conn= (int)strtol(optarg, (char **) NULL, 10);
if (ms_setting.sock_per_conn <= 0)
{
fprintf(stderr, "Number of socks of each concurrency "
break;
case OPT_REP_WRITE_SRV: /* --rep_write or -p */
- ms_setting.rep_write_srv= atoi(optarg);
+ ms_setting.rep_write_srv= (int)strtol(optarg, (char **) NULL, 10);
if (ms_setting.rep_write_srv <= 0)
{
fprintf(stderr,
{
if (ms_setting.srv_str == NULL)
{
- fprintf(stderr, "No Servers provided.\n\n");
- return -1;
+ char *temp;
+
+ if ((temp= getenv("MEMCACHED_SERVERS")))
+ {
+ ms_setting.srv_str= strdup(temp);
+ }
+ else
+ {
+ fprintf(stderr, "No Servers provided\n\n");
+ return -1;
+ }
}
if (ms_setting.nconns % ms_setting.nthreads != 0)
second++;
if ((ms_setting.stat_freq > 0) && (second % ms_setting.stat_freq == 0)
- && ((int32_t)ms_stats.active_conns >= ms_setting.nconns)
- && (ms_stats.active_conns <= (uint32_t)INT_MAX))
+ && (ms_stats.active_conns >= ms_setting.nconns)
+ && (ms_stats.active_conns <= INT_MAX))
{
ms_print_statistics(second);
}
#include <ctype.h>
#include <inttypes.h>
+#include <limits.h>
+#include <pwd.h>
#include <strings.h>
+#include <sys/types.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+
#include "ms_setting.h"
#include "ms_conn.h"
#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 */
*/
static void ms_no_config_file()
{
- FILE *fd= fopen("config", "w+");
+ 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);
- ms_setting.cfg_file= strdup("config");
+exit:
+ ms_setting.cfg_file= strdup(userpath);
} /* ms_no_config_file */
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 ((((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");
fclose(f);
- if (no_cfg)
- {
- remove(ms_setting.cfg_file);
- }
-
if (line != NULL)
+ {
free(line);
+ }
} /* ms_parse_cfg_file */
*/
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)
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));
+ 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");
}
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));
+
+ 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");
static test_return_t generate_pairs(memcached_st *memc __attribute__((unused)))
{
- unsigned long long x;
global_pairs= pairs_generate(GLOBAL_COUNT, 400);
global_count= GLOBAL_COUNT;
- for (x= 0; x < global_count; x++)
+ for (size_t x= 0; x < global_count; x++)
{
global_keys[x]= global_pairs[x].key;
global_keys_length[x]= global_pairs[x].key_length;
static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unused)))
{
- unsigned long long x;
global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
global_count= GLOBAL2_COUNT;
- for (x= 0; x < global_count; x++)
+ for (size_t x= 0; x < global_count; x++)
{
global_keys[x]= global_pairs[x].key;
global_keys_length[x]= global_pairs[x].key_length;
static test_return_t get_read_count(memcached_st *memc)
{
- unsigned int x;
memcached_return_t rc;
memcached_st *memc_clone;
uint32_t flags;
uint32_t count;
- for (x= count= 0; x < global_count; x++)
+ for (size_t x= count= 0; x < global_count; x++)
{
return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
&return_value_length, &flags, &rc);
static test_return_t get_read(memcached_st *memc)
{
- unsigned int x;
memcached_return_t rc;
{
size_t return_value_length;
uint32_t flags;
- for (x= 0; x < global_count; x++)
+ for (size_t x= 0; x < global_count; x++)
{
return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
&return_value_length, &flags, &rc);
static test_return_t delete_generate(memcached_st *memc)
{
- unsigned int x;
-
- for (x= 0; x < global_count; x++)
+ for (size_t x= 0; x < global_count; x++)
{
(void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
}
static test_return_t add_host_test1(memcached_st *memc)
{
- unsigned int x;
memcached_return_t rc;
char servername[]= "0.example.com";
memcached_server_st *servers;
test_truth(servers);
test_truth(1 == memcached_server_list_count(servers));
- for (x= 2; x < 20; x++)
+ for (size_t x= 2; x < 20; x++)
{
char buffer[SMALL_STRING_LEN];
- snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
+ snprintf(buffer, SMALL_STRING_LEN, "%zu.example.com", 400+x);
servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
&rc);
test_truth(rc == MEMCACHED_SUCCESS);
for (int count=0; count < 5; ++count)
{
- for (int x=0; x < 100; ++x)
+ for (size_t x= 0; x < 100; ++x)
{
char key[10];
- size_t len= (size_t)sprintf(key, "%d", x);
+ size_t len= (size_t)sprintf(key, "%zu", x);
switch (count)
{
case 0:
** way it is supposed to do!!!!
*/
int no_msg=0;
- for (uint32_t x=0; x < memcached_server_count(memc); ++x)
+ for (size_t x= 0; x < memcached_server_count(memc); ++x)
{
memcached_server_instance_st *instance=
memcached_server_instance_fetch(memc, x);
/*
** Now validate that all items was set properly!
*/
- for (int x=0; x < 100; ++x)
+ for (size_t x= 0; x < 100; ++x)
{
char key[10];
- size_t len= (size_t)sprintf(key, "%d", x);
+
+ size_t len= (size_t)sprintf(key, "%zu", x);
size_t length;
uint32_t flags;
char* value=memcached_get(memc, key, strlen(key),
memcached_st* mmc[10];
memcached_return_t rc;
- for (int x= 0; x < 10; ++x) {
+ for (size_t x= 0; x < 10; ++x)
+ {
mmc[x]= memcached_pool_pop(pool, false, &rc);
test_truth(mmc[x] != NULL);
test_truth(rc == MEMCACHED_SUCCESS);
rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
test_truth(rc == MEMCACHED_SUCCESS);
- for (unsigned int x= 0; x < 10; ++x) {
+ for (size_t x= 0; x < 10; ++x)
+ {
uint64_t number_value;
rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
test_truth(rc == MEMCACHED_SUCCESS);
}
// Release them..
- for (int x= 0; x < 10; ++x)
+ for (size_t x= 0; x < 10; ++x)
+ {
test_truth(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
+ }
/* verify that I can set behaviors on the pool when I don't have all
const char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
- for (int x=0; x< 4; ++x)
+ for (size_t x= 0; x< 4; ++x)
{
rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
test_truth(rc == MEMCACHED_SUCCESS);
memcached_quit(memc);
- for (int x=0; x< 7; ++x) {
+ for (size_t x= 0; x< 7; ++x)
+ {
const char key[2]= { [0]= (const char)x };
rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 7);
const char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
- for (int x=0; x< 4; ++x)
+ for (size_t x= 0; x< 4; ++x)
{
rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
test_truth(rc == MEMCACHED_SUCCESS);
* This is to verify correct behavior in the library
*/
uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
- for (uint32_t x= 0; x < (repl + 1); ++x)
+ for (size_t x= 0; x < (repl + 1); ++x)
{
memcached_server_instance_st *instance=
memcached_server_instance_fetch(memc_clone, x);
memcached_result_st result_obj;
for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
{
- for (int x= 'a'; x <= 'z'; ++x)
+ for (size_t x= 'a'; x <= 'z'; ++x)
{
const char key[2]= { [0]= (const char)x };
{
uint16_t *ids= malloc(sizeof(uint16_t) * memcached_server_count(memc));
assert(ids != NULL);
- unsigned int x;
- for (x= 0; x < memcached_server_count(memc); x++)
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
{
memcached_server_instance_st *instance=
memcached_server_instance_fetch(memc, x);
static test_return_t post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
{
- unsigned int x;
memcached_server_st *cur_server = memcached_server_list(memc);
uint16_t *cur_req_ids = get_udp_request_ids(memc);
- for (x= 0; x < memcached_server_count(memc); x++)
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
{
test_truth(cur_server[x].cursor_active == 0);
test_truth(cur_req_ids[x] == expected_req_ids[x]);
return TEST_SKIPPED;
uint32_t num_hosts= memcached_server_count(memc);
- unsigned int x= 0;
memcached_server_st servers[num_hosts];
memcpy(servers, memcached_server_list(memc), sizeof(memcached_server_st) * num_hosts);
- for (x= 0; x < num_hosts; x++)
+ for (size_t x= 0; x < num_hosts; x++)
{
memcached_server_instance_st *set_instance=
memcached_server_instance_fetch(memc, x);
memc->number_of_hosts= 0;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
- for (x= 0; x < num_hosts; x++)
+ for (size_t x= 0; x < num_hosts; x++)
{
memcached_server_instance_st *set_instance=
memcached_server_instance_fetch(memc, x);
static test_return_t udp_set_test(memcached_st *memc)
{
- unsigned int x= 0;
unsigned int num_iters= 1025; //request id rolls over at 1024
- for (x= 0; x < num_iters;x++)
+
+ for (size_t x= 0; x < num_iters;x++)
{
memcached_return_t rc;
const char *key= "foo";
value, MAX_UDP_DATAGRAM_LENGTH,
(time_t)0, (uint32_t)0);
test_truth(rc == MEMCACHED_WRITE_FAILURE);
+
return post_udp_op_check(memc,expected_ids);
}
static test_return_t udp_delete_test(memcached_st *memc)
{
- unsigned int x= 0;
unsigned int num_iters= 1025; //request id rolls over at 1024
- for (x= 0; x < num_iters;x++)
+
+ for (size_t x= 0; x < num_iters;x++)
{
memcached_return_t rc;
const char *key= "foo";
{
memcached_return_t rc;
uint16_t *expected_ids= get_udp_request_ids(memc);
- unsigned int x;
- for (x= 0; x < memcached_server_count(memc); x++)
+
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
+ {
increment_request_id(&expected_ids[x]);
+ }
rc= memcached_verbosity(memc,3);
test_truth(rc == MEMCACHED_SUCCESS);
{
memcached_return_t rc;
uint16_t *expected_ids= get_udp_request_ids(memc);
- unsigned int x;
- for (x= 0; x < memcached_server_count(memc);x++)
+
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
+ {
increment_request_id(&expected_ids[x]);
+ }
rc= memcached_flush(memc,0);
test_truth(rc == MEMCACHED_SUCCESS);
{"udp_version_test", 0,
(test_callback_fn)udp_version_test}
};
- unsigned int x= 0;
- for (x= 0; x < 500; x++)
+ for (size_t x= 0; x < 500; x++)
{
current_op= mixed_io_ops[random() % 9];
test_truth(current_op.test_fn(memc) == TEST_SUCCESS);
projects / m6w6 / libmemcached / commitdiff
