Figure: Simplified memory access process when no caching is present
Virtual Address - the address that a process believes it is accessing
Physical Address - the address in main memory that is actually being addressed
Memory Management Unit (MMU) - a hardware device that determines whether an address that the process is trying to access is located physically in main memory
Page Fault - an interrupt caused by the MMU which requests that the OS retrieve a missing page from disk
Translation Lookaside Buffer (TLB) - a method of caching which pages are in memory so that only one memory access is required.
Working Set - the pages that a process most actively uses
Thrashing - describes the action of the memory system when pages are constantly evicted from memory and then subsequently requested again (occurs when the working set is larger than number of available page frames).
One constant problem faced by computer systems is the lack of relatively fast main memory. A computer system might have an address bus of 32 bits capable of addressing 4GB, but a main memory that is much smaller. A process may therefore address a valid location that is outside the range of main memory. Also, if we want to keep many processes in memory for fast switching, the amount that each process can address is further limited. However, neither the programmer or compiler knows the physical address (in main memory) at which the process will begin execution. The solution to all of these problems is paging.
The trick to making the entire address space appear accessible to the programmer is to divide the process into chunks called pages, and map them into equally sized chunks in main memory called page frames. This also allows the programmer to assume that he has access to the entire address space, which is not the case.
Using this method, the entire program does not need to be in memory. Only the parts of the program that are being accessed need appear. A hardware mechanism, the memory management unit (MMU) is responsible for mapping a process's virtual address to an address in main memory.
When a process is created, the OS makes a copy of the executable file on disk and allows it to begin execution. The process begins by trying to fetch its first instruction. The MMU determines that this instruction is located on a page that is not present in main memory and signals a page fault. The OS is requested to retrieve the page from disk. If there are availabe openings in main memory, the incoming page is mapped to one of them. If there are not openings, another page must be evicted. After the page is loaded, the instruction must be run again. Anytime the process now tries to access an address within the same page, the MMU will determine that it exists in memory and translate the virtual address to the physical address.
The translation lookaside buffer (TLB) is simply a cache of the pages in memory. Without the TLB, two accesses to main memory would be required for every memory operation. The first would need to check if the required page was located in main memory. The second could then perform the memory request. The TLB eliminates the first access in the cases where the page actually exists in memory.
The idea behind a working set is that when executing instructions, a process is likely to continually access the same memory locations time after time. This condition arises because of the principles of temporal and spatial locality, and the presence of loops. The pages that are required to be in memory to fulfill the majority of the processes requests are termed its working set.
Thrashing is a term that describes the behavior of a process that is not allowed enough page frames in memory to completely hold its working set. If the working set cannot be held in memory all at once, pages will constantly be evicted and reloaded, causing major slowdowns (because reading/writing from disk is quite expensive).
Information on how the MMU maps a virtual address to a physical address and applies an offset can be found here. The same website also addresses how the operating system manages pages from all running processes.