source: mainline/uspace/app/tester/mm/malloc3.c@ 1b20da0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1b20da0 was 582a0b8, checked in by Jakub Jermar <jakub@…>, 8 years ago

Remove unistd.h

  • Rename usleep() and sleep() to thread_usleep() and thread_sleep() and move to thread.[hc].
  • Include stddef.h in order to provide NULL.
  • Move getpagesize() to libposix.
  • Sync uspace/dist/src/c/demos with originals.
  • Property mode set to 100644
File size: 6.3 KB
Line 
1/*
2 * Copyright (c) 2009 Martin Decky
3 * Copyright (c) 2009 Tomas Bures
4 * Copyright (c) 2009 Lubomir Bulej
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * - Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * - The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31#include <stdio.h>
32#include <stdlib.h>
33#include <stddef.h>
34#include <libarch/config.h>
35#include "common.h"
36#include "../tester.h"
37
38/*
39 * The test is a slight adaptation of malloc1 test. The major difference
40 * is that the test forces the heap allocator to create multiple
41 * heap areas by creating disturbing address space areas.
42 */
43
44static subphase_t subphases_32B[] = {
45 {
46 .name = "Allocation",
47 .cond = {
48 .max_cycles = 200,
49 .no_memory = 1,
50 .no_allocated = 0,
51 },
52 .prob = {
53 .alloc = 90,
54 .free = 100
55 }
56 },
57 {
58 .name = "Alloc/Dealloc",
59 .cond = {
60 .max_cycles = 200,
61 .no_memory = 0,
62 .no_allocated = 0,
63 },
64 .prob = {
65 .alloc = 50,
66 .free = 100
67 }
68 },
69 {
70 .name = "Deallocation",
71 .cond = {
72 .max_cycles = 0,
73 .no_memory = 0,
74 .no_allocated = 1,
75 },
76 .prob = {
77 .alloc = 10,
78 .free = 100
79 }
80 }
81};
82
83static subphase_t subphases_128K[] = {
84 {
85 .name = "Allocation",
86 .cond = {
87 .max_cycles = 0,
88 .no_memory = 1,
89 .no_allocated = 0,
90 },
91 .prob = {
92 .alloc = 70,
93 .free = 100
94 }
95 },
96 {
97 .name = "Alloc/Dealloc",
98 .cond = {
99 .max_cycles = 30,
100 .no_memory = 0,
101 .no_allocated = 0,
102 },
103 .prob = {
104 .alloc = 50,
105 .free = 100
106 }
107 },
108 {
109 .name = "Deallocation",
110 .cond = {
111 .max_cycles = 0,
112 .no_memory = 0,
113 .no_allocated = 1,
114 },
115 .prob = {
116 .alloc = 30,
117 .free = 100
118 }
119 }
120};
121
122static subphase_t subphases_default[] = {
123 {
124 .name = "Allocation",
125 .cond = {
126 .max_cycles = 0,
127 .no_memory = 1,
128 .no_allocated = 0,
129 },
130 .prob = {
131 .alloc = 90,
132 .free = 100
133 }
134 },
135 {
136 .name = "Alloc/Dealloc",
137 .cond = {
138 .max_cycles = 200,
139 .no_memory = 0,
140 .no_allocated = 0,
141 },
142 .prob = {
143 .alloc = 50,
144 .free = 100
145 }
146 },
147 {
148 .name = "Deallocation",
149 .cond = {
150 .max_cycles = 0,
151 .no_memory = 0,
152 .no_allocated = 1,
153 },
154 .prob = {
155 .alloc = 10,
156 .free = 100
157 }
158 }
159};
160
161/*
162 * Phase definitions.
163 */
164static phase_t phases[] = {
165 {
166 .name = "32 B memory blocks",
167 .alloc = {
168 .min_block_size = 32,
169 .max_block_size = 32
170 },
171 .subphases = subphases_32B
172 },
173 {
174 .name = "128 KB memory blocks",
175 .alloc = {
176 .min_block_size = 128 * 1024,
177 .max_block_size = 128 * 1024
178 },
179 .subphases = subphases_128K
180 },
181 {
182 .name = "2500 B memory blocks",
183 .alloc = {
184 .min_block_size = 2500,
185 .max_block_size = 2500
186 },
187 .subphases = subphases_default
188 },
189 {
190 .name = "1 B .. 250000 B memory blocks",
191 .alloc = {
192 .min_block_size = 1,
193 .max_block_size = 250000
194 },
195 .subphases = subphases_default
196 }
197};
198
199static void do_subphase(phase_t *phase, subphase_t *subphase)
200{
201 for (unsigned int cycles = 0; /* always */; cycles++) {
202
203 if ((subphase->cond.max_cycles) &&
204 (cycles >= subphase->cond.max_cycles)) {
205 /*
206 * We have performed the required number of
207 * cycles. End the current subphase.
208 */
209 break;
210 }
211
212 /*
213 * Decide whether we alloc or free memory in this step.
214 */
215 unsigned int rnd = rand() % 100;
216 if (rnd < subphase->prob.alloc) {
217 /*
218 * Compute a random number lying in interval
219 * <min_block_size, max_block_size>
220 */
221 int alloc = phase->alloc.min_block_size +
222 (rand() % (phase->alloc.max_block_size - phase->alloc.min_block_size + 1));
223
224 mem_block_t *blk = alloc_block(alloc);
225 RETURN_IF_ERROR;
226
227 if (blk == NULL) {
228 TPRINTF("F(A)");
229 if (subphase->cond.no_memory) {
230 /* We filled the memory. Proceed to next subphase */
231 break;
232 }
233 } else {
234 TPRINTF("A");
235 fill_block(blk);
236 RETURN_IF_ERROR;
237
238 if ((mem_blocks_count % AREA_GRANULARITY) == 0) {
239 mem_area_t *area = map_area(AREA_SIZE);
240 RETURN_IF_ERROR;
241
242 if (area != NULL) {
243 TPRINTF("*");
244 fill_area(area);
245 RETURN_IF_ERROR;
246 } else
247 TPRINTF("F(*)");
248 }
249 }
250
251 } else if (rnd < subphase->prob.free) {
252 mem_block_t *blk = get_random_block();
253 if (blk == NULL) {
254 TPRINTF("F(R)");
255 if (subphase->cond.no_allocated) {
256 /* We free all the memory. Proceed to next subphase. */
257 break;
258 }
259 } else {
260 TPRINTF("R");
261 check_block(blk);
262 RETURN_IF_ERROR;
263
264 free_block(blk);
265 RETURN_IF_ERROR;
266 }
267 }
268 }
269
270 TPRINTF("\n.. finished.\n");
271}
272
273static void do_phase(phase_t *phase)
274{
275 for (unsigned int subno = 0; subno < 3; subno++) {
276 subphase_t *subphase = &phase->subphases[subno];
277
278 TPRINTF(".. Sub-phase %u (%s)\n", subno + 1, subphase->name);
279 do_subphase(phase, subphase);
280 RETURN_IF_ERROR;
281 }
282}
283
284const char *test_malloc3(void)
285{
286 init_mem();
287
288 for (unsigned int phaseno = 0; phaseno < sizeof_array(phases);
289 phaseno++) {
290 phase_t *phase = &phases[phaseno];
291
292 TPRINTF("Entering phase %u (%s)\n", phaseno + 1, phase->name);
293
294 do_phase(phase);
295 if (error_flag)
296 break;
297
298 TPRINTF("Phase finished.\n");
299 }
300
301 TPRINTF("Cleaning up.\n");
302 done_mem();
303 if (error_flag)
304 return "Test failed";
305
306 return NULL;
307}
Note: See TracBrowser for help on using the repository browser.