Memory Management: The process by which memory is shared, allocated, and released. Not applicable to cache memory.

Transcription

1 Memory Management Page 1 Memory Management Wednesday, October 27, :54 AM Memory Management: The process by which memory is shared, allocated, and released. Not applicable to cache memory. Two kinds of memory management exposed in the operating system: Physical: what is the fast memory used for? Virtual: using disk to simulate extra memory.

2 Memory Management Page 2 Memory management tasks Relocation: moving processes from one area of memory to another. Protection: not allowing user processes to access privileged data. Sharing: allocation and de-allocation of shared resources. Logical organization: what do pages of memory "mean" to processes. Physical organization: what real pages are used for what logical tasks.

3 Internal fragmentation: Fragmentation exists in physical memory Fragmentation does not exist in mapped memory. External fragmentation: Fragmentation exists in mapped memory. Fragmentation may or may not exist in physical memory. Memory Management Page 3

4 What's going on? In the normal process of allocation and de-allocation, memory gets "fragmented" Memory Management Page 4

5 Defragmentation collect all fragments, put them back together, and make access faster. can't do this with real memory. Reason: in C, you can't tell the difference at runtime between pointer and integer. If you move something, you have to move all pointers. Can't "defragment" logical memory. No memory manager can compensate for invariant weaknesses of language. Memory Management Page 5

6 Memory Management Page 6 Partitioning Wednesday, October 27, :58 AM Partitioning The process by which regions of memory are dedicated to particular tasks. Fixed partitioning: pages of memory that always are used for the same thing. Operating system: Always loaded In same place Regardless of what happens in processes Resident programs: "Lock" themselves into memory. Use same pages for their lifetime.

7 Memory Management Page 7 Understanding fixed partitioning Some actions are time-critical, e.g., responding to an I/O device or emptying a buffer. In these cases, "swapping" in order to load code to run is unacceptable. Must "lock" certain time-critical code (including the kernel and any required modules) into memory for fast access.

8 Memory Management Page 8 Things you don't need to know about fixed partitioning No modern operating system uses fixed partitioning for user processes. Instead, modern operating systems depend upon: Pagination: breaking process maps into "pages". Segmentation: separating process memory into segments by use.

9 Memory Management Page 9 Memory management challenges Wednesday, October 27, :59 AM Memory management challenges Fragmentation: memory is broken up into segments with gaps between them; must find a "fragment" big enough for each use. Internal fragmentation: must allocate more memory than needed. External fragmentation: unused memory lies in small gaps between processes

10 Fragmentation kinds: Memory Management Page 10

11 Memory Management Page 11 Fragmentation causes: Fixed page size. Program size is not a multiple of page size So there's room "left over"; internal fragmentation. "Buddy system" Many algorithms depend upon dividing up resources. Allocation sizes are a power of two of pages.

12 Memory Management Page 12 Buddy System Algorithm Wednesday, October 27, :14 AM Buddy system algorithm Start with 2 k bytes/blocks/pages If you need m bytes, you actually get 2 p bytes, for some p, 2 (p-1) <m<=2 p "Divy up" large blocks into smaller blocks by dividing size by two Trick: if we keep linked lists of each size, and limit sizes to 2^p, then can search for a "matching" unused element in o(1).

13 Buddy system in use: Memory Management Page 13

14 Memory Management Page 14 Buddy system descriptors For every memory allocation algorithm, need some kind of description of what memory is in use and what is unused. Buddy system descriptors: array of linked lists of memory descriptors, which themselves live in an array. // simple descriptor table // separate from allocated memory. struct descriptor { struct descriptor *next; void *memory; } descriptors[tablesize], *free[powers], *used[powers];

15 Buddy system example Memory Management Page 15

16 Buddy system example Memory Management Page 16

17 Buddy system example Memory Management Page 17

18 Buddy system example Memory Management Page 18

