1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/*
* $Id: t-test.h,v 1.1 2004/11/04 14:32:21 wg Exp $
* by Wolfram Gloger 1996.
* Common data structures and functions for testing malloc performance.
*/
/* Testing level */
#ifndef TEST
#define TEST 0
#endif
/* For large allocation sizes, the time required by copying in
realloc() can dwarf all other execution times. Avoid this with a
size threshold. */
#ifndef REALLOC_MAX
#define REALLOC_MAX 2000
#endif
struct bin {
unsigned char *ptr;
unsigned long size;
};
#if TEST > 0
static void
mem_init(unsigned char *ptr, unsigned long size)
{
unsigned long i, j;
if(size == 0) return;
for(i=0; i<size; i+=2047) {
j = (unsigned long)ptr ^ i;
ptr[i] = ((j ^ (j>>8)) & 0xFF);
}
j = (unsigned long)ptr ^ (size-1);
ptr[size-1] = ((j ^ (j>>8)) & 0xFF);
}
static int
mem_check(unsigned char *ptr, unsigned long size)
{
unsigned long i, j;
if(size == 0) return 0;
for(i=0; i<size; i+=2047) {
j = (unsigned long)ptr ^ i;
if(ptr[i] != ((j ^ (j>>8)) & 0xFF)) return 1;
}
j = (unsigned long)ptr ^ (size-1);
if(ptr[size-1] != ((j ^ (j>>8)) & 0xFF)) return 2;
return 0;
}
static int
zero_check(unsigned* ptr, unsigned long size)
{
unsigned char* ptr2;
while(size >= sizeof(*ptr)) {
if(*ptr++ != 0)
return -1;
size -= sizeof(*ptr);
}
ptr2 = (unsigned char*)ptr;
while(size > 0) {
if(*ptr2++ != 0)
return -1;
--size;
}
return 0;
}
#endif /* TEST > 0 */
/* Allocate a bin with malloc(), realloc() or memalign(). r must be a
random number >= 1024. */
static void
bin_alloc(struct bin *m, unsigned long size, int r)
{
#if TEST > 0
if(mem_check(m->ptr, m->size)) {
printf("memory corrupt!\n");
exit(1);
}
#endif
r %= 1024;
/*printf("%d ", r);*/
if(r < 4) { /* memalign */
if(m->size > 0) free(m->ptr);
m->ptr = (unsigned char *)memalign(sizeof(int) << r, size);
} else if(r < 20) { /* calloc */
if(m->size > 0) free(m->ptr);
m->ptr = (unsigned char *)calloc(size, 1);
#if TEST > 0
if(zero_check((unsigned*)m->ptr, size)) {
long i;
for(i=0; i<size; i++)
if(m->ptr[i] != 0)
break;
printf("calloc'ed memory non-zero (ptr=%p, i=%ld)!\n", m->ptr, i);
exit(1);
}
#endif
} else if(r < 100 && m->size < REALLOC_MAX) { /* realloc */
if(m->size == 0) m->ptr = NULL;
m->ptr = realloc(m->ptr, size);
} else { /* plain malloc */
if(m->size > 0) free(m->ptr);
m->ptr = (unsigned char *)malloc(size);
}
if(!m->ptr) {
printf("out of memory (r=%d, size=%ld)!\n", r, (long)size);
exit(1);
}
m->size = size;
#if TEST > 0
mem_init(m->ptr, m->size);
#endif
}
/* Free a bin. */
static void
bin_free(struct bin *m)
{
if(m->size == 0) return;
#if TEST > 0
if(mem_check(m->ptr, m->size)) {
printf("memory corrupt!\n");
exit(1);
}
#endif
free(m->ptr);
m->size = 0;
}
/*
* Local variables:
* tab-width: 4
* End:
*/
|
