Memory Management – Module - 2
MEMORY MANAGEMENT
Module – 4
4.1 Swapping
A process needs to be in memory to be executed. A process, can be swapped temporarily out of
memory to a backing store, and then brought back into memory for continued execution. For
example, assume a multiprogramming environment with a round-robin CPU-scheduling algorithm.
When a quantum expires, the memory manager will start to swap out the process that just finished,
and to swap in another process to the memory space that has been freed (Figure 4.1). When each
process finishes its quantum, it will be swapped with another process. Memory manager can swap
processes fast enough that some processes will be in memory, ready to execute, when the CPU
scheduler wants to reschedule the CPU. The quantum must also be sufficiently large that reasonable
amounts of computing are done between swaps.
Figure. 4.1 Swapping of two processes using a disk as a backing store.
A variant of this swapping policy is used for priority-based scheduling algorithms. If a higher-priority
process arrives and wants service, the memory manager can swap out the lower-priority process so
that it can load and execute the higher-priority process. When the higher-priority process finishes,
the lower-priority process can be swapped back in and continued. This variant of swapping is
sometimes called roll out, roll in.
Normally a process that is swapped out will be swapped back into the same memory space that it
occupied previously. This restriction is dictated by the method of address binding. If binding is done
at assembly or load time, then the process cannot be moved to different locations. If execution-time
binding is being used, then a process can be swapped into a different memory space, because the
physical addresses are computed during execution time.
Swapping requires a backing store. The backing store is commonly a fast disk. It must be large enough
to accommodate copies of all memory images for all users, and it must provide direct access to these
memory images. The system maintains a ready queue consisting of all processes whose memory
images are on the backing store or in memory and are ready to run. Whenever the CPU scheduler
decides to execute a process, it calls the dispatcher. The dispatcher checks to see whether the next
process in the queue is in memory. If not, and there is no free memory region, the dispatcher swaps
out a process currently in memory and swaps in the desired process. It then reloads registers as
normal and transfers control to the selected process.
Memory Management – Module - 2
The context-switch time in such a swapping system is fairly high. To get an idea of the context-switch
time, let us assume that the user process is of size 1 MB and the backing store is a standard hard disk
with a transfer rate of 5 MB per second. The actual transfer of the 1 MB process to or from memory
takes 1000 KB/5000 KB per second = 1 /5 second = 200 milliseconds. Assuming that no head seeks
are necessary and an average latency of 8 milliseconds, the swap time takes 208 milliseconds. Since
we must both swap out and swap in, the total swap time is then about 416 milliseconds. For efficient
CPU utilization, we want our execution time for each process to be long relative to the swap time.
Thus, in a round-robin CPU-scheduling algorithm, for example, the time quantum should be
substantially larger than 0.416 seconds.
4.2 Contiguous Memory Allocation
The main memory must accommodate both the operating system and the various user processes.
The memory is usually divided into two partitions: one for the resident operating system, and one
for the user processes. The operating system is placed in either low memory or high memory. The
major factor affecting this decision is the location of the interrupt vector. Since the interrupt vector
is often in low memory, programmers usually place the operating system in low memory.
We usually want several user processes to reside in memory at the same time. We therefore need
to consider how to allocate available memory to the processes that are in the input queue waiting
to be brought into memory. In this contiguous memory allocation, each process is contained in a
single contiguous section of memory.
4.2.1 Memory Protection
Protection can be provided by using a relocation register and with a limit register. The relocation
register contains the value of the smallest physical address; the limit register contains the range of
logical addresses (for example, relocation = 100040 and limit = 74600). With relocation and limit
registers, each logical address must be less than the limit register; the MMU maps the logical address
dynamically by adding the value in the relocation register. This mapped address is sent to memory
(Figure 4.2).
Figure 4.2 Hardware support for relocation and limit registers
When the CPU scheduler selects a process for execution, the dispatcher loads the relocation and
limit registers with the correct values as part of the context switch. Because every address generated
by the CPU is checked against these registers, we can protect both the operating system and the
other users' programs and data from being modified by this running process. The relocation-register
scheme provides an effective way to allow the operating-system size to change dynamically.
4.2.2 Memory Allocation
Memory Management – Module - 2
 One of the simplest methods for memory allocation is to divide memory into several fixed-sized
