Operating Systems Ch. 9 Virtual Memory

Locality of Reference

This is reasonable performance from demand paging.

Reference Bit

This is set by the hardware whenever a page has either had a read or a write to any byte in the page.

Modify bit (dirty bit)

This is set by the hardware whenever any byte in the page is written into, indicating that he page has been changed.

Frame Allocation

This is the process of distributing the fixed amount of free memory to various processes.

Pager

This is used in connection with demand paging, and is used to determine which pages need to be in use at the current time.

Lazy Swapper

This never swaps a page into memory unless that page will be needed.

FIFO Page Replacement

This is a replacement algorithm that associates with each page the time when that the page was brought into memory. The page that was in memory longest will be removed first.

Thrashing

A process is doing this if it is spending more time paging than it it is executing.

Page Replacement

If no frame is free, we find one that is not currently being used and free it. We can now use the freed frame to hold the page for which the process faulted.

Frame-Allocation algorithm

If we have multiple processes in memory, we must decide how many frames to allocate each process using this.

Belady's Anomaly

One would think that with more frames to use in allocation that there would be fewer page faults, but sometimes there are more with more frames. In other words the page-fault rate may increase as the number of allocated frames increases.

Equal Allocation

Say we have m frames and n processes the easiest way to split the frames among the process is to give them all an equal share. If there is a remainder of frames they will be put into the free-frame buffer pool.

Proportional Allocation

Some processes will need differing amounts of memory. In that case we use this which will allocate available memory to each process according to its size. This is defined as a (process size / (All processes size) * Number of free frames)

Pure Demand Paging

This is a technique that never brings a page into memory until it is required. Ex. A process will fault until it has every page it needs and then it will not fault anymore.

Page-Fault rate

The number of times that we cause a page fault out of a certain number of accesses. It is directly proportional to effective access time.

Page Buffering

This is an additional procedure used with page-replacement algorithms which usually has a free-frame pool.

Swap Space

The section of the the disk that is used for swapping is called this.

Stack Algorithm

This is an algorithm for which it can be shown that the set of pages in memory for n frames is always a subset of the set of pages that would be in memory with n+1 frames. Also these algorithms are immune to Belady's anomaly.

Effective Access Time (for paged memory)

This is defined as [1-probability of page fault ([0,1]) * memory-access time + probability * page fault time).

Reference String

The string of memory references. It is used to calculate the number of page faults.

Least Frequently Used Page-Replacement Algorithm

This algorithm requires that the page with the smallest count be replaced. The reason is that page with a large reference count will be actively used and not replaced

Second-Chance Page-Replacement Algorithm

This algorithm uses the reference bits in order to make the page replacement. If the reference bit is set to 1 change it to zero and continue through the list until we come across a page who's reference bit is 0 so we can replace that one. Also known as the clock algorithm.

Least-Recently-Used Page Replacement

This algorithm will replace the page that has not been used for the longest period of time.

Memory-Mapped Files

This allows a part of the virtual address space to be logically associated with a file.

Global Replacement

This allows a process to select a replacement frame from the set of all frames, even if that frame is currently allocated to some other process; that is, one process can take a frame from another.

Copy-On-Write

This happens when a parent and child process are made. Initially a they both share the same pages. Then if either process writes to a shared page, a copy of the shared page is made via a trap/system call that neither process intended to make.

Optimal Page-Replacement Algorithm (OPT)

This has the lowest page-fault rate of all algorithms and will never suffer from Belady's anomaly, however it does not exist because it requires knowledge of the future. It's algorithm is described as this: Replace the page that will not be used for the longest period of time.

Virtual Memory

This involves the separation of logical memory as perceived by users from physical memory.

Page-Fault Frequency

This is used to help prevent thrashing. It helps determine if we have too many frames or if we have too many frames, because if we are thrashing we have a lot of page faults.

Memory Resident

This means that the page is in main memory at the moment.

Working-Set Model

This model uses a parameter, D, to define the working set window. The idea is to examine the most recent D page references. The set of the pages in the most recent D page references is the working set.

Local Replacement

This requires that each process select from only its own set of allocated frames.

Demand Paging

This technique only loads pages as they are needed.

Sparse (address space)

Virtual address spaces that include holes are called this.

Page Fault

When a process tries to access a page that was not brought into main memory, which will cause a trap to the operating system.

Page-Replacement Algorithm

When we use frame-allocation algorithm we must decide what frames that are to be replaced.