kit

qsort.c (5891B)

---

 /* Copyright (C) 2011 by Lynn Ochs
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
  * deal in the Software without restriction, including without limitation the
  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  * sell copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */
 
 /* Minor changes by Rich Felker for integration in musl, 2011-04-27. */
 
 /* Smoothsort, an adaptive variant of Heapsort.  Memory usage: O(1).
    Run time: Worst case O(n log n), close to O(n) in the mostly-sorted case. */
 
 #include <stddef.h>
 #include <stdint.h>
 
 void* memcpy(void* dest, const void* src, size_t n);
 
 typedef int (*cmpfun)(const void*, const void*);
 
 static int ntz(size_t x) {
   int n = 0;
   while ((x & 1) == 0) {
     x >>= 1;
     n++;
   }
   return n;
 }
 
 /* returns index of first bit set, excluding the low bit assumed to always
  * be set, starting from low bit of p[0] up through high bit of p[1] */
 static inline int pntz(size_t p[2]) {
   if (p[0] != 1) return ntz(p[0] - 1);
   if (p[1]) return 8 * sizeof(size_t) + ntz(p[1]);
   return 0;
 }
 
 static void cycle(size_t width, unsigned char* ar[], int n) {
   unsigned char tmp[256];
   size_t l;
   int i;
 
   if (n < 2) {
     return;
   }
 
   ar[n] = tmp;
   while (width) {
     l = sizeof(tmp) < width ? sizeof(tmp) : width;
     memcpy(ar[n], ar[0], l);
     for (i = 0; i < n; i++) {
       memcpy(ar[i], ar[i + 1], l);
       ar[i] += l;
     }
     width -= l;
   }
 }
 
 /* shl() and shr() need n > 0 */
 static inline void shl(size_t p[2], int n) {
   if (n >= 8 * sizeof(size_t)) {
     n -= 8 * sizeof(size_t);
     p[1] = p[0];
     p[0] = 0;
     if (!n) return;
   }
   p[1] <<= n;
   p[1] |= p[0] >> (sizeof(size_t) * 8 - n);
   p[0] <<= n;
 }
 
 static inline void shr(size_t p[2], int n) {
   if (n >= 8 * sizeof(size_t)) {
     n -= 8 * sizeof(size_t);
     p[0] = p[1];
     p[1] = 0;
     if (!n) return;
   }
   p[0] >>= n;
   p[0] |= p[1] << (sizeof(size_t) * 8 - n);
   p[1] >>= n;
 }
 
 /* power-of-two length for working array so that we can mask indices and
  * not depend on any invariant of the algorithm for spatial memory safety.
  * the original size was just 14*sizeof(size_t)+1 */
 #define AR_LEN (16 * sizeof(size_t))
 #define AR_MASK (AR_LEN - 1)
 
 static void sift(unsigned char* head, size_t width, cmpfun cmp, int pshift,
                  size_t lp[]) {
   unsigned char *rt, *lf;
   unsigned char* ar[AR_LEN];
   int i = 1;
 
   ar[0] = head;
   while (pshift > 1) {
     rt = head - width;
     lf = head - width - lp[pshift - 2];
 
     if (cmp(ar[0], lf) >= 0 && cmp(ar[0], rt) >= 0) {
       break;
     }
     if (cmp(lf, rt) >= 0) {
       ar[i++ & AR_MASK] = lf;
       head = lf;
       pshift -= 1;
     } else {
       ar[i++ & AR_MASK] = rt;
       head = rt;
       pshift -= 2;
     }
   }
   cycle(width, ar, i & AR_MASK);
 }
 
 static void trinkle(unsigned char* head, size_t width, cmpfun cmp, size_t pp[2],
                     int pshift, int trusty, size_t lp[]) {
   unsigned char *stepson, *rt, *lf;
   size_t p[2];
   unsigned char* ar[AR_LEN];
   int i = 1;
   int trail;
 
   p[0] = pp[0];
   p[1] = pp[1];
 
   ar[0] = head;
   while (p[0] != 1 || p[1] != 0) {
     stepson = head - lp[pshift];
     if (cmp(stepson, ar[0]) <= 0) {
       break;
     }
     if (!trusty && pshift > 1) {
       rt = head - width;
       lf = head - width - lp[pshift - 2];
       if (cmp(rt, stepson) >= 0 || cmp(lf, stepson) >= 0) {
         break;
       }
     }
 
     ar[i++ & AR_MASK] = stepson;
     head = stepson;
     trail = pntz(p);
     shr(p, trail);
     pshift += trail;
     trusty = 0;
   }
   if (!trusty) {
     cycle(width, ar, i & AR_MASK);
     sift(head, width, cmp, pshift, lp);
   }
 }
 
 __attribute__((weak)) void qsort(void* base, size_t nel, size_t width,
                                  cmpfun cmp) {
   size_t lp[12 * sizeof(size_t)];
   size_t i, size = width * nel;
   unsigned char *head, *high;
   size_t p[2] = {1, 0};
   int pshift = 1;
   int trail;
 
   if (!size) return;
 
   head = base;
   high = head + size - width;
 
   /* Precompute Leonardo numbers, scaled by element width */
   for (lp[0] = lp[1] = width, i = 2;
        (lp[i] = lp[i - 2] + lp[i - 1] + width) < size; i++);
 
   while (head < high) {
     if ((p[0] & 3) == 3) {
       sift(head, width, cmp, pshift, lp);
       shr(p, 2);
       pshift += 2;
     } else {
       if (lp[pshift - 1] >= high - head) {
         trinkle(head, width, cmp, p, pshift, 0, lp);
       } else {
         sift(head, width, cmp, pshift, lp);
       }
 
       if (pshift == 1) {
         shl(p, 1);
         pshift = 0;
       } else {
         shl(p, pshift - 1);
         pshift = 1;
       }
     }
 
     p[0] |= 1;
     head += width;
   }
 
   trinkle(head, width, cmp, p, pshift, 0, lp);
 
   while (pshift != 1 || p[0] != 1 || p[1] != 0) {
     if (pshift <= 1) {
       trail = pntz(p);
       shr(p, trail);
       pshift += trail;
     } else {
       shl(p, 2);
       pshift -= 2;
       p[0] ^= 7;
       shr(p, 1);
       trinkle(head - lp[pshift] - width, width, cmp, p, pshift + 1, 1, lp);
       shl(p, 1);
       p[0] |= 1;
       trinkle(head - width, width, cmp, p, pshift, 1, lp);
     }
     head -= width;
   }
 }