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

merged cleanup

Browse Source
This commit is contained in:
Christoph Urlacher
2022-07-24 21:12:31 +02:00
parent 5ff3d72bfd
commit 6481bae5f6
92 changed files with 663 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
c_os/kernel/allocator/TreeAllocatorOperations.cc
View File

@ -1,12 +1,11 @@
#include "kernel/allocator/TreeAllocator.h"
#include "kernel/Globals.h"
// RBT code taken from https://github.com/Bibeknam/algorithmtutorprograms
// START copy from algorithmtutorprograms
void TreeAllocator::rbt_transplant(tree_block_t* a, tree_block_t* b) {
if (a->parent == nullptr) {
this->free_start = b;
free_start = b;
} else if (a == a->parent->left) {
a->parent->left = b;
} else {
@ -25,11 +24,11 @@ void TreeAllocator::rbt_insert(tree_block_t* node) {
node->red = true; // new node must be red
tree_block_t* y = nullptr;
tree_block_t* x = this->free_start;
tree_block_t* x = free_start;
while (x != nullptr) {
y = x;
if (this->get_size(node) < this->get_size(x)) {
if (get_size(node) < get_size(x)) {
x = x->left;
} else {
x = x->right;
@ -39,8 +38,8 @@ void TreeAllocator::rbt_insert(tree_block_t* node) {
// y is parent of x
node->parent = y;
if (y == nullptr) {
this->free_start = node;
} else if (this->get_size(node) < this->get_size(y)) {
free_start = node;
} else if (get_size(node) < get_size(y)) {
y->left = node;
} else {
y->right = node;
@ -58,7 +57,7 @@ void TreeAllocator::rbt_insert(tree_block_t* node) {
}
// Fix the tree
this->rbt_fix_insert(node);
rbt_fix_insert(node);
}
// fix the red-black tree
@ -77,12 +76,12 @@ void TreeAllocator::rbt_fix_insert(tree_block_t* k) {
if (k == k->parent->left) {
// case 3.2.2
k = k->parent;
this->rbt_rot_r(k);
rbt_rot_r(k);
}
// case 3.2.1
k->parent->red = false;
k->parent->parent->red = true;
this->rbt_rot_l(k->parent->parent);
rbt_rot_l(k->parent->parent);
}
} else {
u = k->parent->parent->right; // uncle
@ -97,19 +96,19 @@ void TreeAllocator::rbt_fix_insert(tree_block_t* k) {
if (k == k->parent->right) {
// mirror case 3.2.2
k = k->parent;
this->rbt_rot_l(k);
rbt_rot_l(k);
}
// mirror case 3.2.1
k->parent->red = false;
k->parent->parent->red = true;
this->rbt_rot_r(k->parent->parent);
rbt_rot_r(k->parent->parent);
}
}
if (k == this->free_start) {
if (k == free_start) {
break;
}
}
this->free_start->red = false;
free_start->red = false;
}
// rotate left at node x
@ -121,7 +120,7 @@ void TreeAllocator::rbt_rot_l(tree_block_t* x) {
}
y->parent = x->parent;
if (x->parent == nullptr) {
this->free_start = y;
free_start = y;
} else if (x == x->parent->left) {
x->parent->left = y;
} else {
@ -140,7 +139,7 @@ void TreeAllocator::rbt_rot_r(tree_block_t* x) {
}
y->parent = x->parent;
if (x->parent == nullptr) {
this->free_start = y;
free_start = y;
} else if (x == x->parent->right) {
x->parent->right = y;
} else {
@ -166,43 +165,43 @@ void TreeAllocator::rbt_remove(tree_block_t* z) {
bool y_original_red = y->red;
if (z->left == nullptr) {
x = z->right;
this->rbt_transplant(z, z->right);
rbt_transplant(z, z->right);
} else if (z->right == nullptr) {
x = z->left;
this->rbt_transplant(z, z->left);
rbt_transplant(z, z->left);
} else {
y = this->rbt_minimum(z->right);
y = rbt_minimum(z->right);
y_original_red = y->red;
x = y->right;
if (y->parent == z) {
x->parent = y;
} else {
this->rbt_transplant(y, y->right);
rbt_transplant(y, y->right);
y->right = z->right;
y->right->parent = y;
}
this->rbt_transplant(z, y);
rbt_transplant(z, y);
y->left = z->left;
y->left->parent = y;
y->red = z->red;
}
if (!y_original_red) {
this->rbt_fix_remove(x);
rbt_fix_remove(x);
}
}
// fix the rb tree modified by the delete operation
void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
tree_block_t* s;
while (x != this->free_start && !x->red) {
while (x != free_start && !x->red) {
if (x == x->parent->left) {
s = x->parent->right;
if (s->red) {
// case 3.1
s->red = false;
x->parent->red = true;
this->rbt_rot_l(x->parent);
rbt_rot_l(x->parent);
s = x->parent->right;
}
@ -215,7 +214,7 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
// case 3.3
s->left->red = false;
s->red = true;
this->rbt_rot_r(s);
rbt_rot_r(s);
s = x->parent->right;
}
@ -223,8 +222,8 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
s->red = x->parent->red;
x->parent->red = false;
s->right->red = false;
this->rbt_rot_l(x->parent);
x = this->free_start;
rbt_rot_l(x->parent);
x = free_start;
}
} else {
s = x->parent->left;
@ -232,7 +231,7 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
// case 3.1
s->red = false;
x->parent->red = true;
this->rbt_rot_r(x->parent);
rbt_rot_r(x->parent);
s = x->parent->left;
}
@ -245,7 +244,7 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
// case 3.3
s->right->red = false;
s->red = true;
this->rbt_rot_l(s);
rbt_rot_l(s);
s = x->parent->left;
}
@ -253,8 +252,8 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
s->red = x->parent->red;
x->parent->red = false;
s->left->red = false;
this->rbt_rot_r(x->parent);
x = this->free_start;
rbt_rot_r(x->parent);
x = free_start;
}
}
}
@ -268,17 +267,17 @@ tree_block_t* TreeAllocator::rbt_search_bestfit(tree_block_t* node, unsigned int
return nullptr;
}
if (req_size < this->get_size(node)) {
if (node->left != nullptr && this->get_size(node->left) >= req_size) {
return this->rbt_search_bestfit(node->left, req_size);
if (req_size < get_size(node)) {
if (node->left != nullptr && get_size(node->left) >= req_size) {
return rbt_search_bestfit(node->left, req_size);
}
return node;
}
if (req_size > this->get_size(node)) {
if (node->right != nullptr && this->get_size(node->right) >= req_size) {
return this->rbt_search_bestfit(node->right, req_size);
if (req_size > get_size(node)) {
if (node->right != nullptr && get_size(node->right) >= req_size) {
return rbt_search_bestfit(node->right, req_size);
}
// Block doesn't fit