Operating Systems IS 0414 INTERPROCESS COMMUNICATION Introduction Interprocess

Operating Systems IS 0414

INTERPROCESS COMMUNICATION

Introduction Ø Ø Ø Interprocess communication (IPC) is a set of programming interfaces that allow a programmer to coordinate activities among different program processes that can run concurrently in an operating system Processes frequently need to communicate with other processes. For example, • In a shell pipeline, the output of the first process must be passed to the second process, and so on down the line. Ø Thus there is a need for communication between processes, in a well-structured way with out using

Cont. . . Ø Ø The issues related to the Interprocess Communication, or IPC is discussed. There are three issues: • How one process can pass information to another. • Making sure two or more processes do not get in each other’s way • Proper sequencing when dependencies are present. Ø These issues apply equally to threads also.

Race Conditions Ø A race condition occurs when a device or system attempts to perform two or more operations at the same time, • But because of the nature of the device or system, the operations must be done in the proper sequence to be done correctly. • Example a light switch

Cont. . . Ø In computer memory or storage, a race condition may occur • If commands to read and write a large amount of data are received at almost the same instant, and • The machine attempts to overwrite some or all of the old data while that old data is still being read. • The result may be one or more of the following: • • A computer crash, An “illegal operation” Notification and shutdown of the program, Errors reading the old data or errors writing the new data. • A race condition can also occur if instructions are processed in the incorrect order.

Critical Regions Ø Ø How to avoid race conditions? The key to preventing trouble here and in many other situations involving shared memory, shared files, and shared everything else is to find • Some way to prohibit more than one process from reading and writing the shared data at the same time. Ø What is required is mutual exclusion, that is, some way of making sure that if one process is using a shared variable or file, the other processes will be excluded from doing the same thing.

Cont. . . Ø Ø The key to preventing trouble involving shared storage is find some way to prohibit more than one process from reading and writing the shared data simultaneously. That part of the program where the shared memory is accessed is called the Critical Section

Cont. . . Ø Conditions to hold for having a good solution: • No two processes may be simultaneously inside their critical regions. • No assumptions may be made about speeds or the number of CPUs. • No process running outside its critical region may block any process. • No process should have to wait forever to enter its critical region

Cont. . . Fig: Mutual exclusion using critical regions.

Mutual Exclusion with Busy Waiting Ø Disabling Interrupts • On a single-processor system, the solution is to have each process disable all interrupts just after entering its critical region and re-enable them just before leaving it. • With interrupts disabled, no clock interrupts can occur. • The CPU is only switched from process to process as a result of clock or other interrupts • With interrupts turned off the CPU will not be switched to another process. • Thus, once a process has disabled interrupts, it can examine and update the shared memory without fear that any other process will intervene.

Cont. . . Ø Drawback of Disabling Interrupts is • Unwise to give user processes the power to turn off interrupts because if the process never turns on again. • If the system is a multiprocessor (with two or more CPUs) disabling interrupts affects only the CPU that executed the disable instruction. The other ones will continue running and can access the shared memory. Ø Ø It is convenient for the kernel itself to disable interrupts for a few instructions while it is updating variables or lists. The conclusion is: • Disabling interrupts is often a useful technique within the operating system itself but is • Not appropriate as a general mutual exclusion mechanism for user processes.

Cont. . . Ø Lock Variables • Consider having a single, shared (lock) variable, initially 0. • When a process wants to enter its critical region, it first tests the lock. If the lock is 0, the process sets it to 1 and enters the critical region. • If the lock is already 1, the process just waits until it becomes 0. • Thus, a 0 means that no process is in its critical region, and a 1 means that some process is in its critical region.

Cont. . . Ø Strict Alternation Fig: A proposed solution to the critical-region problem. (a) Process 0. (b) Process 1. Ø In both cases, be sure to note the semicolons terminating the while statements.

Cont. . . Ø Ø The integer variable turn, initially 0, keeps track of whose turn it is to enter the critical region and examine or update the shared memory. Initially, • Process 0 inspects turn, finds it to be 0, and enters its critical region. • Process 1 also finds it to be 0 and therefore sits in a tight loop continually testing turn to see when it becomes 1. • Continuously testing a variable until some value appears is called busy waiting, should be avoided as it wastes CPU time. • A lock that uses busy waiting is called a spin lock

Peterson’s Solution Fig: Peterson’s solution for achieving mutual exclusion

