Libc-1439.40.11.tar.gz

[apple/libc.git] / stdlib / FreeBSD / qsort.c

diff --git a/stdlib/FreeBSD/qsort.c b/stdlib/FreeBSD/qsort.c
index 1d0e3c54f46e2a4a8a40b780f2537c00389810ed..b1c5257721b4f88127adf1fc3c2bbba7aadde602 100644 (file)
--- a/stdlib/FreeBSD/qsort.c
+++ b/stdlib/FreeBSD/qsort.c
@@ -10,7 +10,7 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.

- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors

  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *


@@ -31,8 +31,9 @@
 static char sccsid[] = "@(#)qsort.c    8.1 (Berkeley) 6/4/93";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>
 static char sccsid[] = "@(#)qsort.c    8.1 (Berkeley) 6/4/93";
 #endif /* LIBC_SCCS and not lint */
 #include <sys/cdefs.h>

-__FBSDID("$FreeBSD: src/lib/libc/stdlib/qsort.c,v 1.15 2008/01/14 09:21:34 das Exp $");
+__FBSDID("$FreeBSD$");

 
 

+#include <stdbool.h>

 #include <stdlib.h>
 #include <string.h>
 
 #include <stdlib.h>
 #include <string.h>
 


@@ -41,52 +42,54 @@ typedef int          cmp_t(void *, const void *, const void *);
 #else
 typedef int             cmp_t(const void *, const void *);
 #endif
 #else
 typedef int             cmp_t(const void *, const void *);
 #endif

-#ifdef I_AM_QSORT_B
-static inline char     *med3(char *, char *, char *, cmp_t ^, void *) __attribute__((always_inline));
-#else
-static inline char     *med3(char *, char *, char *, cmp_t *, void *) __attribute__((always_inline));
-#endif
-static inline void      swapfunc(char *, char *, int, int) __attribute__((always_inline));
+static inline char     *med3(char *, char *, char *, cmp_t *, void *);
+static inline void      swapfunc(char *, char *, size_t, int, int);

 
 

-#define min(a, b)      (a) < (b) ? a : b
+#define        MIN(a, b)       ((a) < (b) ? a : b)

 
 /*
  * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
  */
 
 /*
  * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
  */

-#define swapcode(TYPE, parmi, parmj, n) {              \
-       long i = (n) / sizeof (TYPE);                   \
-       TYPE *pi = (TYPE *) (parmi);            \
-       TYPE *pj = (TYPE *) (parmj);            \
+#define        swapcode(TYPE, parmi, parmj, n) {               \
+       size_t i = (n) / sizeof (TYPE);                 \
+       TYPE *pi = (TYPE *) (parmi);            \
+       TYPE *pj = (TYPE *) (parmj);            \

        do {                                            \
                TYPE    t = *pi;                \
                *pi++ = *pj;                            \
                *pj++ = t;                              \
        do {                                            \
                TYPE    t = *pi;                \
                *pi++ = *pj;                            \
                *pj++ = t;                              \

-        } while (--i > 0);                             \
+       } while (--i > 0);                              \

 }
 
 }
 

-#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
-       es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
+#define        SWAPINIT(TYPE, a, es) swaptype_ ## TYPE =       \
+       ((char *)a - (char *)0) % sizeof(TYPE) ||       \
+       es % sizeof(TYPE) ? 2 : es == sizeof(TYPE) ? 0 : 1;

 
 static inline void
 
 static inline void

-swapfunc(a, b, n, swaptype)
-       char *a, *b;
-       int n, swaptype;
+swapfunc(char *a, char *b, size_t n, int swaptype_long, int swaptype_int)

 {
 {

-       if(swaptype <= 1)
+       if (swaptype_long <= 1)

                swapcode(long, a, b, n)
                swapcode(long, a, b, n)

+       else if (swaptype_int <= 1)
+               swapcode(int, a, b, n)

        else
                swapcode(char, a, b, n)
 }
 
        else
                swapcode(char, a, b, n)
 }
 

-#define swap(a, b)                                     \
-       if (swaptype == 0) {                            \
+#define        swap(a, b)                                      \
+       if (swaptype_long == 0) {                       \

                long t = *(long *)(a);                  \
                *(long *)(a) = *(long *)(b);            \
                *(long *)(b) = t;                       \
                long t = *(long *)(a);                  \
                *(long *)(a) = *(long *)(b);            \
                *(long *)(b) = t;                       \

+       } else if (swaptype_int == 0) {                 \
+               int t = *(int *)(a);                    \
+               *(int *)(a) = *(int *)(b);              \
+               *(int *)(b) = t;                        \

        } else                                          \
        } else                                          \

-               swapfunc(a, b, es, swaptype)
+               swapfunc(a, b, es, swaptype_long, swaptype_int)

 
 

-#define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
+#define        vecswap(a, b, n)                                \
+       if ((n) > 0) swapfunc(a, b, n, swaptype_long, swaptype_int)

 
 #ifdef I_AM_QSORT_R
 #define        CMP(t, x, y) (cmp((t), (x), (y)))
 
 #ifdef I_AM_QSORT_R
 #define        CMP(t, x, y) (cmp((t), (x), (y)))


