void
kma_free(void* ptr, kma_size_t size)
{
struct bud_controller *control;
struct free_block *curr;
struct page_node *currNode ;
void *page_begin_addr;
int offset;
// kma_page_t *tempPage;
int i=0;
int j=0;
control = bud_info();
for(i=0; i<HEADERSIZE; i++) {
if(size <= control->freelist[i].size) {
curr = ptr;
curr->next = NULL;
page_begin_addr = current_page_begin_addr(ptr);
currNode = control->page_list.next;
while(currNode->ptr != page_begin_addr){
currNode = currNode->next;
}
curr->node = currNode;
offset = ((char*)ptr - (char*)currNode->ptr) / MIN_BLK_SIZE;
for(j=0; j< control->freelist[i].size/MIN_BLK_SIZE; j++) {
clear_bit(currNode->bitmap, j+offset);
}
coalescing(ptr, control->freelist[i].size, currNode);
break;
}
}
control->free++;
if(control->free == control->used) {
currNode = control->page_list.next;
while(currNode != control->page_list.prev) {
free_page(currNode->addr);
currNode = currNode->next;
}
free_page(currNode->addr);
for(i=0; i<15; i++) {
if(control->node_list_page[i] != NULL) {
free_page(control->node_list_page[i]);
}
}
free_page(page_entry);
page_entry = NULL;
}
}
//joins all contiguious spans together at end of table
void condensing(vector <Spans*> spanVector, vector <string> memoryTable)
{
coalescing(spanVector);
int totalFreeSpaces = 0;
int difference = 0;
Spans* current = NULL;
for(int i = 0; i < spanVector.size(); i++)
{
current = spanVector[i];
difference = current->getEnding() - current->getBeginning() + 1;
totalFreeSpaces = totalFreeSpaces + difference;
}
//move everything in memory table up if the address above it is free
for(int a = 1; a < memoryTable.size();a++)
{
if(memoryTable[a-1] == "free")
{
memoryTable[a -1] = memoryTable[a];
memoryTable[a] = "free";
}
}
for(int b = memoryTable.size()-totalFreeSpaces; b < totalFreeSpaces; b++)
{
memoryTable[b] = "free";
}
Spans* newSpan = new Spans(memoryTable.size()-totalFreeSpaces,totalFreeSpaces,free);
newSpan->setBeginning(memoryTable.size()-totalFreeSpaces);
newSpan->setEnding(totalFreeSpaces);
resetSpanVector(spanVector);
spanVector.push_back(newSpan);
}
void coalescing(void *ptr, int blkSize, struct page_node *currNode) {
struct bud_controller *control;
struct free_block *blk, *prevBlk;
int offset;
int blkOffset;
int remainder;
void* prime_ptr;
int free = 1;
int i=0;
int p=0;
int found = 0;
control = bud_info();
offset = ((char*)ptr - (char*)currNode->ptr)/MIN_BLK_SIZE;
blkOffset = blkSize / MIN_BLK_SIZE;
remainder = offset % (2 * blkOffset);
for(p=0;p<HEADERSIZE; p++) {
if(control->freelist[p].size == blkSize) {
break;
}
}
if(blkSize == PAGESIZE) {
make_free_block(ptr, currNode);
list_blk_insert(ptr, control->freelist[p].blk);
reset_bitmap(currNode->bitmap);
return ;
}
if(remainder == 0) {
for(i=0;i<blkOffset;i++) {
if(get_bit(currNode->bitmap, offset+i+blkOffset) == 1) {
free = 0;
break;
}
}
if(free == 1) {
prime_ptr = (void*)((char*)ptr + blkSize);
blk = control->freelist[p].blk->next;
prevBlk = control->freelist[p].blk;
while(blk != NULL) {
if(blk == prime_ptr) {
found = 1;
blk_remove(blk, prevBlk);
break;
}
prevBlk = blk;
blk = blk->next;
}
if(found == 0) {
printf("error, coalescing is error\n");
}
blkSize = 2 * blkSize;
return coalescing(ptr, blkSize, currNode);
}
else if(free == 0) {
blk = make_free_block(ptr, currNode);
list_blk_insert(blk, control->freelist[p].blk);
}
}
else if(remainder == blkOffset) {
for(i=0; i<blkOffset;i++) {
if(get_bit(currNode->bitmap, offset+i-blkOffset) == 1) {
free = 0;
break;
}
}
if(free == 1) {
prime_ptr = (void*)((char*)ptr - blkSize);
blk = control->freelist[p].blk->next;
prevBlk = control->freelist[p].blk;
while(blk != NULL) {
if(blk == prime_ptr) {
found = 1;
blk_remove(blk,prevBlk);
break;
}
prevBlk = blk;
blk = blk->next;
}
if(found == 0) {
printf("error, coalescing is error\n");
}
blkSize = 2 * blkSize;
return coalescing(prime_ptr, blkSize, currNode);
}
else if(free == 0) {
blk = make_free_block(ptr, currNode);
list_blk_insert(blk, control->freelist[p].blk);
}
}
else {
printf("Error in coalescing\n");
}
}
