/**
@note This should be testing to see if the server really supports the binary protocol.
*/
static test_return_t pre_binary(memcached_st *memc)
{
memcached_return_t rc= MEMCACHED_FAILURE;
memcached_st *memc_clone;
memcached_server_instance_st instance;
memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
// The memcached_version needs to be done on a clone, because the server
// will not toggle protocol on an connection.
memcached_version(memc_clone);
instance= memcached_server_instance_by_position(memc_clone, 0);
if (instance->major_version >= 1 && instance->minor_version > 2)
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
memcached_free(memc_clone);
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
Memcache(const Memcache &rhs)
:
memc(),
result()
{
memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
}
Memcache(memcached_st *clone)
:
memc(),
result()
{
memcached_clone(&memc, clone);
}
Memc(const memcached_st* arg)
{
_memc= memcached_clone(NULL, arg);
if (_memc == NULL)
{
throw "memcached_clone() failed";
}
}
static test_return_t memcached_clone_benchmark(memcached_st *memc)
{
benchmark_state.clone_init= true;
for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
{
memcached_st *ptr;
ptr= memcached_clone(&benchmark_state.clone[x], memc);
test_true(ptr);
}
return TEST_SUCCESS;
}
/**
* Grow the connection pool by creating a connection structure and clone the
* original memcached handle.
*/
static int grow_pool(memcached_pool_st* pool) {
memcached_st *obj= calloc(1, sizeof(*obj));
if (obj == NULL)
return -1;
if (memcached_clone(obj, pool->master) == NULL)
{
free(obj);
return -1;
}
pool->mmc[++pool->firstfree] = obj;
pool->current_size++;
return 0;
}
pairs_st *load_create_data(memcached_st *memc, unsigned int number_of,
unsigned int *actual_loaded)
{
memcached_st *clone;
pairs_st *pairs;
clone= memcached_clone(NULL, memc);
/* We always used non-blocking IO for load since it is faster */
memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
pairs= pairs_generate(number_of, 400);
*actual_loaded= execute_set(clone, pairs, number_of);
memcached_free(clone);
return pairs;
}
memcached_st * ProxyConnPool::Pop() {
if (error_count_ > kMaxErrorCount) {
return NULL;
}
memcached_st * memc = 0;
IceUtil::Mutex::Lock lock(mutex_);
if (!reseting && !memc_pool_.empty()) {
if (memc_pool_.size() > 1) {
memc = memc_pool_.back();
memc_pool_.pop_back();
} else {
memc = memcached_clone(memc, memc_pool_.front());
}
}
return memc;
}
int pr_memcache_conn_clone(pool *p, pr_memcache_t *mcache) {
memcached_st *old_mc = NULL, *new_mc = NULL;
if (p == NULL ||
mcache == NULL) {
errno = EINVAL;
return -1;
}
memcached_quit(mcache->mc);
old_mc = mcache->mc;
new_mc = memcached_clone(NULL, old_mc);
if (new_mc == NULL) {
errno = ENOMEM;
return -1;
}
/* Now free up the previous context; we don't need it anymore. */
memcached_free(old_mc);
mcache->mc = new_mc;
return 0;
}
void scheduler(memcached_server_st *servers, conclusions_st *conclusion)
{
unsigned int x;
unsigned int actual_loaded= 0; /* Fix warning */
memcached_st *memc;
struct timeval start_time, end_time;
pthread_t mainthread; /* Thread descriptor */
pthread_attr_t attr; /* Thread attributes */
pairs_st *pairs= NULL;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_DETACHED);
memc= memcached_create(NULL);
memcached_server_push(memc, servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
if (opt_flush)
flush_all(memc);
if (opt_createial_load)
pairs= load_create_data(memc, opt_createial_load, &actual_loaded);
/* We set this after we have loaded */
{
if (opt_non_blocking_io)
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
if (opt_tcp_nodelay)
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
}
pthread_mutex_lock(&counter_mutex);
thread_counter= 0;
pthread_mutex_lock(&sleeper_mutex);
master_wakeup= 1;
pthread_mutex_unlock(&sleeper_mutex);
for (x= 0; x < opt_concurrency; x++)
{
thread_context_st *context;
context= (thread_context_st *)malloc(sizeof(thread_context_st));
memset(context, 0, sizeof(thread_context_st));
context->memc= memcached_clone(NULL, memc);
context->test= opt_test;
context->initial_pairs= pairs;
context->initial_number= actual_loaded;
if (opt_test == SET_TEST)
{
context->execute_pairs= pairs_generate(opt_execute_number, 400);
context->execute_number= opt_execute_number;
}
/* now you create the thread */
if (pthread_create(&mainthread, &attr, run_task,
(void *)context) != 0)
{
fprintf(stderr,"Could not create thread\n");
exit(1);
}
thread_counter++;
}
pthread_mutex_unlock(&counter_mutex);
pthread_attr_destroy(&attr);
pthread_mutex_lock(&sleeper_mutex);
master_wakeup= 0;
pthread_mutex_unlock(&sleeper_mutex);
pthread_cond_broadcast(&sleep_threshhold);
gettimeofday(&start_time, NULL);
/*
We loop until we know that all children have cleaned up.
*/
pthread_mutex_lock(&counter_mutex);
while (thread_counter)
{
struct timespec abstime;
memset(&abstime, 0, sizeof(struct timespec));
abstime.tv_sec= 1;
pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
}
pthread_mutex_unlock(&counter_mutex);
gettimeofday(&end_time, NULL);
conclusion->load_time= timedif(end_time, start_time);
conclusion->read_time= timedif(end_time, start_time);
pairs_free(pairs);
memcached_free(memc);
}
static int mcache_ping_servers(pr_memcache_t *mcache) {
memcached_server_st *alive_server_list;
memcached_return res;
memcached_st *clone;
uint32_t server_count;
register unsigned int i;
/* We always start with the configured list of servers. */
clone = memcached_clone(NULL, mcache->mc);
if (clone == NULL) {
errno = ENOMEM;
return -1;
}
memcached_servers_reset(clone);
/* Bug#4242: Don't use memcached_server_push() if we're using
* libmemcached-1.0.18 or earlier. Doing so leads to a segfault, due to
* this libmemcached bug:
*
* https://bugs.launchpad.net/libmemcached/+bug/1154159
*/
#if LIBMEMCACHED_VERSION_HEX > 0x01000018
memcached_server_push(clone, configured_server_list);
#endif
server_count = memcached_server_count(clone);
pr_trace_msg(trace_channel, 16,
"pinging %lu memcached %s", (unsigned long) server_count,
server_count != 1 ? "servers" : "server");
alive_server_list = NULL;
for (i = 0; i < server_count; i++) {
memcached_server_instance_st server;
server = memcached_server_instance_by_position(clone, i);
pr_trace_msg(trace_channel, 17, "pinging server %s:%d",
memcached_server_name(server), memcached_server_port(server));
if (libmemcached_util_ping(memcached_server_name(server),
memcached_server_port(server), &res) == FALSE) {
pr_trace_msg(trace_channel, 4,
"error pinging %s:%d: %s", memcached_server_name(server),
memcached_server_port(server), memcached_strerror(clone, res));
} else {
pr_trace_msg(trace_channel, 17, "server %s:%d is alive",
memcached_server_name(server), memcached_server_port(server));
alive_server_list = memcached_server_list_append(alive_server_list,
memcached_server_name(server), memcached_server_port(server), &res);
if (alive_server_list == NULL) {
pr_trace_msg(trace_channel, 1,
"error appending server %s:%d to list: %s",
memcached_server_name(server), memcached_server_port(server),
memcached_strerror(clone, res));
memcached_free(clone);
errno = EPERM;
return -1;
}
}
}
if (alive_server_list != NULL) {
memcached_servers_reset(mcache->mc);
res = memcached_server_push(mcache->mc, alive_server_list);
if (res != MEMCACHED_SUCCESS) {
unsigned int count;
count = memcached_server_list_count(alive_server_list);
pr_trace_msg(trace_channel, 2,
"error adding %u alive memcached %s to connection: %s",
count, count != 1 ? "servers" : "server",
memcached_strerror(mcache->mc, res));
memcached_free(clone);
errno = EPERM;
return -1;
} else {
unsigned int count;
count = memcached_server_list_count(alive_server_list);
pr_trace_msg(trace_channel, 9,
"now using %d alive memcached %s", count,
count != 1 ? "servers" : "server");
memcached_server_list_free(alive_server_list);
}
}
memcached_free(clone);
return 0;
}
