void* dmalloc(size_t numbytes) {
numbytes = ALIGN(numbytes);
if(unallocated) { //Initialize through sbrk call first time
unallocated = false;
if(!dmalloc_init())
return NULL;
}
assert(numbytes > 0);
//Find the first block that is of sufficient size.
metadata_t* freeBlock = (metadata_t*) firstFitblock(numbytes,convertToIndex(numbytes));
if(freeBlock == NULL){return NULL;}
//Check if we shouldn't split the block - used 8 so we at worst the split has a leftover block of size 8
if(freeBlock->size < numbytes + METADATA_T_ALIGNED + FOOT_T_ALIGNED + 16){//Consider expanding this size requirement
freeBlock->next = (void*) -1;
freeBlock->prev = (void*) -1;
return ((void*)freeBlock) + METADATA_T_ALIGNED;
}
//Otherwise Split the Block - the retBlock: return block and the leftover is freeBlock
metadata_t* retBlock = freeBlock;
//Make freeBlock the leftover block and put it back in blocks
freeBlock = (metadata_t*)(((void*)(freeBlock)) + METADATA_T_ALIGNED + numbytes + FOOT_T_ALIGNED); //Move its address to front of metadata
freeBlock->size = retBlock->size - numbytes - METADATA_T_ALIGNED - FOOT_T_ALIGNED; // adjust size
int i = convertToIndex(freeBlock->size);
freeBlock->next = blocks[i];
freeBlock->prev = NULL;
foot_t* fbFoot = (foot_t*) (((void*) freeBlock) + METADATA_T_ALIGNED + freeBlock->size);
fbFoot->size = freeBlock->size;
//Adjust pointers at front of block
if(blocks[i] != NULL){
blocks[i]->prev = freeBlock;
}
blocks[i] = freeBlock; //make blocks point to freeblock
//Adjust return metadata/footer
retBlock->size = numbytes;
retBlock->next = (void*) - 1;
retBlock->prev = (void*) - 1;
foot_t* retFoot = (foot_t*)(((void*)(retBlock)) + retBlock->size + METADATA_T_ALIGNED);
retFoot->size = retBlock->size;
return (((void*)(retBlock)) + METADATA_T_ALIGNED);
}
void* dmalloc(size_t numbytes, int flag) {
if(!is_init) { //Initialize through sbrk call first time
if(!dmalloc_init()) {
return NULL;
}
}
assert(numbytes > 0);
/* Your code goes here */
size_t space = ALIGN(numbytes);
// go over the linked list, find the first fit
//metadata_t* flpt = freelist;
metadata_t* flpt = find_fit(space, flag);
if (!flpt) {
//return NULL;
if (!(flpt = extend_heap(space))) {
printf("extend heap failed! \n");
return NULL;
}
}
size_t rest = meta_size(flpt) - space;
delete_node(flpt);
if (rest < ALIGN(META_SIZE + FOOTER_SIZE + 1)) {
set_alloc(flpt);
set_alloc((metadata_t *)(to_footer(to_block(flpt))));
}
else {
rest = rest - META_SIZE - FOOTER_SIZE;
set_size(flpt, space);
set_alloc(flpt);
set_size((metadata_t *)(to_footer(to_block(flpt))), space);
set_alloc((metadata_t *)(to_footer(to_block(flpt))));
metadata_t* newmt = (metadata_t *)((void *)flpt + META_SIZE + space + FOOTER_SIZE);
set_size(newmt, rest);
set_free(newmt);
set_size((metadata_t *)to_footer(to_block(newmt)), rest);
set_free((metadata_t *)to_footer(to_block(newmt)));
add_node(newmt);
}
void * result = to_block(flpt);
assert(result != NULL);
if (!result) {
int a = 1;
}
return result;
}
void* dmalloc(size_t numbytes) {
/* initialize through sbrk call first time */
if(freelist == NULL) {
if(!dmalloc_init())
return NULL;
}
assert(numbytes > 0);
/* print_freelist(); */
/* your code here */
metadata_t *allocated, *previous, *traverse, *next;
/* printf("FREELIST: %p\n",freelist); */
traverse = freelist;
// Loop through freelist to find big enough block.
while(traverse != NULL ){
// Compare if enough room to allocate requested number of bytes.
if(traverse->size >= (ALIGN(numbytes)+METADATA_T_ALIGNED)){
// Initialize structure with size and address of VERY beginning of block
size_t temp = traverse->size;
allocated = traverse;
allocated->size = ALIGN(numbytes);
//DEBUG
/* printf("allocated and traverse: %p\n", allocated); */
// Update freelist
previous = traverse->prev;
next = traverse->next;
/* printf("traverse->prev: %p\n", previous); */
/* printf("traverse->next: %p\n", next); */
/* printf("temp original: %zu\n", temp); */
// Move the current node to beginning of free block
void* freeblock_beginning = (void *) traverse;
freeblock_beginning = freeblock_beginning + METADATA_T_ALIGNED + allocated->size;
traverse = (metadata_t *) freeblock_beginning;
/* printf("new traverse: %p\n", freeblock_beginning); */
/* printf("temp after should be the same: %zu\n", temp); */
traverse->size = temp-allocated->size - METADATA_T_ALIGNED;
/* printf("That new size though: %zu\n", traverse->size); */
traverse->next = next;
// Check if block was the first of freelist, if it is,
// make "freeblock_beginning" the head of freelist.
if(previous != NULL){
previous->next = traverse;
traverse->prev = previous;
} else {
freelist = freeblock_beginning;
if (freelist->next != NULL) {
freelist->next->prev = freelist;
}
freelist->prev = NULL;
}
return (allocated + (METADATA_T_ALIGNED)/sizeof(metadata_t));
}
traverse = traverse->next;
};
return NULL;
}
void* dmalloc(size_t numbytes) {
//printf("\n%s\n\n", "DMALLOC STARTED");
/* CHECK IF THERE'S STILL SPACE IN THE HEAP */
if (heapIsCompletelyFull) {
//printf("\n%s\n\n", "HEAP COMPLETELY FILLED!");
return NULL;
}
else {
/* initialize through sbrk call first time */
if (freelist == NULL) {
if (!dmalloc_init())
return NULL;
}
assert(numbytes > 0);
/* determine size of requested block */
size_t blockSize = METADATA_T_ALIGNED + ALIGN(numbytes) + METADATA_F_ALIGNED;
size_t tempBlockSize = blockSize;
freelist = findCorrectFreeList(blockSize);
/* find the appropriate pointer for splitting */
metadata_t* targetPointer;
metadata_t* candidatePointer;
candidatePointer = freelist;
while ((candidatePointer == NULL) || (candidatePointer->size - METADATA_T_ALIGNED - METADATA_F_ALIGNED < blockSize) && (candidatePointer->size != blockSize)) {
/* this block is too small */
if ((candidatePointer == NULL) || (candidatePointer->next == NULL)) {
//printf("\n%s\n\n", "this block is too big!");
if ((candidatePointer != NULL) && (freelist == freelist8192_)) {
/* last possible block doesn't match! No block is big enough */
return NULL;
}
else {
tempBlockSize = tempBlockSize * 2;
freelist = findCorrectFreeList(tempBlockSize);
candidatePointer = freelist;
}
}
else {
/* go to next free block */
candidatePointer = candidatePointer->next;
}
}
/* found the block! */
targetPointer = candidatePointer;
/* ------ splitting the target block --------- */
/* ------ CASE 1: the block is completely filled --------- */
if (targetPointer->size == blockSize) {
/* ------ CASE 1-A: the first free block is being filled --------- */
if (freelist == targetPointer) {
/* ------ CASE 1-A-A: this is NOT the last free block --------- */
if (freelist->next != NULL) {
//printf("\n%s\n\n", "MALLOC CASE M-1-A-A: this is NOT the last free block");
freelist = freelist->next;
targetPointer->next = NULL;
freelist->prev = NULL;
assignCorrectFreeList(freelist, freelist);
}
/* ------ CASE 1-A-B: this is the last free block --------- */
else {
//printf("\n%s\n\n", "MALLOC CASE M-1-A-B: HEAP COMPLETELY FILLED!");
/* EVERYTIME THE HEAP IS COMPLETELY FILLED, FREELIST IS RETURN TO HEAP_START */
assignCorrectFreeList(freelist, NULL);
}
}
/* ------ CASE 1-B: it's NOT the first free block that's being filled --------- */
else {
/* ------ CASE 1-B-A: this IS THE LAST FREE BLOCK --------- */
if (targetPointer->next == NULL) {
//printf("\n%s\n\n", "MALLOC CASE M-1-B-A: this IS THE LAST FREE BLOCK");
targetPointer->prev->next = NULL;
targetPointer->prev = NULL;
targetPointer->next = NULL;
}
/* ------ CASE 1-B-B: this IS NOT THE LAST FREE BLOCK --------- */
else {
//printf("\n%s\n\n", "MALLOC CASE M-1-B-B: this IS NOT THE LAST FREE BLOCK");
targetPointer->prev->next = targetPointer->next;
targetPointer->next->prev = targetPointer->prev;
targetPointer->next = NULL;
targetPointer->prev = NULL;
}
}
}
/* ------ CASE 2: the block is NOT completely filled --------- */
else {
/* create next block header */
metadata_t* header = (void*) targetPointer + blockSize;
/* set next block header */
header->size = targetPointer->size - blockSize;
metadata_t* targetfreelist = findCorrectFreeList(header->size);
if (targetfreelist == NULL) {
assignCorrectFreeList(header, header);
header->next = NULL;
header->prev = NULL;
}
else {
while (targetfreelist->next != NULL && targetfreelist->next < header) {
targetfreelist = targetfreelist->next;
}
if (targetfreelist > header) {
header->next = targetfreelist;
targetfreelist->prev = header;
header-> next = targetfreelist->next;
}
else {
if (header->next != NULL) {
header->next->prev = header;
}
}
header->prev = targetfreelist;
targetfreelist->next = header;
}
header->next = targetPointer->next;
header->prev = targetPointer->prev;
/* align pointers to next block header */
if (header->next != NULL) {
header->next->prev = header;
}
if (header->prev != NULL) {
header->prev->next = header;
}
/* set next block footer */
metadata_f* nextFooter = (void*) header + header->size - METADATA_F_ALIGNED;
nextFooter->size = header->size;
/* create current block footer */
metadata_f* currentFooter = (void*) header - METADATA_F_ALIGNED;
/* set current block footer */
currentFooter->size = blockSize;
/* set current block header */
targetPointer->size = blockSize;
targetPointer->next = NULL;
targetPointer->prev = NULL;
/* update freelist if freelist's block becomes allocated */
freelist = ((void*) freelist == (void*) targetPointer) ? header : freelist;
}
/* return the correct pointer address */
return (void*) targetPointer + METADATA_T_ALIGNED;
}
}
