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

#include "test/jemalloc_test.h"

static size_t
get_max_size_class(void)
{
	unsigned nhchunks;
	size_t mib[4];
	size_t sz, miblen, max_size_class;

	sz = sizeof(unsigned);
	assert_d_eq(mallctl("arenas.nhchunks", (void *)&nhchunks, &sz, NULL, 0),
	    0, "Unexpected mallctl() error");

	miblen = sizeof(mib) / sizeof(size_t);
	assert_d_eq(mallctlnametomib("arenas.hchunk.0.size", mib, &miblen), 0,
	    "Unexpected mallctlnametomib() error");
	mib[2] = nhchunks - 1;

	sz = sizeof(size_t);
	assert_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,
	    NULL, 0), 0, "Unexpected mallctlbymib() error");

	return (max_size_class);
}

TEST_BEGIN(test_size_classes)
{
	size_t size_class, max_size_class;
	szind_t index, max_index;

	max_size_class = get_max_size_class();
	max_index = size2index(max_size_class);

	for (index = 0, size_class = index2size(index); index < max_index ||
	    size_class < max_size_class; index++, size_class =
	    index2size(index)) {
		assert_true(index < max_index,
		    "Loop conditionals should be equivalent; index=%u, "
		    "size_class=%zu (%#zx)", index, size_class, size_class);
		assert_true(size_class < max_size_class,
		    "Loop conditionals should be equivalent; index=%u, "
		    "size_class=%zu (%#zx)", index, size_class, size_class);

		assert_u_eq(index, size2index(size_class),
		    "size2index() does not reverse index2size(): index=%u -->"
		    " size_class=%zu --> index=%u --> size_class=%zu", index,
		    size_class, size2index(size_class),
		    index2size(size2index(size_class)));
		assert_zu_eq(size_class, index2size(size2index(size_class)),
		    "index2size() does not reverse size2index(): index=%u -->"
		    " size_class=%zu --> index=%u --> size_class=%zu", index,
		    size_class, size2index(size_class),
		    index2size(size2index(size_class)));

		assert_u_eq(index+1, size2index(size_class+1),
		    "Next size_class does not round up properly");

		assert_zu_eq(size_class, (index > 0) ?
		    s2u(index2size(index-1)+1) : s2u(1),
		    "s2u() does not round up to size class");
		assert_zu_eq(size_class, s2u(size_class-1),
		    "s2u() does not round up to size class");
		assert_zu_eq(size_class, s2u(size_class),
		    "s2u() does not compute same size class");
		assert_zu_eq(s2u(size_class+1), index2size(index+1),
		    "s2u() does not round up to next size class");
	}

	assert_u_eq(index, size2index(index2size(index)),
	    "size2index() does not reverse index2size()");
	assert_zu_eq(max_size_class, index2size(size2index(max_size_class)),
	    "index2size() does not reverse size2index()");

	assert_zu_eq(size_class, s2u(index2size(index-1)+1),
	    "s2u() does not round up to size class");
	assert_zu_eq(size_class, s2u(size_class-1),
	    "s2u() does not round up to size class");
	assert_zu_eq(size_class, s2u(size_class),
	    "s2u() does not compute same size class");
}
TEST_END

