GOSTSec/sgminer
1
0
Fork 0
mirror of https://github.com/GOSTSec/sgminer synced 2025-02-05 19:44:21 +00:00
Code Issues Releases Wiki Activity

White space cleanup.

Browse Source
This commit is contained in:
Con Kolivas 2011-12-27 10:30:04 +11:00
parent eee665895d
commit a51514d9d1
6 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api.c
View File

@ -993,7 +993,7 @@ void api(void)
send_result(c, isjson); send_result(c, isjson);
did = true; did = true;
} }
else { else {
json_val = json_object_get(json_config, JSON_COMMAND); json_val = json_object_get(json_config, JSON_COMMAND);
if (json_val == NULL) { if (json_val == NULL) {
strcpy(io_buffer, message(MSG_MISSCMD, 0, isjson)); strcpy(io_buffer, message(MSG_MISSCMD, 0, isjson));

14
findnonce.c
View File

@ -4,7 +4,7 @@
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option) * Software Foundation; either version 2 of the License, or (at your option)
* any later version. See COPYING for more details. * any later version. See COPYING for more details.
*/ */
@ -49,7 +49,7 @@ const uint32_t SHA256_K[64] = {
void precalc_hash(dev_blk_ctx *blk, uint32_t *state, uint32_t *data) { void precalc_hash(dev_blk_ctx *blk, uint32_t *state, uint32_t *data) {
cl_uint A, B, C, D, E, F, G, H; cl_uint A, B, C, D, E, F, G, H;
A = state[0]; A = state[0];
B = state[1]; B = state[1];
C = state[2]; C = state[2];
@ -59,7 +59,7 @@ void precalc_hash(dev_blk_ctx *blk, uint32_t *state, uint32_t *data) {
G = state[6]; G = state[6];
H = state[7]; H = state[7];
R(A, B, C, D, E, F, G, H, data[0], SHA256_K[0]); R(A, B, C, D, E, F, G, H, data[0], SHA256_K[0]);
R(H, A, B, C, D, E, F, G, data[1], SHA256_K[1]); R(H, A, B, C, D, E, F, G, data[1], SHA256_K[1]);
R(G, H, A, B, C, D, E, F, data[2], SHA256_K[2]); R(G, H, A, B, C, D, E, F, data[2], SHA256_K[2]);
@ -90,7 +90,7 @@ void precalc_hash(dev_blk_ctx *blk, uint32_t *state, uint32_t *data) {
blk->merkle = data[0]; blk->merkle = data[0];
blk->ntime = data[1]; blk->ntime = data[1];
blk->nbits = data[2]; blk->nbits = data[2];
blk->W16 = blk->fW0 = data[0] + (rotr(data[1], 7) ^ rotr(data[1], 18) ^ (data[1] >> 3)); blk->W16 = blk->fW0 = data[0] + (rotr(data[1], 7) ^ rotr(data[1], 18) ^ (data[1] >> 3));
blk->W17 = blk->fW1 = data[1] + (rotr(data[2], 7) ^ rotr(data[2], 18) ^ (data[2] >> 3)) + 0x01100000; blk->W17 = blk->fW1 = data[1] + (rotr(data[2], 7) ^ rotr(data[2], 18) ^ (data[2] >> 3)) + 0x01100000;
blk->PreVal4 = blk->fcty_e = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + (D ^ (B & (C ^ D))) + 0xe9b5dba5; blk->PreVal4 = blk->fcty_e = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + (D ^ (B & (C ^ D))) + 0xe9b5dba5;
@ -101,8 +101,8 @@ void precalc_hash(dev_blk_ctx *blk, uint32_t *state, uint32_t *data) {
blk->PreW32 = blk->W16 + ((rotr(blk->W17, 7) ^ rotr(blk->W17, 18) ^ (blk->W17 >> 3))); blk->PreW32 = blk->W16 + ((rotr(blk->W17, 7) ^ rotr(blk->W17, 18) ^ (blk->W17 >> 3)));
blk->PreW18 = data[2] + (rotr(blk->W16, 17) ^ rotr(blk->W16, 19) ^ (blk->W16 >> 10)); blk->PreW18 = data[2] + (rotr(blk->W16, 17) ^ rotr(blk->W16, 19) ^ (blk->W16 >> 10));
blk->PreW19 = 0x11002000 + (rotr(blk->W17, 17) ^ rotr(blk->W17, 19) ^ (blk->W17 >> 10)); blk->PreW19 = 0x11002000 + (rotr(blk->W17, 17) ^ rotr(blk->W17, 19) ^ (blk->W17 >> 10));
blk->W2 = data[2]; blk->W2 = data[2];
blk->W2A = blk->W2 + (rotr(blk->W16, 19) ^ rotr(blk->W16, 17) ^ (blk->W16 >> 10)); blk->W2A = blk->W2 + (rotr(blk->W16, 19) ^ rotr(blk->W16, 17) ^ (blk->W16 >> 10));
@ -113,7 +113,7 @@ void precalc_hash(dev_blk_ctx *blk, uint32_t *state, uint32_t *data) {
blk->fW15 = 0x00000280 + (rotr(blk->fW0, 7) ^ rotr(blk->fW0, 18) ^ (blk->fW0 >> 3)); blk->fW15 = 0x00000280 + (rotr(blk->fW0, 7) ^ rotr(blk->fW0, 18) ^ (blk->fW0 >> 3));
blk->fW01r = blk->fW0 + (rotr(blk->fW1, 7) ^ rotr(blk->fW1, 18) ^ (blk->fW1 >> 3)); blk->fW01r = blk->fW0 + (rotr(blk->fW1, 7) ^ rotr(blk->fW1, 18) ^ (blk->fW1 >> 3));
blk->PreVal4addT1 = blk->PreVal4 + blk->T1; blk->PreVal4addT1 = blk->PreVal4 + blk->T1;
blk->T1substate0 = state[0] - blk->T1; blk->T1substate0 = state[0] - blk->T1;
} }

22
main.c
View File

@ -1239,28 +1239,28 @@ static char *set_gpu_memdiff(char *arg)
{ {
int i, val = 0, device = 0; int i, val = 0, device = 0;
char *nextptr; char *nextptr;
nextptr = strtok(arg, ","); nextptr = strtok(arg, ",");
if (nextptr == NULL) if (nextptr == NULL)
return "Invalid parameters for set gpu memdiff"; return "Invalid parameters for set gpu memdiff";
val = atoi(nextptr); val = atoi(nextptr);
if (val < -9999 || val > 9999) if (val < -9999 || val > 9999)
return "Invalid value passed to set_gpu_memdiff"; return "Invalid value passed to set_gpu_memdiff";
gpus[device++].gpu_memdiff = val; gpus[device++].gpu_memdiff = val;
while ((nextptr = strtok(NULL, ",")) != NULL) { while ((nextptr = strtok(NULL, ",")) != NULL) {
val = atoi(nextptr); val = atoi(nextptr);
if (val < -9999 || val > 9999) if (val < -9999 || val > 9999)
return "Invalid value passed to set_gpu_memdiff"; return "Invalid value passed to set_gpu_memdiff";
gpus[device++].gpu_memdiff = val; gpus[device++].gpu_memdiff = val;
} }
if (device == 1) { if (device == 1) {
for (i = device; i < MAX_GPUDEVICES; i++) for (i = device; i < MAX_GPUDEVICES; i++)
gpus[i].gpu_memdiff = gpus[0].gpu_memdiff; gpus[i].gpu_memdiff = gpus[0].gpu_memdiff;
} }
return NULL; return NULL;
} }
@ -3089,7 +3089,7 @@ static void remove_pool(struct pool *pool)
static void write_config(FILE *fcfg) static void write_config(FILE *fcfg)
{ {
int i; int i;
/* Write pool values */ /* Write pool values */
fputs("{\n\"pools\" : [", fcfg); fputs("{\n\"pools\" : [", fcfg);
for(i = 0; i < total_pools; i++) { for(i = 0; i < total_pools; i++) {
@ -3133,7 +3133,7 @@ static void write_config(FILE *fcfg)
fputs("\",\n", fcfg); fputs("\",\n", fcfg);
} }
fprintf(fcfg, "\n\"algo\" : \"%s\"", algo_names[opt_algo]); fprintf(fcfg, "\n\"algo\" : \"%s\"", algo_names[opt_algo]);
/* Simple bool and int options */ /* Simple bool and int options */
struct opt_table *opt; struct opt_table *opt;
for (opt = opt_config_table; opt->type != OPT_END; opt++) { for (opt = opt_config_table; opt->type != OPT_END; opt++) {
@ -3141,12 +3141,12 @@ static void write_config(FILE *fcfg)
for (p = strtok(name, "|"); p; p = strtok(NULL, "|")) { for (p = strtok(name, "|"); p; p = strtok(NULL, "|")) {
if (p[1] != '-') if (p[1] != '-')
continue; continue;
if (opt->type & OPT_NOARG && if (opt->type & OPT_NOARG &&
((void *)opt->cb == (void *)opt_set_bool || (void *)opt->cb == (void *)opt_set_invbool) && ((void *)opt->cb == (void *)opt_set_bool || (void *)opt->cb == (void *)opt_set_invbool) &&
(*(bool *)opt->u.arg == ((void *)opt->cb == (void *)opt_set_bool))) (*(bool *)opt->u.arg == ((void *)opt->cb == (void *)opt_set_bool)))
fprintf(fcfg, ",\n\"%s\" : true", p+2); fprintf(fcfg, ",\n\"%s\" : true", p+2);
if (opt->type & OPT_HASARG && if (opt->type & OPT_HASARG &&
((void *)opt->cb_arg == (void *)set_int_0_to_9999 || ((void *)opt->cb_arg == (void *)set_int_0_to_9999 ||
(void *)opt->cb_arg == (void *)set_int_1_to_65535 || (void *)opt->cb_arg == (void *)set_int_1_to_65535 ||
(void *)opt->cb_arg == (void *)set_int_0_to_10 || (void *)opt->cb_arg == (void *)set_int_0_to_10 ||
@ -3167,7 +3167,7 @@ static void write_config(FILE *fcfg)
#if defined(unix) #if defined(unix)
if (opt_stderr_cmd && *opt_stderr_cmd) if (opt_stderr_cmd && *opt_stderr_cmd)
fprintf(fcfg, ",\n\"monitor\" : \"%s\"", opt_stderr_cmd); fprintf(fcfg, ",\n\"monitor\" : \"%s\"", opt_stderr_cmd);
#endif // defined(unix) #endif // defined(unix)
if (opt_kernel && *opt_kernel) if (opt_kernel && *opt_kernel)
fprintf(fcfg, ",\n\"kernel\" : \"%s\"", opt_kernel); fprintf(fcfg, ",\n\"kernel\" : \"%s\"", opt_kernel);
if (opt_kernel_path && *opt_kernel_path) { if (opt_kernel_path && *opt_kernel_path) {

6
sha256_altivec_4way.c
View File

@ -82,7 +82,7 @@ unsigned int ScanHash_altivec_4way(int thr_id, const unsigned char *pmidstate,
uint32_t nonce) uint32_t nonce)
{ {
unsigned int *nNonce_p = (unsigned int*)(pdata + 12); unsigned int *nNonce_p = (unsigned int*)(pdata + 12);
work_restart[thr_id].restart = 0; work_restart[thr_id].restart = 0;
for (;;) for (;;)
@ -102,7 +102,7 @@ unsigned int ScanHash_altivec_4way(int thr_id, const unsigned char *pmidstate,
for (i = 0; i < 32/4; i++) for (i = 0; i < 32/4; i++)
((unsigned int*)phash)[i] = thash[i][j]; ((unsigned int*)phash)[i] = thash[i][j];
if (fulltest(phash, ptarget)) { if (fulltest(phash, ptarget)) {
*nHashesDone = nonce; *nHashesDone = nonce;
*nNonce_p = nonce + j; *nNonce_p = nonce + j;
@ -138,7 +138,7 @@ static void DoubleBlockSHA256(const void* pin, void* pad, const void *pre, unsig
/* nonce offset for vector */ /* nonce offset for vector */
vector unsigned int offset = (vector unsigned int)(0, 1, 2, 3); vector unsigned int offset = (vector unsigned int)(0, 1, 2, 3);
preNonce = vec_add((vector unsigned int)(In[3],In[3],In[3],In[3]), offset); preNonce = vec_add((vector unsigned int)(In[3],In[3],In[3],In[3]), offset);
for(k = 0; k<NPAR; k+=4) for(k = 0; k<NPAR; k+=4)

72
uthash.h
View File

@ -22,7 +22,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef UTHASH_H #ifndef UTHASH_H
#define UTHASH_H #define UTHASH_H
#include <string.h> /* memcmp,strlen */ #include <string.h> /* memcmp,strlen */
#include <stddef.h> /* ptrdiff_t */ #include <stddef.h> /* ptrdiff_t */
@ -49,7 +49,7 @@ do {
char **_da_dst = (char**)(&(dst)); \ char **_da_dst = (char**)(&(dst)); \
*_da_dst = (char*)(src); \ *_da_dst = (char*)(src); \
} while(0) } while(0)
#else #else
#define DECLTYPE_ASSIGN(dst,src) \ #define DECLTYPE_ASSIGN(dst,src) \
do { \ do { \
(dst) = DECLTYPE(dst)(src); \ (dst) = DECLTYPE(dst)(src); \
@ -121,9 +121,9 @@ do {
HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1))) HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
#else #else
#define HASH_BLOOM_MAKE(tbl) #define HASH_BLOOM_MAKE(tbl)
#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)
#endif #endif
@ -148,7 +148,7 @@ do {
#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_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; \
@ -300,10 +300,10 @@ do {
} \ } \
} while (0) } while (0)
#else #else
#define HASH_FSCK(hh,head) #define HASH_FSCK(hh,head)
#endif #endif
/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to /* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
* the descriptor to which this macro is defined for tuning the hash function. * the descriptor to which this macro is defined for tuning the hash function.
* The app can #include <unistd.h> to get the prototype for write(2). */ * The app can #include <unistd.h> to get the prototype for write(2). */
#ifdef HASH_EMIT_KEYS #ifdef HASH_EMIT_KEYS
@ -313,12 +313,12 @@ do {
write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \ write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \
write(HASH_EMIT_KEYS, keyptr, fieldlen); \ write(HASH_EMIT_KEYS, keyptr, fieldlen); \
} while (0) } while (0)
#else #else
#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) #define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
#endif #endif
/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */ /* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */
#ifdef HASH_FUNCTION #ifdef HASH_FUNCTION
#define HASH_FCN HASH_FUNCTION #define HASH_FCN HASH_FUNCTION
#else #else
#define HASH_FCN HASH_JEN #define HASH_FCN HASH_JEN
@ -335,7 +335,7 @@ do {
} while (0) } while (0)
/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at /* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
* http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */ * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
#define HASH_SAX(key,keylen,num_bkts,hashv,bkt) \ #define HASH_SAX(key,keylen,num_bkts,hashv,bkt) \
do { \ do { \
@ -356,7 +356,7 @@ do {
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 { \
unsigned _ho_i; \ unsigned _ho_i; \
@ -485,14 +485,14 @@ do {
#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.
* For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error. * For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error.
* MurmurHash uses the faster approach only on CPU's where we know it's safe. * MurmurHash uses the faster approach only on CPU's where we know it's safe.
* *
* Note the preprocessor built-in defines can be emitted using: * Note the preprocessor built-in defines can be emitted using:
* *
* 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__))
#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)
@ -562,7 +562,7 @@ do { \
#endif /* HASH_USING_NO_STRICT_ALIASING */ #endif /* HASH_USING_NO_STRICT_ALIASING */
/* key comparison function; return 0 if keys equal */ /* key comparison function; return 0 if keys equal */
#define HASH_KEYCMP(a,b,len) memcmp(a,b,len) #define HASH_KEYCMP(a,b,len) memcmp(a,b,len)
/* iterate over items in a known bucket to find desired item */ /* iterate over items in a known bucket to find desired item */
#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out) \ #define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out) \
@ -603,36 +603,36 @@ do {
} \ } \
if (hh_del->hh_next) { \ if (hh_del->hh_next) { \
hh_del->hh_next->hh_prev = hh_del->hh_prev; \ hh_del->hh_next->hh_prev = hh_del->hh_prev; \
} }
/* Bucket expansion has the effect of doubling the number of buckets /* Bucket expansion has the effect of doubling the number of buckets
* and redistributing the items into the new buckets. Ideally the * and redistributing the items into the new buckets. Ideally the
* items will distribute more or less evenly into the new buckets * items will distribute more or less evenly into the new buckets
* (the extent to which this is true is a measure of the quality of * (the extent to which this is true is a measure of the quality of
* the hash function as it applies to the key domain). * the hash function as it applies to the key domain).
* *
* With the items distributed into more buckets, the chain length * With the items distributed into more buckets, the chain length
* (item count) in each bucket is reduced. Thus by expanding buckets * (item count) in each bucket is reduced. Thus by expanding buckets
* the hash keeps a bound on the chain length. This bounded chain * the hash keeps a bound on the chain length. This bounded chain
* length is the essence of how a hash provides constant time lookup. * length is the essence of how a hash provides constant time lookup.
* *
* The calculation of tbl->ideal_chain_maxlen below deserves some * The calculation of tbl->ideal_chain_maxlen below deserves some
* explanation. First, keep in mind that we're calculating the ideal * explanation. First, keep in mind that we're calculating the ideal
* maximum chain length based on the *new* (doubled) bucket count. * maximum chain length based on the *new* (doubled) bucket count.
* In fractions this is just n/b (n=number of items,b=new num buckets). * In fractions this is just n/b (n=number of items,b=new num buckets).
* Since the ideal chain length is an integer, we want to calculate * Since the ideal chain length is an integer, we want to calculate
* ceil(n/b). We don't depend on floating point arithmetic in this * ceil(n/b). We don't depend on floating point arithmetic in this
* hash, so to calculate ceil(n/b) with integers we could write * hash, so to calculate ceil(n/b) with integers we could write
* *
* ceil(n/b) = (n/b) + ((n%b)?1:0) * ceil(n/b) = (n/b) + ((n%b)?1:0)
* *
* and in fact a previous version of this hash did just that. * and in fact a previous version of this hash did just that.
* But now we have improved things a bit by recognizing that b is * But now we have improved things a bit by recognizing that b is
* always a power of two. We keep its base 2 log handy (call it lb), * always a power of two. We keep its base 2 log handy (call it lb),
* so now we can write this with a bit shift and logical AND: * so now we can write this with a bit shift and logical AND:
* *
* ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0) * ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
* *
*/ */
#define HASH_EXPAND_BUCKETS(tbl) \ #define HASH_EXPAND_BUCKETS(tbl) \
do { \ do { \
@ -684,7 +684,7 @@ do {
/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */ /* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
/* Note that HASH_SORT assumes the hash handle name to be hh. /* Note that HASH_SORT assumes the hash handle name to be hh.
* HASH_SRT was added to allow the hash handle name to be passed in. */ * HASH_SRT was added to allow the hash handle name to be passed in. */
#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn) #define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
#define HASH_SRT(hh,head,cmpfcn) \ #define HASH_SRT(hh,head,cmpfcn) \
@ -766,10 +766,10 @@ do {
} \ } \
} while (0) } while (0)
/* This function selects items from one hash into another hash. /* This function selects items from one hash into another hash.
* The end result is that the selected items have dual presence * The end result is that the selected items have dual presence
* in both hashes. There is no copy of the items made; rather * in both hashes. There is no copy of the items made; rather
* they are added into the new hash through a secondary hash * they are added into the new hash through a secondary hash
* hash handle that must be present in the structure. */ * hash handle that must be present in the structure. */
#define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \ #define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \
do { \ do { \
@ -822,7 +822,7 @@ do {
#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); \
el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL)) el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL))
#else #else
#define HASH_ITER(hh,head,el,tmp) \ #define HASH_ITER(hh,head,el,tmp) \
for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL); \ for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL); \
@ -830,7 +830,7 @@ for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL);
#endif #endif
/* obtain a count of items in the hash */ /* obtain a count of items in the hash */
#define HASH_COUNT(head) HASH_CNT(hh,head) #define HASH_COUNT(head) HASH_CNT(hh,head)
#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0) #define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0)
typedef struct UT_hash_bucket { typedef struct UT_hash_bucket {
@ -839,7 +839,7 @@ typedef struct UT_hash_bucket {
/* expand_mult is normally set to 0. In this situation, the max chain length /* expand_mult is normally set to 0. In this situation, the max chain length
* threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
* the bucket's chain exceeds this length, bucket expansion is triggered). * the bucket's chain exceeds this length, bucket expansion is triggered).
* However, setting expand_mult to a non-zero value delays bucket expansion * However, setting expand_mult to a non-zero value delays bucket expansion
* (that would be triggered by additions to this particular bucket) * (that would be triggered by additions to this particular bucket)
* until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH. * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
@ -847,7 +847,7 @@ typedef struct UT_hash_bucket {
* multiplier is to reduce bucket expansions, since they are expensive, in * multiplier is to reduce bucket expansions, since they are expensive, in
* situations where we know that a particular bucket tends to be overused. * situations where we know that a particular bucket tends to be overused.
* It is better to let its chain length grow to a longer yet-still-bounded * It is better to let its chain length grow to a longer yet-still-bounded
* value, than to do an O(n) bucket expansion too often. * value, than to do an O(n) bucket expansion too often.
*/ */
unsigned expand_mult; unsigned expand_mult;
@ -873,7 +873,7 @@ typedef struct UT_hash_table {
* hash distribution; reaching them in a chain traversal takes >ideal steps */ * hash distribution; reaching them in a chain traversal takes >ideal steps */
unsigned nonideal_items; unsigned nonideal_items;
/* ineffective expands occur when a bucket doubling was performed, but /* ineffective expands occur when a bucket doubling was performed, but
* afterward, more than half the items in the hash had nonideal chain * afterward, more than half the items in the hash had nonideal chain
* positions. If this happens on two consecutive expansions we inhibit any * positions. If this happens on two consecutive expansions we inhibit any
* further expansion, as it's not helping; this happens when the hash * further expansion, as it's not helping; this happens when the hash

8
util.c
View File

@ -244,7 +244,7 @@ int json_rpc_call_sockopt_cb(void *userdata, curl_socket_t fd, curlsocktype purp
int tcp_keepcnt = 5; int tcp_keepcnt = 5;
int tcp_keepidle = 120; int tcp_keepidle = 120;
int tcp_keepintvl = 120; int tcp_keepintvl = 120;
#ifndef WIN32 #ifndef WIN32
if (unlikely(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive)))) if (unlikely(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive))))
@ -269,7 +269,7 @@ int json_rpc_call_sockopt_cb(void *userdata, curl_socket_t fd, curlsocktype purp
# endif /* __APPLE_CC__ */ # endif /* __APPLE_CC__ */
#else /* WIN32 */ #else /* WIN32 */
struct tcp_keepalive vals; struct tcp_keepalive vals;
vals.onoff = 1; vals.onoff = 1;
vals.keepalivetime = tcp_keepidle * 1000; vals.keepalivetime = tcp_keepidle * 1000;
@ -279,7 +279,7 @@ int json_rpc_call_sockopt_cb(void *userdata, curl_socket_t fd, curlsocktype purp
if (unlikely(WSAIoctl(fd, SIO_KEEPALIVE_VALS, &vals, sizeof(vals), NULL, 0, &outputBytes, NULL, NULL))) if (unlikely(WSAIoctl(fd, SIO_KEEPALIVE_VALS, &vals, sizeof(vals), NULL, 0, &outputBytes, NULL, NULL)))
return 1; return 1;
#endif /* WIN32 */ #endif /* WIN32 */
return 0; return 0;
@ -374,7 +374,7 @@ json_t *json_rpc_call(CURL *curl, const char *url,
if (probing) { if (probing) {
pool->probed = true; pool->probed = true;
/* If X-Long-Polling was found, activate long polling */ /* If X-Long-Polling was found, activate long polling */
if (hi.lp_path) if (hi.lp_path)
pool->hdr_path = hi.lp_path; pool->hdr_path = hi.lp_path;
else else
pool->hdr_path = NULL; pool->hdr_path = NULL;