1/* Based on work Copyright 2002 Christopher Clark */ 2/* Copyright 2005-2012 Nick Mathewson */ 3/* Copyright 2009-2012 Niels Provos and Nick Mathewson */ 4/* See license at end. */ 5 6/* Based on ideas by Christopher Clark and interfaces from Niels Provos. */ 7 8#ifndef _EVENT_HT_H 9#define _EVENT_HT_H 10 11#define HT_HEAD(name, type) \ 12 struct name { \ 13 /* The hash table itself. */ \ 14 struct type **hth_table; \ 15 /* How long is the hash table? */ \ 16 unsigned hth_table_length; \ 17 /* How many elements does the table contain? */ \ 18 unsigned hth_n_entries; \ 19 /* How many elements will we allow in the table before resizing it? */ \ 20 unsigned hth_load_limit; \ 21 /* Position of hth_table_length in the primes table. */ \ 22 int hth_prime_idx; \ 23 } 24 25#define HT_INITIALIZER() \ 26 { NULL, 0, 0, 0, -1 } 27 28#ifdef HT_CACHE_HASH_VALUES 29#define HT_ENTRY(type) \ 30 struct { \ 31 struct type *hte_next; \ 32 unsigned hte_hash; \ 33 } 34#else 35#define HT_ENTRY(type) \ 36 struct { \ 37 struct type *hte_next; \ 38 } 39#endif 40 41#define HT_EMPTY(head) \ 42 ((head)->hth_n_entries == 0) 43 44/* How many elements in 'head'? */ 45#define HT_SIZE(head) \ 46 ((head)->hth_n_entries) 47 48#define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm)) 49#define HT_INSERT(name, head, elm) name##_HT_INSERT((head), (elm)) 50#define HT_REPLACE(name, head, elm) name##_HT_REPLACE((head), (elm)) 51#define HT_REMOVE(name, head, elm) name##_HT_REMOVE((head), (elm)) 52#define HT_START(name, head) name##_HT_START(head) 53#define HT_NEXT(name, head, elm) name##_HT_NEXT((head), (elm)) 54#define HT_NEXT_RMV(name, head, elm) name##_HT_NEXT_RMV((head), (elm)) 55#define HT_CLEAR(name, head) name##_HT_CLEAR(head) 56#define HT_INIT(name, head) name##_HT_INIT(head) 57/* Helper: */ 58static inline unsigned 59ht_improve_hash(unsigned h) 60{ 61 /* Aim to protect against poor hash functions by adding logic here 62 * - logic taken from java 1.4 hashtable source */ 63 h += ~(h << 9); 64 h ^= ((h >> 14) | (h << 18)); /* >>> */ 65 h += (h << 4); 66 h ^= ((h >> 10) | (h << 22)); /* >>> */ 67 return h; 68} 69 70#if 0 71/** Basic string hash function, from Java standard String.hashCode(). */ 72static inline unsigned 73ht_string_hash(const char *s) 74{ 75 unsigned h = 0; 76 int m = 1; 77 while (*s) { 78 h += ((signed char)*s++)*m; 79 m = (m<<5)-1; /* m *= 31 */ 80 } 81 return h; 82} 83#endif 84 85/** Basic string hash function, from Python's str.__hash__() */ 86static inline unsigned 87ht_string_hash(const char *s) 88{ 89 unsigned h; 90 const unsigned char *cp = (const unsigned char *)s; 91 h = *cp << 7; 92 while (*cp) { 93 h = (1000003*h) ^ *cp++; 94 } 95 /* This conversion truncates the length of the string, but that's ok. */ 96 h ^= (unsigned)(cp-(const unsigned char*)s); 97 return h; 98} 99 100#ifdef HT_CACHE_HASH_VALUES 101#define _HT_SET_HASH(elm, field, hashfn) \ 102 do { (elm)->field.hte_hash = hashfn(elm); } while (0) 103#define _HT_SET_HASHVAL(elm, field, val) \ 104 do { (elm)->field.hte_hash = (val); } while (0) 105#define _HT_ELT_HASH(elm, field, hashfn) \ 106 ((elm)->field.hte_hash) 107#else 108#define _HT_SET_HASH(elm, field, hashfn) \ 109 ((void)0) 110#define _HT_ELT_HASH(elm, field, hashfn) \ 111 (hashfn(elm)) 112#define _HT_SET_HASHVAL(elm, field, val) \ 113 ((void)0) 114#endif 115 116/* Helper: alias for the bucket containing 'elm'. */ 117#define _HT_BUCKET(head, field, elm, hashfn) \ 118 ((head)->hth_table[_HT_ELT_HASH(elm,field,hashfn) % head->hth_table_length]) 119 120#define HT_FOREACH(x, name, head) \ 121 for ((x) = HT_START(name, head); \ 122 (x) != NULL; \ 123 (x) = HT_NEXT(name, head, x)) 124 125#define HT_PROTOTYPE(name, type, field, hashfn, eqfn) \ 126 int name##_HT_GROW(struct name *ht, unsigned min_capacity); \ 127 void name##_HT_CLEAR(struct name *ht); \ 128 int _##name##_HT_REP_IS_BAD(const struct name *ht); \ 129 static inline void \ 130 name##_HT_INIT(struct name *head) { \ 131 head->hth_table_length = 0; \ 132 head->hth_table = NULL; \ 133 head->hth_n_entries = 0; \ 134 head->hth_load_limit = 0; \ 135 head->hth_prime_idx = -1; \ 136 } \ 137 /* Helper: returns a pointer to the right location in the table \ 138 * 'head' to find or insert the element 'elm'. */ \ 139 static inline struct type ** \ 140 _##name##_HT_FIND_P(struct name *head, struct type *elm) \ 141 { \ 142 struct type **p; \ 143 if (!head->hth_table) \ 144 return NULL; \ 145 p = &_HT_BUCKET(head, field, elm, hashfn); \ 146 while (*p) { \ 147 if (eqfn(*p, elm)) \ 148 return p; \ 149 p = &(*p)->field.hte_next; \ 150 } \ 151 return p; \ 152 } \ 153 /* Return a pointer to the element in the table 'head' matching 'elm', \ 154 * or NULL if no such element exists */ \ 155 static inline struct type * \ 156 name##_HT_FIND(const struct name *head, struct type *elm) \ 157 { \ 158 struct type **p; \ 159 struct name *h = (struct name *) head; \ 160 _HT_SET_HASH(elm, field, hashfn); \ 161 p = _##name##_HT_FIND_P(h, elm); \ 162 return p ? *p : NULL; \ 163 } \ 164 /* Insert the element 'elm' into the table 'head'. Do not call this \ 165 * function if the table might already contain a matching element. */ \ 166 static inline void \ 167 name##_HT_INSERT(struct name *head, struct type *elm) \ 168 { \ 169 struct type **p; \ 170 if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) \ 171 name##_HT_GROW(head, head->hth_n_entries+1); \ 172 ++head->hth_n_entries; \ 173 _HT_SET_HASH(elm, field, hashfn); \ 174 p = &_HT_BUCKET(head, field, elm, hashfn); \ 175 elm->field.hte_next = *p; \ 176 *p = elm; \ 177 } \ 178 /* Insert the element 'elm' into the table 'head'. If there already \ 179 * a matching element in the table, replace that element and return \ 180 * it. */ \ 181 static inline struct type * \ 182 name##_HT_REPLACE(struct name *head, struct type *elm) \ 183 { \ 184 struct type **p, *r; \ 185 if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) \ 186 name##_HT_GROW(head, head->hth_n_entries+1); \ 187 _HT_SET_HASH(elm, field, hashfn); \ 188 p = _##name##_HT_FIND_P(head, elm); \ 189 r = *p; \ 190 *p = elm; \ 191 if (r && (r!=elm)) { \ 192 elm->field.hte_next = r->field.hte_next; \ 193 r->field.hte_next = NULL; \ 194 return r; \ 195 } else { \ 196 ++head->hth_n_entries; \ 197 return NULL; \ 198 } \ 199 } \ 200 /* Remove any element matching 'elm' from the table 'head'. If such \ 201 * an element is found, return it; otherwise return NULL. */ \ 202 static inline struct type * \ 203 name##_HT_REMOVE(struct name *head, struct type *elm) \ 204 { \ 205 struct type **p, *r; \ 206 _HT_SET_HASH(elm, field, hashfn); \ 207 p = _##name##_HT_FIND_P(head,elm); \ 208 if (!p || !*p) \ 209 return NULL; \ 210 r = *p; \ 211 *p = r->field.hte_next; \ 212 r->field.hte_next = NULL; \ 213 --head->hth_n_entries; \ 214 return r; \ 215 } \ 216 /* Invoke the function 'fn' on every element of the table 'head', \ 217 * using 'data' as its second argument. If the function returns \ 218 * nonzero, remove the most recently examined element before invoking \ 219 * the function again. */ \ 220 static inline void \ 221 name##_HT_FOREACH_FN(struct name *head, \ 222 int (*fn)(struct type *, void *), \ 223 void *data) \ 224 { \ 225 unsigned idx; \ 226 struct type **p, **nextp, *next; \ 227 if (!head->hth_table) \ 228 return; \ 229 for (idx=0; idx < head->hth_table_length; ++idx) { \ 230 p = &head->hth_table[idx]; \ 231 while (*p) { \ 232 nextp = &(*p)->field.hte_next; \ 233 next = *nextp; \ 234 if (fn(*p, data)) { \ 235 --head->hth_n_entries; \ 236 *p = next; \ 237 } else { \ 238 p = nextp; \ 239 } \ 240 } \ 241 } \ 242 } \ 243 /* Return a pointer to the first element in the table 'head', under \ 244 * an arbitrary order. This order is stable under remove operations, \ 245 * but not under others. If the table is empty, return NULL. */ \ 246 static inline struct type ** \ 247 name##_HT_START(struct name *head) \ 248 { \ 249 unsigned b = 0; \ 250 while (b < head->hth_table_length) { \ 251 if (head->hth_table[b]) \ 252 return &head->hth_table[b]; \ 253 ++b; \ 254 } \ 255 return NULL; \ 256 } \ 257 /* Return the next element in 'head' after 'elm', under the arbitrary \ 258 * order used by HT_START. If there are no more elements, return \ 259 * NULL. If 'elm' is to be removed from the table, you must call \ 260 * this function for the next value before you remove it. \ 261 */ \ 262 static inline struct type ** \ 263 name##_HT_NEXT(struct name *head, struct type **elm) \ 264 { \ 265 if ((*elm)->field.hte_next) { \ 266 return &(*elm)->field.hte_next; \ 267 } else { \ 268 unsigned b = (_HT_ELT_HASH(*elm, field, hashfn) % head->hth_table_length)+1; \ 269 while (b < head->hth_table_length) { \ 270 if (head->hth_table[b]) \ 271 return &head->hth_table[b]; \ 272 ++b; \ 273 } \ 274 return NULL; \ 275 } \ 276 } \ 277 static inline struct type ** \ 278 name##_HT_NEXT_RMV(struct name *head, struct type **elm) \ 279 { \ 280 unsigned h = _HT_ELT_HASH(*elm, field, hashfn); \ 281 *elm = (*elm)->field.hte_next; \ 282 --head->hth_n_entries; \ 283 if (*elm) { \ 284 return elm; \ 285 } else { \ 286 unsigned b = (h % head->hth_table_length)+1; \ 287 while (b < head->hth_table_length) { \ 288 if (head->hth_table[b]) \ 289 return &head->hth_table[b]; \ 290 ++b; \ 291 } \ 292 return NULL; \ 293 } \ 294 } 295 296#define HT_GENERATE(name, type, field, hashfn, eqfn, load, mallocfn, \ 297 reallocfn, freefn) \ 298 static unsigned name##_PRIMES[] = { \ 299 53, 97, 193, 389, \ 300 769, 1543, 3079, 6151, \ 301 12289, 24593, 49157, 98317, \ 302 196613, 393241, 786433, 1572869, \ 303 3145739, 6291469, 12582917, 25165843, \ 304 50331653, 100663319, 201326611, 402653189, \ 305 805306457, 1610612741 \ 306 }; \ 307 static unsigned name##_N_PRIMES = \ 308 (unsigned)(sizeof(name##_PRIMES)/sizeof(name##_PRIMES[0])); \ 309 /* Expand the internal table of 'head' until it is large enough to \ 310 * hold 'size' elements. Return 0 on success, -1 on allocation \ 311 * failure. */ \ 312 int \ 313 name##_HT_GROW(struct name *head, unsigned size) \ 314 { \ 315 unsigned new_len, new_load_limit; \ 316 int prime_idx; \ 317 struct type **new_table; \ 318 if (head->hth_prime_idx == (int)name##_N_PRIMES - 1) \ 319 return 0; \ 320 if (head->hth_load_limit > size) \ 321 return 0; \ 322 prime_idx = head->hth_prime_idx; \ 323 do { \ 324 new_len = name##_PRIMES[++prime_idx]; \ 325 new_load_limit = (unsigned)(load*new_len); \ 326 } while (new_load_limit <= size && \ 327 prime_idx < (int)name##_N_PRIMES); \ 328 if ((new_table = mallocfn(new_len*sizeof(struct type*)))) { \ 329 unsigned b; \ 330 memset(new_table, 0, new_len*sizeof(struct type*)); \ 331 for (b = 0; b < head->hth_table_length; ++b) { \ 332 struct type *elm, *next; \ 333 unsigned b2; \ 334 elm = head->hth_table[b]; \ 335 while (elm) { \ 336 next = elm->field.hte_next; \ 337 b2 = _HT_ELT_HASH(elm, field, hashfn) % new_len; \ 338 elm->field.hte_next = new_table[b2]; \ 339 new_table[b2] = elm; \ 340 elm = next; \ 341 } \ 342 } \ 343 if (head->hth_table) \ 344 freefn(head->hth_table); \ 345 head->hth_table = new_table; \ 346 } else { \ 347 unsigned b, b2; \ 348 new_table = reallocfn(head->hth_table, new_len*sizeof(struct type*)); \ 349 if (!new_table) return -1; \ 350 memset(new_table + head->hth_table_length, 0, \ 351 (new_len - head->hth_table_length)*sizeof(struct type*)); \ 352 for (b=0; b < head->hth_table_length; ++b) { \ 353 struct type *e, **pE; \ 354 for (pE = &new_table[b], e = *pE; e != NULL; e = *pE) { \ 355 b2 = _HT_ELT_HASH(e, field, hashfn) % new_len; \ 356 if (b2 == b) { \ 357 pE = &e->field.hte_next; \ 358 } else { \ 359 *pE = e->field.hte_next; \ 360 e->field.hte_next = new_table[b2]; \ 361 new_table[b2] = e; \ 362 } \ 363 } \ 364 } \ 365 head->hth_table = new_table; \ 366 } \ 367 head->hth_table_length = new_len; \ 368 head->hth_prime_idx = prime_idx; \ 369 head->hth_load_limit = new_load_limit; \ 370 return 0; \ 371 } \ 372 /* Free all storage held by 'head'. Does not free 'head' itself, or \ 373 * individual elements. */ \ 374 void \ 375 name##_HT_CLEAR(struct name *head) \ 376 { \ 377 if (head->hth_table) \ 378 freefn(head->hth_table); \ 379 head->hth_table_length = 0; \ 380 name##_HT_INIT(head); \ 381 } \ 382 /* Debugging helper: return false iff the representation of 'head' is \ 383 * internally consistent. */ \ 384 int \ 385 _##name##_HT_REP_IS_BAD(const struct name *head) \ 386 { \ 387 unsigned n, i; \ 388 struct type *elm; \ 389 if (!head->hth_table_length) { \ 390 if (!head->hth_table && !head->hth_n_entries && \ 391 !head->hth_load_limit && head->hth_prime_idx == -1) \ 392 return 0; \ 393 else \ 394 return 1; \ 395 } \ 396 if (!head->hth_table || head->hth_prime_idx < 0 || \ 397 !head->hth_load_limit) \ 398 return 2; \ 399 if (head->hth_n_entries > head->hth_load_limit) \ 400 return 3; \ 401 if (head->hth_table_length != name##_PRIMES[head->hth_prime_idx]) \ 402 return 4; \ 403 if (head->hth_load_limit != (unsigned)(load*head->hth_table_length)) \ 404 return 5; \ 405 for (n = i = 0; i < head->hth_table_length; ++i) { \ 406 for (elm = head->hth_table[i]; elm; elm = elm->field.hte_next) { \ 407 if (_HT_ELT_HASH(elm, field, hashfn) != hashfn(elm)) \ 408 return 1000 + i; \ 409 if ((_HT_ELT_HASH(elm, field, hashfn) % head->hth_table_length) != i) \ 410 return 10000 + i; \ 411 ++n; \ 412 } \ 413 } \ 414 if (n != head->hth_n_entries) \ 415 return 6; \ 416 return 0; \ 417 } 418 419/** Implements an over-optimized "find and insert if absent" block; 420 * not meant for direct usage by typical code, or usage outside the critical 421 * path.*/ 422#define _HT_FIND_OR_INSERT(name, field, hashfn, head, eltype, elm, var, y, n) \ 423 { \ 424 struct name *_##var##_head = head; \ 425 struct eltype **var; \ 426 if (!_##var##_head->hth_table || \ 427 _##var##_head->hth_n_entries >= _##var##_head->hth_load_limit) \ 428 name##_HT_GROW(_##var##_head, _##var##_head->hth_n_entries+1); \ 429 _HT_SET_HASH((elm), field, hashfn); \ 430 var = _##name##_HT_FIND_P(_##var##_head, (elm)); \ 431 if (*var) { \ 432 y; \ 433 } else { \ 434 n; \ 435 } \ 436 } 437#define _HT_FOI_INSERT(field, head, elm, newent, var) \ 438 { \ 439 _HT_SET_HASHVAL(newent, field, (elm)->field.hte_hash); \ 440 newent->field.hte_next = NULL; \ 441 *var = newent; \ 442 ++((head)->hth_n_entries); \ 443 } 444 445/* 446 * Copyright 2005, Nick Mathewson. Implementation logic is adapted from code 447 * by Cristopher Clark, retrofit to allow drop-in memory management, and to 448 * use the same interface as Niels Provos's tree.h. This is probably still 449 * a derived work, so the original license below still applies. 450 * 451 * Copyright (c) 2002, Christopher Clark 452 * All rights reserved. 453 * 454 * Redistribution and use in source and binary forms, with or without 455 * modification, are permitted provided that the following conditions 456 * are met: 457 * 458 * * Redistributions of source code must retain the above copyright 459 * notice, this list of conditions and the following disclaimer. 460 * 461 * * Redistributions in binary form must reproduce the above copyright 462 * notice, this list of conditions and the following disclaimer in the 463 * documentation and/or other materials provided with the distribution. 464 * 465 * * Neither the name of the original author; nor the names of any contributors 466 * may be used to endorse or promote products derived from this software 467 * without specific prior written permission. 468 * 469 * 470 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 471 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 472 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 473 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 474 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 475 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 476 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 477 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 478 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 479 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 480 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 481*/ 482 483#endif 484 485