1 #include "test/jemalloc_test.h"
2
3 static size_t
get_max_size_class(void)4 get_max_size_class(void)
5 {
6 unsigned nlextents;
7 size_t mib[4];
8 size_t sz, miblen, max_size_class;
9
10 sz = sizeof(unsigned);
11 assert_d_eq(mallctl("arenas.nlextents", (void *)&nlextents, &sz, NULL,
12 0), 0, "Unexpected mallctl() error");
13
14 miblen = sizeof(mib) / sizeof(size_t);
15 assert_d_eq(mallctlnametomib("arenas.lextent.0.size", mib, &miblen), 0,
16 "Unexpected mallctlnametomib() error");
17 mib[2] = nlextents - 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
TEST_BEGIN(test_size_classes)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
TEST_BEGIN(test_psize_classes)83 TEST_BEGIN(test_psize_classes)
84 {
85 size_t size_class, max_psz;
86 pszind_t pind, max_pind;
87
88 max_psz = get_max_size_class() + PAGE;
89 max_pind = psz2ind(max_psz);
90
91 for (pind = 0, size_class = pind2sz(pind); pind < max_pind || size_class
92 < max_psz; pind++, size_class = pind2sz(pind)) {
93 assert_true(pind < max_pind,
94 "Loop conditionals should be equivalent; pind=%u, "
95 "size_class=%zu (%#zx)", pind, size_class, size_class);
96 assert_true(size_class < max_psz,
97 "Loop conditionals should be equivalent; pind=%u, "
98 "size_class=%zu (%#zx)", pind, size_class, size_class);
99
100 assert_u_eq(pind, psz2ind(size_class),
101 "psz2ind() does not reverse pind2sz(): pind=%u -->"
102 " size_class=%zu --> pind=%u --> size_class=%zu", pind,
103 size_class, psz2ind(size_class),
104 pind2sz(psz2ind(size_class)));
105 assert_zu_eq(size_class, pind2sz(psz2ind(size_class)),
106 "pind2sz() does not reverse psz2ind(): pind=%u -->"
107 " size_class=%zu --> pind=%u --> size_class=%zu", pind,
108 size_class, psz2ind(size_class),
109 pind2sz(psz2ind(size_class)));
110
111 assert_u_eq(pind+1, psz2ind(size_class+1),
112 "Next size_class does not round up properly");
113
114 assert_zu_eq(size_class, (pind > 0) ?
115 psz2u(pind2sz(pind-1)+1) : psz2u(1),
116 "psz2u() does not round up to size class");
117 assert_zu_eq(size_class, psz2u(size_class-1),
118 "psz2u() does not round up to size class");
119 assert_zu_eq(size_class, psz2u(size_class),
120 "psz2u() does not compute same size class");
121 assert_zu_eq(psz2u(size_class+1), pind2sz(pind+1),
122 "psz2u() does not round up to next size class");
123 }
124
125 assert_u_eq(pind, psz2ind(pind2sz(pind)),
126 "psz2ind() does not reverse pind2sz()");
127 assert_zu_eq(max_psz, pind2sz(psz2ind(max_psz)),
128 "pind2sz() does not reverse psz2ind()");
129
130 assert_zu_eq(size_class, psz2u(pind2sz(pind-1)+1),
131 "psz2u() does not round up to size class");
132 assert_zu_eq(size_class, psz2u(size_class-1),
133 "psz2u() does not round up to size class");
134 assert_zu_eq(size_class, psz2u(size_class),
135 "psz2u() does not compute same size class");
136 }
137 TEST_END
138
TEST_BEGIN(test_overflow)139 TEST_BEGIN(test_overflow)
140 {
141 size_t max_size_class, max_psz;
142
143 max_size_class = get_max_size_class();
144 max_psz = max_size_class + PAGE;
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), max_psz,
168 "psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported"
169 " size");
170 assert_zu_eq(psz2u(ZU(PTRDIFF_MAX)+1), max_psz,
171 "psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported "
172 "size");
173 assert_zu_eq(psz2u(SIZE_T_MAX), max_psz,
174 "psz2u() should return (LARGE_MAXCLASS + PAGE) on overflow");
175 }
176 TEST_END
177
178 int
main(void)179 main(void)
180 {
181 return (test(
182 test_size_classes,
183 test_psize_classes,
184 test_overflow));
185 }
186