TEST_BEGIN(test_psize_classes)
{
	size_t size_class, max_size_class;
	pszind_t pind, max_pind;

	max_size_class = get_max_size_class();
	max_pind = psz2ind(max_size_class);

	for (pind = 0, size_class = pind2sz(pind); pind < max_pind ||
	    size_class < max_size_class; pind++, size_class =
	    pind2sz(pind)) {
		assert_true(pind < max_pind,
		    "Loop conditionals should be equivalent; pind=%u, "
		    "size_class=%zu (%#zx)", pind, size_class, size_class);
		assert_true(size_class < max_size_class,
		    "Loop conditionals should be equivalent; pind=%u, "
		    "size_class=%zu (%#zx)", pind, size_class, size_class);

		assert_u_eq(pind, psz2ind(size_class),
		    "psz2ind() does not reverse pind2sz(): pind=%u -->"
		    " size_class=%zu --> pind=%u --> size_class=%zu", pind,
		    size_class, psz2ind(size_class),
		    pind2sz(psz2ind(size_class)));
		assert_zu_eq(size_class, pind2sz(psz2ind(size_class)),
		    "pind2sz() does not reverse psz2ind(): pind=%u -->"
		    " size_class=%zu --> pind=%u --> size_class=%zu", pind,
		    size_class, psz2ind(size_class),
		    pind2sz(psz2ind(size_class)));

		assert_u_eq(pind+1, psz2ind(size_class+1),
		    "Next size_class does not round up properly");

		assert_zu_eq(size_class, (pind > 0) ?
		    psz2u(pind2sz(pind-1)+1) : psz2u(1),
		    "psz2u() does not round up to size class");
		assert_zu_eq(size_class, psz2u(size_class-1),
		    "psz2u() does not round up to size class");
		assert_zu_eq(size_class, psz2u(size_class),
		    "psz2u() does not compute same size class");
		assert_zu_eq(psz2u(size_class+1), pind2sz(pind+1),
		    "psz2u() does not round up to next size class");
	}

	assert_u_eq(pind, psz2ind(pind2sz(pind)),
	    "psz2ind() does not reverse pind2sz()");
	assert_zu_eq(max_size_class, pind2sz(psz2ind(max_size_class)),
	    "pind2sz() does not reverse psz2ind()");

	assert_zu_eq(size_class, psz2u(pind2sz(pind-1)+1),
	    "psz2u() does not round up to size class");
	assert_zu_eq(size_class, psz2u(size_class-1),
	    "psz2u() does not round up to size class");
	assert_zu_eq(size_class, psz2u(size_class),
	    "psz2u() does not compute same size class");
}
TEST_END

TEST_BEGIN(test_overflow)
{
	size_t max_size_class;

	max_size_class = get_max_size_class();

	assert_u_eq(size2index(max_size_class+1), NSIZES,
	    "size2index() should return NSIZES on overflow");
	assert_u_eq(size2index(ZU(PTRDIFF_MAX)+1), NSIZES,
	    "size2index() should return NSIZES on overflow");
	assert_u_eq(size2index(SIZE_T_MAX), NSIZES,
	    "size2index() should return NSIZES on overflow");

	assert_zu_eq(s2u(max_size_class+1), 0,
	    "s2u() should return 0 for unsupported size");
	assert_zu_eq(s2u(ZU(PTRDIFF_MAX)+1), 0,
	    "s2u() should return 0 for unsupported size");
	assert_zu_eq(s2u(SIZE_T_MAX), 0,
	    "s2u() should return 0 on overflow");

	assert_u_eq(psz2ind(max_size_class+1), NPSIZES,
	    "psz2ind() should return NPSIZES on overflow");
	assert_u_eq(psz2ind(ZU(PTRDIFF_MAX)+1), NPSIZES,
	    "psz2ind() should return NPSIZES on overflow");
	assert_u_eq(psz2ind(SIZE_T_MAX), NPSIZES,
	    "psz2ind() should return NPSIZES on overflow");

	assert_zu_eq(psz2u(max_size_class+1), 0,
	    "psz2u() should return 0 for unsupported size");
	assert_zu_eq(psz2u(ZU(PTRDIFF_MAX)+1), 0,
	    "psz2u() should return 0 for unsupported size");
	assert_zu_eq(psz2u(SIZE_T_MAX), 0,
	    "psz2u() should return 0 on overflow");
}
TEST_END

