This chapter describes the pool management. The OpenVMS Alpha operating system creates and uses many data structures in the course of its work. Although it creates some of them at system initialization, it creates most when they are needed and destroys them when their useful life is finished. It maintains distinct areas of virtual address memory, called pools, in which it allocates and deallocates dynamic data structures. Each pool has different characteristics. This chapter describes these memory areas, their uses, and their allocation and deallocation algorithms. It discusses dynamic data structures, and describes the structures and mechanisms of the variable-length pools, such as nonpaged pool, bus-addressable pool (BAP), paged pool, and pageable process-private space pool. It also describes fixed-length pools. Fixed-length pools expedite the allocation and deallocation of the most commonly used sizes and types of storage. In contrast to variable-length allocation, fixed-length allocation is very simple.

This chapter describes paging dynamics, which is the movement of pages of code and data between memory and mass storage. It describes the transitions a page makes as it is faulted into and out of a working set list, and as it moves between its backing store and memory. The page fault handler is entered in response to a translation-not-valid fault. When it is entered, the stack contains the standard exception stack frame. The page fault handler evaluates the memory management data structures to determine what kind of virtual page this is, and takes appropriate actions. Although many steps in page fault handling are common to most types of page, some depend on page type and state. The chapter describes the common steps in page fault handling and serves as a framework for details of type- and state-specific processing. It describes the $FAULT_PAGE system service, and its effect on page fault handling. The service enables an application to fault a set of pages prior to their use. It also discusses modified page writing, the allocation and use of page files, and the operation of the $UPDSEC and $UPDSEC_64 system services.

This chapter provides a brief overview of working set list dynamics. The working set refers to the virtual pages of a process that are currently valid and in physical memory. A valid page is one whose page table entry (PTE) valid bit is set. Execution of asynchronous system trap (AST) procedures, condition handlers, and system services that touch pageable process-private space can cause additional faults into the working set. The working set continues to grow as code running in the process context faults pages until the process occupies as much physical memory as it requires or is allowed. Each subsequent page fault requires that a page be removed from the working set to make room for the new page. The executive maintains a list of working set pages for each process, called the working set list. The chapter describes the structure and makeup of the working set list. It provides a detailed description of replacement paging, that is, removing one virtual page from the working set to make room for another. The size of the working set list and the number of its entries constrain a process's use of physical memory. The working set list size varies over the process's lifetime. It can be affected by the authorization file entry for an interactive user, SYSGEN parameters, availability of physical memory, and the recent paging history of the process. The chapter describes these effects, and discusses the capacity of the working set list.

This chapter provides a brief description of data structures used by the memory management subsystem. These include: structures that describe process virtual memory, page tables that help implement virtual memory, structures that describe granularity hint regions, structures that describe the state of physical memory, structures that enable processes to share memory through global pages and sections, and structures that describe the state of page and swap files. Much of the memory management information about a process is maintained in its process header (PHD). The PHD includes a list of valid virtual process pages, a description of the sections that make up the process-private address space, and a description of the permanent regions in P0, P1, and P2 space. There are two key data structures: process control block (PCB) and kernel thread block (KTB); they contain some information related to memory management. The process control block (PCB) represents a process and the kernel thread block (KTB) represents a kernel. The PHD, PCB, and KTB are all allocated in system space.

This chapter reviews some basic swapper concepts. The swapper process is the system wide physical memory manager. Its responsibilities include maintaining an adequate supply of physical memory and ensuring that the highest priority computable kernel threads are resident in memory. The swapper maintains the number of free pages above the threshold established by the SYSGEN parameter FREELIM. The swapper stops reclaiming pages when the number of free pages exceeds the SYSGEN parameter FREEGOAL. The swapper ensures that there are fewer pages on the modified page list than the threshold established by the SYSGEN parameter MPW_HILIMIT. When the modified page list grows above this limit, the swapper calls the modified page writer routine to write the contents of some modified pages to their backing store and to move the physical pages to the free page list. The swapper spends its idle time hibernating. Executive components that detect a need for swapper activity wake the swapper by calling routine SCH$SWPWAKE, in module RSE. The swapper is implemented as a separate process whose single kernel thread has a priority of 16, the lowest real-time priority. It is selected for execution like any other kernel thread in the system. The swapper serves as a convenient process context for several system functions.

This chapter describes the Alpha memory management architecture, and provides an overview of OpenVMS Alpha memory management. It describes the fundamental concepts of memory management and the architectural mechanisms. It provides an overview of OpenVMS management of virtual and physical memory. Physical memory is the real memory supplied by the hardware. A virtual memory system simulates real memory by transparently moving the contents of memory to and from block-addressable mass storage, usually disks. Virtual memory support for the OpenVMS Alpha operating system is based upon Alpha architectural features. It provides: maximum compatibility with OpenVMS VAX memory management, access to the larger Alpha address space, support for memory shared among multiple OpenVMS instances running on a Galaxy platform, and support for efficient operation of platforms with nonuniform memory access.

This chapter describes several types of memory management system services. The original system services accept only 32-bit address arguments, and are supplemented with 64-bit services that take 64-bit address arguments. The other related services names end with _64 indicating that they accept 64-bit addresses by reference. A process's ability to use the services can be limited by access mode, process quotas, limits, privileges, and SYSGEN parameters. Generally, a process is only permitted to affect P0, P1, and P2 address space, not system space, with these services. The only exception is when a process uses the buffer object services to double-map process-private address space into system space. Almost all the memory management system services accept a desired virtual address range as one or more input arguments. Many of the services can partly succeed, that is, affect only a portion of the specified address range. A system service indicates partial success by returning an error status and the address range for which the operation completed.