1. Chapter 91 Memory Management Chapter 9   Review of process from source to executable (linking, loading, addressing)   General discussion of memory management issues and requirements   Physical and virtual memory   Fixed and dynamic partitioning   Paging   Segmentation

2. From Source to Executable Compiler main() sub1() data source program foo.c main sub1 data object modules foo.o printf scanf gets fopen exit data... static library libc.a Linkage Editor main sub1 data printf exit data load module a.out other programs... main sub1 data printf exit data other... kernel Machine memory ? (system calls) Loader (Run Time) Dynamic library case not shown “Load time”

3. Chapter 93 Linking and Loading  Linking. Bind together the different parts of a program in order to make them into a runnable entity - Linkage editor static (before execution) dynamic (on demand during execution)  Loading. Program is loaded into main memory, ready to execute. May involve address translation. Absolute, relocatable static, dynamic

4. Chapter 94 Addressing Requirements for a Process

5. Chapter 95 Binding of Instructions and Data to Memory Addresses Compile time: If memory location known a priori, absolute code can be generated; must recompile code if starting location changes. Load time: If memory location is not known at compile time, compiler must generate relocatable code. Loader knows final location and binds addresses for that location Execution time: If the process can be moved during its execution, binding must be delayed until run time. Need hardware support for address maps (e.g., base and limit registers).

6. Chapter 96 Aspects of Loading  Finding free memory for load module: could be contiguous or not contiguous  Adjust addresses in program (if required) once it is known where module will be loaded

7. Chapter 97 Addressing Relative address  Linker unifies all object files into a common single address space  Starts at 0 Absolute address  Actual memory address in real memory when loaded  2 choices Add a constant (size of OS) to all addresses Use reallocation

8. Chapter 98 Memory Management  Management tasks carried out by the OS and hardware to accommodate multiple programs in main memory If only a few programs can be in main memory, then much of the time all processes will be blocked waiting for I/O and the CPU will be idle So our object is to allocate memory efficiently to pack as many programs into memory as possible

9. Chapter 99 Memory Management  In most schemes, the kernel occupies some fixed portion of main memory  the rest of memory is shared by all the other programs

10. Chapter 910 Swapping

11. Chapter 911 Memory-Management Issues  Relocation  Protection  Sharing  Logical Organization  Physical Organization

12. Chapter 912 Memory Management Requirements  Relocation Programmer cannot know where the program will be loaded in memory when it is executed A program may be relocated (often) in main memory due to swapping Memory references in code (for both instructions and data) must be translated to actual physical memory addresses

13. Chapter 913 Memory Management Requirements  Protection Processes should not reference memory locations in another process without permission Cannot do this at compile time, because we do not know where the program will be loaded in memory èaddress references must be checked at run time by hardware

14. Chapter 914 Memory Management Requirements  Sharing must allow several processes to access a common portion of data or program without compromising protection  cooperating processes may need to share access to the same data structure  Program text can be shared by several processes executing the same program for a different user Saves memory over separate copy for each also applies to dynamic (sharable) libraries

15. Chapter 915 Memory Management Requirements  Logical Organization Programs are written in modules  code is usually execute-only (reentrant)  data modules can be read-only or read/write  References between modules must be resolved at run time  Segmentation is one useful approach for all this but not the only approach

16. Chapter 916 Memory Management Requirements  Physical Organization Memory hierarchy: (several types of memory: from slow and large to small and fast.) main memory for program and data currently in use, secondary memory is the long term store for swapping and paging moving information between levels of memory is a major concern of memory and file management (OS)  should be transparent to the application programmer

17. Chapter 917 Physical and Virtual Memory  Physical Memory: the actual main memory (RAM) of the computer  Virtual Memory: the address space as seen by a program: can be much larger (or much smaller) than the physical memory. We’ll look at virtual memory later…..

18. Chapter 918 Simple Memory Management  We start with the case where a process image is projected in simple fashion on physical memory normally, this implies that the process image is smaller than physical memory and the program is fully loaded for execution (but see overlays)..  We will look at the following simple memory management techniques : fixed partitioning dynamic partitioning simple paging simple segmentation

19. Chapter 919 Fixed Partitioning (Single Process)  If only one process allowed (e.g. MS-DOS): only one user partition and one for the OS  Not many decisions to make: program either fits or it doesn’t I/O and Interrupt vectors “OperatingSystem” (BIOS) User space 640k

20. Chapter 920 Fixed Partitioning  Partition main memory into a set of non overlapping regions called partitions  Partitions can be of equal or unequal sizes ..both pictures show partitioning of 64 M main memory

21. Chapter 921 Fixed Partitioning  any program smaller than a partition can be loaded into the partition  if all partitions are occupied, the operating system can swap a process out of a partition to make room  a program may be too large to fit in a partition. The programmer would then use overlays: when a module needed is not present the user program must load that module into a part of the program’s partition, overlaying whatever program or data were there before

22. Chapter 922 Overlays Partition Resident part of the program Swapped part of the program

23. Chapter 923 Fixed Partitioning  Main memory use is inefficient. Any program, no matter how small, occupies an entire partition. This leaves holes of unused memory inside the partitions: internal fragmentation.  Unequal-size partitions can help put small programs in small partitions but there will still be holes...  Equal-size partitions was used in early IBM’s OS/MFT (Multiprogramming with a Fixed number of Tasks)

24. Chapter 924 Placement Algorithm with Partitions  Equal-size partitions If there is an available partition, a program can be loaded into that partition  because all partitions are of equal size, it does not matter which partition is used If all partitions are occupied by blocked processes, choose one program to swap out to make room for a new program

25. Chapter 925 Placement Algorithm with Partitions  Unequal-size partitions: fed from a single queue When it is time to load a process into main memory the smallest available partition that will hold the program is selected increases the level of multiprogramming  Does not eliminate internal fragmentation