/
mm.backup.c
367 lines (317 loc) · 9 KB
/
mm.backup.c
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
/*
* mm-implicit.c - Simple allocator based on implicit free lists,
* first fit placement, and boundary tag coalescing.
*
* Each block has header and footer of the form:
*
* 31 3 2 1 0
* -----------------------------------
* | s s s s ... s s s 0 0 a/f
* -----------------------------------
*
* where s are the meaningful size bits and a/f is set
* iff the block is allocated. The list has the following form:
*
* begin end
* heap heap
* -----------------------------------------------------------------
* | pad | hdr(8:a) | ftr(8:a) | zero or more usr blks | hdr(8:a) |
* -----------------------------------------------------------------
* | prologue | | epilogue |
* | block | | block |
*
* The allocated prologue and epilogue blocks are overhead that
* eliminate edge conditions during coalescing.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include "mm.h"
#include "memlib.h"
/*********************************************************
* NOTE TO STUDENTS: Before you do anything else, please
* provide your team information in the following struct.
********************************************************/
team_t team = {
/* Team name */
"Dongers",
/* First member's full name */
"Ryan Bohannon",
/* First member's email address */
"Ryan.Bohannon@colorado.edu",
/* Second member's full name (leave blank if none) */
"",
/* Second member's email address (leave blank if none) */
""
};
/////////////////////////////////////////////////////////////////////////////
// Constants and macros
//
// These correspond to the material in Figure 9.43 of the text
// The macros have been turned into C++ inline functions to
// make debugging code easier.
//
/////////////////////////////////////////////////////////////////////////////
#define WSIZE 4 /* word size (bytes) */
#define DSIZE 8 /* doubleword size (bytes) */
#define CHUNKSIZE (1<<12) /* initial heap size (bytes) */
#define OVERHEAD 8 /* overhead of header and footer (bytes) */
static inline int MAX(int x, int y) {
return x > y ? x : y;
}
//
// Pack a size and allocated bit into a word
// We mask of the "alloc" field to insure only
// the lower bit is used
//
static inline size_t PACK(size_t size, int alloc) {
return ((size) | (alloc & 0x1));
}
//
// Read and write a word at address p
//
static inline size_t GET(void *p) { return *(size_t *)p; }
static inline void PUT( void *p, size_t val)
{
*((size_t *)p) = val;
}
//
// Read the size and allocated fields from address p
//
static inline size_t GET_SIZE( void *p ) {
return GET(p) & ~0x7;
}
static inline int GET_ALLOC( void *p ) {
return GET(p) & 0x1;
}
//
// Given block ptr bp, compute address of its header and footer
//
static inline void *HDRP(void *bp) {
return ( (char *)bp) - WSIZE;
}
static inline void *FTRP(void *bp) {
return ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE);
}
//
// Given block ptr bp, compute address of next and previous blocks
//
static inline void *NEXT_BLKP(void *bp) {
return ((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE)));
}
static inline void* PREV_BLKP(void *bp){
return ((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE)));
}
/////////////////////////////////////////////////////////////////////////////
//
// Global Variables
//
static char *heap_listp; /* pointer to first block */
//
// function prototypes for internal helper routines
//
static void *extend_heap(size_t words);
static void place(void *bp, size_t asize);
static void *find_fit(size_t asize);
static void *coalesce(void *bp);
static void printblock(void *bp);
static void checkblock(void *bp);
//
// mm_init - Initialize the memory manager
//
int mm_init(void)
{
// Create the initial empty heap
if ((heap_listp = mem_sbrk(4*WSIZE)) == (void *)-1)
return -1;
PUT(heap_listp, 0); //Alignment padding
PUT(heap_listp + (1*WSIZE), PACK(DSIZE, 1)); //Prologue header
PUT(heap_listp + (2*WSIZE), PACK(DSIZE, 1)); //prologue footer
PUT(heap_listp + (3*WSIZE), PACK(0, 1)); //Epilogue header
// Extend the empty heap with a free block of CHUNKSIZE bytes
if (extend_heap(CHUNKSIZE/WSIZE) == NULL)
return -1;
return 0;
}
//
// extend_heap - Extend heap with free block and return its block pointer
//
static void *extend_heap(size_t words)
{
char *bp;
size_t size;
// Allocate an even number of words to maintain alignment
size = (words % 2) ? (words+1) * WSIZE : words * WSIZE;
if ((long)(bp = mem_sbrk(size)) == -1)
return NULL;
// Initilalize free block header/footer and the epilogue header
PUT(HDRP(bp), PACK(size, 0)); // Free block header
PUT(FTRP(bp), PACK(size, 0)); // Free block footer
PUT(HDRP(NEXT_BLKP(bp)), PACK(0,1)); // New epilogue header
// Coalesce if the previous block was free
return coalesce(bp);
}
//
// Practice problem 9.8
//
// find_fit - Find a fit for a block with asize bytes
//
static void *find_fit(size_t asize)
{
return NULL; /* no fit */
}
//
// mm_free - Free a block
//
void mm_free(void *bp)
{
size_t size = GET_SIZE(HDRP(bp));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
coalesce(bp);
}
//
// coalesce - boundary tag coalescing. Return ptr to coalesced block
//
static void *coalesce(void *bp)
{
size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));
size_t next_alloc = GET_ALLOC(FTRP(NEXT_BLKP(bp)));
size_t size = GET_SIZE(HDRP(bp));
if (prev_alloc && next_alloc) { // Case 1
return bp;
}
else if (prev_alloc && !next_alloc) { // Case 2
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
}
else if (!prev_alloc && next_alloc) { // Case 3
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
}
else {
size =+ GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(FTRP(NEXT_BLKP(bp)));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
PUT(FTRP(NEXT_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
}
return bp;
}
//
// mm_malloc - Allocate a block with at least size bytes of payload
//
void *mm_malloc(size_t size)
{
size_t asize; //Adjust block size
size_t extendsize; //Amount to extend heap if no fit
char *bp;
// Ignore spurious requests
if (size == 0)
return NULL;
// Adjust block size to include overhead and alignment
if (size <= DSIZE)
asize = 2*DSIZE;
else
asize = DSIZE * ((size + (DSIZE) + (DSIZE-1)) / DSIZE);
// Search teh free list for a fit
if ((bp = find_fit(asize)) != NULL) {
place(bp, asize);
return bp;
}
// No fit found. Get more memeory and place the block
extendsize = MAX(asize, CHUNKSIZE);
if ((bp = extend_heap(extendsize/WSIZE)) == NULL)
return NULL;
place(bp, asize);
return bp;
}
//
//
// Practice problem 9.9
//
// place - Place block of asize bytes at start of free block bp
// and split if remainder would be at least minimum block size
//
static void place(void *bp, size_t asize)
{
}
//
// mm_realloc -- implemented for you
//
void *mm_realloc(void *ptr, size_t size)
{
void *newp;
size_t copySize;
newp = mm_malloc(size);
if (newp == NULL) {
printf("ERROR: mm_malloc failed in mm_realloc\n");
exit(1);
}
copySize = GET_SIZE(HDRP(ptr));
if (size < copySize) {
copySize = size;
}
memcpy(newp, ptr, copySize);
mm_free(ptr);
return newp;
}
//
// mm_checkheap - Check the heap for consistency
//
void mm_checkheap(int verbose)
{
//
// This provided implementation assumes you're using the structure
// of the sample solution in the text. If not, omit this code
// and provide your own mm_checkheap
//
void *bp = heap_listp;
if (verbose) {
printf("Heap (%p):\n", heap_listp);
}
if ((GET_SIZE(HDRP(heap_listp)) != DSIZE) || !GET_ALLOC(HDRP(heap_listp))) {
printf("Bad prologue header\n");
}
checkblock(heap_listp);
for (bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp)) {
if (verbose) {
printblock(bp);
}
checkblock(bp);
}
if (verbose) {
printblock(bp);
}
if ((GET_SIZE(HDRP(bp)) != 0) || !(GET_ALLOC(HDRP(bp)))) {
printf("Bad epilogue header\n");
}
}
static void printblock(void *bp)
{
size_t hsize, halloc, fsize, falloc;
hsize = GET_SIZE(HDRP(bp));
halloc = GET_ALLOC(HDRP(bp));
fsize = GET_SIZE(FTRP(bp));
falloc = GET_ALLOC(FTRP(bp));
if (hsize == 0) {
printf("%p: EOL\n", bp);
return;
}
printf("%p: header: [%d:%c] footer: [%d:%c]\n",
bp,
(int) hsize, (halloc ? 'a' : 'f'),
(int) fsize, (falloc ? 'a' : 'f'));
}
static void checkblock(void *bp)
{
if ((size_t)bp % 8) {
printf("Error: %p is not doubleword aligned\n", bp);
}
if (GET(HDRP(bp)) != GET(FTRP(bp))) {
printf("Error: header does not match footer\n");
}
}