Memory Management - cs.tufts.edu · Partitioning Wednesday, October 27, 2004 4:58 AM Memory Management Page 6. Understanding fixed partitioning Some actions are time-critical, e.g.,

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.

Memory Management Wednesday, October 27, 20044:54 AM

Memory Management Page 1

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.


Internal fragmentation: Fragmentation exists in physical memoryFragmentation does not exist in mapped memory.

External fragmentation:Fragmentation exists in mapped memory. Fragmentation may or may not exist in physical memory.


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


Defragmentationcollect 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.


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 loadedIn same placeRegardless of what happens in processes

○ Resident programs: "Lock" themselves into memory. Use same pages for their lifetime.

Partitioning Wednesday, October 27, 20044:58 AM


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.


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.


Memory management challengesFragmentation: 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

Memory management challenges

Wednesday, October 27, 20047:59 AM


Fragmentation kinds:


Fragmentation causes:○ Fixed page size.

Program size is not a multiple of page sizeSo 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.


Buddy system algorithm○ Start with 2k bytes/blocks/pages○ If you need m bytes, you actually get 2p

bytes, for some p, 2(p-1)<m<=2p

○ "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).

Buddy System Algorithm Wednesday, October 27, 20048:14 AM


Buddy system in use:


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];


Buddy system example








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) thenUnlink 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 liststruct descriptor *head = free[current]; free[current]=free[current]->next;

// Get new descriptorstruct descriptor *newone = getdesc();

// point new descriptor at upper halfnewone->memory = (void *)((char *)(head->memory)+(1<<(current-1)));

// link two elements into next smaller free listhead->next=free[current-1];free[current-1]=head;newone->next=free[current-1]; free[current-1]=newone;

// successreturn true;

} else {Return false;

}

If current list contains an element,


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


More details of buddy algorithm

When you free a chunk of memoryLet 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 sizeIf its nearest neighbor is contiguous, then

combine(current);

void combine(int current) { // unlink contiguous componentsIf (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.

}


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.


What's wrong with this picture: o(n) used list scan for freeo(1) allocation. <= n steps, n=levels => constant. How do we fix the o(n)?

Fixes get rid of used listuse 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:


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.


To fix thisseparate storage descriptorskeep used listo(n) for free. (enable malloc debugging and it does this)


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/writeread-onlynot accessible

Can't be arbitrarily expressiveminimum unit that can have an attribute: 1 pagesegment: operates on a group of pages to assign one attribute

Nomenclature Thursday, October 28, 20046:17 AM



Kernel viewall process pages are also physical frames with physical addresseskernel 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.


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 functionuses the kernelmay modify the memory mapmay take advantage of info at physical addresses.

basic principle: minimize system functionsprovide "cohesive" system interface.

Whysbrk MUST modify the memory map and run in kernel mode. there MUST be a map change in order for sbrk to worksbrk takes significantly more time than an application function call.



Properties of a memory mapbijective: uniqueness in both directions.

Each physical frame corresponds to a unique logical page. Each logical page corresponds to a unique physical frame.


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"

Basic memory mapping model Thursday, October 28, 20046:20 AM



Basic memory mapping: processor support○ Base register: physical address of logical

address 0.○ Bounds register: contains size of map


Hardware translation



Generalization of simple memory mappingEach logical address is separated into a page number and an offset

0xc400

A page table keeps track of the correspondence between pages and frames.

Page tables Thursday, October 28, 20046:38 AM


Caveats about page tablesPage length is always a power of 2For 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!


Four levelsis page table cache enough? is page in memory? is page on disk? else FAIL.


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.

Segmentation Thursday, October 28, 20045:48 AM


Segments in a UNIX process


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.

Thursday, November 11, 20046:03 PM


Memory Management - cs.tufts.edu · Partitioning Wednesday, October 27, 2004 4:58 AM Memory Management Page 6. Understanding fixed partitioning Some actions are time-critical, e.g.,

Documents