527 lines
12 KiB
C
527 lines
12 KiB
C
/*
|
|
* vlibc — rand/srand, abs/div, qsort/bsearch test (todo 12).
|
|
*
|
|
* Exercises the stdlib todo-12 additions end to end:
|
|
*
|
|
* 1. qsort on 0 and 1 element (the comparator is never called), 2048
|
|
* pseudo-random ints, duplicate-heavy, reverse-sorted, and
|
|
* all-equal arrays — each verified ascending with the element-sum
|
|
* checksum preserved.
|
|
* 2. bsearch finds a present key and returns NULL for an absent one.
|
|
* 3. rand is deterministic per seed and stays inside [0, RAND_MAX];
|
|
* div(7,3) == {2,1}, div(-7,3) == {-2,-1}, ldiv/lldiv spot checks;
|
|
* abs/labs/llabs basics plus the INT_MIN/LONG_MIN/LLONG_MIN wrap
|
|
* through volatile locals so the compiler cannot fold the negation.
|
|
* 4. Level 2: rand_r determinism and independence from rand()'s
|
|
* global state, srand48 reseed determinism, drand48 samples in
|
|
* [0,1), lrand48 in [0,2^31), erand48 stepping the caller's xsubi.
|
|
*
|
|
* The instrumented comparator counts calls and records any call where
|
|
* both arguments point at the same element; every scenario asserts the
|
|
* self-compare flag stays clear.
|
|
*
|
|
* The -f mode stress-sorts three static-BSS arrays of 100000 ints
|
|
* (reverse-sorted, already-sorted, all-equal) with the instrumented
|
|
* comparator, verifies ascending order and an O(n log n) comparison
|
|
* count (< 5.2M, far below the ~5e9 an O(n^2) sort would need), and
|
|
* exits plainly — nothing here writes errno, so a normal return is
|
|
* safe.
|
|
*
|
|
* All diagnostics go through raw SYS_write (no stdio): under -Iinclude
|
|
* the vlibc public headers shadow GCC's internal ones, so a host
|
|
* <stdio.h> would not compile. The stdlib.h below is vlibc's own.
|
|
*
|
|
* Not part of the library proper; compiled manually for this todo (the
|
|
* tests/ + make check wiring is owned by a later todo).
|
|
*/
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include "../include/stdlib.h"
|
|
|
|
#include "../src/internal/syscall.h"
|
|
|
|
static int failures;
|
|
|
|
/* Write a NUL-terminated string to fd via the raw syscall layer. */
|
|
static void
|
|
say(int fd, const char *s)
|
|
{
|
|
long n = 0;
|
|
|
|
while (s[n] != '\0')
|
|
{
|
|
n++;
|
|
}
|
|
__syscall3(SYS_write, fd, (long)s, n);
|
|
}
|
|
|
|
/* Write v in decimal to fd. */
|
|
static void
|
|
say_dec(int fd, unsigned long v) // NOLINT(bugprone-easily-swappable-parameters)
|
|
{
|
|
char buf[24];
|
|
int i = (int)sizeof(buf);
|
|
|
|
buf[--i] = '\0';
|
|
do
|
|
{
|
|
buf[--i] = (char)('0' + (v % 10));
|
|
v /= 10;
|
|
} while (v != 0);
|
|
__syscall3(SYS_write, fd, (long)(buf + i), (long)(sizeof(buf) - 1 - i));
|
|
}
|
|
|
|
static void
|
|
check(int cond, const char *what)
|
|
{
|
|
if (cond)
|
|
{
|
|
say(1, "PASS: ");
|
|
say(1, what);
|
|
say(1, "\n");
|
|
}
|
|
else
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, what);
|
|
say(2, "\n");
|
|
failures++;
|
|
}
|
|
}
|
|
|
|
/* xorshift32; deterministic, allocation-independent. */
|
|
static unsigned
|
|
rng_next(unsigned *state)
|
|
{
|
|
unsigned x = *state;
|
|
|
|
x ^= x << 13;
|
|
x ^= x >> 17;
|
|
x ^= x << 5;
|
|
*state = x;
|
|
return x;
|
|
}
|
|
|
|
/* Instrumented int comparator: counts calls and records self-compares. */
|
|
static long compar_count;
|
|
static int self_compare_seen;
|
|
|
|
static int
|
|
int_cmp(const void *a, const void *b)
|
|
{
|
|
const int *pa = a;
|
|
const int *pb = b;
|
|
|
|
compar_count++;
|
|
if (a == b)
|
|
{
|
|
self_compare_seen = 1;
|
|
}
|
|
if (*pa < *pb)
|
|
{
|
|
return -1;
|
|
}
|
|
if (*pa > *pb)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Sort arr (n ints) and verify ascending order and a preserved sum. */
|
|
static int
|
|
sort_and_verify(int *arr, size_t n, const char *what)
|
|
{
|
|
size_t i;
|
|
long long before = 0;
|
|
long long after = 0;
|
|
int asc = 1;
|
|
int ok = 1;
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
before += arr[i];
|
|
}
|
|
compar_count = 0;
|
|
qsort(arr, n, sizeof(int), int_cmp);
|
|
for (i = 1; i < n; i++)
|
|
{
|
|
if (arr[i - 1] > arr[i])
|
|
{
|
|
asc = 0;
|
|
}
|
|
}
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
after += arr[i];
|
|
}
|
|
if (!asc)
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, what);
|
|
say(2, " - not ascending\n");
|
|
failures++;
|
|
ok = 0;
|
|
}
|
|
if (before != after)
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, what);
|
|
say(2, " - element sum changed\n");
|
|
failures++;
|
|
ok = 0;
|
|
}
|
|
if (ok)
|
|
{
|
|
say(1, "PASS: ");
|
|
say(1, what);
|
|
say(1, "\n");
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
static void
|
|
qsort_scenarios(void)
|
|
{
|
|
enum
|
|
{
|
|
N = 2048
|
|
};
|
|
int arr[N];
|
|
unsigned i;
|
|
unsigned rng = 0x2545F491U;
|
|
int one = 7;
|
|
|
|
compar_count = 0;
|
|
qsort(arr, 0, sizeof(int), int_cmp);
|
|
qsort(&one, 1, sizeof(int), int_cmp);
|
|
check(compar_count == 0, "qsort(0) and qsort(1) never call the comparator");
|
|
|
|
for (i = 0; i < N; i++)
|
|
{
|
|
arr[i] = (int)rng_next(&rng);
|
|
}
|
|
sort_and_verify(arr, N, "2048 pseudo-random ints sort");
|
|
|
|
for (i = 0; i < N; i++)
|
|
{
|
|
arr[i] = (int)(i % 7);
|
|
}
|
|
sort_and_verify(arr, N, "2048 duplicate-heavy ints sort");
|
|
|
|
for (i = 0; i < N; i++)
|
|
{
|
|
arr[i] = (int)(N - 1 - i);
|
|
}
|
|
sort_and_verify(arr, N, "2048 reverse-sorted ints sort");
|
|
|
|
for (i = 0; i < N; i++)
|
|
{
|
|
arr[i] = 5;
|
|
}
|
|
sort_and_verify(arr, N, "2048 all-equal ints sort");
|
|
|
|
check(self_compare_seen == 0, "comparator never saw the same element twice");
|
|
}
|
|
|
|
static void
|
|
bsearch_tests(void)
|
|
{
|
|
int arr[16];
|
|
unsigned i;
|
|
int key;
|
|
int *p;
|
|
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
arr[i] = (int)(i * 2);
|
|
}
|
|
key = 14;
|
|
p = bsearch(&key, arr, 16, sizeof(int), int_cmp);
|
|
check(p != NULL && *p == key, "bsearch finds a present key");
|
|
key = 13;
|
|
p = bsearch(&key, arr, 16, sizeof(int), int_cmp);
|
|
check(p == NULL, "bsearch returns NULL for an absent key");
|
|
check(self_compare_seen == 0, "bsearch never self-compared");
|
|
}
|
|
|
|
static void
|
|
rand_tests(void)
|
|
{
|
|
int a[8];
|
|
int b[8];
|
|
unsigned i;
|
|
int same = 1;
|
|
int in_range = 1;
|
|
|
|
srand(1);
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
a[i] = rand();
|
|
}
|
|
srand(1);
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
b[i] = rand();
|
|
}
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
if (a[i] != b[i])
|
|
{
|
|
same = 0;
|
|
}
|
|
}
|
|
check(same, "srand(1) twice gives identical rand sequences");
|
|
srand(12345);
|
|
for (i = 0; i < 1000; i++)
|
|
{
|
|
int v = rand();
|
|
|
|
if (v < 0 || v > RAND_MAX)
|
|
{
|
|
in_range = 0;
|
|
}
|
|
}
|
|
check(in_range, "rand values stay within [0, RAND_MAX]");
|
|
}
|
|
|
|
static void
|
|
div_tests(void)
|
|
{
|
|
div_t d = div(7, 3);
|
|
ldiv_t ld = ldiv(17L, 5L);
|
|
ldiv_t ldn = ldiv(-17L, 5L);
|
|
lldiv_t lld = lldiv(1000000000000000LL, 3LL);
|
|
|
|
check(d.quot == 2 && d.rem == 1, "div(7,3) == {2,1}");
|
|
d = div(-7, 3);
|
|
check(d.quot == -2 && d.rem == -1, "div(-7,3) == {-2,-1}");
|
|
check(ld.quot == 3L && ld.rem == 2L, "ldiv(17,5) == {3,2}");
|
|
check(ldn.quot == -3L && ldn.rem == -2L, "ldiv(-17,5) == {-3,-2}");
|
|
check(lld.quot == 333333333333333LL && lld.rem == 1LL, "lldiv(10^15,3) == {333333333333333,1}");
|
|
}
|
|
|
|
/*
|
|
* noipa proxies for the abs family: GCC knows abs/labs/llabs as const
|
|
* builtins whose result lies in [0, type_MAX], so even with a volatile
|
|
* argument its value-range analysis proves `abs(vi) == INT_MIN` false
|
|
* and folds the check before the call. noipa blocks interprocedural
|
|
* propagation through the proxy (the repo's established pattern, see
|
|
* the SIZE_MAX-10 handling above); the volatile locals then force the
|
|
* wrap values to exist at runtime.
|
|
*/
|
|
static __attribute__((noipa)) int
|
|
abs_proxy(int n)
|
|
{
|
|
return abs(n);
|
|
}
|
|
|
|
static __attribute__((noipa)) long
|
|
labs_proxy(long n)
|
|
{
|
|
return labs(n);
|
|
}
|
|
|
|
static __attribute__((noipa)) long long
|
|
llabs_proxy(long long n)
|
|
{
|
|
return llabs(n);
|
|
}
|
|
|
|
static void
|
|
abs_tests(void)
|
|
{
|
|
volatile int vi = INT_MIN;
|
|
volatile long vl = LONG_MIN;
|
|
volatile long long vll = LLONG_MIN;
|
|
|
|
check(abs(-7) == 7 && abs(7) == 7, "abs basics");
|
|
check(labs(-7L) == 7L, "labs basics");
|
|
check(llabs(-7LL) == 7LL, "llabs basics");
|
|
check(abs_proxy(vi) == INT_MIN, "abs(INT_MIN) wraps to INT_MIN");
|
|
check(labs_proxy(vl) == LONG_MIN, "labs(LONG_MIN) wraps to LONG_MIN");
|
|
check(llabs_proxy(vll) == LLONG_MIN, "llabs(LLONG_MIN) wraps to LLONG_MIN");
|
|
}
|
|
|
|
#if VLIBC_LEVEL_GE(2)
|
|
static void
|
|
rand_r_tests(void)
|
|
{
|
|
unsigned s1 = 123;
|
|
unsigned s2 = 123;
|
|
unsigned s3 = 99;
|
|
int r1 = rand_r(&s1);
|
|
int r2 = rand_r(&s2);
|
|
int before;
|
|
int after;
|
|
|
|
check(r1 == r2 && s1 == s2, "rand_r: equal seeds give equal results and state");
|
|
srand(7);
|
|
before = rand();
|
|
rand_r(&s3);
|
|
rand();
|
|
srand(7);
|
|
after = rand();
|
|
check(before == after, "rand_r does not disturb rand's global state");
|
|
s1 = 5;
|
|
s2 = 5;
|
|
rand();
|
|
rand();
|
|
check(rand_r(&s1) == rand_r(&s2), "rand_r independent of interleaved rand() calls");
|
|
}
|
|
|
|
static void
|
|
drand48_tests(void)
|
|
{
|
|
double d1;
|
|
double d2;
|
|
unsigned i;
|
|
int ok = 1;
|
|
unsigned short xs[3] = {0x330E, 0xABCD, 0x1234};
|
|
double e1 = erand48(xs);
|
|
|
|
srand48(42);
|
|
d1 = drand48();
|
|
srand48(42);
|
|
d2 = drand48();
|
|
check(d1 == d2, "srand48 reseed gives deterministic drand48");
|
|
srand48(1);
|
|
for (i = 0; i < 1000; i++)
|
|
{
|
|
double v = drand48();
|
|
|
|
if (!(v >= 0.0 && v < 1.0))
|
|
{
|
|
ok = 0;
|
|
}
|
|
}
|
|
check(ok, "drand48: 1000 samples in [0,1)");
|
|
srand48(2);
|
|
ok = 1;
|
|
for (i = 0; i < 1000; i++)
|
|
{
|
|
long v = lrand48();
|
|
|
|
if (v < 0 || v >= 2147483648L)
|
|
{
|
|
ok = 0;
|
|
}
|
|
}
|
|
check(ok, "lrand48: 1000 samples in [0, 2^31)");
|
|
check(!(xs[0] == 0x330E && xs[1] == 0xABCD && xs[2] == 0x1234),
|
|
"erand48 steps the caller's xsubi in place");
|
|
srand48(0x1234ABCDL);
|
|
check(e1 == drand48(), "erand48(default xsubi) matches srand48(0x1234ABCD) drand48");
|
|
}
|
|
#endif /* VLIBC_LEVEL_GE(2) */
|
|
|
|
/* -f mode: three 100k-element stress sorts from static BSS (no malloc). */
|
|
#define BIG_N 100000
|
|
|
|
static int big_array[BIG_N];
|
|
|
|
static int
|
|
stress_case(const char *label)
|
|
{
|
|
unsigned i;
|
|
int asc = 1;
|
|
|
|
compar_count = 0;
|
|
qsort(big_array, BIG_N, sizeof(int), int_cmp);
|
|
for (i = 1; i < BIG_N; i++)
|
|
{
|
|
if (big_array[i - 1] > big_array[i])
|
|
{
|
|
asc = 0;
|
|
}
|
|
}
|
|
say(1, label);
|
|
say(1, " comparisons: ");
|
|
say_dec(1, (unsigned long)compar_count);
|
|
say(1, "\n");
|
|
if (!asc)
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, label);
|
|
say(2, " - not ascending\n");
|
|
return 1;
|
|
}
|
|
if (compar_count >= 5200000L)
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, label);
|
|
say(2, " - comparisons >= 5200000 (not O(n log n))\n");
|
|
return 1;
|
|
}
|
|
if (self_compare_seen)
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, label);
|
|
say(2, " - self-compare observed\n");
|
|
return 1;
|
|
}
|
|
say(1, "PASS: ");
|
|
say(1, label);
|
|
say(1, "\n");
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
stress_mode(void)
|
|
{
|
|
unsigned i;
|
|
int rc = 0;
|
|
|
|
self_compare_seen = 0;
|
|
for (i = 0; i < BIG_N; i++)
|
|
{
|
|
big_array[i] = (int)(BIG_N - 1 - i);
|
|
}
|
|
rc |= stress_case("100k reverse-sorted");
|
|
|
|
for (i = 0; i < BIG_N; i++)
|
|
{
|
|
big_array[i] = (int)i;
|
|
}
|
|
rc |= stress_case("100k already-sorted");
|
|
|
|
for (i = 0; i < BIG_N; i++)
|
|
{
|
|
big_array[i] = 42;
|
|
}
|
|
rc |= stress_case("100k all-equal");
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'f')
|
|
{
|
|
return stress_mode();
|
|
}
|
|
|
|
qsort_scenarios();
|
|
bsearch_tests();
|
|
rand_tests();
|
|
div_tests();
|
|
abs_tests();
|
|
#if VLIBC_LEVEL_GE(2)
|
|
rand_r_tests();
|
|
drand48_tests();
|
|
#endif
|
|
|
|
if (failures > 0)
|
|
{
|
|
say(2, "FAILED (");
|
|
say_dec(2, (unsigned long)failures);
|
|
say(2, " check(s))\n");
|
|
return 1;
|
|
}
|
|
say(1, "all rand/div/qsort/bsearch tests passed\n");
|
|
return 0;
|
|
}
|