Added generic array sorter.

Benchmark results on my K6/400MHz:
mj@albireo:~/src/sherlock/run$ bin/asort-test
qsort: 19209 ms
asort: 7544 ms

diff --git a/lib/Makefile b/lib/Makefile
index ad93507dacf6dd896bd95e777525889f917e94a4..e8b6020664996068072d3e4e49a169488ada872f 100644 (file)
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -1,4 +1,4 @@
-# Makefile for the Sherlock Library (c) 1997--2002 Martin Mares <mj@ucw.cz>
+# Makefile for the Sherlock Library (c) 1997--2003 Martin Mares <mj@ucw.cz>
 
 DIRS+=lib
 PROGS+=obj/lib/db-tool obj/lib/buckettool
@@ -25,6 +25,7 @@ obj/lib/lfs-test: obj/lib/lfs-test.o obj/lib/libsh.$(LS)
 obj/lib/regex-test: obj/lib/regex-test.o obj/lib/libsh.$(LS)
 obj/lib/hash-test: obj/lib/hash-test.o obj/lib/libsh.$(LS)
 obj/lib/str-test: obj/lib/str-test.o obj/lib/libsh.$(LS)
+obj/lib/asort-test: obj/lib/asort-test.o obj/lib/libsh.$(LS)
 
 include lib/perl/Makefile
 include lib/shell/Makefile

diff --git a/lib/arraysort.h b/lib/arraysort.h
new file mode 100644 (file)
index 0000000..316bcd2
--- /dev/null
+++ b/lib/arraysort.h
@@ -0,0 +1,167 @@
+/*
+ *     Sherlock Library -- Universal Array Sorter
+ *
+ *     (c) 2003 Martin Mares <mj@ucw.cz>
+ *
+ *     This software may be freely distributed and used according to the terms
+ *     of the GNU Lesser General Public License.
+ */
+
+/*
+ *  This is not a normal header file, it's a generator of sorting
+ *  routines.  Each time you include it with parameters set in the
+ *  corresponding preprocessor macros, it generates an array sorter
+ *  with the parameters given.
+ *
+ *  You might wonder why the heck do we implement our own array sorter
+ *  instead of using qsort(). The primary reason is that qsort handles
+ *  only continuous arrays, but we need to sort array-like data structures
+ *  where the only way to access elements is by using an indexing macro.
+ *  Besides that, we are more than 2 times faster.
+ *
+ *  So much for advocacy, there are the parameters (those marked with [*]
+ *  are mandatory):
+ *
+ *  ASORT_PREFIX(x) [*]        add a name prefix (used on all global names
+ *                     defined by the sorter)
+ *  ASORT_KEY_TYPE  [*]        data type of a single array entry key
+ *  ASORT_ELT(i)    [*]        returns the key of i-th element
+ *  ASORT_LT(x,y)      x < y for ASORT_TYPE (default: "x<y")
+ *  ASORT_SWAP(i,j)    swap i-th and j-th element (default: assume _ELT
+ *                     is a l-value and swap just the keys)
+ *  ASORT_THRESHOLD    threshold for switching between quicksort and insertsort
+ *
+ *  After including this file, a function ASORT_PREFIX(sort)(uns array_size)
+ *  is declared and all parameter macros are automatically undef'd.
+ */
+
+#ifndef ASORT_LT
+#define ASORT_LT(x,y) ((x) < (y))
+#endif
+
+#ifndef ASORT_SWAP
+#define ASORT_SWAP(i,j) do { ASORT_KEY_TYPE tmp = ASORT_ELT(i); ASORT_ELT(i)=ASORT_ELT(j); ASORT_ELT(j)=tmp; } while (0)
+#endif
+
+#ifndef ASORT_THRESHOLD
+#define ASORT_THRESHOLD 8              /* Guesswork and experimentation */
+#endif
+
+static void ASORT_PREFIX(sort)(uns array_size)
+{
+  struct stk { int l, r; } stack[8*sizeof(uns)];
+  int l, r, left, right, m;
+  uns sp = 0;
+  ASORT_KEY_TYPE pivot;
+
+  if (array_size <= 1)
+    return;
+
+  /* QuickSort with optimizations a'la Sedgewick, but stop at ASORT_THRESHOLD */
+
+  left = 0;
+  right = array_size - 1;
+  for(;;)
+    {
+      l = left;
+      r = right;
+      m = (l+r)/2;
+      if (ASORT_LT(ASORT_ELT(m), ASORT_ELT(l)))
+       ASORT_SWAP(l,m);
+      if (ASORT_LT(ASORT_ELT(r), ASORT_ELT(m)))
+       {
+         ASORT_SWAP(m,r);
+         if (ASORT_LT(ASORT_ELT(m), ASORT_ELT(l)))
+           ASORT_SWAP(l,m);
+       }
+      pivot = ASORT_ELT(m);
+      do
+       {
+         while (ASORT_LT(ASORT_ELT(l), pivot))
+           l++;
+         while (ASORT_LT(pivot, ASORT_ELT(r)))
+           r--;
+         if (l < r)
+           {
+             ASORT_SWAP(l,r);
+             l++;
+             r--;
+           }
+         else if (l == r)
+           {
+             l++;
+             r--;
+           }
+       }
+      while (l <= r);
+      if ((r - left) > ASORT_THRESHOLD && (right - l) > ASORT_THRESHOLD)
+       {
+         /* Both partitions ok => push the larger one */
+         if ((r - left) > (right - l))
+           {
+             stack[sp].l = left;
+             stack[sp].r = r;
+             left = l;
+           }
+         else
+           {
+             stack[sp].l = l;
+             stack[sp].r = right;
+             right = r;
+           }
+         sp++;
+       }
+      else if ((r - left) > ASORT_THRESHOLD)
+       {
+         /* Left partition OK, right undersize */
+         right = r;
+       }
+      else if ((right - l) > ASORT_THRESHOLD)
+       {
+         /* Right partition OK, left undersize */
+         left = l;
+       }
+      else
+       {
+         /* Both partitions undersize => pop */
+         if (!sp)
+           break;
+         sp--;
+         left = stack[sp].l;
+         right = stack[sp].r;
+       }
+    }
+
+  /*
+   * We have a partially sorted array, finish by insertsort. Inspired
+   * by qsort() in GNU libc.
+   */
+
+  /* Find minimal element which will serve as a barrier */
+  r = MIN(array_size, ASORT_THRESHOLD);
+  m = 0;
+  for (l=1; l<r; l++)
+    if (ASORT_LT(ASORT_ELT(l),ASORT_ELT(m)))
+      m = l;
+  ASORT_SWAP(0,m);
+
+  /* Insertion sort */
+  for (m=1; m<(int)array_size; m++)
+    {
+      l=m;
+      while (ASORT_LT(ASORT_ELT(m),ASORT_ELT(l-1)))
+       l--;
+      while (l < m)
+       {
+         ASORT_SWAP(l,m);
+         l++;
+       }
+    }
+}
+
+#undef ASORT_PREFIX
+#undef ASORT_TYPE
+#undef ASORT_ELT
+#undef ASORT_EQ
+#undef ASORT_SWAP
+#undef ASORT_THRESHOLD

