static test_return_t cleanup_pairs(memcached_st *memc)
{
(void)memc;
pairs_free(global_pairs);
return 0;
}
void *run_task(void *p)
{
thread_context_st *context= (thread_context_st *)p;
memcached_st *memc;
memc= context->memc;
pthread_mutex_lock(&sleeper_mutex);
while (master_wakeup)
{
pthread_cond_wait(&sleep_threshhold, &sleeper_mutex);
}
pthread_mutex_unlock(&sleeper_mutex);
/* Do Stuff */
switch (context->test)
{
case SET_TEST:
execute_set(memc, context->execute_pairs, context->execute_number);
break;
case GET_TEST:
execute_get(memc, context->initial_pairs, context->initial_number);
break;
}
memcached_free(memc);
if (context->execute_pairs)
pairs_free(context->execute_pairs);
free(context);
pthread_mutex_lock(&counter_mutex);
thread_counter--;
pthread_cond_signal(&count_threshhold);
pthread_mutex_unlock(&counter_mutex);
return NULL;
}
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);
}