Cont. . . Ø Ø Ø Before using the shared variables (i. e. , before entering its critical region), each process calls enter_region with its own process number, 0 or 1, as parameter. This call will cause it to wait, if need be, until it is safe to enter. After it has finished with the shared variables, the process calls leave_region to indicate that it is done and to allow the other process to enter, if it so desires.

Cont. . . Ø Ø Initially neither process is in its critical region, so process 0 calls enter_region. It indicates its interest by setting its array element and sets turn to 0. As process 1 is not interested, enter_region returns immediately. If process 1 now makes a call to enter_region, it will hang there until interested[0] goes to FALSE, an event that happens only when process 0 calls leave_region to exit the critical region

Cont. . . Ø Ø Ø If both processes call enter_region almost simultaneously. Both will store their process number in turn. Whichever store is done last is the one that counts; the first one is overwritten and lost. Suppose that process 1 stores last, so turn is 1. When both processes come to the while statement, process 0 executes it zero times and enters its critical region. Process 1 loops and does not enter its critical region until process 0 exits critical region.

The TSL Instruction Ø Computers designed with multiple processors, have an instruction like TSL RX, LOCK (Test and Set Lock) Ø It reads the contents of the memory word lock into register RX and then stores a nonzero value at the memory address lock. Operations of reading the word and storing into it, are guaranteed to be indivisible No other processor can access the memory word until the instruction is finished. The CPU executing the TSL instruction locks the memory bus to prohibit other CPUs from accessing memory until it is done. Ø Ø Ø

Cont. . . Ø Ø To use the TSL instruction, use a shared variable, lock, to coordinate access to shared memory. When lock is 0, any process may set it to 1 using the TSL instruction and then read or write the shared memory. When it is done, the process sets lock back to 0 using an ordinary move instruction. The solution to prevent two processes from simultaneously entering their critical regions is shown in the code of next slide.

Cont. . . Entering and leaving a critical region using the TSL instruction

Cont. . . Ø Ø Ø An alternative instruction to TSL is XCHG, which exchanges the contents of two locations atomically For example, a register and a memory word. The code is shown in Fig. Entering and leaving a critical region using the XCHG instruction.

Sleep and Wakeup Ø Ø Ø Peterson’s solution and the solutions using TSL or XCHG are correct, but both require busy waiting, which wastes CPU time. In Priority inversion problem high priority processes are made to wait infinitely, when low priority process is executing in critical region. Interprocess communication primitives that block instead of wasting CPU time when they are not allowed to enter their critical regions is the pair sleep and wakeup

Cont. . . Ø Ø Ø Sleep is a system call that causes the caller to block, that is, be suspended until another process wakes it up. The wakeup call has one parameter, the process to be awakened Both sleep and wakeup each have one parameter, a memory address used to match up sleeps with wakeups.

Example Ø The Producer-Consumer Problem (boundedbuffer) • Two processes share a common, fixed-size buffer. • One of them, the producer, puts information into the buffer, and the other one, the consumer, takes it out. • Trouble arises when the producer wants to put a new item in the buffer, but it is already full. • The solution is for the producer to go to sleep, to be awakened when the consumer has removed one or more items • If the consumer wants to remove an item from the buffer and sees that the buffer is empty, it goes to sleep until the producer puts something in the buffer and wakes it up.

Cont. . . The producer-consumer problem with a fatal race condition.

Semaphores Ø Ø Ø A semaphore is a protected variable whose value can be accessed and altered only by the operations P (sleep or down) and V (wakeup or up) and initialization operation called 'Semaphoiinitislize'. A semaphore could have the value 0, indicating that no wakeups (up) were saved, or some positive value if one or more wakeups were pending. The down (Sleep) operation on a semaphore checks to see if the value is greater than 0. If so, it decrements the value and just continues. If the value is 0, the process is put to sleep without completing the down for the moment

Cont. . . Ø Ø Checking the value, changing it, and possibly going to sleep, are all done as a single, indivisible atomic action. It is guaranteed that once a semaphore operation has started, no other process can access the semaphore until the operation has completed or blocked. The up (wakeup) operation increments the value of the semaphore addressed. If one or more processes were sleeping on that semaphore, unable to complete an earlier down operation, one of them is chosen by the system

Mutexes Ø Ø A mutex is a shared variable that can be in one of two states: unlocked or locked. When the semaphore’s ability to count is not needed, a simplified version of the semaphore, that is, mutex, is used. Mutexes are good only for managing mutual exclusion to some shared resource or piece of code. 1 bit is required to represent it, but in practice an integer is used often, with 0 meaning unlocked and all other values meaning locked.

