diff for duplicates of <20140613024005.GA8704@gmail.com> diff --git a/a/1.txt b/N1/1.txt index 9da47d0..2beec12 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -93,3 +93,276 @@ It's good to me. Another topic: I couldn't find any cond_resched. Anyway, it could be another patch. + +>From a4b7c288d8de670adbc45c85991ed3bef31e4e16 Mon Sep 17 00:00:00 2001 +From: Minchan Kim <minchan@kernel.org> +Date: Fri, 13 Jun 2014 10:59:26 +0900 +Subject: [PATCH] mm: call cond_resched right before failing compaction + +David reported in many case of direct compaction for THP page fault +is failed since the async compaction was abort by need_resched. +It's okay because THP could be fallback to 4K page but the problem +is if need_resched is true, we should give a chance to next process +to schedul in for the latency so that we are not greedy any more. + +Signed-off-by: Minchan Kim <minchan@kernel.org> +--- + mm/page_alloc.c | 10 +++++++++- + 1 file changed, 9 insertions(+), 1 deletion(-) + +diff --git a/mm/page_alloc.c b/mm/page_alloc.c +index 4f59fa2..1ac5133 100644 +--- a/mm/page_alloc.c ++++ b/mm/page_alloc.c +@@ -2617,8 +2617,16 @@ rebalance: + * system then fail the allocation instead of entering direct reclaim. + */ + if ((deferred_compaction || contended_compaction) && +- (gfp_mask & __GFP_NO_KSWAPD)) ++ (gfp_mask & __GFP_NO_KSWAPD)) { ++ /* ++ * When THP page fault occurs in large memory system, ++ * contended_compaction is likely to be true by need_resched ++ * checking so let's schedule right before returning NULL page. ++ * That makes I'm not greedy! ++ */ ++ cond_resched(); + goto nopage; ++ } + + /* Try direct reclaim and then allocating */ + page = __alloc_pages_direct_reclaim(gfp_mask, order, +-- +2.0.0 + +With your change(ie, direct compaction is only aware of lock contetion, +not need_resched), when THP page fault occurs and it found rescheduling +while doing async direct compaction, it goes *direct reclaim path*, +not "nopage" and async direct compaction again and then finally nopage. +I think you are changing the behavior heavily to increase latency, +which is not what direct reclaim path want even though I have no data. + +So, what I want is following as. +It is based on previoius inline patch. + +--- + mm/page_alloc.c | 13 +++++++++++-- + 1 file changed, 11 insertions(+), 2 deletions(-) + +diff --git a/mm/page_alloc.c b/mm/page_alloc.c +index 1ac5133..8a4480e5 100644 +--- a/mm/page_alloc.c ++++ b/mm/page_alloc.c +@@ -2624,8 +2624,17 @@ rebalance: + * checking so let's schedule right before returning NULL page. + * That makes I'm not greedy! + */ +- cond_resched(); +- goto nopage; ++ int ret = cond_resched(); ++ ++ /* When THP page fault, we want to bail out for the latency */ ++ if (!(current->flags & PF_KTHREAD) || !ret) ++ goto nopage; ++ ++ /* ++ * I'm khugepaged and took a rest so want to try compaction ++ * with synchronous rather than giving up easily. ++ */ ++ WARN_ON(migration_mode == MIGRATE_ASYNC); + } + + /* Try direct reclaim and then allocating */ +-- +2.0.0 + +I'm off from now on. :) + +> +> >I don't mean we should abort but the process could sleep and retry. +> >The point is that we should give latency pain to the process request +> >high-order alocation, not another random process. +> +> So basically you are saying that there should be cond_resched() also +> for async compaction when need_resched() is true? Now need_resched() +> is a trigger to back off rather quickly all the way back to +> __alloc_pages_direct_compact() which does contain a cond_resched(). +> So there should be a yield before retry. Or are you worried that the +> back off is not quick enough and it shoudl cond_resched() +> immediately? +> +> >IMHO, if we want to increase high-order alloc ratio in page fault, +> >kswapd should be more aggressive than now via feedback loop from +> >fail rate from direct compaction. +> +> Recently I think we have been rather decreasing high-order alloc +> ratio in page fault :) But (at least for the THP) page fault +> allocation attempts contain __GFP_NO_KSWAPD, so there's no feedback +> loop. I guess changing that would be rather disruptive. +> +> >> +> >>>We have taken care of it in direct reclaim path so why direct compaction is +> >>>so special? +> >> +> >>I admit I'm not that familiar with reclaim but I didn't quickly find +> >>any need_resched() there? There's plenty of cond_resched() but that +> >>doesn't mean it will abort? Could you explain for me? +> > +> >I meant cond_resched. +> > +> >> +> >>>Why does khugepaged give up easily if lock contention/need_resched happens? +> >>>khugepaged is important for success ratio as I read your description so IMO, +> >>>khugepaged should do synchronously without considering early bail out by +> >>>lock/rescheduling. +> >> +> >>Well a stupid answer is that's how __alloc_pages_slowpath() works :) +> >>I don't think it's bad to try using first a more lightweight +> >>approach before trying the heavyweight one. As long as the +> >>heavyweight one is not skipped for khugepaged. +> > +> >I'm not saying current two-stage trying is bad. My stand is that we should +> >take care of need_resched and shouldn't become a greedy but khugepaged would +> >be okay. +> > +> >> +> >>>If it causes problems, user should increase scan_sleep_millisecs/alloc_sleep_millisecs, +> >>>which is exactly the knob for that cases. +> >>> +> >>>So, my point is how about making khugepaged doing always dumb synchronous +> >>>compaction thorough PG_KHUGEPAGED or GFP_SYNC_TRANSHUGE? +> >>> +> >>>> +> >>>>Reported-by: David Rientjes <rientjes@google.com> +> >>>>Signed-off-by: Vlastimil Babka <vbabka@suse.cz> +> >>>>Cc: Minchan Kim <minchan@kernel.org> +> >>>>Cc: Mel Gorman <mgorman@suse.de> +> >>>>Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com> +> >>>>Cc: Michal Nazarewicz <mina86@mina86.com> +> >>>>Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com> +> >>>>Cc: Christoph Lameter <cl@linux.com> +> >>>>Cc: Rik van Riel <riel@redhat.com> +> >>>>--- +> >>>> mm/compaction.c | 20 ++++++++++++++------ +> >>>> mm/internal.h | 15 +++++++++++---- +> >>>> 2 files changed, 25 insertions(+), 10 deletions(-) +> >>>> +> >>>>diff --git a/mm/compaction.c b/mm/compaction.c +> >>>>index b73b182..d37f4a8 100644 +> >>>>--- a/mm/compaction.c +> >>>>+++ b/mm/compaction.c +> >>>>@@ -185,9 +185,14 @@ static void update_pageblock_skip(struct compact_control *cc, +> >>>> } +> >>>> #endif /* CONFIG_COMPACTION */ +> >>>> +> >>>>-static inline bool should_release_lock(spinlock_t *lock) +> >>>>+enum compact_contended should_release_lock(spinlock_t *lock) +> >>>> { +> >>>>- return need_resched() || spin_is_contended(lock); +> >>>>+ if (need_resched()) +> >>>>+ return COMPACT_CONTENDED_SCHED; +> >>>>+ else if (spin_is_contended(lock)) +> >>>>+ return COMPACT_CONTENDED_LOCK; +> >>>>+ else +> >>>>+ return COMPACT_CONTENDED_NONE; +> >>>> } +> >>>> +> >>>> /* +> >>>>@@ -202,7 +207,9 @@ static inline bool should_release_lock(spinlock_t *lock) +> >>>> static bool compact_checklock_irqsave(spinlock_t *lock, unsigned long *flags, +> >>>> bool locked, struct compact_control *cc) +> >>>> { +> >>>>- if (should_release_lock(lock)) { +> >>>>+ enum compact_contended contended = should_release_lock(lock); +> >>>>+ +> >>>>+ if (contended) { +> >>>> if (locked) { +> >>>> spin_unlock_irqrestore(lock, *flags); +> >>>> locked = false; +> >>>>@@ -210,7 +217,7 @@ static bool compact_checklock_irqsave(spinlock_t *lock, unsigned long *flags, +> >>>> +> >>>> /* async aborts if taking too long or contended */ +> >>>> if (cc->mode == MIGRATE_ASYNC) { +> >>>>- cc->contended = true; +> >>>>+ cc->contended = contended; +> >>>> return false; +> >>>> } +> >>>> +> >>>>@@ -236,7 +243,7 @@ static inline bool compact_should_abort(struct compact_control *cc) +> >>>> /* async compaction aborts if contended */ +> >>>> if (need_resched()) { +> >>>> if (cc->mode == MIGRATE_ASYNC) { +> >>>>- cc->contended = true; +> >>>>+ cc->contended = COMPACT_CONTENDED_SCHED; +> >>>> return true; +> >>>> } +> >>>> +> >>>>@@ -1095,7 +1102,8 @@ static unsigned long compact_zone_order(struct zone *zone, int order, +> >>>> VM_BUG_ON(!list_empty(&cc.freepages)); +> >>>> VM_BUG_ON(!list_empty(&cc.migratepages)); +> >>>> +> >>>>- *contended = cc.contended; +> >>>>+ /* We only signal lock contention back to the allocator */ +> >>>>+ *contended = cc.contended == COMPACT_CONTENDED_LOCK; +> >>>> return ret; +> >>>> } +> >>>> +> >>>>diff --git a/mm/internal.h b/mm/internal.h +> >>>>index 7f22a11f..4659e8e 100644 +> >>>>--- a/mm/internal.h +> >>>>+++ b/mm/internal.h +> >>>>@@ -117,6 +117,13 @@ extern int user_min_free_kbytes; +> >>>> +> >>>> #if defined CONFIG_COMPACTION || defined CONFIG_CMA +> >>>> +> >>>>+/* Used to signal whether compaction detected need_sched() or lock contention */ +> >>>>+enum compact_contended { +> >>>>+ COMPACT_CONTENDED_NONE = 0, /* no contention detected */ +> >>>>+ COMPACT_CONTENDED_SCHED, /* need_sched() was true */ +> >>>>+ COMPACT_CONTENDED_LOCK, /* zone lock or lru_lock was contended */ +> >>>>+}; +> >>>>+ +> >>>> /* +> >>>> * in mm/compaction.c +> >>>> */ +> >>>>@@ -144,10 +151,10 @@ struct compact_control { +> >>>> int order; /* order a direct compactor needs */ +> >>>> int migratetype; /* MOVABLE, RECLAIMABLE etc */ +> >>>> struct zone *zone; +> >>>>- bool contended; /* True if a lock was contended, or +> >>>>- * need_resched() true during async +> >>>>- * compaction +> >>>>- */ +> >>>>+ enum compact_contended contended; /* Signal need_sched() or lock +> >>>>+ * contention detected during +> >>>>+ * compaction +> >>>>+ */ +> >>>> }; +> >>>> +> >>>> unsigned long +> >>>>-- +> >>>>1.8.4.5 +> >>>> +> >>>>-- +> >>>>To unsubscribe, send a message with 'unsubscribe linux-mm' in +> >>>>the body to majordomo@kvack.org. For more info on Linux MM, +> >>>>see: http://www.linux-mm.org/ . +> >>>>Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> +> >>> +> >> +> >>-- +> >>To unsubscribe, send a message with 'unsubscribe linux-mm' in +> >>the body to majordomo@kvack.org. For more info on Linux MM, +> >>see: http://www.linux-mm.org/ . +> >>Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> +> > +> +> -- +> To unsubscribe, send a message with 'unsubscribe linux-mm' in +> the body to majordomo@kvack.org. For more info on Linux MM, +> see: http://www.linux-mm.org/ . +> Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> + +-- +Kind regards, +Minchan Kim diff --git a/a/content_digest b/N1/content_digest index a853ba5..a8928e1 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -115,6 +115,279 @@ "It's good to me.\n" "\n" "Another topic: I couldn't find any cond_resched. Anyway, it could be\n" - another patch. + "another patch.\n" + "\n" + ">From a4b7c288d8de670adbc45c85991ed3bef31e4e16 Mon Sep 17 00:00:00 2001\n" + "From: Minchan Kim <minchan@kernel.org>\n" + "Date: Fri, 13 Jun 2014 10:59:26 +0900\n" + "Subject: [PATCH] mm: call cond_resched right before failing compaction\n" + "\n" + "David reported in many case of direct compaction for THP page fault\n" + "is failed since the async compaction was abort by need_resched.\n" + "It's okay because THP could be fallback to 4K page but the problem\n" + "is if need_resched is true, we should give a chance to next process\n" + "to schedul in for the latency so that we are not greedy any more.\n" + "\n" + "Signed-off-by: Minchan Kim <minchan@kernel.org>\n" + "---\n" + " mm/page_alloc.c | 10 +++++++++-\n" + " 1 file changed, 9 insertions(+), 1 deletion(-)\n" + "\n" + "diff --git a/mm/page_alloc.c b/mm/page_alloc.c\n" + "index 4f59fa2..1ac5133 100644\n" + "--- a/mm/page_alloc.c\n" + "+++ b/mm/page_alloc.c\n" + "@@ -2617,8 +2617,16 @@ rebalance:\n" + " \t * system then fail the allocation instead of entering direct reclaim.\n" + " \t */\n" + " \tif ((deferred_compaction || contended_compaction) &&\n" + "-\t\t\t\t\t\t(gfp_mask & __GFP_NO_KSWAPD))\n" + "+\t\t\t\t\t\t(gfp_mask & __GFP_NO_KSWAPD)) {\n" + "+\t\t/*\n" + "+\t\t * When THP page fault occurs in large memory system,\n" + "+\t\t * contended_compaction is likely to be true by need_resched\n" + "+\t\t * checking so let's schedule right before returning NULL page.\n" + "+\t\t * That makes I'm not greedy!\n" + "+\t\t */\n" + "+\t\tcond_resched();\n" + " \t\tgoto nopage;\n" + "+\t}\n" + " \n" + " \t/* Try direct reclaim and then allocating */\n" + " \tpage = __alloc_pages_direct_reclaim(gfp_mask, order,\n" + "-- \n" + "2.0.0\n" + "\n" + "With your change(ie, direct compaction is only aware of lock contetion,\n" + "not need_resched), when THP page fault occurs and it found rescheduling\n" + "while doing async direct compaction, it goes *direct reclaim path*,\n" + "not \"nopage\" and async direct compaction again and then finally nopage.\n" + "I think you are changing the behavior heavily to increase latency,\n" + "which is not what direct reclaim path want even though I have no data.\n" + "\n" + "So, what I want is following as.\n" + "It is based on previoius inline patch.\n" + "\n" + "---\n" + " mm/page_alloc.c | 13 +++++++++++--\n" + " 1 file changed, 11 insertions(+), 2 deletions(-)\n" + "\n" + "diff --git a/mm/page_alloc.c b/mm/page_alloc.c\n" + "index 1ac5133..8a4480e5 100644\n" + "--- a/mm/page_alloc.c\n" + "+++ b/mm/page_alloc.c\n" + "@@ -2624,8 +2624,17 @@ rebalance:\n" + " \t\t * checking so let's schedule right before returning NULL page.\n" + " \t\t * That makes I'm not greedy!\n" + " \t\t */\n" + "-\t\tcond_resched();\n" + "-\t\tgoto nopage;\n" + "+\t\tint ret = cond_resched();\n" + "+\n" + "+\t\t/* When THP page fault, we want to bail out for the latency */\n" + "+\t\tif (!(current->flags & PF_KTHREAD) || !ret)\n" + "+\t\t\tgoto nopage;\n" + "+\n" + "+\t\t/*\n" + "+\t\t * I'm khugepaged and took a rest so want to try compaction\n" + "+\t\t * with synchronous rather than giving up easily.\n" + "+\t\t */\n" + "+\t\tWARN_ON(migration_mode == MIGRATE_ASYNC);\n" + " \t}\n" + " \n" + " \t/* Try direct reclaim and then allocating */\n" + "-- \n" + "2.0.0\n" + "\n" + "I'm off from now on. :)\n" + "\n" + "> \n" + "> >I don't mean we should abort but the process could sleep and retry.\n" + "> >The point is that we should give latency pain to the process request\n" + "> >high-order alocation, not another random process.\n" + "> \n" + "> So basically you are saying that there should be cond_resched() also\n" + "> for async compaction when need_resched() is true? Now need_resched()\n" + "> is a trigger to back off rather quickly all the way back to\n" + "> __alloc_pages_direct_compact() which does contain a cond_resched().\n" + "> So there should be a yield before retry. Or are you worried that the\n" + "> back off is not quick enough and it shoudl cond_resched()\n" + "> immediately?\n" + "> \n" + "> >IMHO, if we want to increase high-order alloc ratio in page fault,\n" + "> >kswapd should be more aggressive than now via feedback loop from\n" + "> >fail rate from direct compaction.\n" + "> \n" + "> Recently I think we have been rather decreasing high-order alloc\n" + "> ratio in page fault :) But (at least for the THP) page fault\n" + "> allocation attempts contain __GFP_NO_KSWAPD, so there's no feedback\n" + "> loop. I guess changing that would be rather disruptive.\n" + "> \n" + "> >>\n" + "> >>>We have taken care of it in direct reclaim path so why direct compaction is\n" + "> >>>so special?\n" + "> >>\n" + "> >>I admit I'm not that familiar with reclaim but I didn't quickly find\n" + "> >>any need_resched() there? There's plenty of cond_resched() but that\n" + "> >>doesn't mean it will abort? Could you explain for me?\n" + "> >\n" + "> >I meant cond_resched.\n" + "> >\n" + "> >>\n" + "> >>>Why does khugepaged give up easily if lock contention/need_resched happens?\n" + "> >>>khugepaged is important for success ratio as I read your description so IMO,\n" + "> >>>khugepaged should do synchronously without considering early bail out by\n" + "> >>>lock/rescheduling.\n" + "> >>\n" + "> >>Well a stupid answer is that's how __alloc_pages_slowpath() works :)\n" + "> >>I don't think it's bad to try using first a more lightweight\n" + "> >>approach before trying the heavyweight one. As long as the\n" + "> >>heavyweight one is not skipped for khugepaged.\n" + "> >\n" + "> >I'm not saying current two-stage trying is bad. My stand is that we should\n" + "> >take care of need_resched and shouldn't become a greedy but khugepaged would\n" + "> >be okay.\n" + "> >\n" + "> >>\n" + "> >>>If it causes problems, user should increase scan_sleep_millisecs/alloc_sleep_millisecs,\n" + "> >>>which is exactly the knob for that cases.\n" + "> >>>\n" + "> >>>So, my point is how about making khugepaged doing always dumb synchronous\n" + "> >>>compaction thorough PG_KHUGEPAGED or GFP_SYNC_TRANSHUGE?\n" + "> >>>\n" + "> >>>>\n" + "> >>>>Reported-by: David Rientjes <rientjes@google.com>\n" + "> >>>>Signed-off-by: Vlastimil Babka <vbabka@suse.cz>\n" + "> >>>>Cc: Minchan Kim <minchan@kernel.org>\n" + "> >>>>Cc: Mel Gorman <mgorman@suse.de>\n" + "> >>>>Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>\n" + "> >>>>Cc: Michal Nazarewicz <mina86@mina86.com>\n" + "> >>>>Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>\n" + "> >>>>Cc: Christoph Lameter <cl@linux.com>\n" + "> >>>>Cc: Rik van Riel <riel@redhat.com>\n" + "> >>>>---\n" + "> >>>> mm/compaction.c | 20 ++++++++++++++------\n" + "> >>>> mm/internal.h | 15 +++++++++++----\n" + "> >>>> 2 files changed, 25 insertions(+), 10 deletions(-)\n" + "> >>>>\n" + "> >>>>diff --git a/mm/compaction.c b/mm/compaction.c\n" + "> >>>>index b73b182..d37f4a8 100644\n" + "> >>>>--- a/mm/compaction.c\n" + "> >>>>+++ b/mm/compaction.c\n" + "> >>>>@@ -185,9 +185,14 @@ static void update_pageblock_skip(struct compact_control *cc,\n" + "> >>>> }\n" + "> >>>> #endif /* CONFIG_COMPACTION */\n" + "> >>>>\n" + "> >>>>-static inline bool should_release_lock(spinlock_t *lock)\n" + "> >>>>+enum compact_contended should_release_lock(spinlock_t *lock)\n" + "> >>>> {\n" + "> >>>>-\treturn need_resched() || spin_is_contended(lock);\n" + "> >>>>+\tif (need_resched())\n" + "> >>>>+\t\treturn COMPACT_CONTENDED_SCHED;\n" + "> >>>>+\telse if (spin_is_contended(lock))\n" + "> >>>>+\t\treturn COMPACT_CONTENDED_LOCK;\n" + "> >>>>+\telse\n" + "> >>>>+\t\treturn COMPACT_CONTENDED_NONE;\n" + "> >>>> }\n" + "> >>>>\n" + "> >>>> /*\n" + "> >>>>@@ -202,7 +207,9 @@ static inline bool should_release_lock(spinlock_t *lock)\n" + "> >>>> static bool compact_checklock_irqsave(spinlock_t *lock, unsigned long *flags,\n" + "> >>>> \t\t\t\t bool locked, struct compact_control *cc)\n" + "> >>>> {\n" + "> >>>>-\tif (should_release_lock(lock)) {\n" + "> >>>>+\tenum compact_contended contended = should_release_lock(lock);\n" + "> >>>>+\n" + "> >>>>+\tif (contended) {\n" + "> >>>> \t\tif (locked) {\n" + "> >>>> \t\t\tspin_unlock_irqrestore(lock, *flags);\n" + "> >>>> \t\t\tlocked = false;\n" + "> >>>>@@ -210,7 +217,7 @@ static bool compact_checklock_irqsave(spinlock_t *lock, unsigned long *flags,\n" + "> >>>>\n" + "> >>>> \t\t/* async aborts if taking too long or contended */\n" + "> >>>> \t\tif (cc->mode == MIGRATE_ASYNC) {\n" + "> >>>>-\t\t\tcc->contended = true;\n" + "> >>>>+\t\t\tcc->contended = contended;\n" + "> >>>> \t\t\treturn false;\n" + "> >>>> \t\t}\n" + "> >>>>\n" + "> >>>>@@ -236,7 +243,7 @@ static inline bool compact_should_abort(struct compact_control *cc)\n" + "> >>>> \t/* async compaction aborts if contended */\n" + "> >>>> \tif (need_resched()) {\n" + "> >>>> \t\tif (cc->mode == MIGRATE_ASYNC) {\n" + "> >>>>-\t\t\tcc->contended = true;\n" + "> >>>>+\t\t\tcc->contended = COMPACT_CONTENDED_SCHED;\n" + "> >>>> \t\t\treturn true;\n" + "> >>>> \t\t}\n" + "> >>>>\n" + "> >>>>@@ -1095,7 +1102,8 @@ static unsigned long compact_zone_order(struct zone *zone, int order,\n" + "> >>>> \tVM_BUG_ON(!list_empty(&cc.freepages));\n" + "> >>>> \tVM_BUG_ON(!list_empty(&cc.migratepages));\n" + "> >>>>\n" + "> >>>>-\t*contended = cc.contended;\n" + "> >>>>+\t/* We only signal lock contention back to the allocator */\n" + "> >>>>+\t*contended = cc.contended == COMPACT_CONTENDED_LOCK;\n" + "> >>>> \treturn ret;\n" + "> >>>> }\n" + "> >>>>\n" + "> >>>>diff --git a/mm/internal.h b/mm/internal.h\n" + "> >>>>index 7f22a11f..4659e8e 100644\n" + "> >>>>--- a/mm/internal.h\n" + "> >>>>+++ b/mm/internal.h\n" + "> >>>>@@ -117,6 +117,13 @@ extern int user_min_free_kbytes;\n" + "> >>>>\n" + "> >>>> #if defined CONFIG_COMPACTION || defined CONFIG_CMA\n" + "> >>>>\n" + "> >>>>+/* Used to signal whether compaction detected need_sched() or lock contention */\n" + "> >>>>+enum compact_contended {\n" + "> >>>>+\tCOMPACT_CONTENDED_NONE = 0, /* no contention detected */\n" + "> >>>>+\tCOMPACT_CONTENDED_SCHED, /* need_sched() was true */\n" + "> >>>>+\tCOMPACT_CONTENDED_LOCK, /* zone lock or lru_lock was contended */\n" + "> >>>>+};\n" + "> >>>>+\n" + "> >>>> /*\n" + "> >>>> * in mm/compaction.c\n" + "> >>>> */\n" + "> >>>>@@ -144,10 +151,10 @@ struct compact_control {\n" + "> >>>> \tint order;\t\t\t/* order a direct compactor needs */\n" + "> >>>> \tint migratetype;\t\t/* MOVABLE, RECLAIMABLE etc */\n" + "> >>>> \tstruct zone *zone;\n" + "> >>>>-\tbool contended;\t\t\t/* True if a lock was contended, or\n" + "> >>>>-\t\t\t\t\t * need_resched() true during async\n" + "> >>>>-\t\t\t\t\t * compaction\n" + "> >>>>-\t\t\t\t\t */\n" + "> >>>>+\tenum compact_contended contended; /* Signal need_sched() or lock\n" + "> >>>>+\t\t\t\t\t * contention detected during\n" + "> >>>>+\t\t\t\t\t * compaction\n" + "> >>>>+\t\t\t\t\t */\n" + "> >>>> };\n" + "> >>>>\n" + "> >>>> unsigned long\n" + "> >>>>--\n" + "> >>>>1.8.4.5\n" + "> >>>>\n" + "> >>>>--\n" + "> >>>>To unsubscribe, send a message with 'unsubscribe linux-mm' in\n" + "> >>>>the body to majordomo@kvack.org. For more info on Linux MM,\n" + "> >>>>see: http://www.linux-mm.org/ .\n" + "> >>>>Don't email: <a href=mailto:\"dont@kvack.org\"> email@kvack.org </a>\n" + "> >>>\n" + "> >>\n" + "> >>--\n" + "> >>To unsubscribe, send a message with 'unsubscribe linux-mm' in\n" + "> >>the body to majordomo@kvack.org. For more info on Linux MM,\n" + "> >>see: http://www.linux-mm.org/ .\n" + "> >>Don't email: <a href=mailto:\"dont@kvack.org\"> email@kvack.org </a>\n" + "> >\n" + "> \n" + "> --\n" + "> To unsubscribe, send a message with 'unsubscribe linux-mm' in\n" + "> the body to majordomo@kvack.org. For more info on Linux MM,\n" + "> see: http://www.linux-mm.org/ .\n" + "> Don't email: <a href=mailto:\"dont@kvack.org\"> email@kvack.org </a>\n" + "\n" + "-- \n" + "Kind regards,\n" + Minchan Kim -8af0c10a5486db19c101dd2a3f1c30ea2019cf5ade184ae89ff7bd8b625b3bbf +13274e66ccf6356aef89dbb622c34e03470b88cfe04f1cda15ddbe8145b9d4b6
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.