partitions.
 Each partition may contain exactly one process. Thus, the degree of multiprogramming is bound
by the number of partitions.
 In this multiple-partition method, when a partition is free, a process is selected from the input
queue and is loaded into the free partition. When the process terminates, the partition becomes
available for another process.
 The operating system keeps a table indicating which parts of memory are available and which
are occupied.
 As processes enter the system, they are put into an input queue.
 When a process is allocated space, it is loaded into memory and it can then compete for the CPU.
When a process terminates, it releases its memory, which the operating system may then fill with
another process from the input queue.
 A set of holes, of various sizes, is scattered throughout memory at any given time. When a
process arrives and needs memory, the system searches this set for a hole that is large enough
for this process.
 If the hole is too large, it is split into two: One part is allocated to the arriving process; the other
is returned to the set of holes.
 When a process terminates, it releases its block of memory, which is then placed back in the set
of holes.
 If the new hole is adjacent to other holes, these adjacent holes are merged to form one larger
hole.
 This procedure is a particular instance of the general dynamic storage allocation problem, which
is how to satisfy a request of size n from a list of free holes.
 There are many solutions to this problem. The set of holes is searched to determine which hole
is best to allocate. The first-fit, best-fit, and worst-fit strategies are the most common ones used
to select a free hole from the set of available holes.
Firstfit: Allocate the first hole that is big enough. Searching can start either at the beginning of the
set of holes or where the previous first-fit search ended. Searching is stopped as soon as we find a
free hole that is large enough.
Bestfit: Allocate the smallest hole that is big enough. We must search the entire list, unless the list is
kept ordered by size. This strategy produces the smallest leftover hole.
Worst fit: Allocate the largest hole. Again, we must search the entire list, unless it is sorted by size.
This strategy produces the largest leftover hole, which may be more useful than the smaller leftover
hole from a best-fit approach.
 Simulations have shown that both first fit and best fit are better than worst fit in terms of
decreasing both time and storage utilization. Neither first fit nor best fit is better in terms of
storage utilization, but first fit is generally faster.
 These algorithms, suffer from external fragmentation. As processes are loaded and removed
from memory, the free memory space is broken into little pieces.
4.2.3 Fragmentation : Memory Fragmentation can be internal as well as external.
Memory Management – Module - 2
 External fragmentation exists when enough total memory space exists to satisfy a request, but
it is not contiguous; storage is fragmented into a large number of small holes. In the worst case,
we could have a block of free (or wasted) memory between every two processes. If all this
memory were in one big free block, several more processes can be run.





One solution to the problem of external fragmentation is compaction. The goal is to shuffle the
memory contents to place all free memory together in one large block.
Compaction is not always possible. If relocation is static and is done at assembly or load time,
compaction cannot be done; compaction is possible only if relocation is dynamic, and is done at
execution time.
If addresses are relocated dynamically, relocation requires only moving the program and data, and
then changing the base register to reflect the new base address.
When compaction is possible, we must determine its cost. The simplest compaction algorithm is
simply to move all processes toward one end of memory; all holes move in the other direction,
producing one large hole of available memory. This scheme can be expensive.
Another possible solution to the external-fragmentation problem is to permit the logical-address
space of a process to be noncontiguous, thus allowing a process to be allocated physical memory
wherever the latter is available. Two complementary techniques achieve this solution: paging and
segmentation. These techniques can also be combined.
Figure 4.3(a) Example for external fragmentation

Figure 4.3(b) Example for external fragmentation
Internal Fragmentation: The memory allocated to a process may be slightly larger than the
requested memory. The difference between two numbers is internal fragmentation – memory
that is internal to a partition but is not being used.


Consider a multiple partition allocation scheme with a hole of 18,464 bytes. Suppose that the next
process requests 18,462 bytes. If we allocate exactly the requested block, we are left with a hole of 2
bytes. The overhead to keep track of this hole will be substantially larger than the hole itself.
The general approach is to break the physical memory into fixed-sized blocks, and allocate memory
in unit of block sizes.
Partition size is
18,464
Required memory is
18,462
Unused memory –
Internal Fragmentation
Figure 4.4 Example of Internal fragmentation
4.3 Paging
Memory Management – Module - 2
 Paging is a memory-management scheme that permits the physical-address space of a process
