GOSTSec
/
sgminer
mirror of https://github.com/GOSTSec/sgminer
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Update uthash to latest.

nfactor-troky
Con Kolivas 11 years ago
parent
e6a5068470
commit
b764862128
1 changed files with 109 additions and 65 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 92
      uthash.h

92
uthash.h
Unescape View File

@ -1,5 +1,5 @@
/* /*
Copyright (c) 2003-2011, Troy D. Hanson http://uthash.sourceforge.net Copyright (c) 2003-2013, Troy D. Hanson http://troydhanson.github.com/uthash/
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without Redistribution and use in source and binary forms, with or without
@ -64,14 +64,24 @@ typedef unsigned char uint8_t;
#include <inttypes.h> /* uint32_t */ #include <inttypes.h> /* uint32_t */
#endif #endif
#define UTHASH_VERSION 1.9.4 #define UTHASH_VERSION 1.9.8
#ifndef uthash_fatal
#define uthash_fatal(msg) exit(-1) /* fatal error (out of memory,etc) */ #define uthash_fatal(msg) exit(-1) /* fatal error (out of memory,etc) */
#endif
#ifndef uthash_malloc
#define uthash_malloc(sz) malloc(sz) /* malloc fcn */ #define uthash_malloc(sz) malloc(sz) /* malloc fcn */
#endif
#ifndef uthash_free
#define uthash_free(ptr,sz) free(ptr) /* free fcn */ #define uthash_free(ptr,sz) free(ptr) /* free fcn */
#endif
#ifndef uthash_noexpand_fyi
#define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */ #define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */
#endif
#ifndef uthash_expand_fyi
#define uthash_expand_fyi(tbl) /* can be defined to log expands */ #define uthash_expand_fyi(tbl) /* can be defined to log expands */
#endif
/* initial number of buckets */ /* initial number of buckets */
#define HASH_INITIAL_NUM_BUCKETS 32 /* initial number of buckets */ #define HASH_INITIAL_NUM_BUCKETS 32 /* initial number of buckets */
@ -104,12 +114,12 @@ do {
if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } \ if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } \
memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); \ memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); \
(tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \ (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \
} while (0); } while (0)
#define HASH_BLOOM_FREE(tbl) \ #define HASH_BLOOM_FREE(tbl) \
do { \ do { \
uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \ uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \
} while (0); } while (0)
#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8))) #define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8)))
#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8))) #define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8)))
@ -125,6 +135,7 @@ do {
#define HASH_BLOOM_FREE(tbl) #define HASH_BLOOM_FREE(tbl)
#define HASH_BLOOM_ADD(tbl,hashv) #define HASH_BLOOM_ADD(tbl,hashv)
#define HASH_BLOOM_TEST(tbl,hashv) (1) #define HASH_BLOOM_TEST(tbl,hashv) (1)
#define HASH_BLOOM_BYTELEN 0
#endif #endif
#define HASH_MAKE_TABLE(hh,head) \ #define HASH_MAKE_TABLE(hh,head) \
@ -147,14 +158,24 @@ do {
} while(0) } while(0)
#define HASH_ADD(hh,head,fieldname,keylen_in,add) \ #define HASH_ADD(hh,head,fieldname,keylen_in,add) \
HASH_ADD_KEYPTR(hh,head,&add->fieldname,keylen_in,add) HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)
#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced) \
do { \
replaced=NULL; \
HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced); \
if (replaced!=NULL) { \
HASH_DELETE(hh,head,replaced); \
}; \
HASH_ADD(hh,head,fieldname,keylen_in,add); \
} while(0)
#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \ #define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \
do { \ do { \
unsigned _ha_bkt; \ unsigned _ha_bkt; \
(add)->hh.next = NULL; \ (add)->hh.next = NULL; \
(add)->hh.key = (char*)keyptr; \ (add)->hh.key = (char*)(keyptr); \
(add)->hh.keylen = keylen_in; \ (add)->hh.keylen = (unsigned)(keylen_in); \
if (!(head)) { \ if (!(head)) { \
head = (add); \ head = (add); \
(head)->hh.prev = NULL; \ (head)->hh.prev = NULL; \
@ -205,17 +226,17 @@ do {
_hd_hh_del = &((delptr)->hh); \ _hd_hh_del = &((delptr)->hh); \
if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \ if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \
(head)->hh.tbl->tail = \ (head)->hh.tbl->tail = \
(UT_hash_handle*)((char*)((delptr)->hh.prev) + \ (UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
(head)->hh.tbl->hho); \ (head)->hh.tbl->hho); \
} \ } \
if ((delptr)->hh.prev) { \ if ((delptr)->hh.prev) { \
((UT_hash_handle*)((char*)((delptr)->hh.prev) + \ ((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
(head)->hh.tbl->hho))->next = (delptr)->hh.next; \ (head)->hh.tbl->hho))->next = (delptr)->hh.next; \
} else { \ } else { \
DECLTYPE_ASSIGN(head,(delptr)->hh.next); \ DECLTYPE_ASSIGN(head,(delptr)->hh.next); \
} \ } \
if (_hd_hh_del->next) { \ if (_hd_hh_del->next) { \
((UT_hash_handle*)((char*)_hd_hh_del->next + \ ((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next + \
(head)->hh.tbl->hho))->prev = \ (head)->hh.tbl->hho))->prev = \
_hd_hh_del->prev; \ _hd_hh_del->prev; \
} \ } \
@ -232,14 +253,20 @@ do {
HASH_FIND(hh,head,findstr,strlen(findstr),out) HASH_FIND(hh,head,findstr,strlen(findstr),out)
#define HASH_ADD_STR(head,strfield,add) \ #define HASH_ADD_STR(head,strfield,add) \
HASH_ADD(hh,head,strfield,strlen(add->strfield),add) HASH_ADD(hh,head,strfield,strlen(add->strfield),add)
#define HASH_REPLACE_STR(head,strfield,add,replaced) \
HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)
#define HASH_FIND_INT(head,findint,out) \ #define HASH_FIND_INT(head,findint,out) \
HASH_FIND(hh,head,findint,sizeof(int),out) HASH_FIND(hh,head,findint,sizeof(int),out)
#define HASH_ADD_INT(head,intfield,add) \ #define HASH_ADD_INT(head,intfield,add) \
HASH_ADD(hh,head,intfield,sizeof(int),add) HASH_ADD(hh,head,intfield,sizeof(int),add)
#define HASH_REPLACE_INT(head,intfield,add,replaced) \
HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
#define HASH_FIND_PTR(head,findptr,out) \ #define HASH_FIND_PTR(head,findptr,out) \
HASH_FIND(hh,head,findptr,sizeof(void *),out) HASH_FIND(hh,head,findptr,sizeof(void *),out)
#define HASH_ADD_PTR(head,ptrfield,add) \ #define HASH_ADD_PTR(head,ptrfield,add) \
HASH_ADD(hh,head,ptrfield,sizeof(void *),add) HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
#define HASH_REPLACE_PTR(head,ptrfield,add) \
HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
#define HASH_DEL(head,delptr) \ #define HASH_DEL(head,delptr) \
HASH_DELETE(hh,head,delptr) HASH_DELETE(hh,head,delptr)
@ -355,7 +382,7 @@ do {
for(_fn_i=0; _fn_i < keylen; _fn_i++) \ for(_fn_i=0; _fn_i < keylen; _fn_i++) \
hashv = (hashv * 16777619) ^ _hf_key[_fn_i]; \ hashv = (hashv * 16777619) ^ _hf_key[_fn_i]; \
bkt = hashv & (num_bkts-1); \ bkt = hashv & (num_bkts-1); \
} while(0); } while(0)
#define HASH_OAT(key,keylen,num_bkts,hashv,bkt) \ #define HASH_OAT(key,keylen,num_bkts,hashv,bkt) \
do { \ do { \
@ -389,10 +416,10 @@ do {
#define HASH_JEN(key,keylen,num_bkts,hashv,bkt) \ #define HASH_JEN(key,keylen,num_bkts,hashv,bkt) \
do { \ do { \
unsigned _hj_i,_hj_j,_hj_k; \ unsigned _hj_i,_hj_j,_hj_k; \
char *_hj_key=(char*)(key); \ unsigned char *_hj_key=(unsigned char*)(key); \
hashv = 0xfeedbeef; \ hashv = 0xfeedbeef; \
_hj_i = _hj_j = 0x9e3779b9; \ _hj_i = _hj_j = 0x9e3779b9; \
_hj_k = keylen; \ _hj_k = (unsigned)(keylen); \
while (_hj_k >= 12) { \ while (_hj_k >= 12) { \
_hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \ _hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \
+ ( (unsigned)_hj_key[2] << 16 ) \ + ( (unsigned)_hj_key[2] << 16 ) \
@ -440,7 +467,7 @@ do {
#endif #endif
#define HASH_SFH(key,keylen,num_bkts,hashv,bkt) \ #define HASH_SFH(key,keylen,num_bkts,hashv,bkt) \
do { \ do { \
char *_sfh_key=(char*)(key); \ unsigned char *_sfh_key=(unsigned char*)(key); \
uint32_t _sfh_tmp, _sfh_len = keylen; \ uint32_t _sfh_tmp, _sfh_len = keylen; \
\ \
int _sfh_rem = _sfh_len & 3; \ int _sfh_rem = _sfh_len & 3; \
@ -450,7 +477,7 @@ do {
/* Main loop */ \ /* Main loop */ \
for (;_sfh_len > 0; _sfh_len--) { \ for (;_sfh_len > 0; _sfh_len--) { \
hashv += get16bits (_sfh_key); \ hashv += get16bits (_sfh_key); \
_sfh_tmp = (get16bits (_sfh_key+2) << 11) ^ hashv; \ _sfh_tmp = (uint32_t)(get16bits (_sfh_key+2)) << 11 ^ hashv; \
hashv = (hashv << 16) ^ _sfh_tmp; \ hashv = (hashv << 16) ^ _sfh_tmp; \
_sfh_key += 2*sizeof (uint16_t); \ _sfh_key += 2*sizeof (uint16_t); \
hashv += hashv >> 11; \ hashv += hashv >> 11; \
@ -460,7 +487,7 @@ do {
switch (_sfh_rem) { \ switch (_sfh_rem) { \
case 3: hashv += get16bits (_sfh_key); \ case 3: hashv += get16bits (_sfh_key); \
hashv ^= hashv << 16; \ hashv ^= hashv << 16; \
hashv ^= _sfh_key[sizeof (uint16_t)] << 18; \ hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)] << 18); \
hashv += hashv >> 11; \ hashv += hashv >> 11; \
break; \ break; \
case 2: hashv += get16bits (_sfh_key); \ case 2: hashv += get16bits (_sfh_key); \
@ -480,7 +507,7 @@ do {
hashv ^= hashv << 25; \ hashv ^= hashv << 25; \
hashv += hashv >> 6; \ hashv += hashv >> 6; \
bkt = hashv & (num_bkts-1); \ bkt = hashv & (num_bkts-1); \
} while(0); } while(0)
#ifdef HASH_USING_NO_STRICT_ALIASING #ifdef HASH_USING_NO_STRICT_ALIASING
/* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads. /* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads.
@ -492,7 +519,7 @@ do {
* gcc -m64 -dM -E - < /dev/null (on gcc) * gcc -m64 -dM -E - < /dev/null (on gcc)
* cc -## a.c (where a.c is a simple test file) (Sun Studio) * cc -## a.c (where a.c is a simple test file) (Sun Studio)
*/ */
#if (defined(__i386__) || defined(__x86_64__)) #if (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86))
#define MUR_GETBLOCK(p,i) p[i] #define MUR_GETBLOCK(p,i) p[i]
#else /* non intel */ #else /* non intel */
#define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 0x3) == 0) #define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 0x3) == 0)
@ -531,10 +558,12 @@ do { \
uint32_t _mur_h1 = 0xf88D5353; \ uint32_t _mur_h1 = 0xf88D5353; \
uint32_t _mur_c1 = 0xcc9e2d51; \ uint32_t _mur_c1 = 0xcc9e2d51; \
uint32_t _mur_c2 = 0x1b873593; \ uint32_t _mur_c2 = 0x1b873593; \
uint32_t _mur_k1 = 0; \
const uint8_t *_mur_tail; \
const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \ const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \
int _mur_i; \ int _mur_i; \
for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) { \ for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) { \
uint32_t _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); \ _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); \
_mur_k1 *= _mur_c1; \ _mur_k1 *= _mur_c1; \
_mur_k1 = MUR_ROTL32(_mur_k1,15); \ _mur_k1 = MUR_ROTL32(_mur_k1,15); \
_mur_k1 *= _mur_c2; \ _mur_k1 *= _mur_c2; \
@ -543,8 +572,8 @@ do { \
_mur_h1 = MUR_ROTL32(_mur_h1,13); \ _mur_h1 = MUR_ROTL32(_mur_h1,13); \
_mur_h1 = _mur_h1*5+0xe6546b64; \ _mur_h1 = _mur_h1*5+0xe6546b64; \
} \ } \
const uint8_t *_mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); \ _mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); \
uint32_t _mur_k1=0; \ _mur_k1=0; \
switch((keylen) & 3) { \ switch((keylen) & 3) { \
case 3: _mur_k1 ^= _mur_tail[2] << 16; \ case 3: _mur_k1 ^= _mur_tail[2] << 16; \
case 2: _mur_k1 ^= _mur_tail[1] << 8; \ case 2: _mur_k1 ^= _mur_tail[1] << 8; \
@ -570,10 +599,10 @@ do {
if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head)); \ if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head)); \
else out=NULL; \ else out=NULL; \
while (out) { \ while (out) { \
if (out->hh.keylen == keylen_in) { \ if ((out)->hh.keylen == keylen_in) { \
if ((HASH_KEYCMP(out->hh.key,keyptr,keylen_in)) == 0) break; \ if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break; \
} \ } \
if (out->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,out->hh.hh_next)); \ if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \
else out = NULL; \ else out = NULL; \
} \ } \
} while(0) } while(0)
@ -722,18 +751,22 @@ do {
_hs_qsize--; \ _hs_qsize--; \
} else if ( (_hs_qsize == 0) || !(_hs_q) ) { \ } else if ( (_hs_qsize == 0) || !(_hs_q) ) { \
_hs_e = _hs_p; \ _hs_e = _hs_p; \
if (_hs_p){ \
_hs_p = (UT_hash_handle*)((_hs_p->next) ? \ _hs_p = (UT_hash_handle*)((_hs_p->next) ? \
((void*)((char*)(_hs_p->next) + \ ((void*)((char*)(_hs_p->next) + \
(head)->hh.tbl->hho)) : NULL); \ (head)->hh.tbl->hho)) : NULL); \
} \
_hs_psize--; \ _hs_psize--; \
} else if (( \ } else if (( \
cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \ cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \ DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
) <= 0) { \ ) <= 0) { \
_hs_e = _hs_p; \ _hs_e = _hs_p; \
if (_hs_p){ \
_hs_p = (UT_hash_handle*)((_hs_p->next) ? \ _hs_p = (UT_hash_handle*)((_hs_p->next) ? \
((void*)((char*)(_hs_p->next) + \ ((void*)((char*)(_hs_p->next) + \
(head)->hh.tbl->hho)) : NULL); \ (head)->hh.tbl->hho)) : NULL); \
} \
_hs_psize--; \ _hs_psize--; \
} else { \ } else { \
_hs_e = _hs_q; \ _hs_e = _hs_q; \
@ -748,13 +781,17 @@ do {
} else { \ } else { \
_hs_list = _hs_e; \ _hs_list = _hs_e; \
} \ } \
if (_hs_e) { \
_hs_e->prev = ((_hs_tail) ? \ _hs_e->prev = ((_hs_tail) ? \
ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \ ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \
} \
_hs_tail = _hs_e; \ _hs_tail = _hs_e; \
} \ } \
_hs_p = _hs_q; \ _hs_p = _hs_q; \
} \ } \
if (_hs_tail){ \
_hs_tail->next = NULL; \ _hs_tail->next = NULL; \
} \
if ( _hs_nmerges <= 1 ) { \ if ( _hs_nmerges <= 1 ) { \
_hs_looping=0; \ _hs_looping=0; \
(head)->hh.tbl->tail = _hs_tail; \ (head)->hh.tbl->tail = _hs_tail; \
@ -814,11 +851,18 @@ do {
if (head) { \ if (head) { \
uthash_free((head)->hh.tbl->buckets, \ uthash_free((head)->hh.tbl->buckets, \
(head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \ (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \
HASH_BLOOM_FREE((head)->hh.tbl); \
uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
(head)=NULL; \ (head)=NULL; \
} \ } \
} while(0) } while(0)
#define HASH_OVERHEAD(hh,head) \
(size_t)((((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) + \
((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) + \
(sizeof(UT_hash_table)) + \
(HASH_BLOOM_BYTELEN)))
#ifdef NO_DECLTYPE #ifdef NO_DECLTYPE
#define HASH_ITER(hh,head,el,tmp) \ #define HASH_ITER(hh,head,el,tmp) \
for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL); \ for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL); \

Write Preview
Loading…
Cancel
Save