libc: Sync qsort(3) with FreeBSD revision r318515.
r279663: enhance to handle 32-bit aligned data on 64-bit systems r279666: qsort(3): small style(9) cleanups. r288030: Use ANSI C prototypes. Eliminates -Wold-style-definition warnings. r318514: Use size_t. r318515: Reduce the possible recursion level to log2(N) by always recursing on the smaller partition instead. Bug: 38450217 Test: builds, ./tests/run-on-host.sh 64 Change-Id: Ieb622e6f54f8f6d6f62e1bdb491d3b5c8e2f9965
This commit is contained in:
Xin Li
parent
2d36be5912
commit
4b1a3992de
|
|
@ -41,47 +41,53 @@ typedef int cmp_t(void *, const void *, const void *);
|
|||
typedef int cmp_t(const void *, const void *);
|
||||
#endif
|
||||
static inline char *med3(char *, char *, char *, cmp_t *, void *);
|
||||
static inline void swapfunc(char *, char *, int, int);
|
||||
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".
|
||||
*/
|
||||
#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; \
|
||||
} 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
|
||||
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)
|
||||
else if (swaptype_int <= 1)
|
||||
swapcode(int, 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; \
|
||||
} else if (swaptype_int == 0) { \
|
||||
int t = *(int *)(a); \
|
||||
*(int *)(a) = *(int *)(b); \
|
||||
*(int *)(b) = t; \
|
||||
} 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)))
|
||||
|
|
@ -98,24 +104,25 @@ __unused
|
|||
{
|
||||
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 I_AM_QSORT_R
|
||||
void
|
||||
qsort_r(void *a, size_t n, size_t es, void *thunk, cmp_t *cmp)
|
||||
#else
|
||||
#define thunk NULL
|
||||
#define thunk NULL
|
||||
void
|
||||
qsort(void *a, size_t n, size_t es, cmp_t *cmp)
|
||||
#endif
|
||||
{
|
||||
char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
|
||||
size_t d, r;
|
||||
size_t d1, d2;
|
||||
int cmp_result;
|
||||
int swaptype, swap_cnt;
|
||||
int swaptype_long, swaptype_int, swap_cnt;
|
||||
|
||||
loop: SWAPINIT(a, es);
|
||||
loop: SWAPINIT(long, a, es);
|
||||
SWAPINIT(int, a, es);
|
||||
swap_cnt = 0;
|
||||
if (n < 7) {
|
||||
for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
|
||||
|
|
@ -130,7 +137,8 @@ loop: SWAPINIT(a, es);
|
|||
pl = a;
|
||||
pn = (char *)a + (n - 1) * es;
|
||||
if (n > 40) {
|
||||
d = (n / 8) * es;
|
||||
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);
|
||||
|
|
@ -175,21 +183,43 @@ loop: SWAPINIT(a, 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);
|
||||
if ((r = pb - pa) > es)
|
||||
d1 = MIN(pa - (char *)a, pb - pa);
|
||||
vecswap(a, pb - d1, d1);
|
||||
d1 = MIN(pd - pc, pn - pd - es);
|
||||
vecswap(pb, pn - d1, d1);
|
||||
|
||||
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_r(a, r / es, es, thunk, cmp);
|
||||
qsort_r(a, d1 / es, es, thunk, cmp);
|
||||
#else
|
||||
qsort(a, r / es, es, cmp);
|
||||
qsort(a, d1 / es, es, cmp);
|
||||
#endif
|
||||
if ((r = pd - pc) > es) {
|
||||
/* Iterate rather than recurse to save stack space */
|
||||
a = pn - r;
|
||||
n = r / es;
|
||||
goto loop;
|
||||
}
|
||||
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
|
||||
qsort_r(pn - d2, d2 / es, es, thunk, cmp);
|
||||
#else
|
||||
qsort(pn - d2, d2 / es, es, cmp);
|
||||
#endif
|
||||
}
|
||||
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);*/
|
||||
}
|
||||
|
|
|
|||
|
|
@ -88,6 +88,7 @@ cc_test_library {
|
|||
"nl_types_test.cpp",
|
||||
"pthread_test.cpp",
|
||||
"pty_test.cpp",
|
||||
"qsort_test.cpp",
|
||||
"regex_test.cpp",
|
||||
"resolv_test.cpp",
|
||||
"sched_test.cpp",
|
||||
|
|
|
|||
|
|
@ -0,0 +1,106 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "gtest_globals.h"
|
||||
|
||||
#define BUFFER_SIZE 1024
|
||||
|
||||
static int cmp_long(const void *l, const void *r)
|
||||
{
|
||||
|
||||
return (*(long *)l - *(long *)r);
|
||||
}
|
||||
|
||||
static int cmp_int(const void *l, const void *r)
|
||||
{
|
||||
|
||||
return (*(int *)l - *(int *)r);
|
||||
}
|
||||
|
||||
#ifndef arc4random_uniform
|
||||
static bool seeded;
|
||||
|
||||
u_int32_t arc4random_uniform(uint32_t upper_bound)
|
||||
{
|
||||
if (!seeded) {
|
||||
srandom((int)time(NULL));
|
||||
seeded = true;
|
||||
}
|
||||
|
||||
return (random() % upper_bound);
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST(qsort_test, long_test) {
|
||||
long buf[BUFFER_SIZE];
|
||||
long i;
|
||||
|
||||
/* Initialize buffer with known numbers */
|
||||
for (i=0; i<BUFFER_SIZE; i++)
|
||||
buf[i] = i;
|
||||
|
||||
/* Stir 1/4 pairs in the buffer */
|
||||
for (i=0; i<BUFFER_SIZE/4; i++) {
|
||||
u_int32_t pos1, pos2;
|
||||
long t;
|
||||
|
||||
pos1 = arc4random_uniform(BUFFER_SIZE);
|
||||
pos2 = arc4random_uniform(BUFFER_SIZE);
|
||||
|
||||
t = buf[pos1];
|
||||
buf[pos1] = buf[pos2];
|
||||
buf[pos2] = t;
|
||||
}
|
||||
|
||||
/* Sort */
|
||||
qsort(buf, BUFFER_SIZE, sizeof(buf[0]), &cmp_long);
|
||||
|
||||
for (i=0; i<BUFFER_SIZE; i++)
|
||||
EXPECT_EQ(i, buf[i]);
|
||||
}
|
||||
|
||||
TEST(qsort_test, int_test) {
|
||||
int buf[BUFFER_SIZE];
|
||||
int i;
|
||||
|
||||
/* Initialize buffer with known numbers */
|
||||
for (i=0; i<BUFFER_SIZE; i++)
|
||||
buf[i] = i;
|
||||
|
||||
/* Stir 1/4 pairs in the buffer */
|
||||
for (i=0; i<BUFFER_SIZE/4; i++) {
|
||||
u_int32_t pos1, pos2;
|
||||
int t;
|
||||
|
||||
pos1 = arc4random_uniform(BUFFER_SIZE);
|
||||
pos2 = arc4random_uniform(BUFFER_SIZE);
|
||||
|
||||
t = buf[pos1];
|
||||
buf[pos1] = buf[pos2];
|
||||
buf[pos2] = t;
|
||||
}
|
||||
|
||||
/* Sort */
|
||||
qsort(buf, BUFFER_SIZE, sizeof(buf[0]), &cmp_int);
|
||||
|
||||
for (i=0; i<BUFFER_SIZE; i++)
|
||||
EXPECT_EQ(i, buf[i]);
|
||||
}
|
||||
Loading…
Reference in New Issue