to be noncontiguous.
 Paging avoids the considerable problem of fitting the varying-sized memory chunks onto the
backing store. Because of its advantages over the previous methods, paging is commonly used in
most operating systems.
 Support for paging has been handled by hardware. Paging is implemented on 64-bit
microprocessors.
Figure 4.5 Paging hardware
 Physical memory is broken into fixed-sized blocks called frames.
 Logical memory is also broken into blocks of the same size called pages.
 When a process is to be executed, its pages are loaded into any available memory frames from
the backing store.
 The backing store is divided into fixed-sized blocks that are of the same size as the memory
frames. The hardware support for paging is illustrated in Figure 4.5.
 Every address generated by the CPU is divided into two parts: a page number (p) and a page
offset (d). The page number is used as an index into a page table.
 The page table contains the base address of each page in physical memory. This base address is
combined with the page offset to define the physical memory address that is sent to the memory
unit. The paging model of memory is shown in Figure 4.6.
Figure4.6 Paging model of logical and physical memory
Memory Management – Module - 2
 The size of a page is typically a power of 2, varying between 512 bytes and 16 MB per page. If the
size of logical-address space is 2m, and a page size is 2n addressing units (bytes or words), then
the high-order m – n bits of a logical address designate the page number, and the n low-order
bits designate the page offset. Thus, the logical address is as follows:
Page number
page offset
p
d
m-n
n
where p is an index into the page table and d is the displacement within the page.
 Consider the memory in Figure 4.7. Using a page size of 4 bytes and a physical memory of 32
bytes (8 pages), we show how the user's view of memory can be mapped into physical memory.
 Logical address 0 is page 0, offset 0. Indexing into the page table, we find that page 0 is in frame
5. Thus, logical address 0 maps to physical address 20 (= (5 x 4) + 0).
 Logical address 3 (page 0, offset 3) maps to physical address 23 (= (5 x 4) + 3).
 Logical address 4 is page 1, offset 0; according to the page table, page 1 is mapped to frame 6.
Thus, logical address 4 maps to physical address 24 (= (6 x 4) + 0).
 Logical address 13 maps to physical address 9.
Figure 4.7 Paging example for a 32-byte memory with 4-byte pages
 In paging, there is no external fragmentation. Any free frame can be allocated to a process that
needs it.
 But paging may have some internal fragmentation. If the memory requirements of a process do
not happen to fall on page boundaries, the last frame allocated may not be completely full. For
example, if pages are 2,048 bytes, a process of 72,766 bytes would need 35 pages plus 1,086
bytes. It would be allocated 36 frames, resulting in an internal fragmentation of 2048 - 1086 =
962 bytes.
 Pages typically are between 4 KB and 8 KB, and some systems support even larger page sizes.
Some CPUs and kernels even support multiple page sizes. For instance, Solaris uses 8 KB and 4
MB page sizes.
Memory Management – Module - 2
Hardware support:
 The hardware implementation of the page table can be done in several ways.
 In the simplest case, the page table is implemented as a set of dedicated registers. The CPU
dispatcher reloads these registers, just as it reloads the other registers. The use of registers for
the page table is satisfactory if the page table is reasonably small (for example, 256 entries).
 Most contemporary computers, allow the page table to be very large (for example, 1 million
entries). For these machines, the use of fast registers to implement the page table is not feasible.
Rather, the page table is kept in main memory, and a page-table base register (PTBR) points to
the page table. Changing page tables requires changing only this register. The problem with this
approach is the time required to access a user memory location. If we want to access location i,
we must first index into the page table, using the value in the PTBR offset by the page number
for i. This task requires a memory access.
 The standard solution to this problem is to use a special, small, fast lookup hardware cache, called
translation look-aside buffer (TLB). The TLB is associative, high-speed memory. Each entry in the
TLB consists of two parts: a key (or tag) and a value. When the associative memory is presented
with an item, it is compared with all keys simultaneously. If the item is found, the corresponding
value field is returned. The search is fast; the hardware, however, is expensive. Typically, the
number of entries in a TLB is small, often numbering between 64 and 1,024.
 The TLB is used with page tables in the following way. The TLB contains only a few of the pagetable entries. When a logical address is generated by the CPU, its page number is presented to
