1#include "test/jemalloc_test.h"
2
3static size_t
4get_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);
11	assert_d_eq(mallctl("arenas.nhchunks", (void *)&nhchunks, &sz, NULL, 0),
12	    0, "Unexpected mallctl() error");
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);
20	assert_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,
21	    NULL, 0), 0, "Unexpected mallctlbymib() error");
22
23	return (max_size_class);
24}
25
26TEST_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}
81TEST_END
82
83TEST_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}
138TEST_END
139
140TEST_BEGIN(test_overflow)
141{
142	size_t max_size_class;
143
144	max_size_class = get_max_size_class();
145
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");
157	assert_zu_eq(s2u(SIZE_T_MAX), 0,
158	    "s2u() should return 0 on overflow");
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");
173}
174TEST_END
175
176int
177main(void)
178{
179
180	return (test(
181	    test_size_classes,
182	    test_psize_classes,
183	    test_overflow));
184}
185