Changeset 7fe430

Timestamp:

01/18/08 16:37:01 (4 years ago)

Author:

Tomash Brechko <tomash.brechko@…>

Branches:

master-v0.7, master-v0.6, memcached_hash, upstream_count_limit

Children:

1e6e0c

Parents:

cab62c

git-author:

Tomash Brechko <tomash.brechko@…> (01/18/08 16:37:01)

git-committer:

Tomash Brechko <tomash.brechko@…> (01/18/08 16:37:01)

Message:

Rename bins to buckets.

Location:

memcached_hash

Files:

• TODO (modified) (1 diff)
• ngx_http_upstream_memcached_hash_module.c (modified) (12 diffs)

memcached_hash/TODO

@@ -5 +5 @@
 - Add populate.pl to the distribution.
 
-- Rename bins to buckets.
+- Implement cache of open connections to upstreams.

memcached_hash/ngx_http_upstream_memcached_hash_module.c

@@ -36 +36 @@
 struct memcached_hash
 {
-  struct memcached_hash_continuum *bins;
+  struct memcached_hash_continuum *buckets;
   struct memcached_hash_peer *peers;
-  unsigned int bins_count;
+  unsigned int buckets_count;
   unsigned int peer_count;
   unsigned int total_weight;
@@ -56 +56 @@
 static
 unsigned int
-memcached_hash_find_bin(struct memcached_hash *memd, unsigned int point)
+memcached_hash_find_bucket(struct memcached_hash *memd, unsigned int point)
 {
   struct memcached_hash_continuum *left, *right;
 
-  left = memd->bins;
-  right = memd->bins + memd->bins_count;
+  left = memd->buckets;
+  right = memd->buckets + memd->buckets_count;
 
   while (left < right)
@@ -71 +71 @@
         right = middle;
       else
-        return (middle - memd->bins);
+        return (middle - memd->buckets);
     }
 
   /* Wrap around.  */
-  if (left == memd->bins + memd->bins_count)
-    left = memd->bins;
-
-  return (left - memd->bins);
+  if (left == memd->buckets + memd->buckets_count)
+    left = memd->buckets;
+
+  return (left - memd->buckets);
 }
 
@@ -125 +125 @@
   u_char *key;
   size_t len;
-  unsigned int point, bin, index;
+  unsigned int point, bucket, index;
 
   if (memd->peer_count == 1)
@@ -153 +153 @@
           /*
             Shift point one step forward to possibly get from the
-            border point which belongs to the previous bin.
+            border point which belongs to the previous bucket.
           */
           point += 1;
         }
 
-      bin = memcached_hash_find_bin(memd, point);
-      index = memd->bins[bin].index;
+      bucket = memcached_hash_find_bucket(memd, point);
+      index = memd->buckets[bucket].index;
     }
 
@@ -241 +241 @@
   struct memcached_hash *memd = us->peer.data;
   ngx_http_upstream_server_t *server;
-  unsigned int bins_count, i;
+  unsigned int buckets_count, i;
 
   if (! us->servers)
@@ -267 +267 @@
   if (memd->ketama_points == 0)
     {
-      bins_count = us->servers->nelts;
+      buckets_count = us->servers->nelts;
     }
   else
     {
-      bins_count = 0;
+      buckets_count = 0;
       for (i = 0; i < us->servers->nelts; ++i)
-        bins_count += (memd->ketama_points * server[i].weight
-                       + memd->scale / 2) / memd->scale;
-    }
-
-  memd->bins = ngx_palloc(cf->pool, sizeof(*memd->bins) * bins_count);
-  if (! memd->bins)
+        buckets_count += (memd->ketama_points * server[i].weight
+                          + memd->scale / 2) / memd->scale;
+    }
+
+  memd->buckets = ngx_palloc(cf->pool, sizeof(*memd->buckets) * buckets_count);
+  if (! memd->buckets)
     return NGX_ERROR;
 
@@ -291 +291 @@
           for (j = 0; j < i; ++j)
             {
-              memd->bins[j].point =
-                (memd->bins[j].point
-                 - ((uint64_t) memd->bins[j].point * server[i].weight
+              memd->buckets[j].point =
+                (memd->buckets[j].point
+                 - ((uint64_t) memd->buckets[j].point * server[i].weight
                     + total_weight / 2) / total_weight);
             }
 
-          memd->bins[i].point = CONTINUUM_MAX_POINT;
-          memd->bins[i].index = i;
-        }
-      memd->bins_count = bins_count;
+          memd->buckets[i].point = CONTINUUM_MAX_POINT;
+          memd->buckets[i].index = i;
+        }
+      memd->buckets_count = buckets_count;
     }
   else
     {
-      memd->bins_count = 0;
+      memd->buckets_count = 0;
       for (i = 0; i < us->servers->nelts; ++i)
         {
@@ -344 +344 @@
             {
               u_char buf[4];
-              unsigned int point = crc32, bin;
+              unsigned int point = crc32, bucket;
 
               /*
@@ -358 +358 @@
               ngx_crc32_final(point);
 
-              if (memd->bins_count > 0)
+              if (memd->buckets_count > 0)
                 {
-                  bin = memcached_hash_find_bin(memd, point);
+                  bucket = memcached_hash_find_bucket(memd, point);
 
                   /*
@@ -366 +366 @@
                     max point.
                   */
-                  if (bin == 0 && point > memd->bins[0].point)
+                  if (bucket == 0 && point > memd->buckets[0].point)
                     {
-                      bin = memd->bins_count;
+                      bucket = memd->buckets_count;
                     }
                   else
                     {
-                      if (point == memd->bins[bin].point)
+                      if (point == memd->buckets[bucket].point)
                         {
                           /*
@@ -381 +381 @@
                             server for not to change key distribution.
                             */
-                          ++bin;
+                          ++bucket;
                         }
 
                       /* Move the tail one position forward.  */
-                      ngx_memmove(memd->bins + bin + 1, memd->bins + bin,
-                                  ((memd->bins_count - bin)
-                                   * sizeof(*memd->bins)));
+                      ngx_memmove(memd->buckets + bucket + 1,
+                                  memd->buckets + bucket,
+                                  ((memd->buckets_count - bucket)
+                                   * sizeof(*memd->buckets)));
                     }
                 }
               else
                 {
-                  bin = 0;
+                  bucket = 0;
                 }
 
-              memd->bins[bin].point = point;
-              memd->bins[bin].index = i;
-
-              ++memd->bins_count;
+              memd->buckets[bucket].point = point;
+              memd->buckets[bucket].index = i;
+
+              ++memd->buckets_count;
             }
         }