@@ -94,14 +97,11 @@ swapfunc(a, b, n, swaptype)
 #define        CMP(t, x, y) (cmp((x), (y)))
 #endif
 
 #define        CMP(t, x, y) (cmp((x), (y)))
 #endif
 

+/*
+ * Find the median of 3 elements
+ */

 static inline char *
 static inline char *

-med3(char *a, char *b, char *c,
-#ifdef I_AM_QSORT_B
-cmp_t ^cmp,
-#else
-cmp_t *cmp,
-#endif
-void *thunk
+med3(char *a, char *b, char *c, cmp_t *cmp, void *thunk

 #ifndef I_AM_QSORT_R
 __unused
 #endif
 #ifndef I_AM_QSORT_R
 __unused
 #endif


@@ -109,7 +109,7 @@ __unused
 {
        return CMP(thunk, a, b) < 0 ?
               (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a ))
 {
        return CMP(thunk, a, b) < 0 ?
               (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a ))

-              :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));
+             :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c ));

 }
 
 #ifdef __LP64__
 }
 
 #ifdef __LP64__


@@ -122,63 +122,97 @@ __unused
 int __heapsort_r(void *, size_t, size_t, void *, int (*)(void *, const void *, const void *));
 #endif
 
 int __heapsort_r(void *, size_t, size_t, void *, int (*)(void *, const void *, const void *));
 #endif
 

-static void
-_qsort(void *a, size_t n, size_t es,
+/*
+ * Simple insertion sort routine.
+ */
+static bool
+_isort(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp, int swap_limit, int swaptype_long, int swaptype_int)
+{
+       int swap_cnt = 0;
+       for (char *pm = (char *)a + es; pm < (char *)a + n * es; pm += es) {
+               for (char *pl = pm; pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
+                               pl -= es) {
+                       swap(pl, pl - es);
+                       if (swap_limit && ++swap_cnt > swap_limit) return false;
+               }
+       }
+       return true;
+}
+

 #ifdef I_AM_QSORT_R
 #ifdef I_AM_QSORT_R

-void *thunk,
-#else
-#define thunk  NULL
-#endif
-#ifdef I_AM_QSORT_B
-cmp_t ^cmp,
+static void
+_qsort(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp, int depth_limit)

 #else
 #else

-cmp_t *cmp,
+#define        thunk NULL
+static void
+_qsort(void *a, size_t n, size_t es, cmp_t *cmp, int depth_limit)

 #endif
 #endif

-int depth_limit)

 {
        char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
 {
        char *pa, *pb, *pc, *pd, *pl, *pm, *pn;

-       size_t d, r;
+       size_t d1, d2;

        int cmp_result;
        int cmp_result;

-       int swaptype, swap_cnt;
+       int swaptype_long, swaptype_int, swap_cnt;

 
 loop:
 
 loop:

+       SWAPINIT(long, a, es);
+       SWAPINIT(int, a, es);
+       swap_cnt = 0;
+

        if (depth_limit-- <= 0) {
        if (depth_limit-- <= 0) {

-#ifdef I_AM_QSORT_B
-               heapsort_b(a, n, es, cmp);
-#elif defined(I_AM_QSORT_R)
+               /*
+                * We've hit our recursion limit, switch to heapsort
+                */
+#ifdef I_AM_QSORT_R

                __heapsort_r(a, n, es, thunk, cmp);
 #else
                heapsort(a, n, es, cmp);
 #endif
                return;
        }
                __heapsort_r(a, n, es, thunk, cmp);
 #else
                heapsort(a, n, es, cmp);
 #endif
                return;
        }

-       SWAPINIT(a, es);
-       swap_cnt = 0;
-       if (n < 7) {
-               for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
-                       for (pl = pm; 
-                            pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
-                            pl -= es)
-                               swap(pl, pl - es);
+
+       if (n <= 7) {
+               /*
+                * For sufficiently small inputs, we'll just insertion sort.
+                *
+                * Pass 0 as swap limit, since this must complete.
+                */
+               _isort(a, n, es, thunk, cmp, 0, swaptype_long, swaptype_int);

                return;
        }
                return;
        }

+
+       /*
+        * Compute the pseudomedian.  Small arrays use 3 samples, large ones use 9.
+        */
+       pl = a;

        pm = (char *)a + (n / 2) * es;
        pm = (char *)a + (n / 2) * es;

-       if (n > 7) {
-               pl = a;
-               pn = (char *)a + (n - 1) * es;
-               if (n > 40) {
-                       d = (n / 8) * es;
-                       pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk);
-                       pm = med3(pm - d, pm, pm + d, cmp, thunk);
-                       pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk);
-               }
-               pm = med3(pl, pm, pn, cmp, thunk);
+       pn = (char *)a + (n - 1) * es;
+       if (n > 40) {
+               size_t d = (n / 8) * es;
+
+               pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk);
+               pm = med3(pm - d, pm, pm + d, cmp, thunk);
+               pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk);

        }
        }

