Memory Management. Questions? What is an address space? What abstractions should it provide? How does he OS protect processes from one another?

Transcription

1 Memory Management Questions? What is an address space? What abstractions should it provide? How does he OS protect processes from one another? Remember what a process is? address space + 1 or more threads threads: unit of concurrency (sequential stream of execution) address space: unit of protection (memory space that the thread uses) Uniprogramming: Only one process Have the highest memory hold the OS Process is allocated memory starting at 0, up to the OS area When loading a process, just bring it in at 0.

2 128 MB OS 8 MB User Process 0 Multiprogramming: Multiple processes with protected address spaces at the same time. address space: all the data the program uses as it runs contains program code, stack, data segment(s) Goals: Provide the illusion that: Address independence: Each process can use addresses starting at 0, even if other processes are running, or even if the same program is running twice Address spaces are protected Can fool process further into thinking it has memory that's much larger than available physical memory. Called virtual memory

3 Uniprogramming and multiprogramming Some systems allowed only one process (mostly personal computers). o They are called uniprogramming systems (not uniprocessing; that means only one processor). Easier to write some parts of OS, but many other things are hard to do. E.g. compile a program in background while you edit another file; answer your phone and take messages while you're busy hacking. Early PDAs and early PCs are essentially uniprogramming systems: crash of one application crashes the entire system. Most systems allow more than one process Unix, OS/2, NT. They are called multiprogramming systems. Context-switch: If you are making both a dessert and an appetizer at the same time, switching back-and-forth between them, you are doing multiprogramming. When switching, you have to be careful to remember where you are in each activity (e.g., step in the recipe) so that you don t do the same step twice or miss a step. Operating systems must do the same thing by doing a context-switch. o Question: If you had enough CPUs so that each process can be assigned to one CPU, do you need context switches?

4 State of a process: needs to be saved and restored on context switches. Where does the OS keep track of the state of a process? o How is that different from the state of a thread? o Does a context-switch across process boundary hurt performance more than that within a process? This may become clear when we discuss use of TLBs and caching. What if a process goes into an infinite loop? How does the scheduler get control back from the process?

5 What happens if a process attempts to do something illegal (E.g., divide by 0, write outside its assigned memory area, read/write to a null pointer location): Difference between trap and interrupt? Creating a process: In Unix: fork() system call is the only way to make a new process. It makes an exact copy of existing process, including a copy of the address space and execution state. The OS allocates a new PCB for the process. The forked process does not share memory with the original process. E.g: main() { } What is printed? int i = 0; fork(); i = i + 1; Cout << i << endl;

6 What is the final value of i? What's missing in the above design of fork()? How do you make child do different things than the parent? Often, the child will load and run another program. Exec() family of calls allow a process to load a program from the file system and execute it. Do man exec for more details. What would happen if you put the fork() statement in an infinite loop? o Hint: DON T TRY THIS.

7 Running jobs in background in a command Shell: o % netscape & o The shell forks a new process, executes the typed-in command (netscape) in the new process. Meanwhile, the parent process (shell) can go back and prompt for the new command. On Windows: Fork and exec are effectively combined into a single Win32 call: CreateProcess. CreateProcess is much more complex than the two Unix calls takes about 10 parameters, including the file name of the executable, file handles to be passed to new process, security attributes for the new process, etc. What potential inefficiency is there in doing a fork() followed by exec() as in Unix versus a combined call as in Windows? How can one use copy-on-write principle to redesign fork() and avoid that inefficiency?

8 File handles: Any open file handles are inherited by a child after a fork(). Where there was previously one file handle, there will be two after a fork(). Input-output redirection. File handle 0 refers to stdin, 1 to stdout, and 2 to stderr. They are normally open before the shell starts a process and point to the keyboard (stdin) and terminal (stdout and stderr). How would a shell change it for a child so that input is read from a file? o Step 1: open the file. This may get the file handle 3, since 0, 1, and 2 are already used up. o Step 2: fork the child. Child gets the same handles 0, 1, 2, and 3. o Step 3: The child closes 0. No stdin anymore. o Step 4: The child uses the dup(handle-for-the-file) system call. This call duplicates the file handle and maps it to the lowest available handle, i.e., 0. Now, stdin will come from the file. o Step 5: The child closes handle 3. o Step 6: If the child now calls exec(binary) to execute a program, that program s stdin will come from the file. Open file handles persist across an exec() call.