Cont. . . Ø Ø Two procedures are used with mutexes. When a thread (or process) needs access to a critical region, it calls mutex_lock. If the mutex is currently unlocked, the call succeeds and the calling thread is free to enter the critical region. On the other hand, if the mutex is already locked, the calling thread is blocked until the thread in the critical region is finished and calls mutex_unlock. If multiple threads are blocked on the mutex, one of them is chosen at random and allowed to acquire the lock.

Cont. . . Fig: Implementation of mutex lock and mutex unlock.

Monitors Ø Ø A monitor is a collection of procedures, variables, and data structures that are all grouped together in a special kind of module or package. Processes may call the procedures in a monitor whenever they want to, but they cannot directly access the monitor’s internal data structures from procedures declared outside the monitor

Cont. . . Ø Monitors have an important property that makes them useful for achieving mutual exclusion: • Only one process can be active in a monitor at any instant. Ø Ø Ø Monitors are a programming-language construct, so the compiler knows they are special and can handle calls to monitor procedures differently from other procedure calls. When a process calls a monitor procedure, the first few instructions of the procedure will check to see if any other process is currently active within the monitor. If so, the calling process will be suspended until the other process has left the monitor.

Message Passing Ø Message passing in inter-process communication uses two primitives, send and receive, which, like semaphores and unlike monitors, are system calls rather than language constructs • send(destination, &message); • Sends a message to a given destination • receive(source, &message); • Receives a message from a given source Ø If no message is available, the receiver can block until one arrives or it can return immediately with an error code.

Design Issues for Message-Passing Systems Ø Ø Message-passing systems have many problems and design issues that do not arise with semaphores or with monitors, especially if the communicating processes are on different machines connected by a network. Examples: • Duplication and acknowledgement. • Authentication

Classical Ipc Problems Ø Dining Philosophers Problem • Classic example of a synchronization problem, described in terms of philosophers sitting around a table, eating noodles with chopsticks. • Each philosopher needs two chopsticks to eat, but there are not enough chopsticks to go around. • Each must share a chopstick with each of his neighbors • The life of a philosopher consists of alternating periods of eating and thinking

Cont. . . Ø Significance of this Problem • Potential for deadlock and starvation • An example for demonstrating various process and thread synchronization mechanisms • A good solution has no deadlock or starvation

Solution to the dining philosophers problem

The Readers and Writers Problem Ø Ø Ø An airline reservation system, with many competing processes wishing to read and write it. It is acceptable to have multiple processes reading the database at the same time, but If one process is updating (writing) the database, no other processes may have access to the database, not even readers

Solution to the readers and writers problem

MEMORY MANAGEMENT Ø Ø Ø Main memory (RAM) is an important resource that must be very carefully managed. In this chapter we study how operating systems create abstractions from memory and how they manage them. Memory hierarchy, is defined as computers which have • A few megabytes of very fast, expensive, volatile cache memory, • A few gigabytes of medium-speed, medium-priced, volatile main memory, and • A few terabytes of slow, cheap, nonvolatile magnetic or solid-state disk storage, • And also removable storage, such as DVDs and USB

Cont. . . Ø Ø The part of the operating system that manages (part of) the memory hierarchy is called the memory manager. Its job is to efficiently manage memory: • Keep track of which parts of memory are in use, • Allocate memory to processes when they need it, and deallocate it when they are done.

NO MEMORY ABSTRACTION Ø Ø The simplest memory abstraction is to have no abstraction at all Early mainframe computers (before 1960), early minicomputers (before 1970), and early personal computers (before 1980) had no memory abstraction. Every program simply saw the physical memory. When a program executed an instruction like MOV REGISTER 1, 1000 • The computer just moved the contents of physical memory location 1000 to REGISTER 1. • Thus, the model of memory presented to the programmer was simply physical memory, a set of addresses from 0 to some maximum, each address corresponding to a cell

Cont. . . Ø With these conditions, • Not possible to have two running programs in memory at the same time. • If the first program wrote a new value to, say, location 2000, this would erase whatever value the second program was storing there. • Nothing would work and both programs would crash almost immediately. Ø Ø With the model of memory being just physical memory, several options are possible. Three variations are shown in Fig.

Fig: Three simple ways of organizing memory with an operating system and one user process.

