• Christoph Lameter's avatar
    [PATCH] Swap Migration V5: LRU operations · 21eac81f
    Christoph Lameter authored
    This is the start of the `swap migration' patch series.
    
    Swap migration allows the moving of the physical location of pages between
    nodes in a numa system while the process is running.  This means that the
    virtual addresses that the process sees do not change.  However, the system
    rearranges the physical location of those pages.
    
    The main intent of page migration patches here is to reduce the latency of
    memory access by moving pages near to the processor where the process
    accessing that memory is running.
    
    The patchset allows a process to manually relocate the node on which its
    pages are located through the MF_MOVE and MF_MOVE_ALL options while
    setting a new memory policy.
    
    The pages of process can also be relocated from another process using the
    sys_migrate_pages() function call.  Requires CAP_SYS_ADMIN.  The migrate_pages
    function call takes two sets of nodes and moves pages of a process that are
    located on the from nodes to the destination nodes.
    
    Manual migration is very useful if for example the scheduler has relocated a
    process to a processor on a distant node.  A batch scheduler or an
    administrator can detect the situation and move the pages of the process
    nearer to the new processor.
    
    sys_migrate_pages() could be used on non-numa machines as well, to force all
    of a particualr process's pages out to swap, if someone thinks that's useful.
    
    Larger installations usually partition the system using cpusets into sections
    of nodes.  Paul has equipped cpusets with the ability to move pages when a
    task is moved to another cpuset.  This allows automatic control over locality
    of a process.  If a task is moved to a new cpuset then also all its pages are
    moved with it so that the performance of the process does not sink
    dramatically (as is the case today).
    
    Swap migration works by simply evicting the page.  The pages must be faulted
    back in.  The pages are then typically reallocated by the system near the node
    where the process is executing.
    
    For swap migration the destination of the move is controlled by the allocation
    policy.  Cpusets set the allocation policy before calling sys_migrate_pages()
    in order to move the pages as intended.
    
    No allocation policy changes are performed for sys_migrate_pages().  This
    means that the pages may not faulted in to the specified nodes if no
    allocation policy was set by other means.  The pages will just end up near the
    node where the fault occurred.
    
    There's another patch series in the pipeline which implements "direct
    migration".
    
    The direct migration patchset extends the migration functionality to avoid
    going through swap.  The destination node of the relation is controllable
    during the actual moving of pages.  The crutch of using the allocation policy
    to relocate is not necessary and the pages are moved directly to the target.
    Its also faster since swap is not used.
    
    And sys_migrate_pages() can then move pages directly to the specified node.
    Implement functions to isolate pages from the LRU and put them back later.
    
    This patch:
    
    An earlier implementation was provided by Hirokazu Takahashi
    <taka@valinux.co.jp> and IWAMOTO Toshihiro <iwamoto@valinux.co.jp> for the
    memory hotplug project.
    
    From: Magnus
    
    This breaks out isolate_lru_page() and putpack_lru_page().  Needed for swap
    migration.
    Signed-off-by: default avatarMagnus Damm <magnus.damm@gmail.com>
    Signed-off-by: default avatarChristoph Lameter <clameter@sgi.com>
    Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
    Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
    21eac81f
vmscan.c 37.3 KB