+       pm = med3(pl, pm, pn, cmp, thunk);
+
+       /*
+        * Pull the median to the front, starting us with:
+        *
+        * +-+-------------+
+        * |=|      ?      |
+        * +-+-------------+
+        * a pa,pb         pc,pd
+        */

        swap(a, pm);
        pa = pb = (char *)a + es;
        swap(a, pm);
        pa = pb = (char *)a + es;

-

        pc = pd = (char *)a + (n - 1) * es;
        pc = pd = (char *)a + (n - 1) * es;

+

        for (;;) {
        for (;;) {

+               /*
+                * - Move b forward while it's less than the median
+                * - Move c backwards while it's greater than the median
+                * - When equal to the median, swap to the outside
+                */

                while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) {
                        if (cmp_result == 0) {
                                swap_cnt = 1;
                while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) {
                        if (cmp_result == 0) {
                                swap_cnt = 1;


@@ -203,45 +237,78 @@ loop:
                pc -= es;
        }
 
                pc -= es;
        }
 

+       /*
+        * Now we've got:
+        *
+        * +---+-----+-----+---+
+        * | = |  <  |  >  | = |
+        * +---+-----+-----+---+
+        * a   pa  pc,pb   pd  pn
+        *
+        * So swap the '=' into the middle
+        */
+

        pn = (char *)a + n * es;
        pn = (char *)a + n * es;

-       r = min(pa - (char *)a, pb - pa);
-       vecswap(a, pb - r, r);
-       r = min(pd - pc, pn - pd - es);
-       vecswap(pb, pn - r, r);
+       d1 = MIN(pa - (char *)a, pb - pa);
+       vecswap(a, pb - d1, d1);
+       d1 = MIN(pd - pc, pn - pd - es);
+       vecswap(pb, pn - d1, d1);
+
+       /*
+        * +-----+---+---+-----+
+        * |  <  |   =   |  >  |
+        * +-----+---+---+-----+
+        * a                   pn
+        */

 
        if (swap_cnt == 0) {  /* Switch to insertion sort */
 
        if (swap_cnt == 0) {  /* Switch to insertion sort */

-               r = 1 + n / 4; /* n >= 7, so r >= 2 */
-               for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
-                       for (pl = pm; 
-                            pl > (char *)a && CMP(thunk, pl - es, pl) > 0;
-                            pl -= es) {
-                               swap(pl, pl - es);
-                               if (++swap_cnt > r) goto nevermind;
-                       }
+               int r = 1 + n / 4; /* n > 7, so r >= 2 */
+               if (!_isort(a, n, es, thunk, cmp, r, swaptype_long, swaptype_int)) {
+                       goto nevermind;
+               }

                return;
        }
                return;
        }

-

 nevermind:
 nevermind:

-       if ((r = pb - pa) > es)
+
+       d1 = pb - pa;
+       d2 = pd - pc;
+       if (d1 <= d2) {
+               /* Recurse on left partition, then iterate on right partition */
+               if (d1 > es) {
+#ifdef I_AM_QSORT_R
+                       _qsort(a, d1 / es, es, thunk, cmp, depth_limit);
+#else
+                       _qsort(a, d1 / es, es, cmp, depth_limit);
+#endif
+               }
+               if (d2 > es) {
+                       /* Iterate rather than recurse to save stack space */
+                       /* qsort(pn - d2, d2 / es, es, cmp); */
+                       a = pn - d2;
+                       n = d2 / es;
+                       goto loop;
+               }
+       } else {
+               /* Recurse on right partition, then iterate on left partition */
+               if (d2 > es) {

 #ifdef I_AM_QSORT_R
 #ifdef I_AM_QSORT_R

-               _qsort(a, r / es, es, thunk, cmp, depth_limit);
+                       _qsort(pn - d2, d2 / es, es, thunk, cmp, depth_limit);

 #else
 #else

-               _qsort(a, r / es, es, cmp, depth_limit);
+                       _qsort(pn - d2, d2 / es, es, cmp, depth_limit);

 #endif
 #endif

-       if ((r = pd - pc) > es) {
-               /* Iterate rather than recurse to save stack space */
-               a = pn - r;
-               n = r / es;
-               goto loop;
+               }
+               if (d1 > es) {
+                       /* Iterate rather than recurse to save stack space */
+                       /* qsort(a, d1 / es, es, cmp); */
+                       n = d1 / es;
+                       goto loop;
+               }

        }
        }

-/*             qsort(pn - r, r / es, es, cmp);*/

 }
 
 void
 #ifdef I_AM_QSORT_R
 qsort_r(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp)
 }
 
 void
 #ifdef I_AM_QSORT_R
 qsort_r(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp)

-#elif defined(I_AM_QSORT_B)
-qsort_b(void *a, size_t n, size_t es, cmp_t ^cmp)

 #else
 qsort(void *a, size_t n, size_t es, cmp_t *cmp)
 #endif
 #else
 qsort(void *a, size_t n, size_t es, cmp_t *cmp)
 #endif