9 How to switch between processes? Technique 1: Keep only process in memory at a time? Swap a process out to disk on a context switch and bring another process in. All processes run from address MB 128 MB 128 MB OS Swap P1 to disk; load P2 OS Swap P2 to disk; Swap in P1 OS 8 MB 12 MB 8 MB P1 P2 P This is relatively easy to implement, but very high overhead. Disks are very slow! To swap out a 40 MB process, it may take seconds to minutes! We would like context switches to take less than 0.1 ms if possible so that we can keep response time to users for interactive processes low.

10 Technique 2: Static Address translation We have to keep multiple processes in memory. Memory is cheap. Problem: The compiler generates binary code that assumes that the process is going to be loaded at memory address 0. But: All processes can't run at address 0. Possible solution: When the loader loads the program into memory, adjust all its addresses (used in load and store instructions) to account for where it lands in memory. MAX 128 MB OS OS Load P2 20 MB 8 MB P2 0 P1 8 MB 0 P1 Question: Why is this not sufficient to meet address space goals and a bad idea?

11 Can be difficult to do when some instructions use indirect addressing. LOAD R1, #0x44400 Is the number #0x44400 an address or a constant? It appears to be a number. However, it can be difficult to know. LOAD R1, #0x ADD R2, (R1) It is used as an address in the above case. Even if we could solve the previous problem, no protection o application can load/store arbitrary addresses o a program with a bug (or a malicious program) can crash any other program, or even the OS! Process virtual memory < physical memory. Technique 3: Dynamic Address Translation Instead of changing the address of a program before it's loaded, change the address dynamically during every reference. o virtual address: address generated by the process. Also called logical address. o physical address: actual address in physical memory at run-time

12 ProcessID, Virtual address Address Translation Box Physical address Key points: o Virtual addresses are relative to the process. Each process believes that its virtual addresses start from 0. o The process does not even know where it is located in physical memory the code executes entirely in terms of virtual addresses. LOAD R1, 23 This means load R1 with contents of virtual memory location 23. int x = 2; int *p = &x; This means that p is the virtual address of the location of x. Physical address of a memory location is not available to the process. It is known only to the address translation box and the OS. o The address translation box must know the currently running process. It maps the virtual address of that process to within the physical memory area where the process actually resides. Draw a picture to show the mapping:

13 Protection: Protection is easy to enforce; translation box can refuse to translate virtual addresses that are outside the range of memory for the process. (Generate seg faults for example). Virtual memory larger than physical memory: During translation, one can even move parts of the address space of a process between disk and memory as needed. That allows the virtual address space of the process to be much larger than the physical memory available to it. (Use physical memory as a cache). There are many ways to implement the translation box, some better than others. We will cover these in the next few lectures. Should the address translation box be implemented in hardware of software?

14 An example of an address translation scheme: Base & Bound Registers Basic Idea: Each process has two values associated with it: Base: The starting physical memory location where the process resides in memory Physical address = virtual address + Base value for that process Bound: The last physical memory location where the process resides in memory Memory protection error if virtual address < 0 OR virtual address > bound Hardware Design: Use a base and bound register in the CPU. It becomes part of the process control block (why?) Implement the translation box in hardware to make the translation fast

15 Pros o Cheap and fast to implement in hardware o Memory protection, multiprogramming Cons o Virtual memory < physical memory. Why? o Can t share code between two or more processes easily. (Why do we want that?) o How much physical memory to assign to a process? Hard to change the bound at run time. Why? o External fragmentation: As processes die and get created, we can get lots of holes (free areas) in memory, each of which is too small for a new process. Give an example: