Closes #3320 move fast x1764 to main line.

{{{
svn merge -r29081:29083 https://svn.tokutek.com/tokudb/toku/tokudb.3320
}}}
close[t:3320]  (Note that #3340 and #3341 cover moving this to 5.0.2 and 5.1.2)
.


git-svn-id: file:///svn/toku/tokudb@29108 c7de825b-a66e-492c-adef-691d508d4ae1

newbrt/tests/x1764-test.c

@@ -70,10 +70,33 @@ test2 (void) {
 	}
     }
 }
+
+static void
+test3 (void)
+// Compare the simple version to the highly optimized verison.
+{
+    const int datalen = 1000;
+    char data[datalen];
+    for (int i=0; i<datalen; i++) data[i]=random();
+    for (int off=0; off<32; off++) {
+	if (verbose) {printf("."); fflush(stdout);}
+	for (int len=0; len+off<datalen; len++) {
+	    u_int32_t reference_sum = x1764_memory_simple(data+off, len);
+	    u_int32_t fast_sum      = x1764_memory       (data+off, len);
+	    assert(reference_sum==fast_sum);
+	}
+    }
+}
+
 int
 test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) {
+    if (verbose) printf("0\n");
     test0();
+    if (verbose) printf("1\n");
     test1();
+    if (verbose) printf("2\n");
     test2();
+    if (verbose) printf("3\n");
+    test3();
     return 0;
 }

newbrt/x1764-speedup/x1764-speedup-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+#ident "$Id$"
+#ident "Copyright (c) 2011 Tokutek Inc.  All rights reserved."
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+u_int64_t x1764_simple (const u_int64_t *buf, size_t len)
+{
+    u_int64_t sum=0;
+    for (size_t i=0; i<len ;i++) {
+	sum = sum*17 + buf[i];
+    }
+    return sum;
+}
+
+u_int64_t x1764_2x (const u_int64_t *buf, size_t len)
+{
+    assert(len%2==0);
+    u_int64_t suma=0, sumb=0;
+    for (size_t i=0; i<len ;i+=2) {
+	suma = suma*(17L*17L) + buf[i];
+	sumb = sumb*(17L*17L) + buf[i+1];
+    }
+    return suma*17+sumb;
+}
+
+u_int64_t x1764_3x (const u_int64_t *buf, size_t len)
+{
+    assert(len%3==0);
+    u_int64_t suma=0, sumb=0, sumc=0;
+    for (size_t i=0; i<len ;i+=3) {
+	suma = suma*(17LL*17LL*17LL) + buf[i];
+	sumb = sumb*(17LL*17LL*17LL) + buf[i+1];
+	sumc = sumc*(17LL*17LL*17LL) + buf[i+2];
+    }
+    u_int64_t r = suma*17L*17L + sumb*17L + sumc;
+    return r;
+}
+
+u_int64_t x1764_4x (const u_int64_t *buf, size_t len)
+{
+    assert(len%4==0);
+    u_int64_t suma=0, sumb=0, sumc=0, sumd=0;
+    for (size_t i=0; i<len ;i+=4) {
+	suma = suma*(17LL*17LL*17LL*17LL) + buf[i];
+	sumb = sumb*(17LL*17LL*17LL*17LL) + buf[i+1];
+	sumc = sumc*(17LL*17LL*17LL*17LL) + buf[i+2];
+	sumd = sumd*(17LL*17LL*17LL*17LL) + buf[i+3];
+    }
+    return suma*17L*17L*17L + sumb*17L*17L + sumc*17L + sumd;
+
+}
+
+float tdiff (struct timeval *start, struct timeval *end) {
+    return (end->tv_sec-start->tv_sec) +1e-6*(end->tv_usec - start->tv_usec);
+}
+
+int main (int argc, char *argv[]) {
+    int size = 1024*1024*4 + 8*4;
+    char *data = malloc(size);
+    for (int j=0; j<4; j++) {
+	struct timeval start,end,end2,end3,end4;
+	for (int i=0; i<size; i++) data[i]=i*i+j;
+	gettimeofday(&start, 0);
+	u_int64_t s = x1764_simple((u_int64_t*)data, size/sizeof(u_int64_t));
+	gettimeofday(&end,   0);
+	u_int64_t s2 = x1764_2x((u_int64_t*)data, size/sizeof(u_int64_t));
+	gettimeofday(&end2,   0);
+	u_int64_t s3 = x1764_3x((u_int64_t*)data, size/sizeof(u_int64_t));
+	gettimeofday(&end3,   0);
+	u_int64_t s4 = x1764_4x((u_int64_t*)data, size/sizeof(u_int64_t));
+	gettimeofday(&end4,   0);
+	assert(s==s2);
+	assert(s==s3);
+	assert(s==s4);
+	double b1 = tdiff(&start, &end);
+	double b2 = tdiff(&end, &end2);
+	double b3 = tdiff(&end2, &end3);
+	double b4 = tdiff(&end3, &end4);
+	printf("s=%016llx t=%.6fs %.6fs (%4.2fx), %.6fs (%4.2fx), %.6fs (%4.2fx) [%5.2f MB/s]\n",
+	       (unsigned long long)s,
+	       b1, b2, b1/b2, b3, b1/b3, b4, b1/b4, (size/b4)/(1024*1024));
+    }
+    return 0;
+}