int
main(void)
{

	return (test(
	    test_size_classes,
	    test_psize_classes,
	    test_overflow));
}
Commit	Line	Data
54a0048b SL	1	#include "test/jemalloc_test.h"
	2
	3	static size_t
	4	get_max_size_class(void)
	5	{
	6	unsigned nhchunks;
	7	size_t mib[4];
	8	size_t sz, miblen, max_size_class;
	9
	10	sz = sizeof(unsigned);
3b2f2976 XL	11	assert_d_eq(mallctl("arenas.nhchunks", (void *)&nhchunks, &sz, NULL, 0),
3b2f2976 XL	12	0, "Unexpected mallctl() error");
54a0048b SL	13
	14	miblen = sizeof(mib) / sizeof(size_t);
	15	assert_d_eq(mallctlnametomib("arenas.hchunk.0.size", mib, &miblen), 0,
	16	"Unexpected mallctlnametomib() error");
	17	mib[2] = nhchunks - 1;
	18
	19	sz = sizeof(size_t);
3b2f2976 XL	20	assert_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,
3b2f2976 XL	21	NULL, 0), 0, "Unexpected mallctlbymib() error");
54a0048b SL	22
	23	return (max_size_class);
	24	}
	25
	26	TEST_BEGIN(test_size_classes)
	27	{
	28	size_t size_class, max_size_class;
	29	szind_t index, max_index;
	30
	31	max_size_class = get_max_size_class();
	32	max_index = size2index(max_size_class);
	33
	34	for (index = 0, size_class = index2size(index); index < max_index \|\|
	35	size_class < max_size_class; index++, size_class =
	36	index2size(index)) {
	37	assert_true(index < max_index,
	38	"Loop conditionals should be equivalent; index=%u, "
	39	"size_class=%zu (%#zx)", index, size_class, size_class);
	40	assert_true(size_class < max_size_class,
	41	"Loop conditionals should be equivalent; index=%u, "
	42	"size_class=%zu (%#zx)", index, size_class, size_class);
	43
	44	assert_u_eq(index, size2index(size_class),
	45	"size2index() does not reverse index2size(): index=%u -->"
	46	" size_class=%zu --> index=%u --> size_class=%zu", index,
	47	size_class, size2index(size_class),
	48	index2size(size2index(size_class)));
	49	assert_zu_eq(size_class, index2size(size2index(size_class)),
	50	"index2size() does not reverse size2index(): index=%u -->"
	51	" size_class=%zu --> index=%u --> size_class=%zu", index,
	52	size_class, size2index(size_class),
	53	index2size(size2index(size_class)));
	54
	55	assert_u_eq(index+1, size2index(size_class+1),
	56	"Next size_class does not round up properly");
	57
	58	assert_zu_eq(size_class, (index > 0) ?
	59	s2u(index2size(index-1)+1) : s2u(1),
	60	"s2u() does not round up to size class");
	61	assert_zu_eq(size_class, s2u(size_class-1),
	62	"s2u() does not round up to size class");
	63	assert_zu_eq(size_class, s2u(size_class),
	64	"s2u() does not compute same size class");
	65	assert_zu_eq(s2u(size_class+1), index2size(index+1),
	66	"s2u() does not round up to next size class");
	67	}
	68
	69	assert_u_eq(index, size2index(index2size(index)),
	70	"size2index() does not reverse index2size()");
	71	assert_zu_eq(max_size_class, index2size(size2index(max_size_class)),
	72	"index2size() does not reverse size2index()");
	73
	74	assert_zu_eq(size_class, s2u(index2size(index-1)+1),
	75	"s2u() does not round up to size class");
	76	assert_zu_eq(size_class, s2u(size_class-1),
	77	"s2u() does not round up to size class");
	78	assert_zu_eq(size_class, s2u(size_class),
	79	"s2u() does not compute same size class");
	80	}
	81	TEST_END
	82
