[rustc.git] / src / jemalloc / test / unit / prng.c

#include "test/jemalloc_test.h"

static void
test_prng_lg_range_u32(bool atomic)
{
	uint32_t sa, sb, ra, rb;
	unsigned lg_range;

	sa = 42;
	ra = prng_lg_range_u32(&sa, 32, atomic);
	sa = 42;
	rb = prng_lg_range_u32(&sa, 32, atomic);
	assert_u32_eq(ra, rb,
	    "Repeated generation should produce repeated results");

	sb = 42;
	rb = prng_lg_range_u32(&sb, 32, atomic);
	assert_u32_eq(ra, rb,
	    "Equivalent generation should produce equivalent results");

	sa = 42;
	ra = prng_lg_range_u32(&sa, 32, atomic);
	rb = prng_lg_range_u32(&sa, 32, atomic);
	assert_u32_ne(ra, rb,
	    "Full-width results must not immediately repeat");

	sa = 42;
	ra = prng_lg_range_u32(&sa, 32, atomic);
	for (lg_range = 31; lg_range > 0; lg_range--) {
		sb = 42;
		rb = prng_lg_range_u32(&sb, lg_range, atomic);
		assert_u32_eq((rb & (UINT32_C(0xffffffff) << lg_range)),
		    0, "High order bits should be 0, lg_range=%u", lg_range);
		assert_u32_eq(rb, (ra >> (32 - lg_range)),
		    "Expected high order bits of full-width result, "
		    "lg_range=%u", lg_range);
	}
}

static void
test_prng_lg_range_u64(void)
{
	uint64_t sa, sb, ra, rb;
	unsigned lg_range;

	sa = 42;
	ra = prng_lg_range_u64(&sa, 64);
	sa = 42;
	rb = prng_lg_range_u64(&sa, 64);
	assert_u64_eq(ra, rb,
	    "Repeated generation should produce repeated results");

	sb = 42;
	rb = prng_lg_range_u64(&sb, 64);
	assert_u64_eq(ra, rb,
	    "Equivalent generation should produce equivalent results");

	sa = 42;
	ra = prng_lg_range_u64(&sa, 64);
	rb = prng_lg_range_u64(&sa, 64);
	assert_u64_ne(ra, rb,
	    "Full-width results must not immediately repeat");

	sa = 42;
	ra = prng_lg_range_u64(&sa, 64);
	for (lg_range = 63; lg_range > 0; lg_range--) {
		sb = 42;
		rb = prng_lg_range_u64(&sb, lg_range);
		assert_u64_eq((rb & (UINT64_C(0xffffffffffffffff) << lg_range)),
		    0, "High order bits should be 0, lg_range=%u", lg_range);
		assert_u64_eq(rb, (ra >> (64 - lg_range)),
		    "Expected high order bits of full-width result, "
		    "lg_range=%u", lg_range);
	}
}