diff --git a/lib/asort-test.c b/lib/asort-test.c
new file mode 100644 (file)
index 0000000..e208542
--- /dev/null
+++ b/lib/asort-test.c
@@ -0,0 +1,75 @@
+/*
+ *     Sherlock Library -- Universal Array Sorter Test and Benchmark
+ *
+ *     (c) 2003 Martin Mares <mj@ucw.cz>
+ *
+ *     This software may be freely distributed and used according to the terms
+ *     of the GNU Lesser General Public License.
+ */
+
+#include "lib/lib.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 4000037                      /* a prime */
+
+struct elt {
+  u32 key;
+  u32 x, y;
+};
+
+static struct elt array[N];
+
+#define ASORT_KEY_TYPE u32
+#define ASORT_ELT(i) array[i].key
+#define ASORT_SWAP(i,j) do { struct elt e=array[j]; array[j]=array[i]; array[i]=e; } while(0)
+
+static void generate(void)
+{
+  uns i;
+  for (i=0; i<N; i++)
+#if 0
+    ASORT_ELT(i) = N-i-1;
+#elif 0
+    ASORT_ELT(i) = i;
+#else
+    ASORT_ELT(i) = (i ? ASORT_ELT(i-1)+1944833754 : 3141592) % N;
+#endif
+}
+
+static void check(void)
+{
+  uns i;
+  for (i=0; i<N; i++)
+    if (ASORT_ELT(i) != i)
+      printf("error at pos %d: %08x != %08x\n", i, ASORT_ELT(i), i);
+}
+
+static int qs_comp(const struct elt *X, const struct elt *Y)
+{
+  if (X->key < Y->key)
+    return -1;
+  else if (X->key > Y->key)
+    return 1;
+  else
+    return 0;
+}
+
+#define ASORT_PREFIX(x) as_##x
+#include "lib/arraysort.h"
+
+int main(void)
+{
+  generate();
+  init_timer();
+  qsort(array, N, sizeof(array[0]), (int (*)(const void *, const void *)) qs_comp);
+  printf("qsort: %d ms\n", get_timer());
+  check();
+  generate();
+  init_timer();
+  as_sort(N);  
+  printf("asort: %d ms\n", get_timer());
+  check();
+  return 0;
+}