Cont. . . Ø Ø Ø Fig. (a): The operating system may be at the bottom of memory in RAM (Random Access Memory), which was formerly used on mainframes and minicomputers Fig. (b): It may be in ROM (Read-Only Memory) at the top of memory, which was used on some handheld computers and embedded systems Fig. (c): The device drivers may be at the top of memory in a ROM and the rest of the system in RAM down below, which was used by early personal computers (e. g. , running MSDOS), where the portion of the system in the ROM is called the BIOS (Basic Input Output System).

Cont. . . Ø Ø Ø With Model a & c the disadvantage is a bug in the user program can wipe out the operating system, possibly with disastrous results. With this type of system organization, only one process can be running at a time. User types a command OS copies the requested program from disk to memory and executes it When completed, the OS displays a prompt character and waits for a user new command. When the OS receives the command, it loads a new program into memory, overwriting the first one.

Cont. . . Ø Ø Ø To get some parallelism in a system with no memory abstraction is to program with multiple threads. As all threads in a process are supposed to see the same memory image, the fact that they are forced to is not a problem. Idea works, if it is of limited use since what people often want is unrelated programs to be running at the same time, something the threads abstraction does not provide.

Running Multiple Programs Without a Memory Abstraction Ø Ø With no memory abstraction, it is possible to run multiple programs at the same time. What the operating system has to do is save the entire contents of memory to a disk file, then bring in and run the next program. As long as there is only one program at a time in memory, there are no conflicts Major drawback of this solution is depicted in Fig.

Fig. Illustration of the relocation problem Ø Ø Ø (a) A 16 -KB program. (b) Another 16 -KB program. (c) The two programs loaded consecutively into memory.

Cont. . . Ø Ø Core problem is that the two programs both reference absolute physical memory. What is needed is that each program can reference a private set of addresses local to it. One solution adopted was static relocation, that is When a program was loaded at address 16, 384, the constant 16, 384 was added to every program address during the load process So ‘‘JMP 28’’ became ‘‘JMP 16, 412’’

A MEMORY ABSTRACTION: ADDRESS SPACES Ø Exposing physical memory to processes has several major drawbacks. 1. If user programs can address every byte of memory, they can easily trash the operating system, intentionally or by accident, bringing the system to a grinding halt. 2. It is difficult to have multiple programs running at once (taking turns, if there is only one CPU). • On personal computers, it is common to have several programs open at once (a word processor, an email program, a Web browser), • One of them having the current focus, but the others being reactivated at the click of a mouse. • Since this situation is difficult to achieve when there is no abstraction from physical memory, something had to be done.

The Notion of an Address Space Ø Two problems have to be solved to allow multiple applications to be in memory at the same time without interfering with each other: • Protection and Relocation. Ø Ø The solution for a new abstraction for memory is the address space. As the process concept creates a kind of abstract CPU to run programs, the address space creates a kind of abstract memory for programs to live in. An address space is the set of addresses that a process can use to address memory. Each process has its own address space, independent of those belonging to other processes

Base and Limit Registers Ø Ø This simple solution uses a particularly simple version of dynamic relocation. What it does is map each process’ address space onto a different part of physical memory in a simple way, by using each CPU with two special hardware registers, usually called the base and limit registers. When these registers are used programs are loaded into consecutive memory locations wherever there is room and without relocation during loading. When a process is run, the base register is loaded with the physical address where its program begins in memory and the limit register is loaded with the

Swapping Ø Ø If the physical memory of the computer is large enough to hold all the processes, the schemes described so far will more or less do. The total amount of RAM needed by all the processes is often much more than can fit in memory. 50 -100 processes or more may be started up as soon as the computer is booted Keeping all processes in memory all the time requires a huge amount of memory and cannot be done if there is insufficient memory.

Cont. . . Ø Ø Two general approaches to dealing with memory overload have been developed. The simplest strategy, called swapping, consists of bringing in each process in its entirety, running it for a while, then putting it back on the disk. Idle processes are mostly stored on disk, so they do not take up any memory when they are not running. The other strategy, called virtual memory, allows programs to run even when they are only partially in main memory.

Fig. Memory allocation changes as processes come into memory and leave it. The shaded regions are unused memory.

Cont. . . Ø Ø Ø The operation of a swapping system is illustrated in Fig. Initially, only process A is in memory. Then processes B and C are created or swapped in from disk. In Fig. (d) A is swapped out to disk. Then D comes in and B goes out. Finally A comes in again. As A is now at a different location, addresses contained in it must be relocated, either by software when it is swapped in or (more likely) by hardware during program execution

