X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fhash.c;h=e5f87a7564e9a8cd958890d28aa5d2f1afd2b80f;hb=30e386cd241ac56fd9205d12c143761475307705;hp=1c11c50de2c043bd6df6301945a11f5a3977a2ce;hpb=93eeb24c446d0d0255de2bebb8da6fc0546039fc;p=m6w6%2Flibmemcached diff --git a/libmemcached/hash.c b/libmemcached/hash.c index 1c11c50d..e5f87a75 100644 --- a/libmemcached/hash.c +++ b/libmemcached/hash.c @@ -1,15 +1,43 @@ -/* LibMemcached - * Copyright (C) 2006-2010 Brian Aker - * All rights reserved. +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached library * - * Use and distribution licensed under the BSD license. See - * the COPYING file in the parent directory for full text. + * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Copyright (C) 2006-2009 Brian Aker All rights reserved. * - * Summary: + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#include "common.h" + +#include +#include uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash_t hash_algorithm) @@ -17,36 +45,27 @@ uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memca return libhashkit_digest(key, key_length, (hashkit_hash_algorithm_t)hash_algorithm); } -uint32_t generate_hash(memcached_st *ptr, const char *key, size_t key_length) +static inline uint32_t generate_hash(const memcached_st *ptr, const char *key, size_t key_length) { - uint32_t hash= 1; /* Just here to remove compile warning */ - - - WATCHPOINT_ASSERT(memcached_server_count(ptr)); - - if (memcached_server_count(ptr) == 1) - return 0; - - hash= hashkit_digest(&ptr->hashkit, key, key_length); - - return hash; + return hashkit_digest(&ptr->hashkit, key, key_length); } -static uint32_t dispatch_host(memcached_st *ptr, uint32_t hash) +static uint32_t dispatch_host(const memcached_st *ptr, uint32_t hash) { switch (ptr->distribution) { case MEMCACHED_DISTRIBUTION_CONSISTENT: + case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: { - uint32_t num= ptr->continuum_points_counter; + uint32_t num= ptr->ketama.continuum_points_counter; WATCHPOINT_ASSERT(ptr->continuum); hash= hash; memcached_continuum_item_st *begin, *end, *left, *right, *middle; - begin= left= ptr->continuum; - end= right= ptr->continuum + num; + begin= left= ptr->ketama.continuum; + end= right= ptr->ketama.continuum + num; while (left < right) { @@ -64,8 +83,12 @@ static uint32_t dispatch_host(memcached_st *ptr, uint32_t hash) return hash % memcached_server_count(ptr); case MEMCACHED_DISTRIBUTION_RANDOM: return (uint32_t) random() % memcached_server_count(ptr); - case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: + case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: + { + return memcached_virtual_bucket_get(ptr, hash); + } default: + case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */ return hash % memcached_server_count(ptr); } @@ -73,13 +96,10 @@ static uint32_t dispatch_host(memcached_st *ptr, uint32_t hash) } /* - One day make this public, and have it return the actual memcached_server_st - to the calling application. + One version is public and will not modify the distribution hash, the other will. */ -uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length) +static inline uint32_t _generate_hash_wrapper(const memcached_st *ptr, const char *key, size_t key_length) { - uint32_t hash= 1; /* Just here to remove compile warning */ - WATCHPOINT_ASSERT(memcached_server_count(ptr)); if (memcached_server_count(ptr) == 1) @@ -87,36 +107,70 @@ uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_ if (ptr->flags.hash_with_prefix_key) { - size_t temp_length= ptr->prefix_key_length + key_length; + size_t temp_length= memcached_array_size(ptr->prefix_key) + key_length; char temp[temp_length]; if (temp_length > MEMCACHED_MAX_KEY -1) return 0; - strncpy(temp, ptr->prefix_key, ptr->prefix_key_length); - strncpy(temp + ptr->prefix_key_length, key, key_length); - hash= generate_hash(ptr, temp, temp_length); + strncpy(temp, memcached_array_string(ptr->prefix_key), memcached_array_size(ptr->prefix_key)); + strncpy(temp + memcached_array_size(ptr->prefix_key), key, key_length); + + return generate_hash(ptr, temp, temp_length); } else { - hash= generate_hash(ptr, key, key_length); + return generate_hash(ptr, key, key_length); } +} - if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS) && ptr->next_distribution_rebuild) +static inline void _regen_for_auto_eject(memcached_st *ptr) +{ + if (_is_auto_eject_host(ptr) && ptr->ketama.next_distribution_rebuild) { struct timeval now; if (gettimeofday(&now, NULL) == 0 && - now.tv_sec > ptr->next_distribution_rebuild) + now.tv_sec > ptr->ketama.next_distribution_rebuild) { run_distribution(ptr); } } +} + +void memcached_autoeject(memcached_st *ptr) +{ + _regen_for_auto_eject(ptr); +} + +uint32_t memcached_generate_hash_with_redistribution(memcached_st *ptr, const char *key, size_t key_length) +{ + uint32_t hash= _generate_hash_wrapper(ptr, key, key_length); + + _regen_for_auto_eject(ptr); return dispatch_host(ptr, hash); } -hashkit_st *memcached_get_hashkit(memcached_st *ptr) +uint32_t memcached_generate_hash(const memcached_st *ptr, const char *key, size_t key_length) +{ + return dispatch_host(ptr, _generate_hash_wrapper(ptr, key, key_length)); +} + +const hashkit_st *memcached_get_hashkit(const memcached_st *ptr) { return &ptr->hashkit; } + +memcached_return_t memcached_set_hashkit(memcached_st *self, hashkit_st *hashk) +{ + hashkit_free(&self->hashkit); + hashkit_clone(&self->hashkit, hashk); + + return MEMCACHED_SUCCESS; +} + +const char * libmemcached_string_hash(memcached_hash_t type) +{ + return libhashkit_string_hash((hashkit_hash_algorithm_t)type); +}