Kernel Memory Management

Transcription

1 How does the kernel allocate and manage its own memory? Department of Computer Science UofC CPSC 457 October 24, 2014

2 Agenda Midterm Answers (5 minutes) Discussion of brk() system call. (20 minutes) (25 minutes) unlike malloc(3), kernel tries to be type-aware Buddy, SLAB, SLUB, and SLOB (...)

3 Motivation: Focus Question How does the kernel handle memory allocation for itself and for processes? We ve seen memory regions, but how does the kernel actually set aside page frames? given to a process (sbrk(2), brk(2), mmap(2) malloc(3)) given to the kernel by itself (?) Key issue: how can the kernel make efficient use of the available physical frames given dynamic and unpredictable demands driven by user-level software applications?

4 Motivation/Recall: Fragmentation We briefly discussed some approaches to External Fragmentation: free but useless memory outside allocated areas Internal Fragmentation: free but unused memory inside allocated areas External fragmentation arises because you have allowed arbitrary length segments of memory to be created / allocated and deallocated. While the segment might be of the perfect size to hold the requested data structure or variable, the holes between allocated segments begin to fragment the heap (or other storage area). To address external fragmentation, you might fix a small consistent chunk size (i.e., a page of 4KB) and make sure they are all (virtually) contiguous. You ve now moved the problem to one of internal fragmentation.

5 Userland Memory Allocation Such activity is typically mediated via: programmer s use of a library-based memory allocation (malloc/free) a compiler s use of library-based memory allocation (new/delete) object constructors and VM garbage collection a home-grown memory allocation subsystem but with access to the system call API, we can dispense with them or write our own.

6 Userland Memory Allocation Example (a) Allocate memory with malloc(). (b) Allocate memory with brk(). (c) Allocate memory with sbrk(). (d) Allocate memory with mmap(). 1 byte, 1 type, 1 page. (aside: types and padding)

7 kmalloc() kmalloc (3984 estimated hits in LXR)

8 Kernel Memory Allocation Example This code should look vaugely familiar to you. GFP KERNEL is GFP WAIT GFP IO GFP FS OK to block, OK to do I/O to free page frames, OK to do filesystem ops

9 Kernel Memory Allocators The kernel typically deals with memory requests in terms of pages and page frames; many of the kernel routines for allocating and freeing memory take the linear address of a page as their argument. The Zone Allocator The Buddy System SLAB SLUB SLOB (SLAB / SLUB / SLOB) are mutually exclusive.

10 The Zoned Page Frame Allocator Due to hardware pecularities, page frames are not uniformly equivalent. Per-cpu hot (keep hardware cache lines warm) and cold (page to be used for DMA) caches.

11 Zones Physical memory is actually several nodes (i.e., chips). Each node is divided into three zones: ZONE DMA (page frames below 16MB) ZONE NORMAL (page frames between 16MB and 896MB) ZONE HIGHMEM (page frames greater or equal to 896MB)

12 The Zone Allocator The ZA serves as a generic source of page frames for specific allocator implementations (e.g., SLAB, SLUB, SLOB). It has to perform several duties: avoid taking frames from the reserved pool invoke the PFRA when memory is low avoid handing out frames from the ZONE DMA zone if possible and its job is to deliver frames to the more specific algorithms. It may invoke the OOM Killer if it finds the system critically low on memory.

13 The Buddy System Buddy System s main goal: avoid external fragmentation. It does so by trying hard to match a requested allocation size (in number of pages) with an available block of physically contiguous frames. If paging solves the external fragmentation problem, why do we care to have a complex Buddy System Algorithm? Aren t virtually contiguous page frames enough? some types of memory transfer (e.g., DMA) require physically contiguous pages avoiding manipulation of page tables avoids TLB flushes (doubleplusgood) support for 4MB pages

14 The Buddy System in Operation (i) free page frames fall into 11 lists of blocks (ii) groups contain 1,2,4,8,16,32,64,128,512,1024 (i.e., 4MB) contiguous page frames (iii) need N pages; look in current group. If none free, goto next free group, allocate N pages, move rest to appropriate lower level. The term Buddy System arises from the coalescing of reclaimed page blocks. Buddies: (1) have the same size b, (2) are contiguous, and (3) the first buddy is aligned s.t. its physical address is a multiple of the combined size 2*b*4096

15 The SLAB Allocator This is the oldest Linux page allocator. A slab is a generic concept; SLAB is the name of the implementation. The secret here is that the kernel tries very hard to be type-aware as much as it can, unlike malloc(3). observation: different types of data may affect how an area is allocated and used a memory area is really for holding an object with particular semantics (data structure, ctor, dtor) kernel tends to burst requests for same data type memory areas can be binned according to frequency of requests cache - slab - object picture SLAB allocator asks zoned page frame allocator to provide a group of available contiguous frames (which it then associates with a slab)

16 cat /proc/slabinfo

17 SLUB This is the current default allocator in Linux. It is very close in design to SLAB, but offload metadata to the page structure (about 40MB for tracking all physical page frames): types.h#l40

18 SLOB A lightweight allocator, mostly for use in embedded systems. Abandons the cache/slab/object hierarchy in favor of a simplified small/medium/large grouping of pages (all pages belong to one of these lists). This is a direct contrast to SLAB/SLUB, which attempt to keep object sizes related to the slab they are associated with. In the SLOB approach, different structures of different types might live on the same medium page.

19 SLOB in linux/mm/slob.c

20 Takeaway Message Kernel memory allocation is an interesting example of the practical forces that exist on allocating a resource such as memory. Kernel memory allocation approaches are based on simple, well-known algorithms like the Buddy System or first fit (see SLOB), but are complicated by the need to deal with the properties of the underlying memory hardware, TLBs, and caching circuitry.

21 Resources Material for this lecture was drawn from: LKD, Chapter 12: Memory Management ULK, Chapter 17: Page Frame Reclaiming ULK, Chapter 8: Memory Management

22 Questions Some things we won t cover: non-contiguous memory areas NUMA: Non-uniform memory access memory pools SLQB, SLEB