37#if _MSC_VER >= 1600 && defined(__cplusplus)
38#define DECLTYPE(x) (decltype(x))
44#define DECLTYPE(x) (__typeof(x))
48#define DECLTYPE_ASSIGN(dst,src) \
50 char **_da_dst = (char**)(&(dst)); \
51 *_da_dst = (char*)(src); \
54#define DECLTYPE_ASSIGN(dst,src) \
56 (dst) = DECLTYPE(dst)(src); \
62typedef unsigned int uint32_t;
67#pragma GCC visibility push(hidden)
69#define UTHASH_VERSION 1.9.3
71#define uthash_fatal(msg) exit(-1)
72#define uthash_malloc(sz) malloc(sz)
73#define uthash_free(ptr,sz) free(ptr)
75#define uthash_noexpand_fyi(tbl)
76#define uthash_expand_fyi(tbl)
79#define HASH_INITIAL_NUM_BUCKETS 32
80#define HASH_INITIAL_NUM_BUCKETS_LOG2 5
81#define HASH_BKT_CAPACITY_THRESH 10
84#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
86#define HASH_FIND(hh,head,keyptr,keylen,out) \
88 unsigned _hf_bkt=0,_hf_hashv=0; \
91 HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt); \
92 if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) { \
93 HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], \
100#define HASH_BLOOM_BITLEN (1ULL << HASH_BLOOM)
101#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8) + ((HASH_BLOOM_BITLEN%8) ? 1:0)
102#define HASH_BLOOM_MAKE(tbl) \
104 (tbl)->bloom_nbits = HASH_BLOOM; \
105 (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN); \
106 if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } \
107 memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); \
108 (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \
111#define HASH_BLOOM_FREE(tbl) \
113 uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \
116#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8)))
117#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8)))
119#define HASH_BLOOM_ADD(tbl,hashv) \
120 HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
122#define HASH_BLOOM_TEST(tbl,hashv) \
123 HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
126#define HASH_BLOOM_MAKE(tbl)
127#define HASH_BLOOM_FREE(tbl)
128#define HASH_BLOOM_ADD(tbl,hashv)
129#define HASH_BLOOM_TEST(tbl,hashv) (1)
132#define HASH_MAKE_TABLE(hh,head) \
134 (head)->hh.tbl = (UT_hash_table*)uthash_malloc( \
135 sizeof(UT_hash_table)); \
136 if (!((head)->hh.tbl)) { uthash_fatal( "out of memory"); } \
137 memset((head)->hh.tbl, 0, sizeof(UT_hash_table)); \
138 (head)->hh.tbl->tail = &((head)->hh); \
139 (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS; \
140 (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2; \
141 (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head); \
142 (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc( \
143 HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \
144 if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); } \
145 memset((head)->hh.tbl->buckets, 0, \
146 HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \
147 HASH_BLOOM_MAKE((head)->hh.tbl); \
148 (head)->hh.tbl->signature = HASH_SIGNATURE; \
151#define HASH_ADD(hh,head,fieldname,keylen_in,add) \
152 HASH_ADD_KEYPTR(hh,head,&add->fieldname,keylen_in,add)
156#define HASH_CHECK_KEY(hh,head,keyptr,keylen,out) \
158 __typeof__(out) _out; \
159 HASH_FIND(hh,head,keyptr,keylen,_out); \
160 STARPU_ASSERT_MSG(!_out,"Cannot insert the same key twice"); \
163#define HASH_CHECK_KEY(hh,head,keyptr,keylen,out)
166#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \
168 unsigned _ha_bkt=0; \
169 HASH_CHECK_KEY(hh,head,keyptr,keylen_in,add); \
170 (add)->hh.next = NULL; \
171 (add)->hh.key = (char*)keyptr; \
172 (add)->hh.keylen = keylen_in; \
175 (head)->hh.prev = NULL; \
176 HASH_MAKE_TABLE(hh,head); \
178 (head)->hh.tbl->tail->next = (add); \
179 (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); \
180 (head)->hh.tbl->tail = &((add)->hh); \
182 (head)->hh.tbl->num_items++; \
183 (add)->hh.tbl = (head)->hh.tbl; \
184 HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets, \
185 (add)->hh.hashv, _ha_bkt); \
186 HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh); \
187 HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv); \
188 HASH_EMIT_KEY(hh,head,keyptr,keylen_in); \
189 HASH_FSCK(hh,head); \
192#define HASH_TO_BKT( hashv, num_bkts, bkt ) \
194 bkt = ((hashv) & ((num_bkts) - 1)); \
209#define HASH_DELETE(hh,head,delptr) \
212 struct UT_hash_handle *_hd_hh_del; \
213 if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) ) { \
214 uthash_free((head)->hh.tbl->buckets, \
215 (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
216 HASH_BLOOM_FREE((head)->hh.tbl); \
217 uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
220 _hd_hh_del = &((delptr)->hh); \
221 if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \
222 (head)->hh.tbl->tail = \
223 (UT_hash_handle*)((char*)((delptr)->hh.prev) + \
224 (head)->hh.tbl->hho); \
226 if ((delptr)->hh.prev) { \
227 ((UT_hash_handle*)((char*)((delptr)->hh.prev) + \
228 (head)->hh.tbl->hho))->next = (delptr)->hh.next; \
230 DECLTYPE_ASSIGN(head,(delptr)->hh.next); \
232 if (_hd_hh_del->next) { \
233 ((UT_hash_handle*)((char*)_hd_hh_del->next + \
234 (head)->hh.tbl->hho))->prev = \
237 HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \
238 HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); \
239 (head)->hh.tbl->num_items--; \
241 HASH_FSCK(hh,head); \
246#define HASH_FIND_STR(head,findstr,out) \
247 HASH_FIND(hh,head,findstr,strlen(findstr),out)
248#define HASH_ADD_STR(head,strfield,add) \
249 HASH_ADD(hh,head,strfield[0],strlen(add->strfield),add)
250#define HASH_FIND_INT(head,findint,out) \
251 HASH_FIND(hh,head,findint,sizeof(int),out)
252#define HASH_ADD_INT(head,intfield,add) \
253 HASH_ADD(hh,head,intfield,sizeof(int),add)
254#define HASH_FIND_PTR(head,findptr,out) \
255 HASH_FIND(hh,head,findptr,sizeof(void *),out)
256#define HASH_ADD_PTR(head,ptrfield,add) \
257 HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
258#define HASH_DEL(head,delptr) \
259 HASH_DELETE(hh,head,delptr)
265#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
266#define HASH_FSCK(hh,head) \
269 unsigned _count, _bkt_count; \
271 struct UT_hash_handle *_thh; \
274 for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) { \
276 _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head; \
279 if (_prev != (char*)(_thh->hh_prev)) { \
280 HASH_OOPS("invalid hh_prev %p, actual %p\n", \
281 _thh->hh_prev, _prev ); \
284 _prev = (char*)(_thh); \
285 _thh = _thh->hh_next; \
287 _count += _bkt_count; \
288 if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) { \
289 HASH_OOPS("invalid bucket count %u, actual %u\n", \
290 (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count); \
293 if (_count != (head)->hh.tbl->num_items) { \
294 HASH_OOPS("invalid hh item count %u, actual %u\n", \
295 (head)->hh.tbl->num_items, _count ); \
300 _thh = &(head)->hh; \
303 if (_prev !=(char*)(_thh->prev)) { \
304 HASH_OOPS("invalid prev %p, actual %p\n", \
305 _thh->prev, _prev ); \
307 _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh); \
308 _thh = ( _thh->next ? (UT_hash_handle*)((char*)(_thh->next) + \
309 (head)->hh.tbl->hho) : NULL ); \
311 if (_count != (head)->hh.tbl->num_items) { \
312 HASH_OOPS("invalid app item count %u, actual %u\n", \
313 (head)->hh.tbl->num_items, _count ); \
318#define HASH_FSCK(hh,head)
325#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) \
327 unsigned _klen = fieldlen; \
328 write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \
329 write(HASH_EMIT_KEYS, keyptr, fieldlen); \
332#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
337#define HASH_FCN HASH_FUNCTION
339#define HASH_FCN HASH_JEN
343#define HASH_BER(key,keylen,num_bkts,hashv,bkt) \
345 unsigned _hb_keylen=keylen; \
346 char *_hb_key=(char*)(key); \
348 while (_hb_keylen--) { (hashv) = ((hashv) * 33) + *_hb_key++; } \
349 bkt = (hashv) & (num_bkts-1); \
355#define HASH_SAX(key,keylen,num_bkts,hashv,bkt) \
358 char *_hs_key=(char*)(key); \
360 for(_sx_i=0; _sx_i < keylen; _sx_i++) \
361 hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i]; \
362 bkt = hashv & (num_bkts-1); \
365#define HASH_FNV(key,keylen,num_bkts,hashv,bkt) \
368 char *_hf_key=(char*)(key); \
369 hashv = 2166136261UL; \
370 for(_fn_i=0; _fn_i < keylen; _fn_i++) \
371 hashv = (hashv * 16777619) ^ _hf_key[_fn_i]; \
372 bkt = hashv & (num_bkts-1); \
375#define HASH_OAT(key,keylen,num_bkts,hashv,bkt) \
378 char *_ho_key=(char*)(key); \
380 for(_ho_i=0; _ho_i < keylen; _ho_i++) { \
381 hashv += _ho_key[_ho_i]; \
382 hashv += (hashv << 10); \
383 hashv ^= (hashv >> 6); \
385 hashv += (hashv << 3); \
386 hashv ^= (hashv >> 11); \
387 hashv += (hashv << 15); \
388 bkt = hashv & (num_bkts-1); \
391#define HASH_JEN_MIX(a,b,c) \
393 a -= b; a -= c; a ^= ( c >> 13 ); \
394 b -= c; b -= a; b ^= ( a << 8 ); \
395 c -= a; c -= b; c ^= ( b >> 13 ); \
396 a -= b; a -= c; a ^= ( c >> 12 ); \
397 b -= c; b -= a; b ^= ( a << 16 ); \
398 c -= a; c -= b; c ^= ( b >> 5 ); \
399 a -= b; a -= c; a ^= ( c >> 3 ); \
400 b -= c; b -= a; b ^= ( a << 10 ); \
401 c -= a; c -= b; c ^= ( b >> 15 ); \
404#define HASH_JEN(key,keylen,num_bkts,hashv,bkt) \
406 unsigned _hj_i,_hj_j,_hj_k; \
407 char *_hj_key=(char*)(key); \
408 hashv = 0xfeedbeef; \
409 _hj_i = _hj_j = 0x9e3779b9; \
411 while (_hj_k >= 12) { \
412 _hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \
413 + ( (unsigned)_hj_key[2] << 16 ) \
414 + ( (unsigned)_hj_key[3] << 24 ) ); \
415 _hj_j += (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 ) \
416 + ( (unsigned)_hj_key[6] << 16 ) \
417 + ( (unsigned)_hj_key[7] << 24 ) ); \
418 hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 ) \
419 + ( (unsigned)_hj_key[10] << 16 ) \
420 + ( (unsigned)_hj_key[11] << 24 ) ); \
422 HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
429 case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); \
431 case 10: hashv += ( (unsigned)_hj_key[9] << 16 ); \
433 case 9: hashv += ( (unsigned)_hj_key[8] << 8 ); \
435 case 8: _hj_j += ( (unsigned)_hj_key[7] << 24 ); \
437 case 7: _hj_j += ( (unsigned)_hj_key[6] << 16 ); \
439 case 6: _hj_j += ( (unsigned)_hj_key[5] << 8 ); \
441 case 5: _hj_j += _hj_key[4]; \
443 case 4: _hj_i += ( (unsigned)_hj_key[3] << 24 ); \
445 case 3: _hj_i += ( (unsigned)_hj_key[2] << 16 ); \
447 case 2: _hj_i += ( (unsigned)_hj_key[1] << 8 ); \
449 case 1: _hj_i += _hj_key[0]; \
453 HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
454 bkt = hashv & (num_bkts-1); \
459#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
460 || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
461#define get16bits(d) (*((const uint16_t *) (d)))
464#if !defined (get16bits)
465#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8) \
466 +(uint32_t)(((const uint8_t *)(d))[0]) )
468#define HASH_SFH(key,keylen,num_bkts,hashv,bkt) \
470 char *_sfh_key=(char*)(key); \
471 uint32_t _sfh_tmp, _sfh_len = keylen; \
473 int _sfh_rem = _sfh_len & 3; \
475 hashv = 0xcafebabe; \
478 for (;_sfh_len > 0; _sfh_len--) { \
479 hashv += get16bits (_sfh_key); \
480 _sfh_tmp = (get16bits (_sfh_key+2) << 11) ^ hashv; \
481 hashv = (hashv << 16) ^ _sfh_tmp; \
482 _sfh_key += 2*sizeof (uint16_t); \
483 hashv += hashv >> 11; \
487 switch (_sfh_rem) { \
488 case 3: hashv += get16bits (_sfh_key); \
489 hashv ^= hashv << 16; \
490 hashv ^= _sfh_key[sizeof (uint16_t)] << 18; \
491 hashv += hashv >> 11; \
493 case 2: hashv += get16bits (_sfh_key); \
494 hashv ^= hashv << 11; \
495 hashv += hashv >> 17; \
497 case 1: hashv += *_sfh_key; \
498 hashv ^= hashv << 10; \
499 hashv += hashv >> 1; \
505 hashv ^= hashv << 3; \
506 hashv += hashv >> 5; \
507 hashv ^= hashv << 4; \
508 hashv += hashv >> 17; \
509 hashv ^= hashv << 25; \
510 hashv += hashv >> 6; \
511 bkt = hashv & (num_bkts-1); \
514#ifdef HASH_USING_NO_STRICT_ALIASING
525#if (defined(__i386__) || defined(__x86_64__))
526#define HASH_MUR HASH_MUR_UNALIGNED
528#define HASH_MUR HASH_MUR_ALIGNED
532#define HASH_MUR_UNALIGNED(key,keylen,num_bkts,hashv,bkt) \
534 const unsigned int _mur_m = 0x5bd1e995; \
535 const int _mur_r = 24; \
536 hashv = 0xcafebabe ^ keylen; \
537 char *_mur_key = (char *)(key); \
538 uint32_t _mur_tmp, _mur_len = keylen; \
540 for (;_mur_len >= 4; _mur_len-=4) { \
541 _mur_tmp = *(uint32_t *)_mur_key; \
542 _mur_tmp *= _mur_m; \
543 _mur_tmp ^= _mur_tmp >> _mur_r; \
544 _mur_tmp *= _mur_m; \
552 case 3: hashv ^= _mur_key[2] << 16; \
554 case 2: hashv ^= _mur_key[1] << 8; \
556 case 1: hashv ^= _mur_key[0]; \
562 hashv ^= hashv >> 13; \
564 hashv ^= hashv >> 15; \
566 bkt = hashv & (num_bkts-1); \
570#define HASH_MUR_ALIGNED(key,keylen,num_bkts,hashv,bkt) \
572 const unsigned int _mur_m = 0x5bd1e995; \
573 const int _mur_r = 24; \
574 hashv = 0xcafebabe ^ (keylen); \
575 char *_mur_key = (char *)(key); \
576 uint32_t _mur_len = keylen; \
577 int _mur_align = (int)_mur_key & 3; \
579 if (_mur_align && (_mur_len >= 4)) { \
580 unsigned _mur_t = 0, _mur_d = 0; \
581 switch(_mur_align) { \
582 case 1: _mur_t |= _mur_key[2] << 16; \
584 case 2: _mur_t |= _mur_key[1] << 8; \
586 case 3: _mur_t |= _mur_key[0]; \
590 _mur_t <<= (8 * _mur_align); \
591 _mur_key += 4-_mur_align; \
592 _mur_len -= 4-_mur_align; \
593 int _mur_sl = 8 * (4-_mur_align); \
594 int _mur_sr = 8 * _mur_align; \
596 for (;_mur_len >= 4; _mur_len-=4) { \
597 _mur_d = *(unsigned *)_mur_key; \
598 _mur_t = (_mur_t >> _mur_sr) | (_mur_d << _mur_sl); \
599 unsigned _mur_k = _mur_t; \
601 _mur_k ^= _mur_k >> _mur_r; \
609 if(_mur_len >= _mur_align) { \
610 switch(_mur_align) { \
611 case 3: _mur_d |= _mur_key[2] << 16; \
613 case 2: _mur_d |= _mur_key[1] << 8; \
615 case 1: _mur_d |= _mur_key[0]; \
619 unsigned _mur_k = (_mur_t >> _mur_sr) | (_mur_d << _mur_sl); \
621 _mur_k ^= _mur_k >> _mur_r; \
625 _mur_k += _mur_align; \
626 _mur_len -= _mur_align; \
630 case 3: hashv ^= _mur_key[2] << 16; \
632 case 2: hashv ^= _mur_key[1] << 8; \
634 case 1: hashv ^= _mur_key[0]; \
642 case 3: _mur_d ^= _mur_key[2] << 16; \
644 case 2: _mur_d ^= _mur_key[1] << 8; \
646 case 1: _mur_d ^= _mur_key[0]; \
648 case 0: hashv ^= (_mur_t >> _mur_sr) | (_mur_d << _mur_sl); \
655 hashv ^= hashv >> 13; \
657 hashv ^= hashv >> 15; \
659 for (;_mur_len >= 4; _mur_len-=4) { \
660 unsigned _mur_k = *(unsigned*)_mur_key; \
662 _mur_k ^= _mur_k >> _mur_r; \
670 case 3: hashv ^= _mur_key[2] << 16; \
672 case 2: hashv ^= _mur_key[1] << 8; \
674 case 1: hashv ^= _mur_key[0]; \
680 hashv ^= hashv >> 13; \
682 hashv ^= hashv >> 15; \
684 bkt = hashv & (num_bkts-1); \
689#define HASH_KEYCMP(a,b,len) memcmp(a,b,len)
692#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out) \
694 if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head)); \
697 if (out->hh.keylen == keylen_in) { \
698 if ((HASH_KEYCMP(out->hh.key,keyptr,keylen_in)) == 0) break; \
700 if (out->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,out->hh.hh_next)); \
706#define HASH_ADD_TO_BKT(head,addhh) \
709 (addhh)->hh_next = head.hh_head; \
710 (addhh)->hh_prev = NULL; \
711 if (head.hh_head) { (head).hh_head->hh_prev = (addhh); } \
712 (head).hh_head=addhh; \
713 if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH) \
714 && (addhh)->tbl->noexpand != 1) { \
715 HASH_EXPAND_BUCKETS((addhh)->tbl); \
720#define HASH_DEL_IN_BKT(hh,head,hh_del) \
722 if ((head).hh_head == hh_del) { \
723 (head).hh_head = hh_del->hh_next; \
725 if (hh_del->hh_prev) { \
726 hh_del->hh_prev->hh_next = hh_del->hh_next; \
728 if (hh_del->hh_next) { \
729 hh_del->hh_next->hh_prev = hh_del->hh_prev; \
761#define HASH_EXPAND_BUCKETS(tbl) \
764 unsigned _he_bkt_i; \
765 struct UT_hash_handle *_he_thh, *_he_hh_nxt; \
766 UT_hash_bucket *_he_new_buckets, *_he_newbkt; \
767 _he_new_buckets = (UT_hash_bucket*)uthash_malloc( \
768 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \
769 if (!_he_new_buckets) { uthash_fatal( "out of memory"); } \
770 memset(_he_new_buckets, 0, \
771 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \
772 tbl->ideal_chain_maxlen = \
773 (tbl->num_items >> (tbl->log2_num_buckets+1)) + \
774 ((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0); \
775 tbl->nonideal_items = 0; \
776 for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++) \
778 _he_thh = tbl->buckets[ _he_bkt_i ].hh_head; \
780 _he_hh_nxt = _he_thh->hh_next; \
781 HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt); \
782 _he_newbkt = &(_he_new_buckets[ _he_bkt ]); \
783 if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) { \
784 tbl->nonideal_items++; \
785 _he_newbkt->expand_mult = _he_newbkt->count / \
786 tbl->ideal_chain_maxlen; \
788 _he_thh->hh_prev = NULL; \
789 _he_thh->hh_next = _he_newbkt->hh_head; \
790 if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev = \
792 _he_newbkt->hh_head = _he_thh; \
793 _he_thh = _he_hh_nxt; \
796 uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
797 tbl->num_buckets *= 2; \
798 tbl->log2_num_buckets++; \
799 tbl->buckets = _he_new_buckets; \
800 tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ? \
801 (tbl->ineff_expands+1) : 0; \
802 if (tbl->ineff_expands > 1) { \
804 uthash_noexpand_fyi(tbl); \
806 uthash_expand_fyi(tbl); \
813#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
814#define HASH_SRT(hh,head,cmpfcn) \
817 unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize; \
818 struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; \
822 _hs_list = &((head)->hh); \
823 while (_hs_looping) { \
832 for ( _hs_i = 0; _hs_i < _hs_insize; _hs_i++ ) { \
834 _hs_q = (UT_hash_handle*)((_hs_q->next) ? \
835 ((void*)((char*)(_hs_q->next) + \
836 (head)->hh.tbl->hho)) : NULL); \
837 if (! (_hs_q) ) break; \
839 _hs_qsize = _hs_insize; \
840 while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) { \
841 if (_hs_psize == 0) { \
843 _hs_q = (UT_hash_handle*)((_hs_q->next) ? \
844 ((void*)((char*)(_hs_q->next) + \
845 (head)->hh.tbl->hho)) : NULL); \
847 } else if ( (_hs_qsize == 0) || !(_hs_q) ) { \
849 _hs_p = (UT_hash_handle*)((_hs_p->next) ? \
850 ((void*)((char*)(_hs_p->next) + \
851 (head)->hh.tbl->hho)) : NULL); \
854 cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
855 DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
858 _hs_p = (UT_hash_handle*)((_hs_p->next) ? \
859 ((void*)((char*)(_hs_p->next) + \
860 (head)->hh.tbl->hho)) : NULL); \
864 _hs_q = (UT_hash_handle*)((_hs_q->next) ? \
865 ((void*)((char*)(_hs_q->next) + \
866 (head)->hh.tbl->hho)) : NULL); \
870 _hs_tail->next = ((_hs_e) ? \
871 ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL); \
875 _hs_e->prev = ((_hs_tail) ? \
876 ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \
881 _hs_tail->next = NULL; \
882 if ( _hs_nmerges <= 1 ) { \
884 (head)->hh.tbl->tail = _hs_tail; \
885 DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list)); \
889 HASH_FSCK(hh,head); \
898#define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \
900 unsigned _src_bkt, _dst_bkt; \
901 void *_last_elt=NULL, *_elt; \
902 UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; \
903 ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst)); \
905 for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) { \
906 for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head; \
908 _src_hh = _src_hh->hh_next) { \
909 _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); \
911 _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho); \
912 _dst_hh->key = _src_hh->key; \
913 _dst_hh->keylen = _src_hh->keylen; \
914 _dst_hh->hashv = _src_hh->hashv; \
915 _dst_hh->prev = _last_elt; \
916 _dst_hh->next = NULL; \
917 if (_last_elt_hh) { _last_elt_hh->next = _elt; } \
919 DECLTYPE_ASSIGN(dst,_elt); \
920 HASH_MAKE_TABLE(hh_dst,dst); \
922 _dst_hh->tbl = (dst)->hh_dst.tbl; \
924 HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); \
925 HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh); \
926 (dst)->hh_dst.tbl->num_items++; \
928 _last_elt_hh = _dst_hh; \
933 HASH_FSCK(hh_dst,dst); \
936#define HASH_CLEAR(hh,head) \
939 uthash_free((head)->hh.tbl->buckets, \
940 (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \
941 uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
947#define HASH_ITER(hh,head,el,tmp) \
948for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL); \
949 el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL))
951#define HASH_ITER(hh,head,el,tmp) \
952for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL); \
953 el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))
957#define HASH_COUNT(head) HASH_CNT(hh,head)
958#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0)
976 unsigned expand_mult;
981#define HASH_SIGNATURE 0xa0111fe1
982#define HASH_BLOOM_SIGNATURE 0xb12220f2
986 unsigned num_buckets, log2_num_buckets;
993 unsigned ideal_chain_maxlen;
998 unsigned nonideal_items;
1006 unsigned ineff_expands, noexpand;
1028#pragma GCC visibility pop
Definition: uthash.h:1017