project-base/server-skynet-source-3rd-jemalloc
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use UINT64_C() rather than LLU for 64-bit constants.

Browse Source
This commit is contained in:
Jason Evans 2012-03-05 12:26:26 -08:00
parent 3492daf1ce
commit b8c8be7f8a
6 changed files with 29 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/jemalloc/internal/hash.h
View File

@ -26,7 +26,7 @@ uint64_t hash(const void *key, size_t len, uint64_t seed);
JEMALLOC_INLINE uint64_t JEMALLOC_INLINE uint64_t
hash(const void *key, size_t len, uint64_t seed) hash(const void *key, size_t len, uint64_t seed)
{ {
const uint64_t m = 0xc6a4a7935bd1e995LLU; const uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
const int r = 47; const int r = 47;
uint64_t h = seed ^ (len * m); uint64_t h = seed ^ (len * m);
const uint64_t *data = (const uint64_t *)key; const uint64_t *data = (const uint64_t *)key;

2
include/jemalloc/internal/prof.h
View File

@ -308,7 +308,7 @@ prof_sample_threshold_update(prof_tdata_t *prof_tdata)
* (http://cg.scs.carleton.ca/~luc/rnbookindex.html) * (http://cg.scs.carleton.ca/~luc/rnbookindex.html)
*/ */
prng64(r, 53, prof_tdata->prng_state, prng64(r, 53, prof_tdata->prng_state,
(uint64_t)6364136223846793005LLU, (uint64_t)1442695040888963407LLU); UINT64_C(6364136223846793005), UINT64_C(1442695040888963407));
u = (double)r * (1.0/9007199254740992.0L); u = (double)r * (1.0/9007199254740992.0L);
prof_tdata->threshold = (uint64_t)(log(u) / prof_tdata->threshold = (uint64_t)(log(u) /
log(1.0 - (1.0 / (double)((uint64_t)1U << opt_lg_prof_sample)))) log(1.0 - (1.0 / (double)((uint64_t)1U << opt_lg_prof_sample))))

8
src/ckh.c
View File

@ -535,7 +535,7 @@ ckh_string_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
assert(hash1 != NULL); assert(hash1 != NULL);
assert(hash2 != NULL); assert(hash2 != NULL);
h = hash(key, strlen((const char *)key), 0x94122f335b332aeaLLU); h = hash(key, strlen((const char *)key), UINT64_C(0x94122f335b332aea));
if (minbits <= 32) { if (minbits <= 32) {
/* /*
* Avoid doing multiple hashes, since a single hash provides * Avoid doing multiple hashes, since a single hash provides
@ -546,7 +546,7 @@ ckh_string_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
} else { } else {
ret1 = h; ret1 = h;
ret2 = hash(key, strlen((const char *)key), ret2 = hash(key, strlen((const char *)key),
0x8432a476666bbc13LLU); UINT64_C(0x8432a476666bbc13));
} }
*hash1 = ret1; *hash1 = ret1;
@ -583,7 +583,7 @@ ckh_pointer_hash(const void *key, unsigned minbits, size_t *hash1,
u.i = 0; u.i = 0;
#endif #endif
u.v = key; u.v = key;
h = hash(&u.i, sizeof(u.i), 0xd983396e68886082LLU); h = hash(&u.i, sizeof(u.i), UINT64_C(0xd983396e68886082));
if (minbits <= 32) { if (minbits <= 32) {
/* /*
* Avoid doing multiple hashes, since a single hash provides * Avoid doing multiple hashes, since a single hash provides
@ -594,7 +594,7 @@ ckh_pointer_hash(const void *key, unsigned minbits, size_t *hash1,
} else { } else {
assert(SIZEOF_PTR == 8); assert(SIZEOF_PTR == 8);
ret1 = h; ret1 = h;
ret2 = hash(&u.i, sizeof(u.i), 0x5e2be9aff8709a5dLLU); ret2 = hash(&u.i, sizeof(u.i), UINT64_C(0x5e2be9aff8709a5d));
} }
*hash1 = ret1; *hash1 = ret1;

9
src/prof.c
View File

@ -993,7 +993,7 @@ prof_dump_filename(char *filename, char v, int64_t vseq)
filename[i] = v; filename[i] = v;
i++; i++;
if (vseq != 0xffffffffffffffffLLU) { if (vseq != UINT64_C(0xffffffffffffffff)) {
s = u2s(vseq, 10, buf); s = u2s(vseq, 10, buf);
slen = strlen(s); slen = strlen(s);
memcpy(&filename[i], s, slen); memcpy(&filename[i], s, slen);
@ -1020,7 +1020,7 @@ prof_fdump(void)
if (opt_prof_prefix[0] != '\0') { if (opt_prof_prefix[0] != '\0') {
malloc_mutex_lock(&prof_dump_seq_mtx); malloc_mutex_lock(&prof_dump_seq_mtx);
prof_dump_filename(filename, 'f', 0xffffffffffffffffLLU); prof_dump_filename(filename, 'f', UINT64_C(0xffffffffffffffff));
malloc_mutex_unlock(&prof_dump_seq_mtx); malloc_mutex_unlock(&prof_dump_seq_mtx);
prof_dump(filename, opt_prof_leak, false); prof_dump(filename, opt_prof_leak, false);
} }
@ -1113,7 +1113,8 @@ prof_bt_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
assert(hash1 != NULL); assert(hash1 != NULL);
assert(hash2 != NULL); assert(hash2 != NULL);
h = hash(bt->vec, bt->len * sizeof(void *), 0x94122f335b332aeaLLU); h = hash(bt->vec, bt->len * sizeof(void *),
UINT64_C(0x94122f335b332aea));
if (minbits <= 32) { if (minbits <= 32) {
/* /*
* Avoid doing multiple hashes, since a single hash provides * Avoid doing multiple hashes, since a single hash provides
@ -1124,7 +1125,7 @@ prof_bt_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
} else { } else {
ret1 = h; ret1 = h;
ret2 = hash(bt->vec, bt->len * sizeof(void *), ret2 = hash(bt->vec, bt->len * sizeof(void *),
0x8432a476666bbc13LLU); UINT64_C(0x8432a476666bbc13));
} }
*hash1 = ret1; *hash1 = ret1;

18
test/allocm.c
View File

@ -6,8 +6,8 @@
#include "jemalloc_test.h" #include "jemalloc_test.h"
#define CHUNK 0x400000 #define CHUNK 0x400000
/* #define MAXALIGN ((size_t)0x80000000000LLU) */ /* #define MAXALIGN ((size_t)UINT64_C(0x80000000000)) */
#define MAXALIGN ((size_t)0x2000000LLU) #define MAXALIGN ((size_t)0x2000000LU)
#define NITER 4 #define NITER 4
int int
@ -67,8 +67,8 @@ main(void)
fprintf(stderr, "Unexpected dallocm() error\n"); fprintf(stderr, "Unexpected dallocm() error\n");
#if LG_SIZEOF_PTR == 3 #if LG_SIZEOF_PTR == 3
alignment = 0x8000000000000000LLU; alignment = UINT64_C(0x8000000000000000);
sz = 0x8000000000000000LLU; sz = UINT64_C(0x8000000000000000);
#else #else
alignment = 0x80000000LU; alignment = 0x80000000LU;
sz = 0x80000000LU; sz = 0x80000000LU;
@ -91,8 +91,8 @@ main(void)
fprintf(stderr, "nallocm()/allocm() rsize mismatch\n"); fprintf(stderr, "nallocm()/allocm() rsize mismatch\n");
#if LG_SIZEOF_PTR == 3 #if LG_SIZEOF_PTR == 3
alignment = 0x4000000000000000LLU; alignment = UINT64_C(0x4000000000000000);
sz = 0x8400000000000001LLU; sz = UINT64_C(0x8400000000000001);
#else #else
alignment = 0x40000000LU; alignment = 0x40000000LU;
sz = 0x84000001LU; sz = 0x84000001LU;
@ -109,11 +109,11 @@ main(void)
sz, ALLOCM_ALIGN(alignment)); sz, ALLOCM_ALIGN(alignment));
} }
alignment = 0x10LLU; alignment = 0x10LU;
#if LG_SIZEOF_PTR == 3 #if LG_SIZEOF_PTR == 3
sz = 0xfffffffffffffff0LLU; sz = UINT64_C(0xfffffffffffffff0);
#else #else
sz = 0xfffffff0LU; sz = 0xfffffff0LU;
#endif #endif
nsz = 0; nsz = 0;
r = nallocm(&nsz, sz, ALLOCM_ALIGN(alignment)); r = nallocm(&nsz, sz, ALLOCM_ALIGN(alignment));

17
test/posix_memalign.c
View File

@ -1,5 +1,6 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h>
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
@ -8,8 +9,8 @@
#include "jemalloc_test.h" #include "jemalloc_test.h"
#define CHUNK 0x400000 #define CHUNK 0x400000
/* #define MAXALIGN ((size_t)0x80000000000LLU) */ /* #define MAXALIGN ((size_t)UINT64_C(0x80000000000)) */
#define MAXALIGN ((size_t)0x2000000LLU) #define MAXALIGN ((size_t)0x2000000LU)
#define NITER 4 #define NITER 4
int int
@ -43,8 +44,8 @@ main(void)
} }
#if LG_SIZEOF_PTR == 3 #if LG_SIZEOF_PTR == 3
alignment = 0x8000000000000000LLU; alignment = UINT64_C(0x8000000000000000);
size = 0x8000000000000000LLU; size = UINT64_C(0x8000000000000000);
#else #else
alignment = 0x80000000LU; alignment = 0x80000000LU;
size = 0x80000000LU; size = 0x80000000LU;
@ -57,8 +58,8 @@ main(void)
} }
#if LG_SIZEOF_PTR == 3 #if LG_SIZEOF_PTR == 3
alignment = 0x4000000000000000LLU; alignment = UINT64_C(0x4000000000000000);
size = 0x8400000000000001LLU; size = UINT64_C(0x8400000000000001);
#else #else
alignment = 0x40000000LU; alignment = 0x40000000LU;
size = 0x84000001LU; size = 0x84000001LU;
@ -70,9 +71,9 @@ main(void)
alignment, size); alignment, size);
} }
alignment = 0x10LLU; alignment = 0x10LU;
#if LG_SIZEOF_PTR == 3 #if LG_SIZEOF_PTR == 3
size = 0xfffffffffffffff0LLU; size = UINT64_C(0xfffffffffffffff0);
#else #else
size = 0xfffffff0LU; size = 0xfffffff0LU;
#endif #endif