our version of the buddy algorithm. * If memory is to be allocated 1. Look for a memory slot of a suitable size 1. If it is found, it is allocated to the program 2. If not, it tries to make a suitable memory slot. The system does so by trying the following: 1. Split the next-largest, left-most (lowest address) free memory slot larger than the requested memory size into 2 equal halves 2. If the lower limit is reached, then allocate that amount of memory, from the left-side/lower-address slot. 3. Go back to step 1 (look for a memory slot of a suitable size) 4. Repeat this process until a suitable memory slot is found * If memory is to be freed 1. Free the block of memory 2. Look at the neighbouring block - is it free too? 3. If it is, combine the two, and go back to step 2 and repeat this process until either the upper limit is reached (all memory is freed), or until a non-free neighbour block is encountered here is the start of the world. ROOT-> free start: 0 size: 1024k 1. now we get an alloc req for 64k. we start splitting till we get a chunk of that size. first we split into two pieces of 512k: ROOT-> node / \ free free start: 0 start: 512k size:512k size: 512k now the left piece gets split into two 256k's: ROOT-> node / \ / free / start: 512k / size: 512k node / \ free free start: 0 start: 256k size: 256k size: 256k now the left 256k gets split into two 128k's: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / free / start: 256k / size: 256k node / \ free free start: 0 start: 128k size: 128k size: 128k now the left 128k gets split into two 64k's, and we allocate the left one to request A: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / free / start: 256k / size: 256k node / \ / free / start: 128k node size: 128k / \ ALLOC-A free start: 0 start: 64k size: 64k size: 64k 2. next we get a request B for 128k, and we search the tree, find it exactly, and allocate: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / free / start: 256k / size: 256k node / \ / ALLOC-B / start: 128k node size: 128k / \ ALLOC-A free start: 0 start: 64k size: 64k size: 64k 3. next we get an allocate by C for 64k. we find it and assign: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / free / start: 256k / size: 256k node / \ / ALLOC-B / start: 128k node size: 128k / \ ALLOC-A ALLOC-C start: 0 start: 64k size: 64k size: 64k 4. now we get an alloc request by D for 128k. We can't find it, so we split a 256k node in half: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ node free free / \ start: 256k start: 384k / ALLOC-B size: 128k size: 128k / start: 128k node size: 128k / \ ALLOC-A ALLOC-C start: 0 start: 64k size: 64k size: 64k then we allocate it to the left half: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ node ALLOC-D free / \ start: 256k start: 384k / ALLOC-B size: 128k size: 128k / start: 128k node size: 128k / \ ALLOC-A ALLOC-C start: 0 start: 64k size: 64k size: 64k 5. Program C releases its memory. we simply change its alloc to free. ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ node ALLOC-D free / \ start: 256k start: 384k / ALLOC-B size: 128k size: 128k / start: 128k node size: 128k / \ ALLOC-A free start: 0 start: 64k size: 64k size: 64k 6. Program A releases its memory. its alloc gets changed to free: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ node ALLOC-D free / \ start: 256k start: 384k / ALLOC-B size: 128k size: 128k / start: 128k node size: 128k / \ free free start: 0 start: 64k size: 64k size: 64k But now we notice that there is a node with two free buddies, so we combine it: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ node ALLOC-D free / \ start: 256k start: 384k free ALLOC-B size: 128k size: 128k start: 0 start: 128k size: 128k size: 128k 7. Program B releases its memory, so we free its request: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ node ALLOC-D free / \ start: 256k start: 384k free free size: 128k size: 128k start: 0 start: 128k size: 128k size: 128k There is a node with two free buddies, so we combine: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ free ALLOC-D free start: 0 start: 256k start: 384k size: 256k size: 128k size: 128k 8. Last dealloc. Program D releases, so we free its node: ROOT-> node / \ / free / start: 512k / size: 512k node / \ / \ / +------------- node / / \ free free free start: 0 start: 256k start: 384k size: 256k size: 128k size: 128k Program D's former slot now has 2 buddies, which are combined: ROOT / \ / free / start: 512k / size: 512k node / \ / \ / +------------- free / start: 256k free size: 256k start: 0 size: 256k The node above these buddies now has 2 buddies, so these combine: ROOT-> node / \ / free / start: 512k / size: 512k free start: 0 size: 512k And again, and now we're back to the start. ROOT-> free start: 0 size: 1024k