Unit 5.1 Memory Management_Device Driver_IPC.ppt

Sanjivani Rural Education Society’s
Sanjivani College of Engineering, Kopargaon-423 603
(An Autonomous Institute, Affiliated to Savitribai Phule Pune University, Pune)
NAAC ‘A’ Grade Accredited, ISO 9001:2015 Certified
Department of Computer Engineering
(NBA Accredited)
Prof. A. V. Brahmane
Assistant Professor
E-mail : brahmaneanilkumarcomp@sanjivani.org.in
Contact No: 91301 91301 Ext :145, 9922827812
Subject- Operating System and Administration (CO2013)
Unit V- Memory Management Policies, I/O Subsystem
and IPC

Content
• Swapping,
• Demand Paging,
• Driver interface,
• disk drivers,
• Process Tracing ,
• Network communication,
• Sockets
DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

Memory Management Policies
• Historically, UNIX systems transferred entire processes between primary memory and
the swap device.
• Such a memory management policy is called swapping.
• It made sense to implement such a policy on the PDP 11, where the maximum process
size was 64K.
• The BSD system (release 4.0) was the first major implementation of a demand
paging policy, transferring memory pages instead of processes to and from a secondary
device; later releases of UNIX system V also support demand paging.
• The entire process does not have to reside in main memory to execute, and the kernel
loads pages for a process on demand when the process references the pages.
• This permits greater flexibility in mapping the virtual address space of a process into the
physical memory of a machine, usually allowing the size of a process to be greater than
the amount of available physical memory and allowing more processes to fit
simultaneously in main memory. Swapping policy is easier to implement and has less
overhead.

Swapping
• Swapping has 3 parts to it:
• managing space on the swap device
• swapping processes out of main memory
• swapping processes into main memory

Allocation of Swap Space
• The swap device is a block device in a configurable section of a disk.
• The space on swap device is allocated in the form of contiguous blocks (as opposed to
single block allocation for files).
• The allocation of space on the swap device is transitory (as opposed to long lasting file
allocation).
• A process that resides on the swap device will eventually migrate back to main memory.
• Since speed is critical and the system can do I/O faster in one multi-block operation than
in several single block operations, the kernel allocates contiguous space on the swap
device without regard for fragmentation (as opposed to the flexible allocation for files
which results into minimum fragmentation).
• The allocation scheme for swap space allocation differs from the scheme used for file
systems.

• Therefore, the data structures also differ.
• The kernel maintains the free space for the swap device in an in-core table,
called map.
• A map is an array where each entry consists of an address of an allocatable
resource and the number of resource units available there; the kernel interprets
the address and units according to the type of map.
• Initially, a map contains one entry that indicates the address and the total
number of resources

Initial Swap Map

The algorithm to allocate map space, malloc

• The following figures show the state of the map after allocating 100 units, 50
units, then 100 units again:
• When freeing resources, the kernel finds their proper position in the map by
address. Three cases are possible here:
• The freed resources completely fill a hole in the map. In this case, the kernel
combines the newly freed resources and the existing (two) entries into one entry
in the map.
• The freed resources partially fill a hole. In this case, the kernel adjusts the address
and units fields of an appropriate entry to account for the resources just freed.
• The freed resources partially fill a hole but are not contiguous to any resources in
the map. Then a new entry is created and inserted in the proper position.

• Considering the previous example, if the kernel frees 50 units of swap space
starting at address 101, the swap map will contain a new entry (case 3). If the
kernel then frees 100 units starting at address 1, it adjusts the first entry of the
swap map (case 2). Suppose the kernel now requests 200 units of swap space,
since the first entry cannot satisfy the requirement, the second entry is modified
and space is given from address 251 to 450, both inclusive.
• These actions are shown below on next slide:

Allocating Swap Space from Secondary Entry in Map

Swapping Processes Out of Main Memory
• A process is swapped out if the kernel needs space in memory. It needs space in
memory under following situations:
• The fork system call must allocate space for a child process.
• The brk system call increases the size of a process.
• A process becomes larger by the natural growth of its stack.
• The kernel wants to free space in memory for processes it had previously
swapped out and should now swap in.

• When the kernel decides that a process is eligible for swapping from main memory, it
decrements the reference count of each region in the process and swaps the region out
if its reference count drops to 0.
• The kernel allocates space on a swap device and locks the process in memory (for cases
1-3), preventing swapper from swapping it out while the current swap operation is in
progress.
• The kernel saves the swap address of the region in the region table entry.
• The buffer cache is bypassed when the kernel swaps data between the swap device and
user address space.
• If memory is organized in pages, the data to be swapped out is likely to be discontiguous
in physical memory.
• The kernel must gather the page addresses of data to be swapped out, and the disk
driver may use the collection of page addresses to set up the I/O. The swapper waits for
each I/O operation to complete before swapping out other data.

