43 #if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
44 # define UNLIKELY(value) __builtin_expect((value), 0) && (value > 0 || (value = RUNNING_ON_VALGRIND))
46 # define UNLIKELY(value) (value) && (value > 0 || (value = RUNNING_ON_VALGRIND))
48 static int _running_on_valgrind = -1;
51 #if defined(_JLU3_SELFTEST)
52 # define _JLU3_jlu32w 1
53 # define _JLU3_jlu32l 1
54 # define _JLU3_jlu32lpair 1
55 # define _JLU3_jlu32b 1
62 const unsigned char uc[4];
64 # define HASH_LITTLE_ENDIAN (endian.uc[0] == (unsigned char) 0x44)
65 # define HASH_BIG_ENDIAN (endian.uc[0] == (unsigned char) 0x11)
69 # define ROTL32(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
73 #define _JLU3_INIT(_h, _size) (0xdeadbeef + ((rpmuint32_t)(_size)) + (_h))
119 #define _JLU3_MIX(a,b,c) \
121 a -= c; a ^= ROTL32(c, 4); c += b; \
122 b -= a; b ^= ROTL32(a, 6); a += c; \
123 c -= b; c ^= ROTL32(b, 8); b += a; \
124 a -= c; a ^= ROTL32(c,16); c += b; \
125 b -= a; b ^= ROTL32(a,19); a += c; \
126 c -= b; c ^= ROTL32(b, 4); b += a; \
154 #define _JLU3_FINAL(a,b,c) \
156 c ^= b; c -= ROTL32(b,14); \
157 a ^= c; a -= ROTL32(c,11); \
158 b ^= a; b -= ROTL32(a,25); \
159 c ^= b; c -= ROTL32(b,16); \
160 a ^= c; a -= ROTL32(c,4); \
161 b ^= a; b -= ROTL32(a,14); \
162 c ^= b; c -= ROTL32(b,24); \
165 #if defined(_JLU3_jlu32w)
221 #if defined(_JLU3_jlu32l)
257 union {
const void *ptr;
size_t i; } u;
290 if (
UNLIKELY(_running_on_valgrind)) {
294 case 12: c += k[2]; b+=k[1]; a+=k[0];
break;
298 case 8: b += k[1]; a+=k[0];
break;
302 case 4: a += k[0];
break;
305 case 1: a += k8[0];
break;
313 case 12: c += k[2]; b+=k[1]; a+=k[0];
break;
314 case 11: c += k[2]&0xffffff; b+=k[1]; a+=k[0];
break;
315 case 10: c += k[2]&0xffff; b+=k[1]; a+=k[0];
break;
316 case 9: c += k[2]&0xff; b+=k[1]; a+=k[0];
break;
317 case 8: b += k[1]; a+=k[0];
break;
318 case 7: b += k[1]&0xffffff; a+=k[0];
break;
319 case 6: b += k[1]&0xffff; a+=k[0];
break;
320 case 5: b += k[1]&0xff; a+=k[0];
break;
321 case 4: a += k[0];
break;
322 case 3: a += k[0]&0xffffff;
break;
323 case 2: a += k[0]&0xffff;
break;
324 case 1: a += k[0]&0xff;
break;
440 #if defined(_JLU3_jlu32lpair)
441 void jlu32lpair(
const void *key,
size_t size,
462 union {
const void *ptr;
size_t i; } u;
496 if (
UNLIKELY(_running_on_valgrind)) {
500 case 12: c += k[2]; b+=k[1]; a+=k[0];
break;
504 case 8: b += k[1]; a+=k[0];
break;
508 case 4: a += k[0];
break;
511 case 1: a += k8[0];
break;
519 case 12: c += k[2]; b+=k[1]; a+=k[0];
break;
520 case 11: c += k[2]&0xffffff; b+=k[1]; a+=k[0];
break;
521 case 10: c += k[2]&0xffff; b+=k[1]; a+=k[0];
break;
522 case 9: c += k[2]&0xff; b+=k[1]; a+=k[0];
break;
523 case 8: b += k[1]; a+=k[0];
break;
524 case 7: b += k[1]&0xffffff; a+=k[0];
break;
525 case 6: b += k[1]&0xffff; a+=k[0];
break;
526 case 5: b += k[1]&0xff; a+=k[0];
break;
527 case 4: a += k[0];
break;
528 case 3: a += k[0]&0xffffff;
break;
529 case 2: a += k[0]&0xffff;
break;
530 case 1: a += k[0]&0xff;
break;
648 #if defined(_JLU3_jlu32b)
664 union {
const void *ptr;
size_t i; } u;
697 if (
UNLIKELY(_running_on_valgrind)) {
701 case 12: c += k[2]; b+=k[1]; a+=k[0];
break;
705 case 8: b += k[1]; a+=k[0];
break;
709 case 4: a += k[0];
break;
720 case 12: c += k[2]; b+=k[1]; a+=k[0];
break;
721 case 11: c += k[2]&0xffffff00; b+=k[1]; a+=k[0];
break;
722 case 10: c += k[2]&0xffff0000; b+=k[1]; a+=k[0];
break;
723 case 9: c += k[2]&0xff000000; b+=k[1]; a+=k[0];
break;
724 case 8: b += k[1]; a+=k[0];
break;
725 case 7: b += k[1]&0xffffff00; a+=k[0];
break;
726 case 6: b += k[1]&0xffff0000; a+=k[0];
break;
727 case 5: b += k[1]&0xff000000; a+=k[0];
break;
728 case 4: a += k[0];
break;
729 case 3: a += k[0]&0xffffff00;
break;
730 case 2: a += k[0]&0xffff0000;
break;
731 case 1: a += k[0]&0xff000000;
break;
784 #if defined(_JLU3_SELFTEST)
787 static void driver1(
void)
796 for (i=0; i<256; ++
i) buf[i] =
'x';
797 for (i=0; i<1; ++
i) {
798 h = jlu32l(h, &buf[0],
sizeof(buf[0]));
801 if (z-a > 0) printf(
"time %d %.8x\n", (
int)(z-a), h);
809 static void driver2(
void)
812 rpmuint8_t qa[MAXLEN+1], qb[MAXLEN+2], *a = &qa[0], *b = &qb[1];
813 rpmuint32_t c[HASHSTATE],
d[HASHSTATE], i=0,
j=0, k, l, m=0, z;
814 rpmuint32_t e[HASHSTATE],f[HASHSTATE],g[HASHSTATE],h[HASHSTATE];
818 printf(
"No more than %d trials should ever be needed \n",MAXPAIR/2);
819 for (hlen=0; hlen < MAXLEN; ++hlen) {
821 for (i=0; i<hlen; ++
i) {
822 for (
j=0;
j<8; ++
j) {
823 for (m=1; m<8; ++m) {
824 for (l=0; l<HASHSTATE; ++l)
828 for (k=0; k<MAXPAIR; k+=2) {
831 for (l=0; l<hlen+1; ++l) {a[l] = b[l] = (
rpmuint8_t)0;}
835 c[0] = jlu32l(m, a, hlen);
837 b[
i] ^= ((k+1)>>(8-
j));
838 d[0] = jlu32l(m, b, hlen);
840 for (l=0; l<HASHSTATE; ++l) {
842 f[l] &= ~(c[l]^d[l]);
847 if (e[l]|f[l]|g[l]|h[l]|x[l]|y[l]) finished=0;
853 printf(
"Some bit didn't change: ");
854 printf(
"%.8x %.8x %.8x %.8x %.8x %.8x ",
855 e[0],f[0],g[0],h[0],x[0],y[0]);
856 printf(
"i %d j %d m %d len %d\n", i,
j, m, hlen);
858 if (z == MAXPAIR)
goto done;
864 printf(
"Mix success %2d bytes %2d initvals ",i,m);
865 printf(
"required %d trials\n", z/2);
872 static void driver3(
void)
877 rpmuint8_t q[] =
"This is the time for all good men to come to the aid of their country...";
879 rpmuint8_t qq[] =
"xThis is the time for all good men to come to the aid of their country...";
881 rpmuint8_t qqq[] =
"xxThis is the time for all good men to come to the aid of their country...";
883 rpmuint8_t qqqq[] =
"xxxThis is the time for all good men to come to the aid of their country...";
888 printf(
"Endianness. These lines should all be the same (for values filled in):\n");
889 printf(
"%.8x %.8x %.8x\n",
890 jlu32w(m, (
const rpmuint32_t *)q, (
sizeof(q)-1)/4),
891 jlu32w(m, (
const rpmuint32_t *)q, (
sizeof(q)-5)/4),
892 jlu32w(m, (
const rpmuint32_t *)q, (
sizeof(q)-9)/4));
894 printf(
"%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
895 jlu32l(m, p,
sizeof(q)-1), jlu32l(m, p,
sizeof(q)-2),
896 jlu32l(m, p,
sizeof(q)-3), jlu32l(m, p,
sizeof(q)-4),
897 jlu32l(m, p,
sizeof(q)-5), jlu32l(m, p,
sizeof(q)-6),
898 jlu32l(m, p,
sizeof(q)-7), jlu32l(m, p,
sizeof(q)-8),
899 jlu32l(m, p,
sizeof(q)-9), jlu32l(m, p,
sizeof(q)-10),
900 jlu32l(m, p,
sizeof(q)-11), jlu32l(m, p,
sizeof(q)-12));
902 printf(
"%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
903 jlu32l(m, p,
sizeof(q)-1), jlu32l(m, p,
sizeof(q)-2),
904 jlu32l(m, p,
sizeof(q)-3), jlu32l(m, p,
sizeof(q)-4),
905 jlu32l(m, p,
sizeof(q)-5), jlu32l(m, p,
sizeof(q)-6),
906 jlu32l(m, p,
sizeof(q)-7), jlu32l(m, p,
sizeof(q)-8),
907 jlu32l(m, p,
sizeof(q)-9), jlu32l(m, p,
sizeof(q)-10),
908 jlu32l(m, p,
sizeof(q)-11), jlu32l(m, p,
sizeof(q)-12));
910 printf(
"%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
911 jlu32l(m, p,
sizeof(q)-1), jlu32l(m, p,
sizeof(q)-2),
912 jlu32l(m, p,
sizeof(q)-3), jlu32l(m, p,
sizeof(q)-4),
913 jlu32l(m, p,
sizeof(q)-5), jlu32l(m, p,
sizeof(q)-6),
914 jlu32l(m, p,
sizeof(q)-7), jlu32l(m, p,
sizeof(q)-8),
915 jlu32l(m, p,
sizeof(q)-9), jlu32l(m, p,
sizeof(q)-10),
916 jlu32l(m, p,
sizeof(q)-11), jlu32l(m, p,
sizeof(q)-12));
918 printf(
"%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
919 jlu32l(m, p,
sizeof(q)-1), jlu32l(m, p,
sizeof(q)-2),
920 jlu32l(m, p,
sizeof(q)-3), jlu32l(m, p,
sizeof(q)-4),
921 jlu32l(m, p,
sizeof(q)-5), jlu32l(m, p,
sizeof(q)-6),
922 jlu32l(m, p,
sizeof(q)-7), jlu32l(m, p,
sizeof(q)-8),
923 jlu32l(m, p,
sizeof(q)-9), jlu32l(m, p,
sizeof(q)-10),
924 jlu32l(m, p,
sizeof(q)-11), jlu32l(m, p,
sizeof(q)-12));
926 for (h=0, b=buf+1; h<8; ++h, ++
b) {
927 for (i=0; i<MAXLEN; ++
i) {
934 ref = jlu32l(m, b, len);
937 x = jlu32l(m, b, len);
938 y = jlu32l(m, b, len);
939 if ((ref != x) || (ref != y))
940 printf(
"alignment error: %.8x %.8x %.8x %d %d\n",ref,x,y, h, i);
946 static void driver4(
void)
955 for (i=0; i<HASHSTATE; ++
i)
957 printf(
"These should all be different\n");
959 for (i=0; i<8; ++
i) {
960 h = jlu32l(h, buf, 0);
961 printf(
"%2ld 0-byte strings, hash is %.8x\n", (
long)i, h);
966 int main(
int argc,
char ** argv)
const char const double d
const char const char size_t len
int main(int argc, const char **argv, char **envp)
unsigned short rpmuint16_t
#define _JLU3_MIX(a, b, c)
static const union _dbswap endian
unsigned char rpmuint8_t
Private int typedefs to avoid C99 portability issues.
#define HASH_LITTLE_ENDIAN
#define UNLIKELY(value)
To be included after all other includes.
const char const bson * key
#define _JLU3_INIT(_h, _size)
#define _JLU3_FINAL(a, b, c)
_JLU3_FINAL – final mixing of 3 32-bit values (a,b,c) into c
const char const char size_t size