path: root/vppinfra/vppinfra/qsort.c

/*
 * Copyright (c) 2015 Cisco and/or its affiliates.
 * 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.
 */
/*
 * Imported into CLIB by Eliot Dresselhaus from:
 *
 *  This file is part of
 *	MakeIndex - A formatter and format independent index processor
 *
 *  This file is public domain software donated by
 *  Nelson Beebe (beebe@science.utah.edu).
 *
 *  modifications copyright (c) 2003 Cisco Systems, Inc.
 */

#include <vppinfra/clib.h>

/*
 * qsort.c: Our own version of the system qsort routine which is faster by an
 * average of 25%, with lows and highs of 10% and 50%. The THRESHold below is
 * the insertion sort threshold, and has been adjusted for records of size 48
 * bytes. The MTHREShold is where we stop finding a better median.
 */

#define THRESH  4		/* threshold for insertion */
#define MTHRESH 6		/* threshold for median */

typedef struct
{
  word qsz;			/* size of each record */
  word thresh;			/* THRESHold in chars */
  word mthresh;			/* MTHRESHold in chars */
  int (*qcmp) (const void *, const void *);	/* the comparison routine */
} qst_t;

static void qst (qst_t * q, char *base, char *max);

/*
 * qqsort: First, set up some global parameters for qst to share.
 * Then, quicksort with qst(), and then a cleanup insertion sort ourselves.
 * Sound simple?  It's not...
 */

void
qsort (void *base, uword n, uword size,
       int (*compar) (const void *, const void *))
{
  char *i;
  char *j;
  char *lo;
  char *hi;
  char *min;
  char c;
  char *max;
  qst_t _q, *q = &_q;

  if (n <= 1)
    return;

  q->qsz = size;
  q->qcmp = compar;
  q->thresh = q->qsz * THRESH;
  q->mthresh = q->qsz * MTHRESH;
  max = base + n * q->qsz;
  if (n >= THRESH)
    {
      qst (q, base, max);
      hi = base + q->thresh;
    }
  else
    {
      hi = max;
    }
  /*
   * First put smallest element, which must be in the first THRESH, in the
   * first position as a sentinel.  This is done just by searching the
   * first THRESH elements (or the first n if n < THRESH), finding the min,
   * and swapping it into the first position.
   */
  for (j = lo = base; (lo += q->qsz) < hi;)
    {
      if ((*compar) (j, lo) > 0)
	j = lo;
    }
  if (j != base)
    {				/* swap j into place */
      for (i = base, hi = base + q->qsz; i < hi;)
	{
	  c = *j;
	  *j++ = *i;
	  *i++ = c;
	}
    }
  /*
   * With our sentinel in place, we now run the following hyper-fast
   * insertion sort. For each remaining element, min, from [1] to [n-1],
   * set hi to the index of the element AFTER which this one goes. Then, do
   * the standard insertion sort shift on a character at a time basis for
   * each element in the frob.
   */
  for (min = base; (hi = min += q->qsz) < max;)
    {
      while ((*q->qcmp) (hi -= q->qsz, min) > 0);
      if ((hi += q->qsz) != min)
	{
	  for (lo = min + q->qsz; --lo >= min;)
	    {
	      c = *lo;
	      for (i = j = lo; (j -= q->qsz) >= hi; i = j)
		*i = *j;
	      *i = c;
	    }
	}
    }
}



/*
 * qst: Do a quicksort.  First, find the median element, and put that one in
 * the first place as the discriminator.  (This "median" is just the median
 * of the first, last and middle elements).  (Using this median instead of
 * the first element is a big win). Then, the usual partitioning/swapping,
 * followed by moving the discriminator into the right place.  Then, figure
 * out the sizes of the two partions, do the smaller one recursively and the
 * larger one via a repeat of this code.  Stopping when there are less than
 * THRESH elements in a partition and cleaning up with an insertion sort (in
 * our caller) is a huge win. All data swaps are done in-line, which is
 * space-losing but time-saving. (And there are only three places where this
 * is done).
 */

static void
qst (qst_t * q, char *base, char *max)
{
  char *i;
  char *j;
  char *jj;
  char *mid;
  int ii;
  char c;
  char *tmp;
  int lo;
  int hi;
  int qsz = q->qsz;

  lo = (int) (max - base);	/* number of elements as chars */
  do
    {
      /*
       * At the top here, lo is the number of characters of elements in the
       * current partition.  (Which should be max - base). Find the median
       * of the first, last, and middle element and make that the middle
       * element.  Set j to largest of first and middle.  If max is larger
       * than that guy, then it's that guy, else compare max with loser of
       * first and take larger.  Things are set up to prefer the middle,
       * then the first in case of ties.
       */
      mid = i = base + qsz * ((unsigned) (lo / qsz) >> 1);
      if (lo >= q->mthresh)
	{
	  j = ((*q->qcmp) ((jj = base), i) > 0 ? jj : i);
	  if ((*q->qcmp) (j, (tmp = max - qsz)) > 0)
	    {
	      /* switch to first loser */
	      j = (j == jj ? i : jj);
	      if ((*q->qcmp) (j, tmp) < 0)
		j = tmp;
	    }
	  if (j != i)
	    {
	      ii = qsz;
	      do
		{
		  c = *i;
		  *i++ = *j;
		  *j++ = c;
		}
	      while (--ii);
	    }
	}
      /* Semi-standard quicksort partitioning/swapping */
      for (i = base, j = max - qsz;;)
	{
	  while (i < mid && (*q->qcmp) (i, mid) <= 0)
	    i += qsz;
	  while (j > mid)
	    {
	      if ((*q->qcmp) (mid, j) <= 0)
		{
		  j -= qsz;
		  continue;
		}
	      tmp = i + qsz;	/* value of i after swap */
	      if (i == mid)
		{		/* j <-> mid, new mid is j */
		  mid = jj = j;
		}
	      else
		{		/* i <-> j */
		  jj = j;
		  j -= qsz;
		}
	      goto swap;
	    }
	  if (i == mid)
	    {
	      break;
	    }
	  else
	    {			/* i <-> mid, new mid is i */
	      jj = mid;
	      tmp = mid = i;	/* value of i after swap */
	      j -= qsz;
	    }
	swap:
	  ii = qsz;
	  do
	    {
	      c = *i;
	      *i++ = *jj;
	      *jj++ = c;
	    }
	  while (--ii);
	  i = tmp;
	}
      /*
       * Look at sizes of the two partitions, do the smaller one first by
       * recursion, then do the larger one by making sure lo is its size,
       * base and max are update correctly, and branching back. But only
       * repeat (recursively or by branching) if the partition is of at
       * least size THRESH.
       */
      i = (j = mid) + qsz;
      if ((lo = (int) (j - base)) <= (hi = (int) (max - i)))
	{
	  if (lo >= q->thresh)
	    qst (q, base, j);
	  base = i;
	  lo = hi;
	}
      else
	{
	  if (hi >= q->thresh)
	    qst (q, i, max);
	  max = j;
	}
    }
  while (lo >= q->thresh);
}

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */