lkml.org 
[lkml]   [2010]   [Nov]   [12]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH/RFC] MM slub: add a sysfs entry to show the calculated number of fallback slabs
    From
    Date
    Add a slub sysfs entry to show the calculated number of fallback slabs.

    Using the information already available it is straightforward to
    calculate the number of fallback & full size slabs. We can then track
    which slabs are particularly effected by memory fragmentation and how
    long they take to recover.

    There is no change to the mainline code, the calculation is only
    performed on request, and the value is available without having to
    enable CONFIG_SLUB_STATS.

    Note that this could give the wrong value if the user changes the slab
    order via the sysfs interface.

    Signed-off-by: Richard Kennedy <richard@rsk.demon.co.uk>
    ---


    As we have the information needed to do this calculation is seem useful
    to expose it and provide another way to understand what is happening
    inside the memory manager.

    On my desktop workloads (kernel compile etc) I'm seeing surprisingly
    little slab fragmentation. Do you have any suggestions for test cases
    that will fragment the memory?

    I copied the code to count the total objects from the slabinfo s_show
    function, but as I don't need the partial count I didn't extract it into
    a helper function.

    regards
    Richard


    diff --git a/mm/slub.c b/mm/slub.c
    index 8fd5401..8c79eaa 100644
    --- a/mm/slub.c
    +++ b/mm/slub.c
    @@ -4043,6 +4043,46 @@ static ssize_t destroy_by_rcu_show(struct kmem_cache *s, char *buf)
    }
    SLAB_ATTR_RO(destroy_by_rcu);

    +/* The number of fallback slabs can be calculated to give an
    + * indication of how fragmented this slab is.
    + * This is a snapshot of the current makeup of this cache.
    + *
    + * Given
    + *
    + * total_objects = (nr_fallback_slabs * objects_per_fallback_slab) +
    + * ( nr_normal_slabs * objects_per_slab)
    + * and
    + * nr_slabs = nr_normal_slabs + nr_fallback_slabs
    + *
    + * then we can easily calculate nr_fallback_slabs.
    + *
    + * Note that this can give the wrong answer if the user has changed the
    + * order of this slab via sysfs.
    + */
    +
    +static ssize_t fallback_show(struct kmem_cache *s, char *buf)
    +{
    + unsigned long nr_objects = 0;
    + unsigned long nr_slabs = 0;
    + unsigned long nr_fallback = 0;
    + unsigned long acc;
    + int node;
    +
    + if (oo_order(s->oo) != oo_order(s->min)) {
    + for_each_online_node(node) {
    + struct kmem_cache_node *n = get_node(s, node);
    + nr_slabs += atomic_long_read(&n->nr_slabs);
    + nr_objects += atomic_long_read(&n->total_objects);
    + }
    + acc = nr_objects - nr_slabs * oo_objects(s->min);
    + acc /= (oo_objects(s->oo) - oo_objects(s->min));
    + nr_fallback = nr_slabs - acc;
    + }
    + return sprintf(buf, "%lu\n", nr_fallback);
    +}
    +SLAB_ATTR_RO(fallback);
    +
    +
    #ifdef CONFIG_SLUB_DEBUG
    static ssize_t slabs_show(struct kmem_cache *s, char *buf)
    {
    @@ -4329,6 +4369,7 @@ static struct attribute *slab_attrs[] = {
    &reclaim_account_attr.attr,
    &destroy_by_rcu_attr.attr,
    &shrink_attr.attr,
    + &fallback_attr.attr,
    #ifdef CONFIG_SLUB_DEBUG
    &total_objects_attr.attr,
    &slabs_attr.attr,



    \
     
     \ /
      Last update: 2010-11-12 12:31    [W:0.023 / U:31.080 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site