🏗 Add xdelta3 dependency

lib/xdelta3/examples/compare_test.c

@@ -0,0 +1,138 @@
+/* xdelta3 - delta compression tools and library
+   Copyright 2016 Joshua MacDonald
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <assert.h>
+
+#include "xdelta3.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;
+}