the TLB. If the page number is found, its frame number is immediately available and is used to
access memory. If the page number is not in the TLB (known as a TLB miss), a memory reference
to the page table must be made. When the frame number is obtained, we can use it to access
memory (Figure 4.8). In addition, we add the page number and frame number to the TLB, so that
they will be found quickly on the next reference. If the TLB is already full of entries, the operating
system must select one for replacement. Replacement policies range from least recently used
(LRU) to random.
Figure 4.8 Paging hardware with TLB
Memory Management – Module - 2
4.4 Segmentation
 Segmentation is a memory-management scheme that supports the user view of memory.
 A logical-address space is a collection of segments.
 The user specifies each address by two quantities: a segment name and an offset. Each of these
segments is referred to by name and is of variable length. Segments are numbered and are
referred to by a segment number, rather than by a segment name. Thus, a logical address consists
of a two tuple: <segment-number, offset>.
 Memory is viewed as a collection of variable-sized segments, with no necessary ordering among
segments (Figure 4.9)
 Elements within a segment are identified by their offset from the beginning of the segment: The
first statement of the program, the seventeenth entry in the symbol table, and so on.
 The user program is compiled, and the compiler automatically constructs segments reflecting the
input program. A Pascal compiler might create separate segments for the following: the global
variables; the procedure call stack, to store parameters and return addresses; the code portion
of each procedure or function; the local variables of each procedure and function.
Figure 4.9 User’s view of a program
Hardware:
 The user can refer to objects in the program by a two-dimensional address, the actual physical
memory is a one-dimensional sequence of bytes.
 Thus, we must define an implementation to map two dimensional user-defined addresses into
one-dimensional physical addresses. This mapping is affected by a segment table.
 Each entry of the segment table has a segment base and a segment limit. The segment base
contains the starting physical address where the segment resides in memory, whereas the
segment limit specifies the length of the segment. The use of a segment table is illustrated in
Figure 4.10.
Figure 4.10 Segmentation hardware
Memory Management – Module - 2
 A logical address consists of two parts: a segment number, s, and an offset into that segment, d.
The segment number is used as an index into the segment table. The offset d of the logical
address must be between 0 and the segment limit. It is added to the segment base to produce
the address in physical memory of the desired byte.
 As an example, consider the situation shown in Figure 4.11. We have five segments numbered
from 0 through 4. The segments are stored in physical memory as shown. The segment table has
a separate entry for each segment, giving the beginning address of the segment in physical
memory (or base) and the length of that segment.
 For example, segment 2 is 400 bytes long and begins at location 4300. Thus, a reference to byte
53 of segment 2 is mapped onto location 4300 + 53 = 4353. A reference to segment 3, byte 852,
is mapped to 3200 (the base of segment 3) + 852 = 4052. A reference to byte 1222 of segment 0
would result in a trap to the operating system, as this segment is only 1,000 bytes long.
 Advantage of segmentation is the association of protection with the segments. Because the
segments represent a semantically defined portion of the program and instruction segments can
be defined as read only or execute only.
 Advantage of segmentation involves the sharing of code or data. Each process has a segment
table associated with it, which the dispatcher uses to define the hardware segment table when
this process is given the CPU. Segments are shared when entries in the segment tables of two
different processes point to the same physical location (Figure 4.11).
 Segmentation may cause external fragmentation, when all blocks of free memory are too small
to accommodate a segment. In this case, the process may simply have to wait until more memory
becomes available, or until compaction creates a larger hole.
Figure 4.11 Sharing of segments in a segmented memory system
Disk Scheduling : One of the responsibilities of the operating system is to use the hardware
efficiently. The access time has two major components. The seek time is the time for the disk arm to
move the heads to the cylinder containing the desired sector. The rotational latency is the additional
time waiting for the disk to rotate the desired sector to the disk head. The disk bandwidth is the total
number of bytes transferred, divided by the total time between the first request for service and the
completion of the last transfer. We can improve both the access time and the bandwidth by
Memory Management – Module - 2
scheduling the servicing of disk I/O requests in a good order. Several algorithms exist to schedule the
servicing of disk I/O requests.
5.7.1 FCFS Scheduling: (First-come first-serve Scheduling)
 The first-come, first-served algorithm is the
