X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached_hosts.c;h=2678a7c1ae131a9ada0d451dd868fb02528ba534;hb=7c41f51579dc36df33ec83a743dba8cc1ddc3e3f;hp=79bcb99d021eb2bf895c5f088dea109f53cc519c;hpb=9cfbe639c04a9308a37c012f741845f2b51f0f42;p=awesomized%2Flibmemcached

diff --git a/libmemcached/memcached_hosts.c b/libmemcached/memcached_hosts.c
index 79bcb99d..2678a7c1 100644
--- a/libmemcached/memcached_hosts.c
+++ b/libmemcached/memcached_hosts.c
@@ -4,19 +4,36 @@
 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)
     {
@@ -28,6 +45,8 @@ static void rebalance_wheel(memcached_st *ptr)
 
     ptr->wheel[x]= y;
   }
+
+  return MEMCACHED_SUCCESS;
 }
 
 static int compare_servers(const void *p1, const void *p2)
@@ -55,6 +74,28 @@ void sort_hosts(memcached_st *ptr)
   }
 }
 
+
+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)
@@ -80,7 +121,10 @@ void server_list_free(memcached_st *ptr, memcached_server_st *servers)
 
   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);
@@ -90,8 +134,8 @@ void server_list_free(memcached_st *ptr, memcached_server_st *servers)
 
 static int continuum_item_cmp(const void *t1, const void *t2)
 {
-  struct continuum_item *ct1 = (struct continuum_item *)t1;
-  struct continuum_item *ct2 = (struct continuum_item *)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)
@@ -102,26 +146,31 @@ static int continuum_item_cmp(const void *t1, const void *t2)
     return -1;
 }
 
-static uint32_t internal_generate_ketama_md5(char *key, size_t key_length)
-{
-  unsigned char results[16];
-
-  md5_signature((unsigned char*)key, (unsigned int)key_length, results);
-
-  return ( (results[3] ) << 24)
-    | ( (results[2] ) << 16)
-    | ( (results[1] ) << 8)
-    | ( results[0] );
-}
-
-void update_continuum(memcached_st *ptr)
+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 = ptr->hosts;
+  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) 
@@ -132,20 +181,22 @@ void update_continuum(memcached_st *ptr)
       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= internal_generate_ketama_md5(sort_host, 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(struct continuum_item), continuum_item_cmp);
+  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;
 }
 
 
@@ -183,25 +234,7 @@ memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *l
   }
   ptr->hosts[0].count= ptr->number_of_hosts;
 
-  if (ptr->flags & MEM_USE_SORT_HOSTS)
-    sort_hosts(ptr);
-
-  switch (ptr->distribution) 
-  {
-  case MEMCACHED_DISTRIBUTION_CONSISTENT:
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
-    update_continuum(ptr);
-    break;
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL:
-    rebalance_wheel(ptr);
-    break;
-  case MEMCACHED_DISTRIBUTION_MODULA:
-    break;
-  default:
-    WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
-  }
-
-  return MEMCACHED_SUCCESS;
+  return run_distribution(ptr);
 }
 
 memcached_return memcached_server_add_unix_socket(memcached_st *ptr, char *filename)
@@ -243,8 +276,6 @@ static memcached_return server_add(memcached_st *ptr, char *hostname,
                                    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, 
@@ -259,30 +290,9 @@ static memcached_return server_add(memcached_st *ptr, char *hostname,
 
   host_reset(ptr, &ptr->hosts[ptr->number_of_hosts], hostname, port, type);
   ptr->number_of_hosts++;
-
-  if (ptr->flags & MEM_USE_SORT_HOSTS)
-    sort_hosts(ptr);
-
   ptr->hosts[0].count= ptr->number_of_hosts;
 
-  switch (ptr->distribution) 
-  {
-  case MEMCACHED_DISTRIBUTION_CONSISTENT:
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
-    update_continuum(ptr);
-    break;
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL:
-    rebalance_wheel(ptr);
-    break;
-  case MEMCACHED_DISTRIBUTION_MODULA:
-    break;
-  default:
-    WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
-  }
-
-  LIBMEMCACHED_MEMCACHED_SERVER_ADD_END();
-
-  return MEMCACHED_SUCCESS;
+  return run_distribution(ptr);
 }
 
 memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,