Memory management

Memory management is the act of managing computer memory. The essential requirement of memory management is to provide ways to dynamically allocate portions of memory to programs at their request, and freeing it for reuse when no longer needed. This is critical to the computer system.

Several methods have been devised, that increase the effectiveness of memory management. Virtual memory systems separate the memory addresses used by a process from actual physical addresses, allowing separation of processes and increasing the effectively available amount of RAM using paging or swapping to secondary storage. The quality of the virtual memory manager can have a big impact on overall system performance.

Dynamic memory allocation

Details

The task of fulfilling an allocation request consists of finding a block of unused memory of sufficient size. Even though this task seems simple, several issues make the implementation complex.^{[citation needed]} One of such problems is internal and external fragmentation, which arises when there are a lot of small gaps between allocated memory blocks, which are insufficient to fulfill the request. Another is that allocator's metadata can inflate the size of (individually) small allocations; this effect can be reduced by Chunking.

Usually, memory is allocated from a large pool of unused memory area called the heap (also called the free store). Since the precise location of the allocation is not known in advance, the memory is accessed indirectly, usually via a pointer reference. The precise algorithm used to organize the memory area and allocate and deallocate chunks is hidden behind an abstract interface and may use any of the methods described below.

Efficiency

The dynamic memory allocation algorithm actually used can impact performance significantly and a study conducted in 1994 by Digital Equipment Corporation illustrates the overheads involved for a variety of allocators. The lowest average instruction path length required to allocate a single memory slot was 52 (as measured with an instruction level profiler on a variety of software).^[1]

Implementations

Fixed-size-blocks allocation

Main article: memory pool

Fixed-size-blocks allocation, also called memory pool allocation, uses a free list of fixed-size blocks of memory (often all of the same size). This works well for simple embedded systems where no large objects need to be allocated, but it suffers from fragmentation.

Buddy blocks

For more details on this topic, see Buddy memory allocation.

In this system, memory is allocated from several pools of memory instead of just one, where each pool represents blocks of memory of a certain power of two in size. If a smaller size is requested than is available, the smallest available size is selected and it is then broken in two. One of the resulting halves is selected, and the process repeats (checking the size again and splitting if needed) until the block is just large enough. All new blocks that are formed during these splits are added to their respective memory pools for later use.

All the blocks of a particular size are kept in a sorted linked list or tree. When a block is freed, it is compared to its buddy. If they are both free, they are combined and placed in the next-largest size buddy-block list (when a block is allocated, the allocator will start with the smallest sufficiently large block avoiding needlessly breaking blocks).

Systems with virtual memory

Virtual memory is a method of decoupling the memory organisation from the actual physical hardware. The applications operate memory via virtual adresses. Each time an attempt to access the actual data is made, virtual memory subsystem translates the virtual address to a physical address, which corresponds to the address of the data as seen by the hardware. The address translation process itself is managed by the operating system. In this way addition of virtual memory enables granular control over the main memory and ways to access it. This can be used to increase the effectiveness of memory management.

Protection

Main article: Memory protection

In virtual memory systems the operating system controls the ways a process can access the memory. This feature can be used to disallow a process to read or write to memory that is not allocated to the said process, essentially prevents malicious or malfunctioning code in one program from interfering with the operation of other running programs.

Sharing

Main article: Shared memory

Even though the memory for different processes is normally protected from each other, different processes sometimes need to be able to share information. One way to provide this is to allow the processes to access the same part of memory. Shared memory is one of the fastest techniques for Inter-process communication.

Physical organization

Memory is usually divided into fast primary storage and slow secondary storage. Memory management in the operating system handles moving information between these two levels of memory.

See also

• Heap (data structure)
• Automatic memory allocation
• Dynamic array
• Garbage collection
• Memory pool
• Region-based memory management
• Slab allocation
• Stack-based memory allocation
• Demand paging
• Memory management unit (MMU)
• Page table
• Paging
• Pointer
• Virtual memory

Foot notes

1. ^ http://www.eecs.northwestern.edu/~robby/uc-courses/15400-2008-spring/spe895.pdf

References

• Donald Knuth. Fundamental Algorithms, Third Edition. Addison-Wesley, 1997. ISBN 0-201-89683-4. Section 2.5: Dynamic Storage Allocation, pp. 435–456.
• Simple Memory Allocation Algorithms^{[dead link]} on OSDEV Community
• Wilson, P.R.; Johnstone, M.S.; Neely, M.; Boles, D. (1995). "Dynamic Storage Allocation: A Survey and Critical Review". Memory Management: International Workshop, Iwmm'95, Kinross, Uk, September 27-29, 1995: Proceedings (Springer). ISBN 9783540603689. http://books.google.com/?id=m0yZN2bA3TcC&pg=PA1&dq=paul+wilson. Retrieved 2008-01-06. 
• Berger, E.D.; Zorn, B.G.; McKinley, K.S. (2001). "Composing high-performance memory allocators". ACM SIGPLAN Notices 36 (5): 114–124. doi:10.1145/381694. http://portal.acm.org/citation.cfm?id=381694.378821. 
• Berger, E.D.; Zorn, B.G.; McKinley, K.S. (2002). "Reconsidering custom memory allocation". Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. ACM Press New York, NY, USA. pp. 1–12. http://portal.acm.org/citation.cfm?id=582419.582421. 

Further reading

• "Dynamic Storage Allocation: A Survey and Critical Review", Department of Computer Sciences University of Texas at Austin

External links

• Sample bit-mapped arena memory allocator in C
• TLSF: a constant time allocator for real-time systems
• Slides for knowing about Dynamic memory allocation
• Inside A Storage Allocator
• The Memory Management Reference
• Linux Memory Management
• Memory Management For System Programmers
• "Generic Memory Manager" C++ library