simplest algorithm.
 This algorithm does not provide the fastest
service.
 Consider, for example, a disk queue with
requests for I/0 to blocks on cylinders 98,
183, 37, 122, 14, 124, 65, 67 in that order.
If the disk head is initially at cylinder 53, it
will first move from 53 to 98, then to 183,
37, 122, 14, 124, 65, and finally to 67, for a
Figure 5.15 FCFS Scheduling
total head movement of 640 cylinders.
Total Head movement is 640 cylinders
5.7.2 SSTF Scheduling: (Shortest-seek-time-first algorithm)
 This algorithm services requests close to
the current head position, before moving
the head far away to service other
requests.
 The SSTF algorithm selects the request
with the minimum seek time from the
current head position.
 For our example request queue, the closest
request to the initial head position (53) is
at cylinder 65. Once we are at cylinder 65,
the next closest request is at cylinder 67.
Figure 5.16 SSTF Scheduling
From there, the request at cylinder 37 is
Total Head movement is 236 cylinders
closer than 98, 37 is served
next. Continuing, we service the request at cylinder 14, then 98, 122, 124, and finally 183.
 This scheduling method results in a total head movement of only 236 cylinders little more than
one-third of the distance needed for FCFS scheduling of this request queue. This algorithm gives
a substantial improvement in performance.
5.7.3 SCAN Scheduling:
Memory Management – Module - 2
 In the SCAN algorithm, the disk arm starts at
one end of the disk, and moves toward the
other end, servicing requests as it reaches
each cylinder, until it gets to the other end
of the disk.
 At the other end, the direction of head
movement is reversed, and servicing
continues. The head continuously scans
back and forth across the disk.
 Before applying SCAN to schedule the
requests on cylinders, we need to know the
direction of head movement, in addition to
the head's current position (53).
Figure 5.17 SCAN Scheduling
Total Head movement is 236 cylinders
 If the disk arm is moving toward 0, the head will service 37 and then 14. At cylinder 0, the arm
will reverse and will move toward the other end of the disk, servicing the requests at
65,67,98,122, 124, and 183 (Figure 5.17). If a request arrives in the queue just in front of the
head, it will be serviced almost immediately; a request arriving just behind the head will have to
wait until the arm moves to the end of the disk, reverses direction, and comes back.
 The SCAN algorithm is sometimes called the elevator algorithm, since the disk arm behaves just
like an elevator in a building, first servicing all the requests going up, and then reversing to service
requests the other way.
5.7.4 C-SCAN Scheduling:
 Circular SCAN (C-SCAN) scheduling is a variant
of SCAN designed to provide a more uniform
wait time.
 Like SCAN, C-SCAN moves the head from one
end of the disk to the other, servicing requests
along the way.
 When the head reaches the other end, it
immediately returns to the beginning of the
disk, without servicing any requests on the
return trip.
 The C-SCAN scheduling algorithm essentially
treats the cylinders as a circular list that wraps
around from the final cylinder to the first one.
Figure 5.18 C-SCAN Scheduling
Memory Management – Module - 2
5.7.5 LOOK Scheduling: Look Scheduling is a version of SCAN. Arm only goes as far as the last request
in each direction, then reverses direction immediately, without first going all the way to the end of
the disk. These versions of SCAN and C-SCAN are called LOOK and C-LOOK scheduling, because they
look for a request before continuing to move in a given direction.
5.7.6 C-LOOK Scheduling:
 C-Look is similar to C-Scan. In C-Scan, the arm
goes till the end of the disk or the beginning
of the disk.
 But in C-Look the arm only goes as far as the
last request in each direction. Like C-Scan, in
C-Look, the requests will not be serviced in
the return trip.
Figure 5.19 C-LOOK Scheduling
5.8 Disk Management: The operating system is responsible for managing the disk. The Management
of the disk deals with
 disk initialization or disk formatting,
 boot block
 and bad-block .
