-#include <memcached.h>
#include "common.h"
/* Protoypes (static) */
static memcached_return server_add(memcached_st *ptr, char *hostname,
unsigned int port,
memcached_connection type);
+memcached_return update_continuum(memcached_st *ptr);
#define MEMCACHED_WHEEL_SIZE 1024
#define MEMCACHED_STRIDE 4
-static void rebalance_wheel(memcached_st *ptr)
+static memcached_return rebalance_wheel(memcached_st *ptr)
{
unsigned int x;
unsigned int y;
unsigned int latch;
+ if (ptr->number_of_hosts > ptr->wheel_count)
+ {
+ uint32_t *new_ptr;
+
+ if (ptr->call_realloc)
+ new_ptr= (uint32_t *)ptr->call_realloc(ptr, ptr->wheel, sizeof(uint32_t) * (ptr->number_of_hosts + MEMCACHED_CONTINUUM_ADDITION) * MEMCACHED_STRIDE);
+ else
+ new_ptr= (uint32_t *)realloc(ptr->wheel, sizeof(uint32_t) * (ptr->number_of_hosts + MEMCACHED_CONTINUUM_ADDITION) * MEMCACHED_STRIDE);
+
+ if (new_ptr == 0)
+ return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+
+ ptr->wheel= new_ptr;
+ ptr->wheel_count= ptr->number_of_hosts + MEMCACHED_CONTINUUM_ADDITION;
+ }
+
/* Seed the Wheel */
- memset(ptr->wheel, 0, sizeof(unsigned int) * MEMCACHED_WHEEL_SIZE);
+ memset(ptr->wheel, 0, sizeof(uint32_t) * MEMCACHED_STRIDE * ptr->wheel_count);
- for (latch= y= x= 0; x < MEMCACHED_WHEEL_SIZE; x++, latch++)
+ for (latch= y= x= 0; x < MEMCACHED_STRIDE * ptr->wheel_count; x++, latch++)
{
if (latch == MEMCACHED_STRIDE)
{
ptr->wheel[x]= y;
}
+
+ return MEMCACHED_SUCCESS;
}
static int compare_servers(const void *p1, const void *p2)
if (return_value == 0)
{
- if (a->port > b->port)
- return_value++;
- else
- return_value--;
+ return_value= (int) (a->port - b->port);
}
return return_value;
}
+void sort_hosts(memcached_st *ptr)
+{
+ if (ptr->number_of_hosts)
+ {
+ qsort(ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st), compare_servers);
+ ptr->hosts[0].count= ptr->number_of_hosts;
+ }
+}
+
+
+memcached_return run_distribution(memcached_st *ptr)
+{
+ switch (ptr->distribution)
+ {
+ case MEMCACHED_DISTRIBUTION_CONSISTENT:
+ case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
+ return update_continuum(ptr);
+ case MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL:
+ return rebalance_wheel(ptr);
+ break;
+ case MEMCACHED_DISTRIBUTION_MODULA:
+ if (ptr->flags & MEM_USE_SORT_HOSTS)
+ sort_hosts(ptr);
+ break;
+ default:
+ WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
+ }
+
+ return MEMCACHED_SUCCESS;
+}
+
static void host_reset(memcached_st *ptr, memcached_server_st *host,
char *hostname, unsigned int port,
memcached_connection type)
for (x= 0; x < servers->count; x++)
if (servers[x].address_info)
+ {
freeaddrinfo(servers[x].address_info);
+ servers[x].address_info= NULL;
+ }
if (ptr && ptr->call_free)
ptr->call_free(ptr, servers);
free(servers);
}
+static int continuum_item_cmp(const void *t1, const void *t2)
+{
+ memcached_continuum_item_st *ct1 = (memcached_continuum_item_st *)t1;
+ memcached_continuum_item_st *ct2 = (memcached_continuum_item_st *)t2;
+
+ WATCHPOINT_ASSERT(ct1->value != 153);
+ if (ct1->value == ct2->value)
+ return 0;
+ else if (ct1->value > ct2->value)
+ return 1;
+ else
+ return -1;
+}
+
+memcached_return update_continuum(memcached_st *ptr)
+{
+ uint32_t index;
+ uint32_t host_index;
+ uint32_t continuum_index= 0;
+ uint32_t value;
+ memcached_server_st *list;
+
+ if (ptr->number_of_hosts > ptr->continuum_count)
+ {
+ memcached_continuum_item_st *new_ptr;
+
+ if (ptr->call_realloc)
+ new_ptr= (memcached_continuum_item_st *)ptr->call_realloc(ptr, ptr->continuum, sizeof(memcached_continuum_item_st) * (ptr->number_of_hosts + MEMCACHED_CONTINUUM_ADDITION) * MEMCACHED_POINTS_PER_SERVER);
+ else
+ new_ptr= (memcached_continuum_item_st *)realloc(ptr->continuum, sizeof(memcached_continuum_item_st) * (ptr->number_of_hosts + MEMCACHED_CONTINUUM_ADDITION) * MEMCACHED_POINTS_PER_SERVER);
+
+ if (new_ptr == 0)
+ return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+
+ ptr->continuum= new_ptr;
+ ptr->continuum_count= ptr->number_of_hosts + MEMCACHED_CONTINUUM_ADDITION;
+ }
+
+ list = ptr->hosts;
+ for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
+ {
+ for(index= 1; index <= MEMCACHED_POINTS_PER_SERVER; ++index)
+ {
+ char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
+ size_t sort_host_length;
+
+ sort_host_length= snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH, "%s:%d-%d",
+ list[host_index].hostname, list[host_index].port, index);
+ WATCHPOINT_ASSERT(sort_host_length);
+ value= generate_hash(ptr, sort_host, sort_host_length);
+ ptr->continuum[continuum_index].index= host_index;
+ ptr->continuum[continuum_index++].value= value;
+ }
+ }
+
+ WATCHPOINT_ASSERT(ptr->number_of_hosts * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE);
+ qsort(ptr->continuum, ptr->number_of_hosts * MEMCACHED_POINTS_PER_SERVER, sizeof(memcached_continuum_item_st), continuum_item_cmp);
+#ifdef HAVE_DEBUG
+ for (index= 0; index < ((ptr->number_of_hosts * MEMCACHED_POINTS_PER_SERVER) - 1); index++)
+ {
+ WATCHPOINT_ASSERT(ptr->continuum[index].value <= ptr->continuum[index + 1].value);
+ }
+#endif
+
+ return MEMCACHED_SUCCESS;
+}
+
+
memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
{
unsigned int x;
}
ptr->hosts[0].count= ptr->number_of_hosts;
- if (ptr->number_of_hosts > 1)
- qsort(ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st), compare_servers);
-
- rebalance_wheel(ptr);
-
- return MEMCACHED_SUCCESS;
+ return run_distribution(ptr);
}
memcached_return memcached_server_add_unix_socket(memcached_st *ptr, char *filename)
memcached_connection type)
{
memcached_server_st *new_host_list;
- LIBMEMCACHED_MEMCACHED_SERVER_ADD_START();
-
if (ptr->call_realloc)
new_host_list= (memcached_server_st *)ptr->call_realloc(ptr, ptr->hosts,
host_reset(ptr, &ptr->hosts[ptr->number_of_hosts], hostname, port, type);
ptr->number_of_hosts++;
- ptr->hosts[0].count++;
-
- if (ptr->number_of_hosts > 1)
- qsort(ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st), compare_servers);
-
- rebalance_wheel(ptr);
-
- LIBMEMCACHED_MEMCACHED_SERVER_ADD_END();
+ ptr->hosts[0].count= ptr->number_of_hosts;
- return MEMCACHED_SUCCESS;
+ return run_distribution(ptr);
}
memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
host_reset(NULL, &new_host_list[count-1], hostname, port, MEMCACHED_CONNECTION_TCP);
/* Backwards compatibility hack */
- new_host_list[0].count++;
-
- count= new_host_list[0].count;
-
- if (new_host_list[0].count > 1)
- qsort(new_host_list, count, sizeof(memcached_server_st), compare_servers);
-
new_host_list[0].count= count;
-
*error= MEMCACHED_SUCCESS;
return new_host_list;
}
projects / awesomized / libmemcached / blobdiff