public
Fork of federicomenaquintero/bprof
Description: LD_PRELOAD hooks for GMemVTable
Homepage: http://live.gnome.org/SummerOfCode2008/Ideas/MemoryFragmentation
Clone URL: git://github.com/asoare/bprof.git
Andrei Soare (author)
Fri Aug 15 17:18:56 -0700 2008
commit  7d3ce7e275d385ab85994f1f2c4d9d2f07289bec
tree    e7c2cb8e0d0d78990de9be9b1e8470b61a1bcbd1
parent  c07753b1a1cf6459944582c8ec55ee1542d201a8
bprof / free_size.c
100644 136 lines (118 sloc) 2.605 kb
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
#include <stdio.h>
#include <stdlib.h>
 
 
#define M 666013
 
 
typedef void * Ptr;
 
typedef struct Node {
Ptr adr; // key
size_t size;
struct Node *lnk;
} Node;
 
typedef Node *Hash[M];
 
 
void initH (Hash h) {
int i;
for (i=0; i<M; i++)
h[i] = NULL;
}
 
int hash_gen (Ptr key) {
return (size_t) key % M;
}
 
void addH (Hash h, Ptr adr, int size) {
int k = hash_gen (adr);
Node *p = (Node *) malloc(sizeof(Node));
p->adr = adr;
p->size = size;
p->lnk = h[k];
h[k] = p;
}
 
void delH (Hash h, Ptr adr) {
int k = hash_gen (adr);
Node *p = h[k], *q;
if(!p) return;
if (p->adr == adr) {
h[k] = p->lnk;
free(p);
}
else {
while (p->lnk && p->lnk->adr != adr)
p = p->lnk;
if (p->lnk) {
q = p->lnk;
p->lnk = q->lnk;
free(q);
}
}
}
 
Node *locH (Hash h, Ptr adr) {
int k = hash_gen(adr);
Node *p = h[k];
while ( p && p->adr != adr )
p = p->lnk;
return p;
}
 
int main (int argc, char **argv) {
 
FILE *fi = fopen(argv[1], "r");
FILE *fo = fopen(argv[2], "w");
Hash h;
Ptr adr, old;
size_t size;
char *s = (char *) malloc(10);
Node *p;
int i=0;
 
    if (!fi) {
        printf("Invalid input file\n");
        return 0;
    }
 
    if (!fo) {
        printf("Invalid output file\n");
        return 0;
    }
 
initH(h);
while( fgets(s, 10, fi) ) // s will have a maximum size of 9: realloc\n\0
switch (s[0]) {
case 'm': {
fscanf(fi, "%p %lu\n", &adr, &size);
addH(h, adr, size);
fprintf(fo, "USED\t%p\t%lu\n", adr, size);
break;
}
case 'f': {
fscanf(fi, "%p", &adr);
if (adr) {
                                    p = locH(h, adr);
if (p) {
fprintf(fo, "FREE\t%p\t%lu\n", adr, p->size);
delH(h,adr);
}
else fprintf(stderr, "[%d]Free error: %p unallocated before\n", ++i,adr);
}
break;
}
case 'r': {
fscanf(fi, "%p %p %lu", &old, &adr, &size);
if (old==NULL && size==0) break;
if (old==NULL) {
fprintf(fo, "USED\t%p\t%lu\n", adr, size);
                                        addH(h,adr,size);
                                }
else if (size==0) {
p = locH(h, old);
if (p) fprintf(fo, "FREE\t%p\t%lu\n", old, p->size);
else fprintf(stderr, "[%d]Realloc error: %p unallocated before\n", ++i,old);
}
else {
p = locH(h, old);
if (p) {
fprintf(fo, "FREE\t%p\t%lu\n", old, p->size);
fprintf(fo, "USED\t%p\t%lu\n", adr, size);
delH(h,old);
addH(h,adr,size);
}
else fprintf(stderr, "[%d]Realloc error: %p unallocated before\n", ++i,old);
}
break;
}
}
fclose(fi);
fclose(fo);
return 0;
}