[UCRT] Import Microsoft.Windows.SDK.CRTSource version 10.0.22621.3

Imported from https://www.nuget.org/packages/Microsoft.Windows.SDK.CRTSource/10.0.22621.3
License: MIT

sdk/lib/ucrt/stdlib/qsort.cpp

@@ -0,0 +1,396 @@
+//
+// qsort.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines qsort(), a routine for sorting arrays.
+//
+#include <corecrt_internal.h>
+#include <search.h>
+
+
+/* Temporarily define optimization macros (to be removed by the build team: RsmqblCompiler alias) */
+#if !defined(BEGIN_PRAGMA_OPTIMIZE_DISABLE)
+#define BEGIN_PRAGMA_OPTIMIZE_DISABLE(flags, bug, reason) \
+    __pragma(optimize(flags, off))
+#define BEGIN_PRAGMA_OPTIMIZE_ENABLE(flags, bug, reason) \
+    __pragma(optimize(flags, on))
+#define END_PRAGMA_OPTIMIZE() \
+    __pragma(optimize("", on))
+#endif
+
+
+// Always compile this module for speed, not size
+BEGIN_PRAGMA_OPTIMIZE_ENABLE("t", MSFT:4499497, "This file is performance-critical and should always be optimized for speed")
+
+
+
+#ifdef _M_CEE
+    #define __fileDECL __clrcall
+#else
+    #define __fileDECL __cdecl
+#endif
+
+
+
+#ifdef __USE_CONTEXT
+    #define __COMPARE(context, p1, p2)                comp(context, p1, p2)
+    #define __SHORTSORT(lo, hi, width, comp, context) shortsort_s(lo, hi, width, comp, context);
+#else
+    #define __COMPARE(context, p1, p2)                comp(p1, p2)
+    #define __SHORTSORT(lo, hi, width, comp, context) shortsort(lo, hi, width, comp);
+#endif
+
+
+
+// Swaps the objects of size 'width' that are pointed to by 'a' and 'b'
+#ifndef _QSORT_SWAP_DEFINED
+#define _QSORT_SWAP_DEFINED
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+static void __fileDECL swap(_Inout_updates_(width) char* a, _Inout_updates_(width) char* b, size_t width)
+{
+    if (a != b)
+    {
+        // Do the swap one character at a time to avoid potential alignment
+        // problems:
+        while (width--)
+        {
+            char const tmp = *a;
+            *a++ = *b;
+            *b++ = tmp;
+        }
+    }
+}
+#endif // _QSORT_SWAP_DEFINED
+
+
+
+// An insertion sort for sorting short arrays.  Sorts the sub-array of elements
+// between lo and hi (inclusive).  Assumes lo < hi.  lo and hi are pointers to
+// the first and last elements in the range to be sorted (note:  hi does not
+// point one-past-the-end).  The comp is a comparer with the same behavior as
+// specified for qsort.
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+#ifdef __USE_CONTEXT
+static void __fileDECL shortsort_s(
+    _Inout_updates_(hi - lo + 1) char*        lo,
+    _Inout_updates_(width)       char*        hi,
+    size_t const width,
+    int (__fileDECL* comp)(void*, void const*, void const*),
+    void*  const context
+    )
+#else // __USE_CONTEXT
+static void __fileDECL shortsort(
+    _Inout_updates_(hi - lo + 1) char*        lo,
+    _Inout_updates_(width)       char*        hi,
+    size_t const width,
+    int (__fileDECL* comp)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+    // Note: in assertions below, i and j are alway inside original bound of
+    // array to sort.
+
+    // Reentrancy diligence: Save (and unset) global-state mode to the stack before making callout to 'compare'
+    __crt_state_management::scoped_global_state_reset saved_state;
+
+    while (hi > lo)
+    {
+        // A[i] <= A[j] for i <= j, j > hi
+        char* max = lo;
+        for (char* p = lo+width; p <= hi; p += width)
+        {
+            // A[i] <= A[max] for lo <= i < p
+            if (__COMPARE(context, p, max) > 0)
+            {
+                max = p;
+            }
+            // A[i] <= A[max] for lo <= i <= p
+        }
+
+        // A[i] <= A[max] for lo <= i <= hi
+
+        swap(max, hi, width);
+
+        // A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi
+
+        hi -= width;
+
+        // A[i] <= A[j] for i <= j, j > hi, loop top condition established
+    }
+
+    // A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
+    // so array is sorted
+}
+
+
+
+// This macro defines the cutoff between using QuickSort and insertion sort for
+// arrays; arrays with lengths shorter or equal to the below value use insertion
+// sort.
+#define CUTOFF 8 // Testing shows that this is a good value.
+
+// Note:  The theoretical number of stack entries required is no more than 1 +
+// log2(num).  But we switch to insertion sort for CUTOFF elements or less, so
+// we really only need 1 + log2(num) - log(CUTOFF) stack entries.  For a CUTOFF
+// of 8, that means we need no more than 30 stack entries for 32-bit platforms
+// and 62 for 64-bit platforms.
+#define STKSIZ (8 * sizeof(void*) - 2)
+
+
+
+// QuickSort function for sorting arrays.  The array is sorted in place.
+// Parameters:
+//  * base:  Pointer to the initial element of the array
+//  * num:   Number of elements in the array
+//  * width: Width of each element in the array, in bytes
+//  * comp:  Pointer to a function returning analog of strcmp for strings, but
+//           supplied by the caller for comparing the array elements.  It
+//           accepts two pointers to elements; returns negative if 1 < 2;
+//           zero if 1 == 2, and positive if 1 > 2.
+#ifndef _M_CEE
+extern "C"
+#endif
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+#ifdef __USE_CONTEXT
+void __fileDECL qsort_s(
+    void*  const base,
+    size_t const num,
+    size_t const width,
+    int (__fileDECL* const comp)(void*, void const*, void const*),
+    void*  const context
+    )
+#else // __USE_CONTEXT
+void __fileDECL qsort(
+    void*  const base,
+    size_t const num,
+    size_t const width,
+    int (__fileDECL* const comp)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+    _VALIDATE_RETURN_VOID(base != nullptr || num == 0, EINVAL);
+    _VALIDATE_RETURN_VOID(width > 0, EINVAL);
+    _VALIDATE_RETURN_VOID(comp != nullptr, EINVAL);
+
+    // A stack for saving the sub-arrays yet to be processed:
+    char* lostk[STKSIZ];
+    char* histk[STKSIZ];
+    int stkptr = 0;
+
+    if (num < 2)
+        return; // Nothing to do:
+
+    // The ends of the sub-array currently being sorted (note that 'hi' points
+    // to the last element, not one-past-the-end):
+    char* lo = static_cast<char*>(base);
+    char* hi = static_cast<char*>(base) + width * (num-1);
+
+    // This entry point is for pseudo-recursion calling: setting
+    // lo and hi and jumping to here is like recursion, but stkptr is
+    // preserved, locals aren't, so we preserve stuff on the stack.
+recurse:
+
+    // The number of elements in the sub-array currently being sorted:
+    size_t const size = (hi - lo) / width + 1;
+
+    // Below a certain size, it is faster to use a O(n^2) sorting method:
+    if (size <= CUTOFF)
+    {
+        __SHORTSORT(lo, hi, width, comp, context);
+    }
+    else
+    {
+        // First we pick a partitioning element.  The efficiency of the
+        // algorithm demands that we find one that is approximately the median
+        // of the values, but also that we select one fast.  We choose the
+        // median of the first, middle, and last elements, to avoid bad
+        // performance in the face of already sorted data, or data that is made
+        // up of multiple sorted runs appended together.  Testing shows that a
+        // median-of-three algorithm provides better performance than simply
+        // picking the middle element for the latter case.
+
+        // Find the middle element:
+        char* mid = lo + (size / 2) * width;
+
+        // Sort the first, middle, last elements into order:
+        if (__COMPARE(context, lo, mid) > 0)
+            swap(lo, mid, width);
+
+        if (__COMPARE(context, lo, hi) > 0)
+            swap(lo, hi, width);
+
+        if (__COMPARE(context, mid, hi) > 0)
+            swap(mid, hi, width);
+
+        // We now wish to partition the array into three pieces, one consisting
+        // of elements <= partition element, one of elements equal to the
+        // partition element, and one of elements > than it.  This is done
+        // below; comments indicate conditions established at every step.
+
+        char* loguy = lo;
+        char* higuy = hi;
+
+        // Note that higuy decreases and loguy increases on every iteration,
+        // so loop must terminate.
+        for (;;)
+        {
+            // lo <= loguy < hi, lo < higuy <= hi,
+            // A[i] <= A[mid] for lo <= i <= loguy,
+            // A[i] > A[mid] for higuy <= i < hi,
+            // A[hi] >= A[mid]
+
+            // The doubled loop is to avoid calling comp(mid,mid), since some
+            // existing comparison funcs don't work when passed the same
+            // value for both pointers.
+
+            if (mid > loguy)
+            {
+                do
+                {
+                    loguy += width;
+                }
+                while (loguy < mid && __COMPARE(context, loguy, mid) <= 0);
+            }
+            if (mid <= loguy)
+            {
+                do
+                {
+                    loguy += width;
+                }
+                while (loguy <= hi && __COMPARE(context, loguy, mid) <= 0);
+            }
+
+            // lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
+            // either loguy > hi or A[loguy] > A[mid]
+
+            do
+            {
+                higuy -= width;
+            }
+            while (higuy > mid && __COMPARE(context, higuy, mid) > 0);
+
+            // lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
+            // either higuy == lo or A[higuy] <= A[mid]
+
+            if (higuy < loguy)
+                break;
+
+            // if loguy > hi or higuy == lo, then we would have exited, so
+            // A[loguy] > A[mid], A[higuy] <= A[mid],
+            // loguy <= hi, higuy > lo
+
+            swap(loguy, higuy, width);
+
+            // If the partition element was moved, follow it.  Only need
+            // to check for mid == higuy, since before the swap,
+            // A[loguy] > A[mid] implies loguy != mid.
+
+            if (mid == higuy)
+                mid = loguy;
+
+            // A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
+            // of loop is re-established
+        }
+
+        //     A[i] <= A[mid] for lo <= i < loguy,
+        //     A[i] > A[mid] for higuy < i < hi,
+        //     A[hi] >= A[mid]
+        //     higuy < loguy
+        // implying:
+        //     higuy == loguy-1
+        //     or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid]
+
+        // Find adjacent elements equal to the partition element.  The
+        // doubled loop is to avoid calling comp(mid,mid), since some
+        // existing comparison funcs don't work when passed the same value
+        // for both pointers.
+
+        higuy += width;
+        if (mid < higuy)
+        {
+            do
+            {
+                higuy -= width;
+            }
+            while (higuy > mid && __COMPARE(context, higuy, mid) == 0);
+        }
+        if (mid >= higuy)
+        {
+            do
+            {
+                higuy -= width;
+            }
+            while (higuy > lo && __COMPARE(context, higuy, mid) == 0);
+        }
+
+        // OK, now we have the following:
+        //    higuy < loguy
+        //    lo <= higuy <= hi
+        //    A[i]  <= A[mid] for lo <= i <= higuy
+        //    A[i]  == A[mid] for higuy < i < loguy
+        //    A[i]  >  A[mid] for loguy <= i < hi
+        //    A[hi] >= A[mid] */
+
+        // We've finished the partition, now we want to sort the subarrays
+        // [lo, higuy] and [loguy, hi].
+        // We do the smaller one first to minimize stack usage.
+        // We only sort arrays of length 2 or more.
+
+        if (higuy - lo >= hi - loguy)
+        {
+            if (lo < higuy)
+            {
+                // Save the big recursion for later:
+                lostk[stkptr] = lo;
+                histk[stkptr] = higuy;
+                ++stkptr;
+            }
+
+            if (loguy < hi)
+            {
+                // Do the small recursion:
+                lo = loguy;
+                goto recurse;
+            }
+        }
+        else
+        {
+            if (loguy < hi)
+            {
+                // Save the big recursion for later:
+                lostk[stkptr] = loguy;
+                histk[stkptr] = hi;
+                ++stkptr;
+            }
+
+            if (lo < higuy)
+            {
+                // Do the small recursion:
+                hi = higuy;
+                goto recurse;
+            }
+        }
+    }
+
+    // We have sorted the array, except for any pending sorts on the stack.
+    // Check if there are any, and sort them:
+    --stkptr;
+    if (stkptr >= 0)
+    {
+        // Pop sub-array from the stack:
+        lo = lostk[stkptr];
+        hi = histk[stkptr];
+        goto recurse;
+    }
+    else
+    {
+        // Otherwise, all sub-arrays have been sorted:
+        return;
+    }
+}
+
+#undef __COMPARE
+#undef __SHORTSORT
+
+END_PRAGMA_OPTIMIZE()