Cont. . . Ø Ø Ø When swapping creates multiple holes in memory, it is possible to combine them all into one big one by moving all the processes downward as far as possible. This technique is known as memory compaction, and it is usually not done because it requires a lot of CPU time. If it is expected that most processes will grow as they run, it is probably a good idea to allocate a little extra memory whenever a process is swapped in or moved, • to reduce the overhead associated with moving or

Fig. (a) Allocating space for a growing data segment. (b) Allocating space for a growing stack and a growing data segment.

Managing Free Memory Ø Ø When memory is assigned dynamically, the operating system must manage it. In general terms, there are two ways to keep track of memory usage: • Bitmaps and • Free lists.

Memory Management with Bitmaps Ø Ø Ø With a bitmap, memory is divided into allocation units as small as a few words and as large as several kilobytes. Corresponding to each allocation unit is a bit in the bitmap, which is 0 if the unit is free and 1 if it is occupied (or vice versa). Fig. shows part of memory and the corresponding bitmap.

Cont. . . Ø Ø Ø Fig. (a) A part of memory with five processes and three holes. The tick marks show the memory allocation units. The shaded regions (0 in the bitmap) are free. (b) The corresponding bitmap. (c) The same information as a list.

Cont. . . Ø Ø Ø The size of the allocation unit is an important design issue. The smaller the allocation unit, the larger the bitmap A bitmap provides a simple way to keep track of memory words in a fixed amount of memory because the size of the bitmap depends only on the size of memory and the size of the allocation unit

Memory Management with Linked Lists Ø Another way of keeping track of memory is to maintain a linked list of allocated and free memory segments, where a segment either • Contains a process or • Is an empty hole between two processes. Ø Ø Ø The segment list is kept sorted by address. The advantage of this is when a process terminates or is swapped out, updating the list is straightforward. A terminating process normally has two neighbors (except when it is at the very top or bottom of memory)

Fig: Four neighbor Combinations for the terminating process X

Cont. . . Ø Ø Ø These may be either processes or holes, leading to the four combinations shown in Fig. In Fig. (a) updating the list requires replacing a P by an H. In Fig. (b) and Fig. (c), two entries are coalesced into one, and the list becomes one entry shorter. In Fig. (d), three entries are merged and two items are removed from the list. The memory manager knows how much memory to allocate.

Cont. . . Ø Ø Ø The simplest and fastest algorithm is first fit. The memory manager scans along the list of segments until it finds a hole that is big enough. The hole is then broken up into two pieces, • One for the process and • One for the unused memory Ø Ø Next fit keeps track of where it is whenever it finds a suitable hole. The next time it is called to find a hole, it starts searching the list from the place where it left off last time, instead of always at the beginning

Cont. . . Ø Ø Ø Best fit searches the entire list, from beginning to end, and takes the smallest hole that is adequate. Worst fit, always take the largest available hole, so that the new hole will be big enough to be useful Quick fit, maintains separate lists for some of the more common sizes requested

VIRTUAL MEMORY Ø Ø Virtual memory is a feature of an operating system (OS) that allows a computer to compensate for shortages of physical memory by temporarily transferring pages of data from random access memory (RAM) to disk storage. The basic idea behind virtual memory is that each program has its own address space, which is broken up into chunks called pages. Each page is a contiguous range of addresses. These pages are mapped onto physical memory, but not all pages have to be in physical memory at the same time to run the program.

Cont. . . Ø Ø When the program references a part of its address space that is in physical memory, the hardware performs the necessary mapping on the fly. When the program references a part of its address space that is not in physical memory, the operating system is alerted to go get the missing piece and reexecute the instruction that failed.

Paging Ø Ø Ø Most virtual memory systems use a technique called paging. On any computer, programs reference a set of memory addresses. When a program executes an instruction like MOV REG, 1000 It copy the contents of memory address 1000 to REG (or vice versa, depending on the computer). Addresses can be generated using indexing, base registers, segment registers, and other ways.

Cont. . . Ø Ø Ø These program-generated addresses are called virtual addresses and form the virtual address space. On computers without virtual memory, the virtual address is put directly onto the memory bus and causes the physical memory word with the same address to be read or written. When virtual memory is used, the virtual addresses do not go directly to the memory bus, but, they go to an MMU (Memory Management Unit) that maps the virtual addresses onto the physical memory addresses, as illustrated in Fig.