5.8.1 Disk Formatting :
 A new magnetic disk is a blank slate: It is just platters of a magnetic recording material.
 Before a disk can store data, it must be divided into sectors that the disk controller can read and
write. This process is called low-level formatting (or physical formatting).
 Low-level formatting fills the disk with a special data structure for each sector. The data structure
for a sector typically consists of a header, a data area (usually 512 bytes in size), and a trailer.
 The header and trailer contain information used by the disk controller, such as a sector number
and an error-correcting code (ECC). When the controller writes a sector of data during normal
I/O, the ECC is updated with a value calculated from all the bytes in the data area. When the
sector is read, the ECC is recalculated and is compared with the stored value. If the stored and
calculated numbers are different, this mismatch indicates that the data area of the sector has
become corrupted and that the disk sector may be bad.
 Most hard disks are low-level formatted at the factory as a part of the manufacturing process.
This formatting enables the manufacturer to test the disk and to initialize the mapping from
logical block numbers to defect-free sectors on the disk.
 To use a disk to hold files, the operating system still needs to record its own data structures on
the disk. It does so in two steps.
Memory Management – Module - 2
 The first step is to partition the disk into one or more groups of cylinders. The operating
system can treat each partition as though it were a separate disk. For instance, one partition
can hold a copy of the operating system's executable code, while another holds user files.
 After partitioning, the second step is logical formatting. In this step, the operating system
stores the initial file-system data structures onto the disk. These data structures may
include maps of free and allocated space (a FAT or inodes) and an initial empty directory.
5.8.2 Boot Block:
 Bootstrap program helps to start running when it is powered up or rebooted. It initializes all
aspects of the system, from CPU registers to device controllers and the contents of main memory,
and then starts the operating system.
 To do its job, the bootstrap program finds the operating system kernel on disk, loads that kernel
into memory, and jumps to an initial address to begin the operating-system execution.
 For most computers, the bootstrap is stored in read-only memory (ROM) because ROM needs no
initialization and is at a fixed location that the processor can start executing when powered up
or reset.
 And, since ROM is read only, it cannot be infected by a computer virus.
 The problem is that changing this bootstrap code requires changing the ROM hardware chips.
For this reason, most systems store a tiny bootstrap loader program in the boot ROM, whose
only job is to bring in a full bootstrap program from disk.
 The full bootstrap program can be changed easily: A new version is simply written onto the disk.
The full bootstrap program is stored in a partition called the boot blocks, at a fixed location on
the disk. A disk that has a boot partition is called a boot disk or system disk.
 The code in the boot ROM instructs the disk controller to read the boot blocks into memory, and
then starts executing that code. The full bootstrap program is more sophisticated than the
bootstrap loader in the boot ROM; it is able to load the entire operating system from a nonfixed
location on disk, and to start the operating system running.
5.8.3 Bad Block:
 Because disks have moving parts and small tolerances, they are prone to failure. Sometimes the
failure is complete, and the disk needs to be replaced, and its contents restored from backup
media to the new disk.
 More frequently, one or more sectors become defective. Most disks even come from the factory
with bad blocks.
 The bad blocks are handled in a variety of ways.
 MS-DOS format command does a logical format, scans the disk to find bad blocks. If format finds
a bad block, it writes a special value into the corresponding FAT entry to tell the allocation
routines not to use that block.
Memory Management – Module - 2
 If blocks go bad during normal operation, a special program (such as chkdsk) must be run
manually to search for the bad blocks and to lock them away as before. Data that resided on the
bad blocks usually are lost.
 In more sophisticated disks, the controller maintains a list of bad blocks on the disk. The list is
initialized during the low-level format at the factory, and is updated over the life of the disk. Low
level formatting also sets aside spare sectors not visible to the operating system. The controller
can be told to replace each bad sector logically with one of the spare sectors. This scheme is
known as sector sparing or forwarding.
 A typical bad-sector transaction might be as follows:
 The operating system tries to read logical block 87. The controller calculates the ECC and finds
that the sector is bad. It reports this finding to the operating system.
 The next time that the system is rebooted, a special command is run to tell the SCSI controller
to replace the bad sector with a spare. After that, whenever the system requests logical block
87, the request is translated into the replacement sector's address by the controller.