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

diff --git a/libmemcached/memcached_hosts.c b/libmemcached/memcached_hosts.c
index 2678a7c1..54440d35 100644
--- a/libmemcached/memcached_hosts.c
+++ b/libmemcached/memcached_hosts.c
@@ -1,4 +1,5 @@
 #include "common.h"
+#include <math.h>
 
 /* Protoypes (static) */
 static memcached_return server_add(memcached_st *ptr, char *hostname, 
@@ -6,49 +7,6 @@ static memcached_return server_add(memcached_st *ptr, char *hostname,
                                    memcached_connection type);
 memcached_return update_continuum(memcached_st *ptr);
 
-#define MEMCACHED_WHEEL_SIZE 1024
-#define MEMCACHED_STRIDE 4
-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(uint32_t) * MEMCACHED_STRIDE * ptr->wheel_count);
-
-  for (latch= y= x= 0; x < MEMCACHED_STRIDE * ptr->wheel_count; x++, latch++)
-  {
-    if (latch == MEMCACHED_STRIDE)
-    {
-      y++;
-      if (y == ptr->number_of_hosts)
-        y= 0;
-      latch= 0;
-    }
-
-    ptr->wheel[x]= y;
-  }
-
-  return MEMCACHED_SUCCESS;
-}
-
 static int compare_servers(const void *p1, const void *p2)
 {
   int return_value;
@@ -82,9 +40,6 @@ memcached_return run_distribution(memcached_st *ptr)
   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);
@@ -134,9 +89,10 @@ void server_list_free(memcached_st *ptr, memcached_server_st *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;
+  memcached_continuum_item_st *ct1= (memcached_continuum_item_st *)t1;
+  memcached_continuum_item_st *ct2= (memcached_continuum_item_st *)t2;
 
+  /* Why 153? Hmmm... */
   WATCHPOINT_ASSERT(ct1->value != 153);
   if (ct1->value == ct2->value)
     return 0;
@@ -153,6 +109,12 @@ memcached_return update_continuum(memcached_st *ptr)
   uint32_t continuum_index= 0;
   uint32_t value;
   memcached_server_st *list;
+  uint32_t pointer_counter= 0;
+  uint32_t pointer_per_server= MEMCACHED_POINTS_PER_SERVER;
+  memcached_return rc;
+  uint64_t total_mem_bytes= 0;
+  memcached_stat_st *stat_p= NULL;
+  uint32_t is_ketama_weighted= 0;
 
   if (ptr->number_of_hosts > ptr->continuum_count)
   {
@@ -171,9 +133,29 @@ memcached_return update_continuum(memcached_st *ptr)
   }
 
   list = ptr->hosts;
+
+  is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+  if(is_ketama_weighted) 
+  {
+    stat_p = memcached_stat(ptr, NULL, &rc);
+    for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index) 
+    {
+      list[host_index].limit_maxbytes= (stat_p + host_index)->limit_maxbytes;
+      total_mem_bytes += (stat_p + host_index)->limit_maxbytes;
+    }
+  }
+
   for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index) 
   {
-    for(index= 1; index <= MEMCACHED_POINTS_PER_SERVER; ++index) 
+    if(is_ketama_weighted) 
+    {
+        float pct = (float)list[host_index].limit_maxbytes/ (float)total_mem_bytes;
+        pointer_per_server= floorf( pct * MEMCACHED_POINTS_PER_SERVER * (float)(ptr->number_of_hosts));
+#ifdef HAVE_DEBUG
+        printf("ketama_weighted:%s|%d|%llu|%u\n", list[host_index].hostname, list[host_index].port,  list[host_index].limit_maxbytes, pointer_per_server);
+#endif
+    }
+    for(index= 1; index <= pointer_per_server; ++index) 
     {
       char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
       size_t sort_host_length;
@@ -181,14 +163,23 @@ memcached_return 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= generate_hash(ptr, sort_host, sort_host_length);
+      value= generate_hash_value(sort_host, sort_host_length, ptr->hash_continuum);
       ptr->continuum[continuum_index].index= host_index;
       ptr->continuum[continuum_index++].value= value;
     }
+    pointer_counter+= pointer_per_server;
   }
 
+  WATCHPOINT_ASSERT(ptr);
+  WATCHPOINT_ASSERT(ptr->continuum);
+  WATCHPOINT_ASSERT(ptr->number_of_hosts);
   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);
+
+  ptr->continuum_points_counter= pointer_counter;
+  if (stat_p)
+    memcached_stat_free(NULL, stat_p);
+
 #ifdef HAVE_DEBUG
   for (index= 0; index < ((ptr->number_of_hosts * MEMCACHED_POINTS_PER_SERVER) - 1); index++) 
   {
@@ -295,6 +286,32 @@ static memcached_return server_add(memcached_st *ptr, char *hostname,
   return run_distribution(ptr);
 }
 
+memcached_return memcached_server_remove(memcached_server_st *st_ptr)
+{
+  uint32_t x, index;
+  memcached_st *ptr= st_ptr->root;
+  memcached_server_st *list= ptr->hosts;
+
+  for (x= 0, index= 0; x < ptr->number_of_hosts; x++) 
+  {
+    if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH)!=0 || list[x].port != st_ptr->port) 
+    {
+      memcpy(list+index, list+x, sizeof(memcached_server_st));
+      index++;
+    } 
+  }
+  ptr->number_of_hosts= index;
+
+  if (st_ptr->address_info) 
+  {
+    freeaddrinfo(st_ptr->address_info);
+    st_ptr->address_info= NULL;
+  }
+  run_distribution(ptr);
+
+  return MEMCACHED_SUCCESS;
+}
+
 memcached_server_st *memcached_server_list_append(memcached_server_st *ptr, 
                                                   char *hostname, unsigned int port, 
                                                   memcached_return *error)