Static partition techniques are limited by having a fixed number of active processes, and space use may not be optimal. The buddy system is a memory allocation and management technique that uses power-of-two increments. Assume the memory size is 2U and a size of S is required. In this article, we are going to discuss the Buddy System in detail along with examples, advantages, disadvantages, etc.
What is the Buddy System?
Buddy System is a memory allocation technique used in computer OS to allocate and manage memory efficiently. This technique by dividing the memory into fixed-size blocks, and whenever a process requests memory, the system finds the smallest available block that can accommodate the requested memory size.
The Buddy System is a reminiscence control method utilized in working systems to allocate memory dynamically. It is by and large applied in systems wherein reminiscence is allocated and deallocated frequently, inclusive in multitasking environments or structures with varying memory demands. In the Buddy System, the memory is split into fixed-length blocks, regularly in powers of (e.g., 1KB, 2KB, 4KB, and so on.). When a request for memory allocation is made, the device seems for the correct-sized block. If an appropriate block is determined, it’s far allocated to the inquiring manner. However, if the asked size doesn’t shape any existing block precisely, the device allocates a bigger block after which splits it into smaller blocks till an accurately sized one is received.
Algorithm of Buddy System Memory Allocation Technique
Below are the steps involved in the Buddy System Memory Allocation Technique:
- The first step includes the division of memory into fixed-sized blocks that have a power of 2 in size (such as 2, 4, 8, 16, 32, 64, 128, etc. ).
- Each block is labeled with its size and unique identification.
- Initially, all the memory blocks are free and are linked together in a binary tree structure, with each node representing a block and the tree’s leaves representing the smallest available blocks.
- When a process requests memory, the system finds the smallest available block that can accommodate the requested size. If the block is larger than the requested size, the system splits the block into two equal-sized “buddy” blocks.
- The system marks one of the buddy blocks as allocated and adds it to the process’s memory allocation table, while the other buddy block is returned to the free memory pool and linked back into the binary tree structure.
- When a process releases memory, the system marks the corresponding block as free and looks for its buddy block. If the buddy block is also free, the system merges the two blocks into a larger block and links it back into the binary tree structure.
The Buddy System technique has several advantages, including efficient use of memory, reduced fragmentation, and fast allocation and deallocation of memory blocks. However, it also has some drawbacks, such as internal fragmentation, where a block may be larger than what the process requires, leading to a waste of memory. Overall, the Buddy System is a useful memory allocation technique in operating systems, particularly for embedded systems with limited memory.
- If 2U-1<S<=2U: Allocate the whole block
- Else: Recursively divide the block equally and test the condition at each time, when it satisfies, allocate the block and get out of the loop.
The system also keeps a record of all the unallocated blocks and can merge these different-sized blocks to make one big chunk.
Types of Buddy System
The Buddy System in memory control generally refers to a selected method used to allocate and deallocate memory blocks. However, within this framework, versions or adaptations may additionally exist relying on specific necessities or optimizations wished for distinctive structures. Here are a few types of Buddy Systems:
- Fibonacci Buddy System: A Fibonacci buddy system has block sizes of 16, 32, 48, 80, 128, and 208 bytes, with each block size equal to the total of the two blocks previous it. When a block is divided from one free list, its two portions are added to the two free lists that came before it. It can be minimized by bringing the allowable block sizes close together. Now, let’s look at an example to better grasp the Fibonacci buddy system. Assume the memory size is 377 kb. Then, 377 kb will be partitioned into 144 kb and 233 kb. Following that, 144 will be divided into (55 + 89), whereas 233 will be divided into (89 + 144). This separation will continue based on memory requirements.
- Binary Buddy System: The buddy system keeps track of the free blocks of each size (known as a free list) so that you can easily discover a block of the necessary size if one is available. If no blocks of the requested size are available, Allocate examines the first non-empty list for blocks of at least the requested size. In both cases, a block is deleted from the free list. For ex: The 512 KB memory size is initially partitioned into two active partitions of 256 KB each, with additional subdivisions based on a capacity of 2 to handle memory requests.
- Weighted Buddy System: In a weighted peer system, each memory block is associated with a weight, which represents its size relative to other blocks. When a memory allocation request occurs, the system searches for the appropriate block considering the size of the requested memory and the weight of the available blocks.
- Tertiary Buddy System : In a traditional buddy system, memory is divided into blocks of fixed size, usually a power of 2, and allocated to these blocks but the tertiary buddy system introduces a third memory structure, which allows flexibility large in memory allocation.
Features of Buddy System
- Scalability: The Buddy System can scale nicely with growing memory demands. It can manage huge quantities of memory efficiently by means of dividing it into smaller blocks and dynamically adjusting block sizes based totally on allocation and deallocation styles.
- Efficient Splitting and Merging: The Buddy System ensures that memory blocks are split and merged effectively. When a block is allotted, it’s divided into smaller pal blocks. Conversely, when memory is deallocated, the gadget tests if the friend of the deallocated block is also free. If so, they’re merged back into a larger block.
- Reduced Fragmentation: By correctly splitting and merging reminiscence blocks, the Buddy System enables reduce memory fragmentation. Fragmentation occurs whilst memory is allotted and deallocated in a manner that leaves small, unusable gaps between allocated blocks. The Buddy System minimizes this by way of merging adjacent loose blocks into large ones whenever feasible.
- Allocation Efficiency: The Buddy System presents quite speedy allocation and deallocation of memory blocks. Since memory blocks are pre-allotted and managed in a based manner, the overhead of finding and allocating reminiscence is decreased compared to extra complicated reminiscence control strategies.
- Power of Two Block Sizes: The Buddy System commonly divides memory into blocks of sizes which can be powers of (e.g., 1KB, 2KB, 4KB, etc.). This simplifies the splitting and merging strategies, as blocks may be easily divided or blended.
Advantages of Buddy System
- Easy to implement a buddy system
- Allocates block of correct size
- It is easy to merge adjacent holes
- Fast to allocate memory and de-allocating memory
- It provides optimal memory performance while allocating blocks of memory of appropriate size and prevents unnecessary memory waste, unlike other allocation techniques which allocate larger memory blocks than necessary
- It provides a flexible and efficient way to manage memory allocation in systems that require dynamic memory allocation, such as embedded systems and operating systems
- It can handle a large number of small memory allocations efficiently thanks to its block partitioning mechanism, which helps prevent fragmentation and keeps system performance up
- It can prevent memory leaks by ensuring that all shared memory is cleared when not in use, which can improve system stability and reliability
- It provides a high level of flexibility in memory allocation and monitoring processes, which is particularly useful in systems that require frequent memory allocation and sharing, such as real-time systems
Disadvantages of Buddy System
- It requires all allocation unit to be powers of 2
- It leads to internal fragmentation
- It is designed for fixed-sized memory allocations, and it is not suitable for variable-sized allocations. This can limit its applicability in some systems, such as databases and file systems.
- It is a general-purpose memory allocation technique and may not be optimal for all applications. Some applications may require more specialized memory allocation techniques to achieve the best performance.
Example of Buddy system
Consider a system having buddy system with physical address space 128 KB.Calculate the size of partition for 18 KB process.
Solution:
Frequently Asked Question on Buddy System – FAQs
How does the Buddy System work?
In the Buddy System, memory is split into constant-size blocks. When a reminiscence allocation request is made, the system searches for the ideal-sized block. If an actual match is discovered, the block is allotted. Otherwise, a bigger block is cut up into smaller “friend” blocks till an accurately sized one is acquired. When reminiscence is deallocated, the system merges adjacent loose blocks back into larger blocks to reduce fragmentation.
What are the advantages of the Buddy System?
Some advantages of the Buddy System encompass decreased fragmentation, efficient reminiscence allocation and deallocation, scalability with increasing reminiscence demands, and comparatively easy implementation as compared to more complicated reminiscence management techniques.
Where is the Buddy System used?
The Buddy System is normally used in running structures, mainly in environments wherein memory is allotted and deallocated frequently, including multitasking structures or structures with varying memory needs. It is frequently hired in reminiscence allocators, which includes the pal allocator in the Linux kernel.