static void
test_prng_lg_range_zu(bool atomic)
{
	size_t sa, sb, ra, rb;
	unsigned lg_range;

	sa = 42;
	ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	sa = 42;
	rb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	assert_zu_eq(ra, rb,
	    "Repeated generation should produce repeated results");

	sb = 42;
	rb = prng_lg_range_zu(&sb, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	assert_zu_eq(ra, rb,
	    "Equivalent generation should produce equivalent results");

	sa = 42;
	ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	rb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	assert_zu_ne(ra, rb,
	    "Full-width results must not immediately repeat");

	sa = 42;
	ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	for (lg_range = (ZU(1) << (3 + LG_SIZEOF_PTR)) - 1; lg_range > 0;
	    lg_range--) {
		sb = 42;
		rb = prng_lg_range_zu(&sb, lg_range, atomic);
		assert_zu_eq((rb & (SIZE_T_MAX << lg_range)),
		    0, "High order bits should be 0, lg_range=%u", lg_range);
		assert_zu_eq(rb, (ra >> ((ZU(1) << (3 + LG_SIZEOF_PTR)) -
		    lg_range)), "Expected high order bits of full-width "
		    "result, lg_range=%u", lg_range);
	}
}

TEST_BEGIN(test_prng_lg_range_u32_nonatomic)
{

	test_prng_lg_range_u32(false);
}
TEST_END

TEST_BEGIN(test_prng_lg_range_u32_atomic)
{

	test_prng_lg_range_u32(true);
}
TEST_END

TEST_BEGIN(test_prng_lg_range_u64_nonatomic)
{

	test_prng_lg_range_u64();
}
TEST_END

TEST_BEGIN(test_prng_lg_range_zu_nonatomic)
{

	test_prng_lg_range_zu(false);
}
TEST_END

TEST_BEGIN(test_prng_lg_range_zu_atomic)
{

	test_prng_lg_range_zu(true);
}
TEST_END

static void
test_prng_range_u32(bool atomic)
{
	uint32_t range;
#define	MAX_RANGE	10000000
#define	RANGE_STEP	97
#define	NREPS		10

	for (range = 2; range < MAX_RANGE; range += RANGE_STEP) {
		uint32_t s;
		unsigned rep;

		s = range;
		for (rep = 0; rep < NREPS; rep++) {
			uint32_t r = prng_range_u32(&s, range, atomic);

			assert_u32_lt(r, range, "Out of range");
		}
	}
}

static void
test_prng_range_u64(void)
{
	uint64_t range;
#define	MAX_RANGE	10000000
#define	RANGE_STEP	97
#define	NREPS		10

	for (range = 2; range < MAX_RANGE; range += RANGE_STEP) {
		uint64_t s;
		unsigned rep;

		s = range;
		for (rep = 0; rep < NREPS; rep++) {
			uint64_t r = prng_range_u64(&s, range);

			assert_u64_lt(r, range, "Out of range");
		}
	}
}

static void
test_prng_range_zu(bool atomic)
{
	size_t range;
#define	MAX_RANGE	10000000
#define	RANGE_STEP	97
#define	NREPS		10

	for (range = 2; range < MAX_RANGE; range += RANGE_STEP) {
		size_t s;
		unsigned rep;

		s = range;
		for (rep = 0; rep < NREPS; rep++) {
			size_t r = prng_range_zu(&s, range, atomic);

			assert_zu_lt(r, range, "Out of range");
		}
	}
}

TEST_BEGIN(test_prng_range_u32_nonatomic)
{

	test_prng_range_u32(false);
}
TEST_END

TEST_BEGIN(test_prng_range_u32_atomic)
{

	test_prng_range_u32(true);
}
TEST_END

TEST_BEGIN(test_prng_range_u64_nonatomic)
{

	test_prng_range_u64();
}
TEST_END

TEST_BEGIN(test_prng_range_zu_nonatomic)
{

	test_prng_range_zu(false);
}
TEST_END

TEST_BEGIN(test_prng_range_zu_atomic)
{

	test_prng_range_zu(true);
}
TEST_END

int
main(void)
{

	return (test(
	    test_prng_lg_range_u32_nonatomic,
	    test_prng_lg_range_u32_atomic,
	    test_prng_lg_range_u64_nonatomic,
	    test_prng_lg_range_zu_nonatomic,
	    test_prng_lg_range_zu_atomic,
	    test_prng_range_u32_nonatomic,
	    test_prng_range_u32_atomic,
	    test_prng_range_u64_nonatomic,
	    test_prng_range_zu_nonatomic,
	    test_prng_range_zu_atomic));
}
Commit	Line	Data
54a0048b SL	1	#include "test/jemalloc_test.h"
54a0048b SL	2
3b2f2976 XL	3	static void
	4	test_prng_lg_range_u32(bool atomic)
	5	{
	6	uint32_t sa, sb, ra, rb;
	7	unsigned lg_range;
	8
	9	sa = 42;
	10	ra = prng_lg_range_u32(&sa, 32, atomic);
	11	sa = 42;
	12	rb = prng_lg_range_u32(&sa, 32, atomic);
	13	assert_u32_eq(ra, rb,
	14	"Repeated generation should produce repeated results");
	15
	16	sb = 42;
	17	rb = prng_lg_range_u32(&sb, 32, atomic);
	18	assert_u32_eq(ra, rb,
	19	"Equivalent generation should produce equivalent results");
	20
	21	sa = 42;
	22	ra = prng_lg_range_u32(&sa, 32, atomic);
	23	rb = prng_lg_range_u32(&sa, 32, atomic);
	24	assert_u32_ne(ra, rb,
	25	"Full-width results must not immediately repeat");
	26
	27	sa = 42;
	28	ra = prng_lg_range_u32(&sa, 32, atomic);
	29	for (lg_range = 31; lg_range > 0; lg_range--) {
	30	sb = 42;
	31	rb = prng_lg_range_u32(&sb, lg_range, atomic);
	32	assert_u32_eq((rb & (UINT32_C(0xffffffff) << lg_range)),
	33	0, "High order bits should be 0, lg_range=%u", lg_range);
	34	assert_u32_eq(rb, (ra >> (32 - lg_range)),
	35	"Expected high order bits of full-width result, "
	36	"lg_range=%u", lg_range);
	37	}
	38	}
	39
	40	static void
	41	test_prng_lg_range_u64(void)
54a0048b SL	42	{
	43	uint64_t sa, sb, ra, rb;
	44	unsigned lg_range;
	45
	46	sa = 42;
3b2f2976	47	ra = prng_lg_range_u64(&sa, 64);
54a0048b	48	sa = 42;
3b2f2976	49	rb = prng_lg_range_u64(&sa, 64);
54a0048b SL	50	assert_u64_eq(ra, rb,
	51	"Repeated generation should produce repeated results");
	52
	53	sb = 42;
3b2f2976	54	rb = prng_lg_range_u64(&sb, 64);
54a0048b SL	55	assert_u64_eq(ra, rb,
	56	"Equivalent generation should produce equivalent results");
	57
	58	sa = 42;
3b2f2976 XL	59	ra = prng_lg_range_u64(&sa, 64);
3b2f2976 XL	60	rb = prng_lg_range_u64(&sa, 64);
54a0048b SL	61	assert_u64_ne(ra, rb,
	62	"Full-width results must not immediately repeat");
	63
	64	sa = 42;
3b2f2976	65	ra = prng_lg_range_u64(&sa, 64);
54a0048b SL	66	for (lg_range = 63; lg_range > 0; lg_range--) {
54a0048b SL	67	sb = 42;
3b2f2976	68	rb = prng_lg_range_u64(&sb, lg_range);
54a0048b SL	69	assert_u64_eq((rb & (UINT64_C(0xffffffffffffffff) << lg_range)),
	70	0, "High order bits should be 0, lg_range=%u", lg_range);
	71	assert_u64_eq(rb, (ra >> (64 - lg_range)),
	72	"Expected high order bits of full-width result, "
	73	"lg_range=%u", lg_range);
	74	}
	75	}
3b2f2976 XL	76
	77	static void
	78	test_prng_lg_range_zu(bool atomic)
	79	{
	80	size_t sa, sb, ra, rb;
	81	unsigned lg_range;
	82
	83	sa = 42;
	84	ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	85	sa = 42;
	86	rb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	87	assert_zu_eq(ra, rb,
	88	"Repeated generation should produce repeated results");
	89
	90	sb = 42;
	91	rb = prng_lg_range_zu(&sb, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	92	assert_zu_eq(ra, rb,
	93	"Equivalent generation should produce equivalent results");
	94
	95	sa = 42;
	96	ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	97	rb = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	98	assert_zu_ne(ra, rb,
	99	"Full-width results must not immediately repeat");
	100
	101	sa = 42;
	102	ra = prng_lg_range_zu(&sa, ZU(1) << (3 + LG_SIZEOF_PTR), atomic);
	103	for (lg_range = (ZU(1) << (3 + LG_SIZEOF_PTR)) - 1; lg_range > 0;
	104	lg_range--) {
	105	sb = 42;
	106	rb = prng_lg_range_zu(&sb, lg_range, atomic);
	107	assert_zu_eq((rb & (SIZE_T_MAX << lg_range)),
	108	0, "High order bits should be 0, lg_range=%u", lg_range);
	109	assert_zu_eq(rb, (ra >> ((ZU(1) << (3 + LG_SIZEOF_PTR)) -
	110	lg_range)), "Expected high order bits of full-width "
	111	"result, lg_range=%u", lg_range);
	112	}
	113	}
	114
	115	TEST_BEGIN(test_prng_lg_range_u32_nonatomic)
	116	{
	117
	118	test_prng_lg_range_u32(false);
	119	}
	120	TEST_END
	121
	122	TEST_BEGIN(test_prng_lg_range_u32_atomic)
	123	{
	124
	125	test_prng_lg_range_u32(true);
	126	}
	127	TEST_END
	128
	129	TEST_BEGIN(test_prng_lg_range_u64_nonatomic)
	130	{
	131
	132	test_prng_lg_range_u64();
	133	}
	134	TEST_END
	135
	136	TEST_BEGIN(test_prng_lg_range_zu_nonatomic)
	137	{
	138
	139	test_prng_lg_range_zu(false);
140	}
54a0048b SL	141	TEST_END
54a0048b SL	142
3b2f2976 XL	143	TEST_BEGIN(test_prng_lg_range_zu_atomic)
	144	{
	145
	146	test_prng_lg_range_zu(true);
	147	}
	148	TEST_END
	149
	150	static void
	151	test_prng_range_u32(bool atomic)
	152	{
	153	uint32_t range;
	154	#define MAX_RANGE 10000000
	155	#define RANGE_STEP 97
	156	#define NREPS 10
	157
	158	for (range = 2; range < MAX_RANGE; range += RANGE_STEP) {
	159	uint32_t s;
	160	unsigned rep;
	161
	162	s = range;
	163	for (rep = 0; rep < NREPS; rep++) {
	164	uint32_t r = prng_range_u32(&s, range, atomic);
	165
	166	assert_u32_lt(r, range, "Out of range");
	167	}
	168	}
	169	}
	170
	171	static void
	172	test_prng_range_u64(void)
54a0048b SL	173	{
	174	uint64_t range;
	175	#define MAX_RANGE 10000000
	176	#define RANGE_STEP 97
	177	#define NREPS 10
	178
	179	for (range = 2; range < MAX_RANGE; range += RANGE_STEP) {
	180	uint64_t s;
	181	unsigned rep;
	182
	183	s = range;
	184	for (rep = 0; rep < NREPS; rep++) {
3b2f2976	185	uint64_t r = prng_range_u64(&s, range);
54a0048b SL	186
	187	assert_u64_lt(r, range, "Out of range");
	188	}
	189	}
	190	}
3b2f2976 XL	191
	192	static void
	193	test_prng_range_zu(bool atomic)
	194	{
	195	size_t range;
	196	#define MAX_RANGE 10000000
	197	#define RANGE_STEP 97
	198	#define NREPS 10
	199
	200	for (range = 2; range < MAX_RANGE; range += RANGE_STEP) {
	201	size_t s;
	202	unsigned rep;
	203
	204	s = range;
	205	for (rep = 0; rep < NREPS; rep++) {
	206	size_t r = prng_range_zu(&s, range, atomic);
	207
	208	assert_zu_lt(r, range, "Out of range");
	209	}
	210	}
	211	}
	212
	213	TEST_BEGIN(test_prng_range_u32_nonatomic)
	214	{
	215
	216	test_prng_range_u32(false);
	217	}
	218	TEST_END
	219
	220	TEST_BEGIN(test_prng_range_u32_atomic)
	221	{
	222
	223	test_prng_range_u32(true);
	224	}
	225	TEST_END
	226
	227	TEST_BEGIN(test_prng_range_u64_nonatomic)
	228	{
	229
	230	test_prng_range_u64();
	231	}
	232	TEST_END
	233
	234	TEST_BEGIN(test_prng_range_zu_nonatomic)
	235	{
	236
	237	test_prng_range_zu(false);
	238	}
	239	TEST_END
	240
	241	TEST_BEGIN(test_prng_range_zu_atomic)
	242	{
	243
	244	test_prng_range_zu(true);
	245	}
54a0048b SL	246	TEST_END
	247
	248	int
	249	main(void)
	250	{
	251
	252	return (test(
3b2f2976 XL	253	test_prng_lg_range_u32_nonatomic,
	254	test_prng_lg_range_u32_atomic,
	255	test_prng_lg_range_u64_nonatomic,
	256	test_prng_lg_range_zu_nonatomic,
	257	test_prng_lg_range_zu_atomic,
	258	test_prng_range_u32_nonatomic,
	259	test_prng_range_u32_atomic,
	260	test_prng_range_u64_nonatomic,
	261	test_prng_range_zu_nonatomic,
	262	test_prng_range_zu_atomic));
54a0048b	263	}