From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756006Ab0CXMGx (ORCPT ); Wed, 24 Mar 2010 08:06:53 -0400 Received: from mail-px0-f184.google.com ([209.85.216.184]:49466 "EHLO mail-px0-f184.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755610Ab0CXMGw convert rfc822-to-8bit (ORCPT ); Wed, 24 Mar 2010 08:06:52 -0400 DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=WTCXhk5Xs9Y6SK6miaER1XObFQkp/WdbEfEBWkPO5MsMdFoSAPBVerb6KdVEfaY7A9 viQfDJXzWAUeZgvqleim59lUJrhvrkYPqjopWvZlUV/K5WmG3ZFrgjHVz3/lRfyu/7kT IvrACZz/jQ7kcUPsBQEpzX4bJax9DlKzVJJx4= MIME-Version: 1.0 In-Reply-To: <28c262361003240459m7d981203nea98df5196812b6c@mail.gmail.com> References: <1269347146-7461-1-git-send-email-mel@csn.ul.ie> <1269347146-7461-11-git-send-email-mel@csn.ul.ie> <28c262361003231610p3753a136v51720df8568cfa0a@mail.gmail.com> <20100324111159.GD21147@csn.ul.ie> <28c262361003240459m7d981203nea98df5196812b6c@mail.gmail.com> Date: Wed, 24 Mar 2010 21:06:51 +0900 Message-ID: <28c262361003240506k34874895qa335f98ed0b8801b@mail.gmail.com> Subject: Re: [PATCH 10/11] Direct compact when a high-order allocation fails From: Minchan Kim To: Mel Gorman Cc: Andrew Morton , Andrea Arcangeli , Christoph Lameter , Adam Litke , Avi Kivity , David Rientjes , KAMEZAWA Hiroyuki , KOSAKI Motohiro , Rik van Riel , linux-kernel@vger.kernel.org, linux-mm@kvack.org Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Mar 24, 2010 at 8:59 PM, Minchan Kim wrote: > On Wed, Mar 24, 2010 at 8:11 PM, Mel Gorman wrote: >> On Wed, Mar 24, 2010 at 08:10:40AM +0900, Minchan Kim wrote: >>> Hi, Mel. >>> >>> On Tue, Mar 23, 2010 at 9:25 PM, Mel Gorman wrote: >>> > Ordinarily when a high-order allocation fails, direct reclaim is entered to >>> > free pages to satisfy the allocation.  With this patch, it is determined if >>> > an allocation failed due to external fragmentation instead of low memory >>> > and if so, the calling process will compact until a suitable page is >>> > freed. Compaction by moving pages in memory is considerably cheaper than >>> > paging out to disk and works where there are locked pages or no swap. If >>> > compaction fails to free a page of a suitable size, then reclaim will >>> > still occur. >>> > >>> > Direct compaction returns as soon as possible. As each block is compacted, >>> > it is checked if a suitable page has been freed and if so, it returns. >>> > >>> > Signed-off-by: Mel Gorman >>> > Acked-by: Rik van Riel >>> > --- >>> >  include/linux/compaction.h |   16 +++++- >>> >  include/linux/vmstat.h     |    1 + >>> >  mm/compaction.c            |  118 ++++++++++++++++++++++++++++++++++++++++++++ >>> >  mm/page_alloc.c            |   26 ++++++++++ >>> >  mm/vmstat.c                |   15 +++++- >>> >  5 files changed, 172 insertions(+), 4 deletions(-) >>> > >>> > diff --git a/include/linux/compaction.h b/include/linux/compaction.h >>> > index c94890b..b851428 100644 >>> > --- a/include/linux/compaction.h >>> > +++ b/include/linux/compaction.h >>> > @@ -1,14 +1,26 @@ >>> >  #ifndef _LINUX_COMPACTION_H >>> >  #define _LINUX_COMPACTION_H >>> > >>> > -/* Return values for compact_zone() */ >>> > +/* Return values for compact_zone() and try_to_compact_pages() */ >>> >  #define COMPACT_INCOMPLETE     0 >>> > -#define COMPACT_COMPLETE       1 >>> > +#define COMPACT_PARTIAL                1 >>> > +#define COMPACT_COMPLETE       2 >>> > >>> >  #ifdef CONFIG_COMPACTION >>> >  extern int sysctl_compact_memory; >>> >  extern int sysctl_compaction_handler(struct ctl_table *table, int write, >>> >                        void __user *buffer, size_t *length, loff_t *ppos); >>> > + >>> > +extern int fragmentation_index(struct zone *zone, unsigned int order); >>> > +extern unsigned long try_to_compact_pages(struct zonelist *zonelist, >>> > +                       int order, gfp_t gfp_mask, nodemask_t *mask); >>> > +#else >>> > +static inline unsigned long try_to_compact_pages(struct zonelist *zonelist, >>> > +                       int order, gfp_t gfp_mask, nodemask_t *nodemask) >>> > +{ >>> > +       return COMPACT_INCOMPLETE; >>> > +} >>> > + >>> >  #endif /* CONFIG_COMPACTION */ >>> > >>> >  #if defined(CONFIG_COMPACTION) && defined(CONFIG_SYSFS) && defined(CONFIG_NUMA) >>> > diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h >>> > index 56e4b44..b4b4d34 100644 >>> > --- a/include/linux/vmstat.h >>> > +++ b/include/linux/vmstat.h >>> > @@ -44,6 +44,7 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT, >>> >                KSWAPD_SKIP_CONGESTION_WAIT, >>> >                PAGEOUTRUN, ALLOCSTALL, PGROTATED, >>> >                COMPACTBLOCKS, COMPACTPAGES, COMPACTPAGEFAILED, >>> > +               COMPACTSTALL, COMPACTFAIL, COMPACTSUCCESS, >>> >  #ifdef CONFIG_HUGETLB_PAGE >>> >                HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL, >>> >  #endif >>> > diff --git a/mm/compaction.c b/mm/compaction.c >>> > index 8df6e3d..6688700 100644 >>> > --- a/mm/compaction.c >>> > +++ b/mm/compaction.c >>> > @@ -34,6 +34,8 @@ struct compact_control { >>> >        unsigned long nr_anon; >>> >        unsigned long nr_file; >>> > >>> > +       unsigned int order;             /* order a direct compactor needs */ >>> > +       int migratetype;                /* MOVABLE, RECLAIMABLE etc */ >>> >        struct zone *zone; >>> >  }; >>> > >>> > @@ -301,10 +303,31 @@ static void update_nr_listpages(struct compact_control *cc) >>> >  static inline int compact_finished(struct zone *zone, >>> >                                                struct compact_control *cc) >>> >  { >>> > +       unsigned int order; >>> > +       unsigned long watermark = low_wmark_pages(zone) + (1 << cc->order); >>> > + >>> >        /* Compaction run completes if the migrate and free scanner meet */ >>> >        if (cc->free_pfn <= cc->migrate_pfn) >>> >                return COMPACT_COMPLETE; >>> > >>> > +       /* Compaction run is not finished if the watermark is not met */ >>> > +       if (!zone_watermark_ok(zone, cc->order, watermark, 0, 0)) >>> > +               return COMPACT_INCOMPLETE; >>> > + >>> > +       if (cc->order == -1) >>> > +               return COMPACT_INCOMPLETE; >>> > + >>> > +       /* Direct compactor: Is a suitable page free? */ >>> > +       for (order = cc->order; order < MAX_ORDER; order++) { >>> > +               /* Job done if page is free of the right migratetype */ >>> > +               if (!list_empty(&zone->free_area[order].free_list[cc->migratetype])) >>> > +                       return COMPACT_PARTIAL; >>> > + >>> > +               /* Job done if allocation would set block type */ >>> > +               if (order >= pageblock_order && zone->free_area[order].nr_free) >>> > +                       return COMPACT_PARTIAL; >>> > +       } >>> > + >>> >        return COMPACT_INCOMPLETE; >>> >  } >>> > >>> > @@ -348,6 +371,101 @@ static int compact_zone(struct zone *zone, struct compact_control *cc) >>> >        return ret; >>> >  } >>> > >>> > +static inline unsigned long compact_zone_order(struct zone *zone, >>> > +                                               int order, gfp_t gfp_mask) >>> > +{ >>> > +       struct compact_control cc = { >>> > +               .nr_freepages = 0, >>> > +               .nr_migratepages = 0, >>> > +               .order = order, >>> > +               .migratetype = allocflags_to_migratetype(gfp_mask), >>> > +               .zone = zone, >>> > +       }; >>> > +       INIT_LIST_HEAD(&cc.freepages); >>> > +       INIT_LIST_HEAD(&cc.migratepages); >>> > + >>> > +       return compact_zone(zone, &cc); >>> > +} >>> > + >>> > +/** >>> > + * try_to_compact_pages - Direct compact to satisfy a high-order allocation >>> > + * @zonelist: The zonelist used for the current allocation >>> > + * @order: The order of the current allocation >>> > + * @gfp_mask: The GFP mask of the current allocation >>> > + * @nodemask: The allowed nodes to allocate from >>> > + * >>> > + * This is the main entry point for direct page compaction. >>> > + */ >>> > +unsigned long try_to_compact_pages(struct zonelist *zonelist, >>> > +                       int order, gfp_t gfp_mask, nodemask_t *nodemask) >>> > +{ >>> > +       enum zone_type high_zoneidx = gfp_zone(gfp_mask); >>> > +       int may_enter_fs = gfp_mask & __GFP_FS; >>> > +       int may_perform_io = gfp_mask & __GFP_IO; >>> > +       unsigned long watermark; >>> > +       struct zoneref *z; >>> > +       struct zone *zone; >>> > +       int rc = COMPACT_INCOMPLETE; >>> > + >>> > +       /* Check whether it is worth even starting compaction */ >>> > +       if (order == 0 || !may_enter_fs || !may_perform_io) >>> > +               return rc; >>> > + >>> > +       /* >>> > +        * We will not stall if the necessary conditions are not met for >>> > +        * migration but direct reclaim seems to account stalls similarly >>> > +        */ Then, Let's remove this comment. -- Kind regards, Minchan Kim