19 Memory Management Page 19 Details of buddy algorithm When you need a chunk of memory, Start at free list for least power of two greater than size; call its number "current". If that free list contains an element, or divide(current + 1) then Unlink it. Link to used list. Return pointer to memory. int divide(int current) { If current>=powers) return false; if (free[current] divide(current+1)) { // unlink first element of list struct descriptor *head = free[current]; free[current]=free[current]->next; // Get new descriptor struct descriptor *newone = getdesc(); // point new descriptor at upper half newone->memory = (void *)((char *)(head-> memory)+(1<<(current-1))); // link two elements into next smaller free list head->next=free[current-1]; free[current-1]=head; newone->next=free[current-1]; free[current-1]=newone; // success return true; } else { Return false; } If current list contains an element,

20 If current list contains an element, Divide element in half Unlink element from free list, Get new descriptor for top half, Link both descriptors into free[current-1] Memory Management Page 20

21 Memory Management Page 21 More details of buddy algorithm When you free a chunk of memory Let the current used list it is in be called "current". Unlink it from used list for its size. Link it into free list for its size If its nearest neighbor is contiguous, then combine(current); void combine(int current) { // unlink contiguous components If (free[current] && free[current]->next and these are contiguous blocks, Unlink both from current free list. Return descriptor of high block to descriptor pool. Link descriptor of low block into next higher free list. }

22 Memory Management Page 22 Strengths of 'buddy system" Can defragment unused memory easily; low external fragmentation. Principle of locality => defragmentation is likely. Can reuse segments by division or combination with other segments. Speed: descriptor table is really easy to search for unallocated blocks of the appropriate size. Weaknesses of "buddy system" Resource overhead: for every request, there is wasted memory (internal fragmentation) (though at release, the fragmentation ceases) Still used for dynamic memory allocation (malloc and free) and kernel memory allocation. Not used anymore for static process memory.

23 Memory Management Page 23 What's wrong with this picture: o(n) used list scan for free o(1) allocation. <= n steps, n=levels => constant. How do we fix the o(n)? Fixes get rid of used list use local descriptors to replace it. "trust" application to return a valid pointer (note: in the previous version, we didn't need to trust, if we sent an invalid element, free could INFER that) First, must change each memory element:

24 Memory Management Page 24 Way this is written struct desc { struct desc *next; int power; } ; char *buf = { pointer to 128 bytes of memory } Manipulate (struct desc *buf) as LL element. Hand out (void *) ((char *)buf+8) as address from malloc. Get back same address, call it b. Get struct desc as (struct desc *)((char *)b-8) This solution is fast: o(1) for allocate and deallocate. unsafe: can easily mess up storage descriptor with the application, e.g., int *a = (int *)malloc(5*sizeof(int)); a[-1]=10; // lie about length of block.

25 To fix this separate storage descriptors keep used list o(n) for free. (enable malloc debugging and it does this) Memory Management Page 25

26 Memory Management Page 26 Nomenclature Thursday, October 28, :17 AM We need a new language to understand how an operating system handles memory allocation Page: a unit of memory that a process needs. Every page has a Logical address within the process. Frame: a unit of memory that the processor has. Every frame has a Physical address: where it is in the machine Segment: a group of logically contiguous pages with a particular function within a process. Game: want to be precise about exactly what a process can do with a page. read/write read-only not accessible Can't be arbitrarily expressive minimum unit that can have an attribute: 1 page segment: operates on a group of pages to assign one attribute

27 Memory Management Page 27

28 Memory Management Page 28 Kernel view all process pages are also physical frames with physical addresses kernel knows what segment they're, as well as map. How segments are determined: ld takes.o files, create a.out, has segments. when you run it, ld.so (shared linker) adds "shared libraries". ".so" files. final image contains segment markers.

29 fundamental difference between an "application function" and an "OS function". application function: lives in logical memory. doesn't make system calls (except for limited reasons, e.g., sbrk) does not use the kernel. system function uses the kernel may modify the memory map may take advantage of info at physical addresses. basic principle: minimize system functions provide "cohesive" system interface. Why sbrk MUST modify the memory map and run in kernel mode. there MUST be a map change in order for sbrk to work sbrk takes significantly more time than an application function call. Memory Management Page 29

30 Memory Management Page 30

31 Properties of a memory map bijective: uniqueness in both directions. Each physical frame corresponds to a unique logical page. Each logical page corresponds to a unique physical frame. Memory Management Page 31

32 Memory Management Page 32 Basic memory mapping model Thursday, October 28, :20 AM Basic memory mapping model Establish a map between pages and frames When the process requests memory from a page, translate into the appropriate frame address, then do the work. If there is no frame address for a page address, crash. "Segmentation fault; core dumped"

33 Memory Management Page 33

34 Memory Management Page 34 Basic memory mapping: processor support Base register: physical address of logical address 0. Bounds register: contains size of map

35 Hardware translation Memory Management Page 35

36 Memory Management Page 36

37 Memory Management Page 37 Page tables Thursday, October 28, :38 AM Generalization of simple memory mapping Each logical address is separated into a page number and an offset 0xc400 A page table keeps track of the correspondence between pages and frames.

38 Caveats about page tables Page length is always a power of 2 For large processes, page table can only be partly loaded into the processor. Processor contains a page table cache of part of the page table. This is a part of process context! Memory Management Page 38

39 Four levels is page table cache enough? is page in memory? is page on disk? else FAIL. Memory Management Page 39

40 Memory Management Page 40 Segmentation Thursday, October 28, :48 AM Segmentation A logical way of grouping a set of pages together. Independent of paging scheme. Intent: group pages by function, protection, sharing, etc. Segment descriptor table: encodes protections for segments. An OS can use both page maps and segments. Typically not supported by the processor; a software abstraction. Book's example of segmentation without paging does not occur in practice.

41 Segments in a UNIX process Memory Management Page 41

42 Memory Management Page 42 Thursday, November 11, :03 PM Missing piece: malloc and free (new and delete) calls sbrk to get a page at a time. manages heap memory. "allows holes" "buddy system" System calls: Malloc might call sbrk. Free never calls sbrk. From point of view of OS, memory for a process only grows. Reason: pointers can't be unravelled; need new model of memory in order to recover blocks.