christoph/lecture-operating-system-development
1
Fork 0
Code Activity

use DEBUG in more places

Browse Source
This commit is contained in:
churl
2022-05-23 12:20:29 +02:00
parent d6d071d6fd
commit cc35dda947
6 changed files with 46 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
c_os/kernel/allocator/BumpAllocator.cc
View File

@ -25,9 +25,7 @@ void BumpAllocator::init() {
this->allocations = 0;
this->next = (unsigned char*)heap_start;
kout << "Initialized Bump Allocator" << endl
<< " - Heap Start: " << hex << (unsigned int)this->heap_start
<< ", Heap End: " << hex << (unsigned int)this->heap_end << endl;
if (DEBUG) kout << "Initialized Bump Allocator" << endl;
}
/*****************************************************************************
@ -53,10 +51,10 @@ void* BumpAllocator::alloc(unsigned int req_size) {
/* Hier muess Code eingefuegt werden */
kout << "Requested " << hex << req_size << " Bytes" << endl;
if (DEBUG) kout << "Requested " << hex << req_size << " Bytes" << endl;
if (req_size + (unsigned int)this->next > this->heap_end) {
kout << " - More memory requested than available :(" << endl;
if (DEBUG) kout << " - More memory requested than available :(" << endl;
return NULL;
}
@ -64,7 +62,7 @@ void* BumpAllocator::alloc(unsigned int req_size) {
this->next = (unsigned char*)((unsigned int)this->next + req_size);
this->allocations = this->allocations + 1;
kout << " - Allocated " << hex << req_size << " Bytes." << endl;
if (DEBUG) kout << " - Allocated " << hex << req_size << " Bytes." << endl;
return allocated;
}
@ -75,5 +73,5 @@ void* BumpAllocator::alloc(unsigned int req_size) {
* Beschreibung: Nicht implementiert. *
*****************************************************************************/
void BumpAllocator::free(void* ptr) {
kout << " mm_free: ptr= " << hex << (unsigned int)ptr << ", not supported" << endl;
if (DEBUG) kout << " mm_free: ptr= " << hex << (unsigned int)ptr << ", not supported" << endl;
}

32
c_os/kernel/allocator/LinkedListAllocator.cc
View File

@ -37,11 +37,7 @@ void LinkedListAllocator::init() {
this->free_start->size = this->heap_size - sizeof(free_block_t);
this->free_start->next = this->free_start; // Only one block, points to itself
kout << "Initialized LinkedList Allocator" << endl
<< " - Heap Start: " << hex << (unsigned int)this->heap_start
<< ", Heap End: " << hex << (unsigned int)this->heap_end
<< ", Heap Size: " << hex << this->heap_size << endl;
kout << endl;
if (DEBUG) kout << "Initialized LinkedList Allocator" << endl;
}
/*****************************************************************************
@ -79,10 +75,10 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
/* Hier muess Code eingefuegt werden */
// NOTE: next pointer zeigt auf headeranfang, returned wird zeiger auf anfang des nutzbaren freispeichers
kout << "Requested " << hex << req_size << " Bytes" << endl;
if (DEBUG) kout << "Requested " << hex << req_size << " Bytes" << endl;
if (this->free_start == NULL) {
kout << " - No free memory remaining :(" << endl;
if (DEBUG) kout << " - No free memory remaining :(" << endl;
return NULL;
}
@ -90,7 +86,7 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
unsigned int req_size_diff = (BASIC_ALIGN - req_size % BASIC_ALIGN) % BASIC_ALIGN;
unsigned int rreq_size = req_size + req_size_diff;
if (req_size_diff > 0) {
kout << " - Rounded to word border (+" << dec << req_size_diff << " bytes)" << endl;
if (DEBUG) kout << " - Rounded to word border (+" << dec << req_size_diff << " bytes)" << endl;
}
free_block_t* current = this->free_start;
@ -121,7 +117,7 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
// Next-fit
this->free_start = new_next;
kout << " - Allocated " << hex << rreq_size << " Bytes with cutting" << endl;
if (DEBUG) kout << " - Allocated " << hex << rreq_size << " Bytes with cutting" << endl;
} else {
// Block too small to be cut, allocate whole block
@ -129,11 +125,11 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
this->free_start = current->next; // Pointer keeps pointing to current if last block
if (this->free_start == current) {
// No free block remaining
kout << " - Disabled freelist" << endl;
if (DEBUG) kout << " - Disabled freelist" << endl;
this->free_start = NULL;
}
kout << " - Allocated " << hex << current->size << " Bytes without cutting" << endl;
if (DEBUG) kout << " - Allocated " << hex << current->size << " Bytes without cutting" << endl;
}
// Block aushängen
@ -150,7 +146,7 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
current = current->next;
} while (current != this->free_start); // Stop when arriving at the first block again
kout << " - More memory requested than available :(" << endl;
if (DEBUG) kout << " - More memory requested than available :(" << endl;
return NULL;
}
@ -163,7 +159,7 @@ void LinkedListAllocator::free(void* ptr) {
/* Hier muess Code eingefuegt werden */
kout << "Freeing " << hex << (unsigned int)ptr << endl;
if (DEBUG) kout << "Freeing " << hex << (unsigned int)ptr << endl;
free_block_t* block_start = (free_block_t*)((unsigned int)ptr - sizeof(free_block_t));
@ -174,7 +170,7 @@ void LinkedListAllocator::free(void* ptr) {
block_start->allocated = false;
block_start->next = block_start;
kout << " - Enabling freelist with one block" << endl;
if (DEBUG) kout << " - Enabling freelist with one block" << endl;
return;
}
@ -205,7 +201,7 @@ void LinkedListAllocator::free(void* ptr) {
// Try to merge forward ========================================================================
if (next_block == next_free) {
kout << " - Merging block forward" << endl;
if (DEBUG) kout << " - Merging block forward" << endl;
// Current and next adjacent block can be merged
// [previous_free | previous_free_next | <> | block_start | next_free]
@ -224,7 +220,7 @@ void LinkedListAllocator::free(void* ptr) {
if (this->free_start == next_free) {
// next_free is now invalid after merge
kout << " - Moving freelist start to " << hex << (unsigned int)block_start << endl;
if (DEBUG) kout << " - Moving freelist start to " << hex << (unsigned int)block_start << endl;
this->free_start = block_start;
}
} else {
@ -240,7 +236,7 @@ void LinkedListAllocator::free(void* ptr) {
// Try to merge backward =====================================================================
if (previous_free_next == block_start) {
kout << " - Merging block backward" << endl;
if (DEBUG) kout << " - Merging block backward" << endl;
// Current and previous adjacent block can be merged
// [previous_free | block_start]
@ -253,7 +249,7 @@ void LinkedListAllocator::free(void* ptr) {
if (this->free_start == block_start) {
// block_start is now invalid after merge
kout << " - Moving freelist start to " << hex << (unsigned int)previous_free << endl;
if (DEBUG) kout << " - Moving freelist start to " << hex << (unsigned int)previous_free << endl;
this->free_start = previous_free;
}
}

10
c_os/kernel/allocator/TreeAllocator.cc
View File

@ -14,7 +14,7 @@ void TreeAllocator::init() {
this->free_start->next = (list_block_t*)this->free_start;
this->free_start->previous = (list_block_t*)this->free_start;
kout << "Initialized Tree Allocator" << endl;
if (DEBUG) kout << "Initialized Tree Allocator" << endl;
}
void TreeAllocator::dump_free_memory() {
@ -33,7 +33,7 @@ void TreeAllocator::dump_free_memory(tree_block_t* node) {
}
void* TreeAllocator::alloc(unsigned int req_size) {
kout << "Requested " << dec << req_size << " Bytes" << endl;
if (DEBUG) kout << "Requested " << dec << req_size << " Bytes" << endl;
// Round to word borders + tree_block size
unsigned int rreq_size = req_size;
@ -52,12 +52,12 @@ void* TreeAllocator::alloc(unsigned int req_size) {
// Finds smallest block that is large enough
tree_block_t* best_fit = this->rbt_search_bestfit(rreq_size);
if (best_fit == NULL) {
kout << " - No block found" << endl;
if (DEBUG) kout << " - No block found" << endl;
return NULL;
}
if (best_fit->allocated) {
// Something went really wrong
kout << " - Block already allocated :(" << endl;
if (DEBUG) kout << " - Block already allocated :(" << endl;
return NULL;
}
best_fit->allocated = true;
@ -88,7 +88,7 @@ void* TreeAllocator::alloc(unsigned int req_size) {
}
void TreeAllocator::free(void* ptr) {
kout << "Freeing " << hex << (unsigned int)ptr << endl;
if (DEBUG) kout << "Freeing " << hex << (unsigned int)ptr << endl;
list_block_t* block = (list_block_t*)((char*)ptr - sizeof(list_block_t));
if (!block->allocated) {