• C
    [PATCH] zoned vm counters: basic ZVC (zoned vm counter) implementation · 2244b95a
    Christoph Lameter 提交于
    Per zone counter infrastructure
    
    The counters that we currently have for the VM are split per processor.  The
    processor however has not much to do with the zone these pages belong to.  We
    cannot tell f.e.  how many ZONE_DMA pages are dirty.
    
    So we are blind to potentially inbalances in the usage of memory in various
    zones.  F.e.  in a NUMA system we cannot tell how many pages are dirty on a
    particular node.  If we knew then we could put measures into the VM to balance
    the use of memory between different zones and different nodes in a NUMA
    system.  For example it would be possible to limit the dirty pages per node so
    that fast local memory is kept available even if a process is dirtying huge
    amounts of pages.
    
    Another example is zone reclaim.  We do not know how many unmapped pages exist
    per zone.  So we just have to try to reclaim.  If it is not working then we
    pause and try again later.  It would be better if we knew when it makes sense
    to reclaim unmapped pages from a zone.  This patchset allows the determination
    of the number of unmapped pages per zone.  We can remove the zone reclaim
    interval with the counters introduced here.
    
    Futhermore the ability to have various usage statistics available will allow
    the development of new NUMA balancing algorithms that may be able to improve
    the decision making in the scheduler of when to move a process to another node
    and hopefully will also enable automatic page migration through a user space
    program that can analyse the memory load distribution and then rebalance
    memory use in order to increase performance.
    
    The counter framework here implements differential counters for each processor
    in struct zone.  The differential counters are consolidated when a threshold
    is exceeded (like done in the current implementation for nr_pageache), when
    slab reaping occurs or when a consolidation function is called.
    
    Consolidation uses atomic operations and accumulates counters per zone in the
    zone structure and also globally in the vm_stat array.  VM functions can
    access the counts by simply indexing a global or zone specific array.
    
    The arrangement of counters in an array also simplifies processing when output
    has to be generated for /proc/*.
    
    Counters can be updated by calling inc/dec_zone_page_state or
    _inc/dec_zone_page_state analogous to *_page_state.  The second group of
    functions can be called if it is known that interrupts are disabled.
    
    Special optimized increment and decrement functions are provided.  These can
    avoid certain checks and use increment or decrement instructions that an
    architecture may provide.
    
    We also add a new CONFIG_DMA_IS_NORMAL that signifies that an architecture can
    do DMA to all memory and therefore ZONE_NORMAL will not be populated.  This is
    only currently set for IA64 SGI SN2 and currently only affects
    node_page_state().  In the best case node_page_state can be reduced to
    retrieving a single counter for the one zone on the node.
    
    [akpm@osdl.org: cleanups]
    [akpm@osdl.org: export vm_stat[] for filesystems]
    Signed-off-by: NChristoph Lameter <clameter@sgi.com>
    Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
    Signed-off-by: NAndrew Morton <akpm@osdl.org>
    Signed-off-by: NLinus Torvalds <torvalds@osdl.org>
    2244b95a
page_alloc.c 62.9 KB