• It is not necessary that the kernel write the entire virtual address space of a process
to a swap device.
• Instead, it copies the physical memory assigned to a process to the allocated space
on the swap device, ignoring unassigned virtual addresses.
• When the kernel swaps the process back into memory, it knows the virtual address
map of the process, so it can reassign the process to the correct virtual addresses.
• The kernel eliminates an extra copy from a data buffer to physical memory by
reading the data into the physical memory locations that were previously set up to
conform to the virtual address locations.

Mapping process Space onto the Swap Device

Swapping Processes Into the Main Memory
• The swapper process (process 0), is the only process that swaps processes into
memory from swap devices.
• After system initialization, the swapper goes into an infinite loop, where its only
task is to do process swapping.
• The swapper sleeps if there is no work for it. Swapper executes only in kernel
mode.
• When swapper wakes up to swap processes in, it selects the processes which has
spent the longest time in the state "ready to run but swapped out".

The algorithm swapper

• The swapper tries to swap out sleeping processes rather than ready-to-run
processes, because ready-to-run processes might get scheduled earlier than sleeping
processes.
• A ready-to-run process must be core resident for at least 2 seconds before being
swapped out, and a process to be swapped in must have been swapped out for at
least 2 seconds.
• If the swapper cannot find a processes to swap out or if neither the process to be
swapped in nor the process to be swapped out have accumulated more than 2
seconds residence time in their environment, then swapper sleeps on the event that
it wants to swap a process into memory but cannot find room for it.
• The clock will awaken the swapper once a second in that state. The kernel also
awakens swapper if another process goes to sleep, since it may be more eligible for
swapping out than the processes previously considered by the swapper. In any case,
the swapper wakes up and begins execution from the beginning, attempting to swap
in eligible processes

• Here is an example of process scheduling in a system where A, B, C, D are same
sized processes and only 2 processes can stay in main memory.
• This is the scheduling timeline:

Sequence of Swapping operations

• The swapper chooses processes to swap in based on the amount of time the
processes had been swapped out.
• Another criterion could have been to swap in the highest-priority process that is
ready to run, since such processes deserve a better chance to execute.
• It has been demonstrated that such a policy results in "slightly" better throughput
under heavy system load.

• The algorithm for choosing a process to swap out has some serious flaws:
• The swapper swaps out a process based on its priority, memory-residence time,
and nice value.
• Although it swaps out a process only to make room for a process being swapped
in, it may swap out a process that does not provide enough memory for the
incoming process.
• For instance, if the swapper attempts to swap in a process that occupies 1
megabyte of memory and the system contains no free memory, it is futile to swap
out a process that occupies only 2K bytes of memory.
• An alternative strategy would be to swap out groups of processes only if they
provide enough memory for the incoming process.

• If the swapper sleeps because it could not find enough memory to swap in a
process, it searches again for a process to swap in although it had previously
chosen one.
• The reason is that other swapped processes may have awakened in the meantime
and they may be more eligible for swapping in than the previously chosen
process.
• But that is small solace to the original process still trying to be swapped in.
• In some implementations, the swapper tries to swap out many smaller processes
to make room for the big process to be swapped in before searching for another
process to swap in; this is the revision in the swapper algorithm shown by the
comments in the algorithm given above.

• If the swapper chooses a "ready-to-run" process to swap out, it is possible that
the process had not executed since it was previously swapped in. The following
figure shows such a case, where the kernel swaps in process D at the 2-second
mark, schedules process C, and then swaps out process D at the 3-second mark in
favor of process E (because of the interaction of the nice value) even though
process D had never run. Such thrashing is clearly undesirable:
• If the swapper attempts to swap out a process but cannot find space on the swap
device, a system deadlock could arise if the following four conditions are met:
• All the processes in main memory are asleep
• All the ready-to-run processes are swapped out
• There is no room on the swap device for new processes
• There is no room in main memory for incoming processes

Demand Paging
• Machines whose memory architectures is based on pages and whose CPU has
restartable instructions can support a kernel that implements a demand paging
algorithm, swapping pages of memory between main memory and a swap device.
• Demand paging systems free processes from size limitations otherwise imposed
by the amount of physical memory available on a machine.
• The kernel still has a limit on the virtual size of a process, dependent on the
amount of virtual memory the machine can address.
• Demand paging is transparent to the user except for the virtual size permissible
to a process.