Fig. The position and function of the MMU.

Cont. . . A very simple example of how this mapping works is shown in Fig: The relation between virtual addresses and physical memory addresses is given by the page table. Every page begins on a multiple of 4096 and ends 4095 addresses higher, so 4 K– 8 K really means 4096– 8191 and 8 K to 12 K means 8192– 12287. Ø

Cont. . . Ø Ø In this example, we have a computer that generates 16 -bit addresses, from 0 up to 64 K − 1, which are the virtual addresses. This computer, however, has only 32 KB of physical memory. So although 64 -KB programs can be written, they cannot be loaded into memory in their entirety and run. A complete copy of a program’s core image, up to 64 KB, must be present on the disk, however, so that pieces can be brought in as needed.

Cont. . . Ø Ø Ø The virtual address space consists of fixed-size units called pages. The corresponding units in the physical memory are called page frames. The pages and page frames are generally the same size. The range marked 0 K– 4 K means that the virtual or physical addresses in that page are 0 to 4095. The range 4 K– 8 K refers to addresses 4096 to 8191, and so on. Each page contains exactly 4096 addresses starting at a multiple of 4096 and ending one shy of a

Cont. . . Ø Ø Ø When the program tries to access address 0, for example, using the instruction MOV REG, 0 virtual address 0 is sent to the MMU. The MMU sees that this virtual address falls in page 0 (0 to 4095), which according to its mapping is page frame 2 It thus transforms the address to 8192 and outputs address 8192 onto the bus. The memory knows nothing at all about the MMU and just sees a request for reading or writing address 8192, which it honors

Cont. . . Ø Ø Ø If the program references an unmapped address page fault occurs. A page fault is the sequence of events occurring when a program attempts to access data (or code) that is in its address space, but is not currently located in the system's RAM. The operating system must handle page faults by somehow making the accessed data memory resident, allowing the program to continue operation as if the page fault had never occurred.

Page Tables Ø Ø Ø The page number is used as an index into the page table, yielding the number of the page frame corresponding to that virtual page. The purpose of the page table is to map virtual pages onto page frames. The page table is a function, with the virtual page number as argument and the physical frame number as result

Structure of a Page Table Entry Ø Ø The exact layout of an entry in the page table is machine dependent, but the kind of information present is same from machine to machine. Fig. presents a sample page table entry.

Cont. . . Ø Ø The size varies from computer to computer, but 32 bits is a common size. The important field is the Page frame number. The goal of the page mapping is to output this value. Next is the Present/absent bit: • If this bit is 1, the entry is valid and can be used and • If it is 0, the virtual page to which the entry belongs is not currently in memory. Ø Accessing a page table entry with this bit set to 0 causes a page fault.

Cont. . . Ø Ø Ø Protection bits tell what kinds of access are permitted, this field contains 1 bit, with 0 for read/write and 1 for read only. A more sophisticated arrangement is having 3 bits, one bit each for enabling reading, writing, and executing the page. The Modified and Referenced bits keep track of page usage. When a page is written to, the hardware automatically sets the Modified bit. This bit is of value when the operating system decides to reclaim a page frame.

Cont. . . Ø Ø Ø If the page in it has been modified (i. e. , is ‘‘dirty’’), it must be written back to the disk. If it has not been modified (i. e. , is ‘‘clean’’), it can just be abandoned, since the disk copy is still valid. The bit is sometimes called the dirty bit, since it reflects the page’s state. The Referenced bit is set whenever a page is referenced, either for reading or for writing. Its value is used to help the operating system choose a page to evict when a page fault occurs. Last bit allows caching to be disabled for the page.

Speeding Up Paging Ø In any paging system, two major issues must be faced: 1. The mapping from virtual address to physical address must be fast. 2. If the virtual address space is large, the page table will be large. Ø Ø One solution is to equip computers with a small hardware device for mapping virtual addresses to physical addresses without going through the page table. The device, called a TLB (Translation Look-aside Buffer) or sometimes an associative memory, as shown in Fig.

Fig: A TLB to speed up paging

Cont. . . Ø Each entry contains information about one page, including • • Ø Ø The virtual page number, A bit that is set when the page is modified, The protection code (read/write/execute permissions), and The physical page frame in which the page is located. These fields have a one-to-one correspondence with the fields in the page table, except for the virtual page number, which is not needed in the page table. Another bit indicates whether the entry is valid (i. e. , in use) or not.