From: Martin Mares <mj@ucw.cz>
Date: Sat, 4 Jan 2003 15:25:06 +0000 (+0000)
Subject: Added generic array sorter.
X-Git-Tag: holmes-import~1310
X-Git-Url: http://mj.ucw.cz/gitweb/?a=commitdiff_plain;h=c08795753ea2d9a9b12d857f7b22b69c757b66e1;p=libucw.git

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 ad93507d..e8b60206 100644
--- 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
index 00000000..316bcd20
--- /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
index 00000000..e2085423
--- /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;
+}