• The portion of the text section which contains the frequently called subroutines
and program loops is a small subset of the total space of the process. This is
known as the principle of "locality".
• The working set of a process is the set of pages that the process has referenced in
its last n memory references; the number n is called the window of the working
set.
• If the working set stays in the memory, swapping could be reduced.
• When a process addresses a page that is not in its working set, it incurs a page
fault; in handling the fault, the kernel updates the working set, reading in pages
from a secondary device if necessary.

Working set a process

• As shown in the diagram, working sets with larger window sizes are more
efficient, implying that the process will not fault often as often.
• It is expensive to remember the order of page references. Instead, systems
approximate a working set model by setting a reference bit whenever a process
accesses a page and by sampling memory references periodically: If a page was
recently referenced, it is part of a working set; otherwise, it "ages" in memory
until it is eligible for swapping.
• When a process accesses a page that is not part of its working set, it incurs
a validity page fault. The kernel suspends execution of the process until it reads
the page into memory and makes it accessible to the process. When the page is
loaded in memory, the process restarts the instruction it was executing when it
incurred the fault. Thus, the implementation of a paging subsystem has two
parts: swapping rarely used pages to a swapping device and handling page faults.

Data Structures for Demand Paging
• The kernel contains 4 major data structures to support low-level memory
management functions and demand paging:
• page table entries
• disk block descriptors
• page frame data table (called pfdata for short)
• swap-use table
• pfdata table is allocated once for the lifetime of the system, but allocations for
other structure are dynamic.

• As seen previously, the region contains page tables to access physical memory.
Each entry of a page table contains the physical address of the page, protection
bits indicating whether processes can read, write or execute from the page, and
the following bit fields to support demand paging:
• Valid
• Reference
• Modify
• Copy on write
• Age

• The kernel sets the valid bit to indicate that the contents of a page are legal, but
the page reference is not necessarily illegal if the valid bit is not set.
• The reference bit indicates whether a process recently referenced a page, and
the modify bit indicates whether a process recently modified the contents of a
page.
• The copy on write bit, used in the fork system call, indicates that the kernel must
create a new copy of the page when a process modifies its contents.
• The kernel manipulates the age bits to indicate how long a page has been a
member of the working set of a process.
• Assume the kernel manipulates the valid, copy on write, and age bits, and the
hardware sets the reference and modify bits of the page table entry (later, a
hardware that does not have these capabilities is considered).

The structure of region
•

• Each page table entry is associated with a disk block descriptor, which describes
the disk copy of the virtual page.
• Processes that share a region therefore access common page table entries and
disk block descriptors.
• The contents of a virtual pages are either in a particular block on a swap device,
in an executable, or not on a swap device. If the page is on a swap device, the
disk block descriptor contains the logical device number and block number
containing the page contents.
• If the page is contained in an executable file, the disk block descriptor contains
the logical block number in the file that contains the page; the kernel can quickly
map this number into its disk address.
• The disk block descriptor also indicates two special conditions set during exec:
that a page is "demand fill" or "demand zero", studied later.

Pfdata table
• The pfdata table describes each page of physical memory and is indexed by page
number. It contains these fields:
• State of the page, indicating that the page is on a swap device or executable file,
that DMA is currently underway for the page (reading data from a swap device),
or that the page can be reassigned.
• The number of processes that reference the page. The reference count equals the
number of valid page table entries that reference the page. It may differ from the
number of processes that share regions containing the page, as will be described
below when reconsidering the algorithm fork.
• The logical device (swap or file system) and block number that contains a copy of
the page.
• Pointers to other pfdata table entries on a list of free pages and on a hash queue
of pages.

Relationship between page table entries, disk block descriptors, pfdata table
entries, and the swap-use count table.

Fork in Paging System
• In swapping systems, the kernel copies the address space of the parent. But in
paging system, for shared regions, kernel just increments the reference count in
the region table entry to share the region. And for private regions such as data
and stack, the kernel allocates a new region table entry and page table. Then it
examines the pages on the parent process and if they are valid, increments the
reference count in pfdata table entry, sharing the page (as opposed to sharing the
region).
• The kernel sets the "copy-on-write" bit in fork, for the shared pages in the private
regions. If any process writes on such shared page, it incurs the "protection fault".
In the fault handler, the kernel makes a copy of page and then the process can
write on its private copy. So the copying is differed until an actually write
operation is done.

The diagram below shows the kernel data structures after
the fork system call:

Exec in a Paging System
• On a demand paged system, the executable file may be too large to fit in the
available main memory. Therefore, the kernel does not preassign memory to
executable file but "faults" it in, assigning memory as needed. It first assigns the
page tables and disk block descriptors for the executable file, marking the page
table entries "demand fill" (for non-bss data) or "demand zero" (for bss data).
Following a variant of read algorithm for reading the file into memory, the
process incurs a validity fault as it reads each page. The fault handler notes
whether the page is "demand fill", meaning its contents will immediately be
overwritten with the contents of the executable file so it need not be cleared, or
that it is "demand zero", meaning that its contents should be cleared. If the
process cannot fit into memory, the page-stealer process periodically swaps
pages from memory, making room for the incoming file.

• There are some inefficiencies in this scheme:
• A process incurs a page fault when reading each page of the executable file, even though it may
never access the page.
• The page stealer may swap pages from memory before the exec is done, resulting in two extra
swap operations per page if the process needs the page early.
• To make exec more efficient, the kernel can demand page directly from the executable file if the
data is properly aligned, as indicated by a special magic number. However, use of standard
algorithms (such as bmap) to access a file would make it expensive to demand page from indirect
blocks because of the multiple buffer cache accesses necessary to read a block.
• Consistency problems could arise because bmap is not reentrant. The kernel sets various I/O
parameters in the u-area during the read system call. If a process incurs a page fault during
a read system call when attempting to copy data to user space, it would overwrite these fields in
the u-area to read the page from the file system. Therefore, the kernel cannot use the regular
algorithms to fault in pages from the file system. The algorithms are, of course, reentrant in
regular cases, because each process has separate u-area and a process cannot simultaneously
execute multiple system calls.

The Page-Stealer Process
• The page stealer is a kernel process that swaps out memory pages that are no
longer part of the working set of a process.
• It is created on system initialization and is invoked throughout the system lifetime
when system is low on free pages. It examines every active, unlocked region and
increments the age field of all valid pages.
• The kernel locks a region when a process faults on a page in the region, so that
the page stealer cannot steal the page being faulted in.

• There are two paging states for a page in memory: the page is aging and is not yet
eligible for swapping, or the page is eligible fro swapping and is available for
reassignment to other virtual pages.
• The first state indicates that a process recently accessed the page. Some
machines set a reference bit when they reference a page, but software methods
can be substituted if the hardware does not have this feature.
• The page stealer turns off the reference bit for such pages but remembers how
many examinations have passed since the page was last referenced.
• The first state thus consists of several substates, corresponding to the number of
passes the page stealer makes before the page is eligible for swapping.
• When the number exceeds a threshold value, the kernel puts the page into the
second state, ready to be swapped.

State diagram for Page Aging

Page Faults
• There are two types of page faults: validity faults and protection faults.
• The fault handlers may have to read a page from disk to memory and sleep
during the I/O operation, therefore, they are an exception to the general rule that
interrupt handlers cannot sleep.
• Validity Fault Handler
• If a process attempts to access a page whose valid bit is not set, it incurs a validity
fault and then the kernel invokes the validity fault handler.

Protection Fault Handler
• If a process accesses a valid page but its permission bits do not permit access to
it, the process incurs a protection fault. A process also incurs a protection fault
when it attempts to write a page whose copy on write bit was set during
the fork system call. The kernel must determine whether permission was denied
because the page requires a copy on write or whether something truly illegal
happened.

A Hybrid System with Swapping and Demand Paging
• Demand paging systems treat memory more flexibly than swapping systems. But
there could be situations where the page stealer and validity fault handler thrash
(spend more time on swapping pages rather than process execution) because of
shortage of memory. If the sum of the working sets of all processes is greater
than the physical memory on a machine, the fault handler will usually sleep,
because it cannot allocate pages for a process. The page stealer will not be able
to steal pages fast enough, because all pages are in a working set. System
throughput will be affected badly.

• The system V kernel runs swapping and demand paging both to avoid
thrashing. When the kernel is not able to allocate pages for a process,
it wakes up the swapper and puts the calling process in a state
equivalent to "ready to run but swapped". The swapper swaps out
entire processes until available memory exceeds the high-water mark.
For each process swapped out, it makes one "ready-to-run but
swapped" process ready to run. It does not swap those processes in
via the normal swapping algorithm but lets them fault in pages as
needed. This method slows down the system fault rate and reduces
thrashing.
•

• Thank you….

Unit 5.1 Memory Management_Device Driver_IPC.ppt

More Related Content

Similar to Unit 5.1 Memory Management_Device Driver_IPC.ppt (20)

More from AnilkumarBrahmane2 (20)

Recently uploaded (20)

Unit 5.1 Memory Management_Device Driver_IPC.ppt