Upload
bernard-caldwell
View
17
Download
1
Embed Size (px)
DESCRIPTION
Introduction Computer System Structures Operating System Structures Processes Process Synchronization Deadlocks CPU Scheduling. Memory Management Virtual Memory File Management Security Networking Distributed Systems Case Studies Conclusions. - PowerPoint PPT Presentation
Citation preview
Memory Management 1 © 2000 Franz Kurfess
Course OverviewPrinciples of Operating Systems
Course OverviewPrinciples of Operating Systems
Introduction Computer System
Structures Operating System
Structures Processes Process Synchronization Deadlocks CPU Scheduling
Memory Management Virtual Memory File Management Security Networking Distributed Systems Case Studies Conclusions
Memory Management 2 © 2000 Franz Kurfess
Chapter Overview Memory Management
Chapter Overview Memory Management
Motivation Objectives Background Address Spaces
logical physical
Partitioning fixed dynamic
Swapping
Contiguous Allocation Paging Segmentation Segmentation with Paging Important Concepts and
Terms Chapter Summary
Memory Management 3 © 2000 Franz Kurfess
MotivationMotivation
after CPU time, memory is the second most important resource in a computer system
even with relatively large amounts of memory, the amount of available memory is often not satisfactory
getting information from hard disk instead of main memory takes orders of magnitudes longer 60 ns access time for main memory 10 ms (= 10,000,000 ns) average access time for hard
disks
several processes must coexist in memory
Memory Management 4 © 2000 Franz Kurfess
ObjectivesObjectives
understand the purpose and usage of main memory in computer systems
understand the addressing scheme used by the CPU to access information in main memory
distinguish between logical and physical addresses understand various methods to allocate available
memory sections to processes
Memory Management 5 © 2000 Franz Kurfess
Background and PrerequisitesBackground and Prerequisites
main memory and computer system architecture linking and loading program execution and processes instruction execution
Memory Management 6 © 2000 Franz Kurfess
MemoryMemory
main memory is used to store information required for the execution of programs code, data, auxiliary information
the CPU can only access items that are in main memory
memory is a large array of addressable words or bytes
a process needs memory space to execute sufficient memory can increase the utilization of
resources and improve response time
Memory Management 7 © 2000 Franz Kurfess
Hardware ArchitectureHardware Architecture
[David Jones]
CPUMain Memory
I/O Devices
System Bus
Control Unit
Reg
iste
rs
Arithmetic LogicUnit
(ALU)
Controllers
Memory Management 8 © 2000 Franz Kurfess
CPU
Main Memory
Bus
Control Unit
Reg
iste
rs
Arithmetic LogicUnit
(ALU)
Memory and CPUMemory and CPU
MM
U
Memory Management 9 © 2000 Franz Kurfess
Memory OrganizationMemory Organization memory size =
memory “height” * memory width usually measured in MByte
memory “height” number of memory locations = physical address space
memory width number of bits per memory location either one Byte or one word
memory location each location has its own unique (physical)
address larger items may be assigned to consecutive
locations
0
7FFFFMain Memory
Memory Management 10 © 2000 Franz Kurfess
Hierarchy of Storage DevicesHierarchy of Storage DevicesRegisters
Cache
Main Memory
Electronic Disk
Magnetic Disk
Optical Disk
Magnetic Tape
Memory Management 11 © 2000 Franz Kurfess
Storage Device CharacteristicsStorage Device CharacteristicsStorageDevice
AccessSpeed
Capacity Cost Volatility
Registers nanoseconds Kbytes veryhigh
high
Cache tens ofnanoseconds
Mbytes $100 perMbyte
high
MainMemory
50-70nanoseconds
tens orhundreds of
Mbytes
$10 perMbyte
high
ElectronicDisk
100-200nanoseconds
hundreds ofMbytes
$1 perMbyte
medium(battery)
MagneticDisk
5-15milliseconds
tens of Gbytes $100 perGbyte
low
OpticalDisk
100milliseconds
hundreds ofGbytes
$10 perGbyte
low
TapeDrive
milliseconds toseconds
hundreds ofGbytes to
TBytes
$1 perGbyte
low
Memory Management 12 © 2000 Franz Kurfess
From Program to ProcessFrom Program to ProcessProcess Image
Process Control Block
User Stack
Shared Address Space
Data
Program
Load Module
Data
Program
Loader
Data
Program
Memory Management 13 © 2000 Franz Kurfess
Linking and LoadingLinking and Loading
LinkerLibrary
Module 1
Module 2
Module 3Loader
Main Memory
ProcessImage
Load Module
Memory Management 14 © 2000 Franz Kurfess
LinkingLinking
several components are combined into one load module modules, objects libraries
references across modules must be resolved the load module is passed to the loader
Memory Management 15 © 2000 Franz Kurfess
Static vs. Dynamic LinkingStatic vs. Dynamic Linking
static linking done at compile or link time does not facilitate sharing of libraries
dynamic linking linking is deferred until load or runtime to allow integration
of libraries
Memory Management 16 © 2000 Franz Kurfess
Dynamic Runtime LinkingDynamic Runtime Linking
linking is postponed until runtime unresolved references initiate the loading of the
respective module and its linking to the calling module
easy sharing of modules only the modules that are really needed are loaded
and linked rather complex
Memory Management 17 © 2000 Franz Kurfess
LoadingLoading
creation of an active process from a program process image
process image is loaded into main memory execution can start now
symbolic addresses must be resolved into relative or absolute addresses
absolute loading relocatable loading dynamic run-time loading
Memory Management 18 © 2000 Franz Kurfess
Absolute LoadingAbsolute Loading
a given load module must always be given the same location in main memory
all address references must be absolute refer to the starting address of physical memory can be done by the programmer or compiler
severe disadvantages inflexible: modifications require recoding or recompilation
of the program requires knowledge about memory allocation impractical for multiprogramming, multitasking, etc.
Memory Management 19 © 2000 Franz Kurfess
Relocatable LoadingRelocatable Loading
load module can be located anywhere in main memory
addresses are relative to the start of the program the location where the image is loaded is added to
the relative address at load time or during execution
Memory Management 20 © 2000 Franz Kurfess
Dynamic Runtime LoadingDynamic Runtime Loading
memory references are still relative in the process image when it is loaded into main memory
the absolute address is only calculated when the instruction is executed requires hardware support (MMU)
allows swapping out and back in of processes the new location of a process may be different after a
swap
Memory Management 21 © 2000 Franz Kurfess
Processes and AddressesProcesses and AddressesProcess
Process Control Block
User Stack
Shared Address Space
Data
Program
Process ControlInformation
Program EntryPoint
Top of Stack
ProgramExecution
Data Access
process image determines logical address
space must be placed in physical
memory process execution
relative addresses: relevant information is addressed within the process image
must be converted to absolute (physical) addresses
Memory Management 22 © 2000 Franz Kurfess
Process in Main MemoryProcess in Main MemoryMain Memory
Process Control Block
User Stack
Shared Address Space
Data
Program
Process ControlInformation
Program EntryPoint
Top of Stack
ProgramExecution
Data Access
mapping from logical address space (process image) to physical address space (main memory) memory size address conversions
contiguous allocation the whole process
image is allocated in one piece
Memory Management 23 © 2000 Franz Kurfess
Processes and Address SpacesProcesses and Address SpacesProcess 1 Process 2 Process n
Process Identification
Process StateInformation
Process Control Information
System Stack
User Stack
UserAddress Space
Shared Address Space
Process Identification
Process StateInformation
Process Control Information
System Stack
User Stack
UserAddress Space
Shared Address Space
Process Identification
Process StateInformation
Process Control Information
System Stack
User Stack
UserAddress Space
Process ControlBlock
[adapted from Stallings 98]
Memory Management 24 © 2000 Franz Kurfess
Processes in MemoryProcesses in Memory several processes need to
be accommodated OS has its own memory
section simplified view
larger number of processes processes do not occupy one
single section in memory, but several smaller ones (non-contiguous allocation)
not the whole process image is always present in memory (virtual memory)
Process 1
Process 2
Process n
OperatingSystem
Main Memory
Memory Management 25 © 2000 Franz Kurfess
Instruction Execution CycleInstruction Execution Cycle
the execution of one instruction consists of several steps fetch an instruction from memory decode the instruction fetch operands from memory execute instruction store result in memory
the execution of one instruction may require several memory accesses even worse with indirect addressing (pointers)
Memory Management 26 © 2000 Franz Kurfess
TerminologyTerminology contiguous allocation
information is stored in consecutive memory addresses a process occupies a single section of memory
non-contiguous allocation a process is distributed over several, disjoint sections of main
memory information is not necessarily stored in consecutive addresses
real memory memory directly available in the form of RAM chips
virtual memory extension of real memory through the use hard disk space for less
frequently used information
Memory Management 27 © 2000 Franz Kurfess
Terminology (cont.)Terminology (cont.) logical address
address generated by the CPU
physical addresses address applied to memory chips
block data are transferred in units of fixed size used for hard disks and similar devices typical block sizes are 512 Bytes to 16 KBytes
locality of reference there is a good chance that the next access to instructions or data will be
close to the current one
fragmentation memory or disk space is allocated in small parts, leading to inefficient
utilization
Memory Management 28 © 2000 Franz Kurfess
Memory Management Requirements
Memory Management Requirements
relocation protection sharing logical organization physical organization
Memory Management 29 © 2000 Franz Kurfess
RelocationRelocation
the location of a process image in main memory may be different for different runs of the program availability of memory areas at the start of the execution process may be temporarily swapped out
as a consequence, the logical address is different from the physical address
the conversion is performed by the memory management
common schemes require hardware support special registers, or memory management unit (MMU)
Memory Management 30 © 2000 Franz Kurfess
Static RelocationStatic Relocation
relocation done at linking or at loading time requires knowledge about available memory sections
a statically relocated program cannot be moved once it has its memory section assigned
Memory Management 31 © 2000 Franz Kurfess
Dynamic RelocationDynamic Relocation
relocation done at run time requires hardware support
relocation registers, MMU
the process image, or a part of it, can be moved around at any time the value of the relocation registers must be changed
accordingly
Memory Management 32 © 2000 Franz Kurfess
ProtectionProtection processes may only access their own memory sections
in addition, shared memory sections may be accessible to selected processes
access to other memory areas must be restricted sections of other processes sections of the operating system
memory references must be checked at run time the location and size of the memory section of a process may
change during execution
requires hardware assistance frequently relocation and limit register
Memory Management 33 © 2000 Franz Kurfess
SharingSharing
code processes executing the same program should share its
code
data data structures used by several programs
examples for sharing code libraries common programs (editors, mail, etc.) producer-consumer scenarios with shared memory
Memory Management 34 © 2000 Franz Kurfess
Shared LibrariesShared Libraries
prewritten code for commonly used functions is stored in libraries
statically linked libraries library code is linked at link time into an executable
program results in large executables with no sharing
dynamically linked libraries if libraries are linked at run time they can be shared
between processes
Memory Management 35 © 2000 Franz Kurfess
Logical OrganizationLogical Organization
abstract view of memory programs are usually composed of separate modules,
procedures, objects, etc. separate management of these components allows
various optimizations development, testing, compilation allocation sharing protection
it also is more complicated references across modules must be resolved at runtime
Memory Management 36 © 2000 Franz Kurfess
Physical OrganizationPhysical Organization
view of memory as physical device dictated by the structure of hardware
size of the physical address space available memory size memory width arrangement of memory modules
interleaved memory, banks, etc.
usually handled by the MMU
Memory Management 37 © 2000 Franz Kurfess
Address SpacesAddress Spaces
address binding logical address space physical address space
Memory Management 38 © 2000 Franz Kurfess
Logical to Physical AddressLogical to Physical AddressProcess
Process Control Block
User Stack
Shared Address Space
Data
Program
Main Memory
CPU MMU
log
ical
ad
dre
ss
ph
ysic
al a
dd
ress
Memory Management 39 © 2000 Franz Kurfess
Logical vs. Physical AddressLogical vs. Physical Address
+logicaladdress
physicaladdress
MAR
relocationregister
Memory
CPU
logical address is generated by the CPU
physical address is loaded into the memory address register (MAR) usually part of the MMU
Memory Management 40 © 2000 Franz Kurfess
Memory AllocationMemory Allocation
assign sections of memory to processes section size: partitioning contiguous
one section per process
non-contiguous each process has several sections
Memory Management 41 © 2000 Franz Kurfess
PartitioningPartitioning
fixed/dynamic paging/segmentation virtual memory
Memory Management 42 © 2000 Franz Kurfess
Fixed PartitioningFixed Partitioning
memory is divided into a number of fixed partitions sizes of partitions may be different
chosen by the OS, developer, system administrator
maintain a queue for each partition internal fragmentation
space in a partition not used by a process is lost
number of partitions (specified at system generation) limits number of active processes
Small jobs do not use partition space efficiently used by older IBM OS/360 (MFT)
Memory Management 43 © 2000 Franz Kurfess
OS
50K
100K
200K
75K
Fixed Partitions - Multiple QueuesFixed Partitions - Multiple Queues
Processes
MainMemory
Memory Management 44 © 2000 Franz Kurfess
OS
50K
100K
200K
75K
Fixed Partitions - Single QueueFixed Partitions - Single Queue
ProcessesMainMemory
Memory Management 45 © 2000 Franz Kurfess
Variable PartitioningVariable Partitioning
each process is assigned a partition number, size, and location of the partition can vary overcomes some problems of fixed partitioning
but still inefficient use of memory
higher overhead
Memory Management 46 © 2000 Franz Kurfess
SwappingSwapping
processes are temporarily taken out of main memory to make more space available
swap space secondary storage space provides a special area for these
processes
swap time very high compared with in-memory context switch example:
1 MByte process image, 10 MByte/sec transfer rate= 100 ms swap time
head seek time, latency not considered
Memory Management 47 © 2000 Franz Kurfess
Dynamic Storage AllocationDynamic Storage Allocation
problem: find a suitable free section of memory to accommodate a process
analogy: packing boxes of different sizes ~ free memory sections items to be packed ~ processes
Memory Management 48 © 2000 Franz Kurfess
Storage Allocation StrategiesStorage Allocation Strategies
first-fit:allocate the first hole that is big enough
best-fit: allocate the smallest hole that is big enough
worst-fit: allocate the largest hole
Memory Management 49 © 2000 Franz Kurfess
First-FitFirst-Fit
low overhead no searching required
generates reasonably large holes on average
Memory Management 50 © 2000 Franz Kurfess
Best-FitBest-Fit
slower than first-fit must search the entire list
tends to fill up memory with tiny useless holes can be made faster by sorting the hole list by size
Memory Management 51 © 2000 Franz Kurfess
Worst-FitWorst-Fit
worst-fit leaves larger holes than best-fit
Memory Management 52 © 2000 Franz Kurfess
ObservationsObservations
overhead to keep track of small holes may be substantially larger than the hole itself
in simulations first-fit and best-fit give better results, with first-fit being faster
separate lists for processes and holes to speed up these algorithms
Memory Management 53 © 2000 Franz Kurfess
Keeping Track of Memory UsageKeeping Track of Memory Usage
bit maps linked lists
Memory Management 54 © 2000 Franz Kurfess
Bit MapsBit Maps
memory is divided into allocation units each allocation unit is represented by a bit bit map shows which parts of the memory are in use
or free
Memory Management 55 © 2000 Franz Kurfess
Memory
...
Bit Map
...0 1 1 1 0 1 0 0
Bit MapBit Map
Memory Management 56 © 2000 Franz Kurfess
Bit Map PropertiesBit Map Properties
the smaller the allocation unit the bigger the bit map once the allocation unit is fixed, the size of the bit
map does not change for a fixed (physical) memory size
searching a bit map for a block of a certain size is a slow operation requires counting the number of successive ones or zeros
Memory Management 57 © 2000 Franz Kurfess
Linked ListsLinked Lists
memory is represented by a linked list of allocated and free segments
the list is sorted by address facilitates updating
when a process terminates, its space can be combined with that of its neighbors
Memory Management 58 © 2000 Franz Kurfess
Contiguous AllocationContiguous Allocation
each process occupies a single memory section requires adjustment of addresses for relocation may lead to inefficient memory utilization
processes must fit into free memory sections relatively large “holes” may be left
Memory Management 59 © 2000 Franz Kurfess
Contiguous AllocationContiguous AllocationMain Memory
Process Control Block
User Stack
Shared Address Space
Data
Program
Process ControlInformation
Program EntryPoint
Top of Stack
ProgramExecution
Data Access
contiguous allocation the whole process
image is allocated in one piece
Memory Management 60 © 2000 Franz Kurfess
Non-Contiguous AllocationNon-Contiguous Allocation
a process occupies several disjoint memory sections addresses need to be adjusted for relocation and
displacement relative distances between different sections of one process
better memory utilization small free sections can be utilized by parts of processes “holes” still exist, but are smaller
higher overhead requires a table to keep track of the parts of a process
usually in the form of paging, segmentation
Memory Management 61 © 2000 Franz Kurfess
Non-Contiguous AllocationNon-Contiguous AllocationMain Memory
Process Control Block
Process ControlInformation
Program EntryPoint
Top of Stack
ProgramExecution
Data Access
parts of the process image are allocated to different sections of main memory
may break relative addresses
Program
Data
User Stack
Memory Management 62 © 2000 Franz Kurfess
PagingPaging
a frequently used case of non-contiguous allocation the process image is divided into pieces of equal
size (pages) physical memory is divided into pieces of the same
size (page frames) any page can be allocated to any page frame memory allocation becomes very simple additional overhead to keep track of which page is in
which page frame kept in a page table
Memory Management 63 © 2000 Franz Kurfess
Paging DiagramPaging DiagramProcess
Process Control Block
User Stack
Shared Address Space
Data
Program
Main Memory
Page Table
123
56789101112131415
3458
122
99385543
131102171
76123144
93
4 68
Memory Management 64 © 2000 Franz Kurfess
Page SizePage Size
small page size less internal fragmentation large page table
large page size less overhead, both in
page table size page transfer time.
Memory Management 65 © 2000 Franz Kurfess
Page Table ImplementationPage Table Implementation
set of dedicated registers memory associative registers
Memory Management 66 © 2000 Franz Kurfess
Dedicated RegistersDedicated Registers
reasonable only for small page tables example:
16 bit logical address space
page size = 8K
page table size = 8
Memory Management 67 © 2000 Franz Kurfess
Page Table in MemoryPage Table in Memory
use a page table base register (PTBR) to point to the page table of the current process
two memory accesses are needed for every data access
speed could be intolerable
Memory Management 68 © 2000 Franz Kurfess
Address TranslationAddress TranslationMain Memory
3458
122
99385543
131102171
76123144
93
68
CPU
logical address physical address
Page Table
page # frame #offset offset
Memory Management 69 © 2000 Franz Kurfess
Address TranslationAddress Translation the page table contains an entry for every page of the
process each process has its own page table
a logical address is divided into page number and offset
the physical address is calculated by looking up the frame in which the requested page resides adding the offset to the starting address of that frame
the page table itself is in main memory as a consequence an extra memory access is required for every
regular memory access this doubles the overall time for memory accesses
Memory Management 70 © 2000 Franz Kurfess
Address TranslationAddress Translation
page = logical-address / page-size offset = logical-address mod page-size page-frame = page-table[page] physical address =
(page-frame * page-size) + offset
Memory Management 71 © 2000 Franz Kurfess
Fragmentation in PagingFragmentation in Paging
no external fragmentation every page frame can be used
internal fragmentation the last page in the logical space of every process may not
be completely used (on average: half a page per process)
Memory Management 72 © 2000 Franz Kurfess
Associative RegistersAssociative Registers
associative registers or translation look-aside buffers (TLBs)
special-purpose hardware to improve access times for paging
acts as cache for page table entries only few page table entries are kept in the associative
registers hit ratio is the percentage of times that a page number
is found in the associative registers simultaneous (“associative”) access to all stored values
Memory Management 73 © 2000 Franz Kurfess
TLB SchemaTLB SchemaMain Memory
TLB
CPU
logical address
physical address
3458
122
99385543
131102171
76123144
93
68
Page Table
page # offset
frame # offset
page # frame #
TLB hit
TLBmiss
Memory Management 74 © 2000 Franz Kurfess
Effective Access TimeEffective Access Time
the average access time for main memory depends on how often the requested page number is found in the TLB this is known as the hit ratio
the effective access time (EAT) is calculated by weighing the case when the page is found in the TLB vs. not found according to the probability given by the hit ratio
effective access time = hit ratio * entry found + (1-hit ratio) * entry not found
Memory Management 75 © 2000 Franz Kurfess
Example EATExample EAT basic assumptions
memory access time: 60 ns; TLB access time: 6 ns EAT no paging: 60 ns EAT page table only: 60 ns + 60 ns = 120 ns EAT TLB/page table
hit ratio 90% EAT = 0.9 * (6 + 60) + 0.1 * (6 + 60 + 60)
= 59.4 + 12.6 = 72 20% performance loss with respect to “no paging”
hit ratio 99% EAT = 0.99 * (6 + 60) + 0.01 * (6 + 60 + 60)
= 65.34 + 1.26 = 66.60 11% performance loss with respect to “no paging”
Memory Management 76 © 2000 Franz Kurfess
ProtectionProtection
protection bits are associated with each page a page can have any combination of: read, write, or
execute permissions
Memory Management 77 © 2000 Franz Kurfess
Very Large Page TablesVery Large Page Tables
page tables can be huge:
32-bit virtual address space (maximum size of processes)
4K page size
page table size = 232 / 212 = 220 entries
over 1 million entries!
Memory Management 78 © 2000 Franz Kurfess
Multilevel PagingMultilevel Paging
instead of using huge page tables, the page table itself can be paged it is split up into several smaller level 2 page tables these tables are accessed via a level 1 page table the page number is divided into two parts
level 1 page number page offset for level 2 pages
modern computer architectures/OSs support multilevel paging Windows NT, OS/2: 32-bit virtual address, two-level paging, 4K
page size Unix: hardware dependent (three or four levels)
Memory Management 79 © 2000 Franz Kurfess
Multilevel PagingMultilevel PagingMain Memory
CPU
logical address
physical address
Level 1Page Table
p1 p2 offset
frame # offset
page #
Level 2Page Tables
p2
Memory Management 80 © 2000 Franz Kurfess
Inverted Page TablesInverted Page Tables
one page table in memory for all processes size of the table is determined by physical memory each process maintains an external page table on secondary
storage inverted page table maps page frames to the virtual
pages of various processes advantage
avoids keeping huge page tables in main memory disadvantage
cannot use page number as index into the page table must search for process id in the table
Memory Management 81 © 2000 Franz Kurfess
Inverted Page TableInverted Page TableMain Memory
CPU
logical address
physical address
Hash Table
pid page # offset
frame # offset
Page Table
pid page # frame
Memory Management 82 © 2000 Franz Kurfess
Shared PagesShared Pages
pages holding the code section of commonly used programs can be shared code must be re-entrant data sections must be different
each user’s page table maps the pages into the same physical frames
page boundaries do not necessarily coincide with the structure of the program
Memory Management 83 © 2000 Franz Kurfess
code
data
editor process
5
2
3
4
P00
editor
editor
editor
data - P2
data - P0
data - P1
Shared Pages ExampleShared Pages Example
page tables 5
2
3
0
P1
5
2
3
7
P2
1
2
3
4
5
6
7
Memory Management 84 © 2000 Franz Kurfess
SegmentationSegmentation
logical address space is divided into segments according to the internal structure of the process program: procedures, functions data: records, arrays
management is more complicated each segment has to be dynamically allocated
sharing of segments is easier boundaries are reflected
external fragmentation
Memory Management 85 © 2000 Franz Kurfess
Segmentation Diagram
Segmentation Diagram
Process
Process Control Block
User Stack
Shared Address Space
Data
Program
Main Memory
Program
Segment Table
123
56789101112131415
234425592872
65398958025733662291169221447008612310449309
4
Program
6539
Memory Management 86 © 2000 Franz Kurfess
Combined Paging/SegmentationCombined Paging/Segmentation
paging characteristics transparent to the programmer eliminates external fragmentation manipulating fixed size blocks implies development of
sophisticated memory management algorithms
segmentation characteristics visible to programmer ability to handle dynamic data structures modularity support for protection and sharing
Memory Management 87 © 2000 Franz Kurfess
Segmentation with PagingSegmentation with Paging
paging is used to manage the segments combines advantages of both approaches
Memory Management 88 © 2000 Franz Kurfess
Important Concepts and TermsImportant Concepts and Terms address binding best fit allocation bit map contiguous allocation dynamic linking/loading dynamic relocation effective access time external fragmentation first fit allocation fragmentation hardware internal fragmentation inverted page table library linker
loader logical address memory protection MMU multilevel paging non-contiguous allocation page page frame page table physical address relocation run-time dynamic linking segmentation static relocation worst fit allocation
Memory Management 89 © 2000 Franz Kurfess
Summary Memory ManagementSummary Memory Management
allocation of processes in main memory efficient utilization of memory various allocation strategies paging and segmentation