Adds compare_test for benchmarking xd3_forward_match, the optimized

version is not yet enabled in xdelta3.c

3 files changed, 137 insertions, 11 deletions

diff --git a/xdelta3/examples/Makefile b/xdelta3/examples/Makefile
index a79d775..0e1825d 100755
--- a/xdelta3/examples/Makefile
+++ b/xdelta3/examples/Makefile
@@ -1,12 +1,12 @@
 #CFLAGS = -g -Wall -I.. -DXD3_DEBUG=1
-CFLAGS = -O3 -pg -Wall -I.. -DXD3_DEBUG=0
+CFLAGS = -O3 -Wall -I.. -DXD3_DEBUG=0 -fno-builtin
 # -pg
 
 SOURCES = small_page_test.c encode_decode_test.c speed_test.c
 
 DEPS = ../*.h ../*.c
 
-TARGETS = small_page_test encode_decode_test speed_test32 speed_test64
+TARGETS = small_page_test encode_decode_test speed_test32 speed_test64 compare_test
 
 all: $(TARGETS)
 
@@ -22,5 +22,8 @@ speed_test32: speed_test.c $(DEPS)
 speed_test64: speed_test.c $(DEPS)
         $(CC) $(CFLAGS) -DXD3_USE_LARGEFILE64=1 speed_test.c -o speed_test64
 
+compare_test: compare_test.c
+        $(CC) $(CFLAGS) compare_test.c -o compare_test
+
 clean:
         rm -f *.exe *.stackdump $(TARGETS)
diff --git a/xdelta3/examples/compare_test.c b/xdelta3/examples/compare_test.c
new file mode 100644
index 0000000..1cc41a8
--- /dev/null
+++ b/xdelta3/examples/compare_test.c
@@ -0,0 +1,121 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <assert.h>
+
+#define NUM (1<<20)
+#define ITERS 100
+
+/* From wikipedia on RDTSC */
+__inline__ uint64_t rdtsc() {
+  uint32_t lo, hi;
+  __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+  return (uint64_t)hi << 32 | lo;
+}
+
+typedef int (*test_func)(const char *s1, const char *s2, int n);
+
+void run_test(const char *buf1, const char *buf2,
+              const char *name, test_func func) {
+  uint64_t start, end;
+  uint64_t accum = 0;
+  int i, x;
+
+  for (i = 0; i < ITERS; i++) {
+    start = rdtsc();
+    x = func(buf1, buf2, NUM);
+    end = rdtsc();
+    accum += end - start;
+    assert(x == NUM - 1);
+  }
+
+  accum /= ITERS;
+
+  printf("%s : %qu cycles\n", name, accum);
+}
+
+/* Build w/ -fno-builtin for this to be fast, this assumes that there
+ * is a difference at s1[n-1] */
+int memcmp_fake(const char *s1, const char *s2, int n) {
+  int x = memcmp(s1, s2, n);
+  return x < 0 ? n - 1 : n + 1;
+}
+
+#define UNALIGNED_OK 1
+static inline int
+test2(const char *s1c, const char *s2c, int n)
+{
+  int i = 0;
+#if UNALIGNED_OK
+  int nint = n / sizeof(int);
+
+  if (nint >> 3)
+    {
+      int j = 0;
+      const int *s1 = (const int*)s1c;
+      const int *s2 = (const int*)s2c;
+      int nint_8 = nint - 8;
+
+      while (i <= nint_8 &&
+             s1[i++] == s2[j++] &&
+             s1[i++] == s2[j++] &&
+             s1[i++] == s2[j++] &&
+             s1[i++] == s2[j++] &&
+             s1[i++] == s2[j++] &&
+             s1[i++] == s2[j++] &&
+             s1[i++] == s2[j++] &&       
+             s1[i++] == s2[j++]) { }
+
+      i = (i - 1) * sizeof(int);
+    }
+#endif
+
+  while (i < n && s1c[i] == s2c[i])
+    {
+      i++;
+    }
+  return i;
+}
+
+static inline int
+test1(const char *s1c, const char *s2c, int n) {
+  int i = 0;
+  while (i < n && s1c[i] == s2c[i])
+    {
+      i++;
+    }
+  return i;
+}
+
+int main(/*int argc, char **argv*/) {
+  char *buf1 = malloc(NUM+1);
+  char *buf2 = malloc(NUM+1);
+  int i;
+
+  for (i = 0; i < NUM; i++) {
+    buf1[i] = buf2[i] = rand();
+  }
+
+  buf2[NUM-1]++;
+
+  printf ("ALIGNED\n");
+
+  run_test(buf1, buf2, "memcmp", &memcmp_fake);
+  run_test(buf1, buf2, "test1", &test1);
+  run_test(buf1, buf2, "test2", &test2);
+
+  for (i = 0; i < NUM; i++) {
+    buf1[i] = buf2[i+1] = rand();
+  }
+
+  buf2[NUM]++;
+
+  printf ("UNALIGNED\n");
+
+  run_test(buf1, buf2+1, "memcmp", &memcmp_fake);
+  run_test(buf1, buf2+1, "test1", &test1);
+  run_test(buf1, buf2+1, "test2", &test2);
+
+  return 0;
+}
diff --git a/xdelta3/examples/speed_test.c b/xdelta3/examples/speed_test.c
index 58e9aca..dea6621 100644
--- a/xdelta3/examples/speed_test.c
+++ b/xdelta3/examples/speed_test.c
@@ -53,22 +53,24 @@ int read_whole_file(const char *name,
 }
 
 int main(int argc, char **argv) {
-  int repeat;
+  int repeat, level;
   char *from, *to;
   uint8_t *from_buf = NULL, *to_buf = NULL, *delta_buf = NULL;
   size_t from_len, to_len, delta_alloc, delta_size = 0;
   long start, finish;
   int i, ret;
-  int flags = XD3_COMPLEVEL_1;
+  int flags;
 
-  if (argc != 4) {
-    fprintf(stderr, "usage: speed_test COUNT FROM TO\n");
+  if (argc != 5) {
+    fprintf(stderr, "usage: speed_test LEVEL COUNT FROM TO\n");
     return 1;
   }
 
-  repeat = atoi(argv[1]);
-  from = argv[2];
-  to = argv[3];
+  level = atoi(argv[1]);
+  repeat = atoi(argv[2]);
+  from = argv[3];
+  to = argv[4];
+  flags = (level << XD3_COMPLEVEL_SHIFT) & XD3_COMPLEVEL_MASK;
 
   if ((ret = read_whole_file(from, &from_buf, &from_len)) ||
       (ret = read_whole_file(to, &to_buf, &to_len))) {
@@ -88,8 +90,8 @@ int main(int argc, char **argv) {
   finish = get_millisecs_now();
 
   fprintf(stderr,
-          "STAT: encode %3ld ms from %s to %s repeat %d %dbit delta %d\n",
-          (finish - start) / repeat, from, to, repeat, sizeof (xoff_t) * 8, delta_size);
+          "STAT: encode %3.2f ms from %s to %s repeat %d %dbit delta %d\n",
+          (double)(finish - start) / repeat, from, to, repeat, sizeof (xoff_t) * 8, delta_size);
 
   ret = 0;