newbrt/x1764.c

@@ -6,7 +6,8 @@
 
 #define PRINT 0
 
-u_int32_t x1764_memory (const void *buf, int len)
+
+u_int32_t x1764_memory_simple (const void *buf, int len)
 {
     const u_int64_t *lbuf=buf;
     u_int64_t c=0;
@@ -28,6 +29,37 @@ u_int32_t x1764_memory (const void *buf, int len)
     return ~((c&0xFFFFFFFF) ^ (c>>32));
 }
 
+u_int32_t x1764_memory (const void *vbuf, int len)
+{
+    const u_int8_t *buf = vbuf;
+    int len_4_words = 4*sizeof(u_int64_t);
+    u_int64_t suma=0, sumb=0, sumc=0, sumd=0;
+    while (len >= len_4_words) {
+	suma = suma*(17LL*17LL*17LL*17LL) + *(u_int64_t*)(buf +0*sizeof(u_int64_t));
+	sumb = sumb*(17LL*17LL*17LL*17LL) + *(u_int64_t*)(buf +1*sizeof(u_int64_t));
+	sumc = sumc*(17LL*17LL*17LL*17LL) + *(u_int64_t*)(buf +2*sizeof(u_int64_t));
+	sumd = sumd*(17LL*17LL*17LL*17LL) + *(u_int64_t*)(buf +3*sizeof(u_int64_t));
+	buf += len_4_words;
+	len -= len_4_words;
+    }
+    u_int64_t sum = suma*17L*17L*17L + sumb*17L*17L + sumc*17L + sumd;
+    assert(len>=0);
+    while ((u_int64_t)len>=sizeof(u_int64_t)) {
+	sum = sum*17 + *(u_int64_t*)buf;
+	buf+=sizeof(u_int64_t);
+	len-=sizeof(u_int64_t);
+    }
+    if (len>0) {
+	u_int64_t tailsum = 0;
+	for (int i=0; i<len; i++) {
+	    tailsum |= ((u_int64_t)(buf[i]))<<(8*i);
+	}
+	sum = sum*17 + tailsum;
+    }
+    return ~((sum&0xFFFFFFFF) ^ (sum>>32));
+}
+
+
 void x1764_init(struct x1764 *l) {
     l->sum=0;
     l->input=0;

newbrt/x1764.h

@@ -19,6 +19,10 @@ extern "C" {
 u_int32_t x1764_memory (const void *buf, int len);
 // Effect: Compute x1764 on the bytes of buf.  Return the 32 bit answer.
 
+u_int32_t x1764_memory_simple (const void *buf, int len);
+// Effect: Same as x1764_memory, but not highly optimized (more likely to be correct).  Useful for testing the optimized version.
+
+
 // For incrementally computing an x1764, use the following interfaces.
 struct x1764 {
     u_int64_t sum;