c++ Memory Management Buddy System Weird Memory Address Issue - memory

Question

I am attempting to implement a buddy memory system using c++, but I am running into some issues. I assign a memory address to an element in an array, and the memory address that is stored in main is different than the one returned by the function. I believe there is an error when the address is stored, resetting it to a "valid" position, but i'm not sure which one is the "correct" address. Code and input are posted below.
void buddy_manager(memoryNode* root, process* processes, int num){
int i = 0, count = 0, removed = 0, j = 0;
process running[num];
while(removed < 5){
if(i % 50 == 0 && count<5){
cout << "Adding process: " << count << endl;
running[count] = processes[count];
running[count].space = my_malloc(root, running[count].memory * 1000);
printf("Made new node # %p \n", running[count].space);
count++;
}
//Check to remove the process from the list omitted
}
char* my_malloc (memoryNode* root, int size) {
//If there are child nodes and the current node is not occupied, visit them!
if(root->left != NULL && root->right != NULL && root->occupied == 0){
if(my_malloc(root->left, size) == NULL){
my_malloc(root->right, size);
}
} else{ //we are at a leaf node
if(root->max_size >= size && root->max_size/2 < size && root->left == NULL && root->right == NULL && root->occupied == 0){ //if the node is good for insertion{
printf("address of new node: %p with slize: %d and element size: %d \n", root->start, root->max_size, size);
root->occupied = 1;
return root->start;
} else if(!(root->max_size > size && root->max_size/2 < size) && root->max_size > 0 && root->occupied == 0 && root->left == NULL && root->right == NULL) { //Grow the tree
root->left = new memoryNode(root->start, root->max_size/2, NULL, NULL, 0);
root->right = new memoryNode((char*)(root->start + (root->max_size)/2), root->max_size/2, NULL, NULL, 0);
//printf("Made new nodes at %p and %p \n", root->left->start, root->right->start);
my_malloc(root->left, size);
} else{
return NULL;
}
}
}
My output is as follows:
address of new node: 0xb6d86008 with size: 156250 and element size: 94000
Made new node # 0xb6d86008
Adding process: 1
address of new node: 0xb6dd24bc with size: 312500 and element size: 193000
Made new node # 0xb6dd2400
Adding process: 2
address of new node: 0xb6e1e970 with size: 156250 and element size: 106000
Made new node # 0xb6e1e900
Adding process: 3
address of new node: 0xb6dc8c25 with size: 39062 and element size: 26000
Made new node # 0xb6dc8c00
Adding process: 4
address of new node: 0xb6e44bca with size: 19531 and element size: 18000
Made new node # 0xb6e44b00
A you can see, the first node is fine, but the rest of the nodes end up getting reset to 00 for their last two digits.

Answer 1

A wild guess, if you're using a 32-bit system:
The size of your process structure is not a multiple of 4 bytes. So the space field in the second element of your process running[num] array is not properly aligned to a 4-byte address.
Adding 4-sizeof(process)%4 bytes at the end of this structure should solve the problem.
A wild guess, if you're using a 64-bit system:
The size of your process structure is not a multiple of 8 bytes. So the space field in the second element of your process running[num] array is not properly aligned to an 8-byte address.
Adding 8-sizeof(process)%8 bytes at the end of this structure should solve the problem.
UPDATE:
If you have verified that the issue above is not the reason behind the problem, then print root->start before returning it from function my_malloc, and make sure that it's always aligned to 4 (or 8) bytes.
I've also noticed that function my_malloc doesn't return a value in all cases, which might be leading to undefined behavior (I don't understand how you managed to compile it without an error to begin with).
So inside this function, add return before my_malloc(root->left, size).