3b2f2976 XL	83	TEST_BEGIN(test_psize_classes)
	84	{
	85	size_t size_class, max_size_class;
	86	pszind_t pind, max_pind;
	87
	88	max_size_class = get_max_size_class();
	89	max_pind = psz2ind(max_size_class);
	90
	91	for (pind = 0, size_class = pind2sz(pind); pind < max_pind \|\|
	92	size_class < max_size_class; pind++, size_class =
	93	pind2sz(pind)) {
	94	assert_true(pind < max_pind,
	95	"Loop conditionals should be equivalent; pind=%u, "
	96	"size_class=%zu (%#zx)", pind, size_class, size_class);
	97	assert_true(size_class < max_size_class,
	98	"Loop conditionals should be equivalent; pind=%u, "
	99	"size_class=%zu (%#zx)", pind, size_class, size_class);
	100
	101	assert_u_eq(pind, psz2ind(size_class),
	102	"psz2ind() does not reverse pind2sz(): pind=%u -->"
	103	" size_class=%zu --> pind=%u --> size_class=%zu", pind,
	104	size_class, psz2ind(size_class),
	105	pind2sz(psz2ind(size_class)));
	106	assert_zu_eq(size_class, pind2sz(psz2ind(size_class)),
	107	"pind2sz() does not reverse psz2ind(): pind=%u -->"
	108	" size_class=%zu --> pind=%u --> size_class=%zu", pind,
	109	size_class, psz2ind(size_class),
	110	pind2sz(psz2ind(size_class)));
	111
	112	assert_u_eq(pind+1, psz2ind(size_class+1),
	113	"Next size_class does not round up properly");
	114
	115	assert_zu_eq(size_class, (pind > 0) ?
	116	psz2u(pind2sz(pind-1)+1) : psz2u(1),
	117	"psz2u() does not round up to size class");
	118	assert_zu_eq(size_class, psz2u(size_class-1),
	119	"psz2u() does not round up to size class");
	120	assert_zu_eq(size_class, psz2u(size_class),
	121	"psz2u() does not compute same size class");
	122	assert_zu_eq(psz2u(size_class+1), pind2sz(pind+1),
	123	"psz2u() does not round up to next size class");
	124	}
	125
	126	assert_u_eq(pind, psz2ind(pind2sz(pind)),
	127	"psz2ind() does not reverse pind2sz()");
	128	assert_zu_eq(max_size_class, pind2sz(psz2ind(max_size_class)),
	129	"pind2sz() does not reverse psz2ind()");
	130
	131	assert_zu_eq(size_class, psz2u(pind2sz(pind-1)+1),
	132	"psz2u() does not round up to size class");
	133	assert_zu_eq(size_class, psz2u(size_class-1),
	134	"psz2u() does not round up to size class");
	135	assert_zu_eq(size_class, psz2u(size_class),
	136	"psz2u() does not compute same size class");
	137	}
	138	TEST_END
	139
54a0048b SL	140	TEST_BEGIN(test_overflow)
	141	{
	142	size_t max_size_class;
	143
	144	max_size_class = get_max_size_class();
	145
3b2f2976 XL	146	assert_u_eq(size2index(max_size_class+1), NSIZES,
	147	"size2index() should return NSIZES on overflow");
	148	assert_u_eq(size2index(ZU(PTRDIFF_MAX)+1), NSIZES,
	149	"size2index() should return NSIZES on overflow");
	150	assert_u_eq(size2index(SIZE_T_MAX), NSIZES,
	151	"size2index() should return NSIZES on overflow");
	152
	153	assert_zu_eq(s2u(max_size_class+1), 0,
	154	"s2u() should return 0 for unsupported size");
	155	assert_zu_eq(s2u(ZU(PTRDIFF_MAX)+1), 0,
	156	"s2u() should return 0 for unsupported size");
54a0048b SL	157	assert_zu_eq(s2u(SIZE_T_MAX), 0,
54a0048b SL	158	"s2u() should return 0 on overflow");
3b2f2976 XL	159
	160	assert_u_eq(psz2ind(max_size_class+1), NPSIZES,
	161	"psz2ind() should return NPSIZES on overflow");
	162	assert_u_eq(psz2ind(ZU(PTRDIFF_MAX)+1), NPSIZES,
	163	"psz2ind() should return NPSIZES on overflow");
	164	assert_u_eq(psz2ind(SIZE_T_MAX), NPSIZES,
	165	"psz2ind() should return NPSIZES on overflow");
	166
	167	assert_zu_eq(psz2u(max_size_class+1), 0,
	168	"psz2u() should return 0 for unsupported size");
	169	assert_zu_eq(psz2u(ZU(PTRDIFF_MAX)+1), 0,
	170	"psz2u() should return 0 for unsupported size");
	171	assert_zu_eq(psz2u(SIZE_T_MAX), 0,
	172	"psz2u() should return 0 on overflow");
54a0048b SL	173	}
	174	TEST_END
	175
	176	int
	177	main(void)
	178	{
	179
	180	return (test(
	181	test_size_classes,
3b2f2976	182	test_psize_classes,
54a0048b SL	183	test_overflow));
54a0048b SL	184	}