generic-library/curl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Speed up the hash code considerably, removing a bunch of legacy crud

Browse Source
This commit is contained in:
Sterling Hughes 2002-04-12 23:40:19 +00:00
parent f339bf613c
commit 9ebcfe9dff
2 changed files with 115 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
lib/hash.c
View File

@ -34,55 +34,45 @@
#endif #endif
static unsigned long /* {{{ static unsigned long _hash_str (const char *, size_t)
curl_hash_str(const char *key, unsigned int key_length) */
static unsigned long
_hash_str (const char *key, size_t key_length)
{ {
register unsigned long h = 0; char *end = (char *) key + key_length;
register unsigned long g; unsigned long h = 5381;
register char *p = (char *) key;
register char *end = (char *) key + key_length;
while (p < end) { while (key < end) {
h = (h << 4) + *p++; h += h << 5;
if ((g = (h & 0xF0000000))) { h ^= (unsigned long) *key++;
h = h ^ (g >> 24);
h = h ^ g;
}
} }
return h; return h;
} }
/* }}} */
static unsigned long /* {{{ static void _hash_element_dtor (void *, void *)
curl_hash_num(unsigned long key) */
{
key += ~(key << 15);
key ^= (key >> 10);
key += (key << 3);
key ^= (key >> 6);
key += (key << 11);
key ^= (key >> 16);
return key;
}
static void static void
hash_element_dtor(void *u, void *ele) _hash_element_dtor (void *user, void *element)
{ {
curl_hash_element *e = (curl_hash_element *) ele; curl_hash *h = (curl_hash *) user;
curl_hash *h = (curl_hash *) u; curl_hash_element *e = (curl_hash_element *) element;
if (e->key.type == CURL_HASH_KEY_IS_STRING) { if (e->key) {
free(e->key.value.str.val); free(e->key);
} }
h->dtor(e->ptr); h->dtor(e->ptr);
free(e); free(e);
e = NULL;
} }
/* }}} */
/* {{{ void curl_hash_init (curl_hash *, int, curl_hash_dtor)
*/
void void
curl_hash_init(curl_hash *h, int slots, curl_hash_dtor dtor) curl_hash_init (curl_hash *h, int slots, curl_hash_dtor dtor)
{ {
int i; int i;
@ -91,115 +81,108 @@ curl_hash_init(curl_hash *h, int slots, curl_hash_dtor dtor)
h->slots = slots; h->slots = slots;
h->table = (curl_llist **) malloc(slots * sizeof(curl_llist *)); h->table = (curl_llist **) malloc(slots * sizeof(curl_llist *));
for (i = 0; i < h->slots; ++i) { for (i = 0; i < slots; ++i) {
h->table[i] = curl_llist_alloc((curl_llist_dtor) hash_element_dtor); h->table[i] = curl_llist_alloc((curl_llist_dtor) _hash_element_dtor);
} }
} }
/* }}} */
/* {{{ curl_hash *curl_hash_alloc (int, curl_hash_dtor)
*/
curl_hash * curl_hash *
curl_hash_alloc(int slots, curl_hash_dtor dtor) curl_hash_alloc (int slots, curl_hash_dtor dtor)
{ {
curl_hash *h; curl_hash *h;
h = (curl_hash *)malloc(sizeof(curl_hash)); h = (curl_hash *) malloc(sizeof(curl_hash));
if(NULL == h) if (NULL == h)
return NULL; return NULL;
curl_hash_init(h, slots, dtor); curl_hash_init(h, slots, dtor);
return h; return h;
} }
/* }}} */
#define FIND_SLOT(__h, __s_key, __s_key_len, __n_key) \ /* {{{ static int _hash_key_compare (char *, size_t, char *, size_t)
((__s_key ? curl_hash_str(__s_key, __s_key_len) : curl_hash_num(__n_key)) % (__h)->slots) */
#define KEY_CREATE(__k, __s_key, __s_key_len, __n_key, __dup) \
if (__s_key) { \
if (__dup) { \
(__k)->value.str.val = (char *) malloc(__s_key_len); \
memcpy((__k)->value.str.val, __s_key, __s_key_len); \
} else { \
(__k)->value.str.val = __s_key; \
} \
(__k)->value.str.len = __s_key_len; \
(__k)->type = CURL_HASH_KEY_IS_STRING; \
} else { \
(__k)->value.num = __n_key; \
(__k)->type = CURL_HASH_KEY_IS_NUM; \
}
#define MIN(a, b) (a > b ? b : a)
static int static int
curl_hash_key_compare(curl_hash_key *key1, curl_hash_key *key2) _hash_key_compare (char *key1, size_t key1_len, char *key2, size_t key2_len)
{ {
if (key1->type == CURL_HASH_KEY_IS_NUM) { if (key1_len == key2_len &&
if (key2->type == CURL_HASH_KEY_IS_STRING) *key1 == *key2 &&
return 0; memcmp(key1, key2, key1_len) == 0) {
return 1;
if (key1->value.num == key2->value.num)
return 1;
} else {
if (key2->type == CURL_HASH_KEY_IS_NUM)
return 0;
if (memcmp(key1->value.str.val, key2->value.str.val,
MIN(key1->value.str.len, key2->value.str.len)) == 0)
return 1;
} }
return 0; return 0;
} }
/* }}} */
int /* {{{ static int _mk_hash_element (curl_hash_element **, char *, size_t, const void *)
curl_hash_add_or_update(curl_hash *h, char *str_key, unsigned int str_key_len, */
unsigned long num_key, const void *p) static int
_mk_hash_element (curl_hash_element **e, char *key, size_t key_len, const void *p)
{ {
curl_hash_element *e; *e = (curl_hash_element *) malloc(sizeof(curl_hash_element));
curl_hash_key tmp; (*e)->key = strdup(key);
curl_llist *l; (*e)->key_len = key_len;
curl_llist_element *le; (*e)->ptr = (void *) p;
int slot;
slot = FIND_SLOT(h, str_key, str_key_len, num_key); return 0;
l = h->table[slot]; }
KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0); /* }}} */
for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) { #define find_slot(__h, __k, __k_len) (_hash_str(__k, __k_len) % (__h)->slots)
curl_hash_element *to_update = CURL_LLIST_VALP(le);
h->dtor(to_update->ptr); #define FETCH_LIST \
to_update->ptr = (void *) p; curl_llist *l = h->table[find_slot(h, key, key_len)]
/* {{{ int curl_hash_add (curl_hash *, char *, size_t, const void *)
*/
int
curl_hash_add (curl_hash *h, char *key, size_t key_len, const void *p)
{
curl_hash_element *he;
curl_llist_element *le;
FETCH_LIST;
for (le = CURL_LLIST_HEAD(l);
le != NULL;
le = CURL_LLIST_NEXT(le)) {
he = (curl_hash_element *) CURL_LLIST_VALP(le);
if (_hash_key_compare(he->key, he->key_len, key, key_len)) {
h->dtor(he->ptr);
he->ptr = (void *) p;
return 1; return 1;
} }
} }
e = (curl_hash_element *) malloc(sizeof(curl_hash_element)); if (_mk_hash_element(&he, key, key_len, p) != 0)
KEY_CREATE(&e->key, str_key, str_key_len, num_key, 1); return 0;
e->ptr = (void *) p;
if (curl_llist_insert_next(l, CURL_LLIST_TAIL(l), e)) { if (curl_llist_insert_next(l, CURL_LLIST_TAIL(l), he)) {
++h->size; ++h->size;
return 1; return 1;
} else {
return 0;
} }
return 0;
} }
/* }}} */
int int
curl_hash_extended_delete(curl_hash *h, char *str_key, unsigned int str_key_len, curl_hash_delete(curl_hash *h, char *key, size_t key_len)
unsigned long num_key)
{ {
curl_llist *l; curl_hash_element *he;
curl_llist_element *le; curl_llist_element *le;
curl_hash_key tmp; FETCH_LIST;
int slot;
slot = FIND_SLOT(h, str_key, str_key_len, num_key); for (le = CURL_LLIST_HEAD(l);
l = h->table[slot]; le != NULL;
le = CURL_LLIST_NEXT(le)) {
KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0); he = CURL_LLIST_VALP(le);
for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) { if (_hash_key_compare(he->key, he->key_len, key, key_len)) {
if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
curl_llist_remove(l, le, (void *) h); curl_llist_remove(l, le, (void *) h);
--h->size; --h->size;
return 1; return 1;
@ -210,21 +193,18 @@ curl_hash_extended_delete(curl_hash *h, char *str_key, unsigned int str_key_len,
} }
int int
curl_hash_extended_find(curl_hash *h, char *str_key, unsigned int str_key_len, curl_hash_find(curl_hash *h, char *key, size_t key_len, void **p)
unsigned long num_key, void **p)
{ {
curl_llist *l;
curl_llist_element *le; curl_llist_element *le;
curl_hash_key tmp; curl_hash_element *he;
int slot; FETCH_LIST;
slot = FIND_SLOT(h, str_key, str_key_len, num_key); for (le = CURL_LLIST_HEAD(l);
l = h->table[slot]; le != NULL;
le = CURL_LLIST_NEXT(le)) {
KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0); he = CURL_LLIST_VALP(le);
for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) { if (_hash_key_compare(he->key, he->key_len, key, key_len)) {
if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) { *p = he->ptr;
*p = ((curl_hash_element *) CURL_LLIST_VALP(le))->ptr;
return 1; return 1;
} }
} }
@ -255,7 +235,6 @@ curl_hash_clean(curl_hash *h)
} }
free(h->table); free(h->table);
h->table = NULL;
} }
size_t size_t
@ -267,13 +246,11 @@ curl_hash_count(curl_hash *h)
void void
curl_hash_destroy(curl_hash *h) curl_hash_destroy(curl_hash *h)
{ {
if (!h) { if (!h)
return; return;
}
curl_hash_clean(h); curl_hash_clean(h);
free(h); free(h);
h = NULL;
} }
/* /*

50
lib/hash.h
View File

@ -29,9 +29,6 @@
#include "llist.h" #include "llist.h"
#define CURL_HASH_KEY_IS_STRING 0
#define CURL_HASH_KEY_IS_NUM 1
typedef void (*curl_hash_dtor)(void *); typedef void (*curl_hash_dtor)(void *);
typedef struct _curl_hash { typedef struct _curl_hash {
@ -41,45 +38,32 @@ typedef struct _curl_hash {
size_t size; size_t size;
} curl_hash; } curl_hash;
typedef struct _curl_hash_key {
union {
struct {
char *val;
unsigned int len;
} str;
unsigned long num;
} value;
int type;
} curl_hash_key;
typedef struct _curl_hash_element { typedef struct _curl_hash_element {
curl_hash_key key; void *ptr;
void *ptr; char *key;
size_t key_len;
} curl_hash_element; } curl_hash_element;
void curl_hash_init(curl_hash *h, int slots, curl_hash_dtor dtor); void curl_hash_init(curl_hash *, int, curl_hash_dtor);
curl_hash *curl_hash_alloc(int slots, curl_hash_dtor dtor); curl_hash *curl_hash_alloc(int, curl_hash_dtor);
int curl_hash_add_or_update(curl_hash *h, char *str_key, unsigned int str_key_len, int curl_hash_add(curl_hash *, char *, size_t, const void *);
unsigned long num_key, const void *p); int curl_hash_delete(curl_hash *h, char *key, size_t key_len);
int curl_hash_extended_delete(curl_hash *h, char *str_key, unsigned int str_key_len, int curl_hash_find(curl_hash *, char *, size_t, void **p);
unsigned long num_key);
int curl_hash_extended_find(curl_hash *h, char *str_key, unsigned int str_key_len,
unsigned long num_key, void **p);
void curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *)); void curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *));
size_t curl_hash_count(curl_hash *h); size_t curl_hash_count(curl_hash *h);
void curl_hash_clean(curl_hash *h); void curl_hash_clean(curl_hash *h);
void curl_hash_destroy(curl_hash *h); void curl_hash_destroy(curl_hash *h);
#define curl_hash_find(h, key, key_len, p) curl_hash_extended_find(h, key, key_len, 0, p)
#define curl_hash_delete(h, key, key_len) curl_hash_extended_delete(h, key, key_len, 0)
#define curl_hash_add(h, key, key_len, p) curl_hash_add_or_update(h, key, key_len, 0, p)
#define curl_hash_update curl_hash_add #define curl_hash_update curl_hash_add
#define curl_hash_index_find(h, key, p) curl_hash_extended_find(h, NULL, 0, key, p)
#define curl_hash_index_delete(h, key) curl_hash_extended_delete(h, NULL, 0, key)
#define curl_hash_index_add(h, key, p) curl_hash_add_or_update(h, NULL, 0, key, p)
#define curl_hash_index_update curl_hash_index_add
#endif #endif
/*
* local variables:
* eval: (load-file "../curl-mode.el")
* end:
* vim600: fdm=marker
* vim: et sw=2 ts=2 sts=2 tw=78
*/