100 lines
2.5 KiB
C
100 lines
2.5 KiB
C
/*
|
|
* mm-naive.c - The fastest, least memory-efficient malloc package.
|
|
*
|
|
* In this naive approach, a block is allocated by simply incrementing
|
|
* the brk pointer. A block is pure payload. There are no headers or
|
|
* footers. Blocks are never coalesced or reused. Realloc is
|
|
* implemented directly using mm_malloc and mm_free.
|
|
*
|
|
* NOTE TO STUDENTS: Replace this header comment with your own header
|
|
* comment that gives a high level description of your solution.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <unistd.h>
|
|
#include <string.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 */
|
|
"anna.schlittenhardt@stud.uni-due.de+tuan-dat.tran@stud.uni-due.de",
|
|
/* First member's full name */
|
|
"Anna Schlittenhardt",
|
|
/* First member's email address */
|
|
"anna.schlittenhardt@stud.uni-due.de",
|
|
/* Second member's full name (leave blank if none) */
|
|
"Tuan-Dat Tran",
|
|
/* Second member's email address (leave blank if none) */
|
|
"tuan-dat.tran@stud.uni-due.de"
|
|
};
|
|
|
|
/* single word (4) or double word (8) alignment */
|
|
#define ALIGNMENT 8
|
|
|
|
/* rounds up to the nearest multiple of ALIGNMENT */
|
|
#define ALIGN(size) (((size) + (ALIGNMENT-1)) & ~0x7)
|
|
|
|
|
|
#define SIZE_T_SIZE (ALIGN(sizeof(size_t)))
|
|
|
|
/*
|
|
* mm_init - initialize the malloc package.
|
|
*/
|
|
int mm_init(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* mm_malloc - Allocate a block by incrementing the brk pointer.
|
|
* Always allocate a block whose size is a multiple of the alignment.
|
|
*/
|
|
void *mm_malloc(size_t size)
|
|
{
|
|
int newsize = ALIGN(size + SIZE_T_SIZE);
|
|
void *p = mem_sbrk(newsize);
|
|
if (p == (void *)-1)
|
|
return NULL;
|
|
else {
|
|
*(size_t *)p = size;
|
|
return (void *)((char *)p + SIZE_T_SIZE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* mm_free - Freeing a block does nothing.
|
|
*/
|
|
void mm_free(void *ptr)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* mm_realloc - Implemented simply in terms of mm_malloc and mm_free
|
|
*/
|
|
void *mm_realloc(void *ptr, size_t size)
|
|
{
|
|
/*
|
|
* ATTENTION: You do not need to implement realloc for this assignment
|
|
*/
|
|
void *oldptr = ptr;
|
|
void *newptr;
|
|
size_t copySize;
|
|
|
|
newptr = mm_malloc(size);
|
|
if (newptr == NULL)
|
|
return NULL;
|
|
copySize = *(size_t *)((char *)oldptr - SIZE_T_SIZE);
|
|
if (size < copySize)
|
|
copySize = size;
|
|
memcpy(newptr, oldptr, copySize);
|
|
mm_free(oldptr);
|
|
return newptr;
|
|
}
|