mm/compaction: correct deferral logic for proactive compaction
Subsystems (2)
PATCH v3 1/1 mm/compaction: correct deferral logic for proactive compaction
should_proactive_compact_node() returns true when sum of the weighted fragmentation score of all the zones in the node is greater than the wmark_high of compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater than wmark_low(=wmark_high - 10).
This means that the sum of the weighted fragmentation scores of all the zones can exceed the wmark_high but individual weighted fragmentation zone scores can still be less than wmark_low which makes the unnecessary trigger of the proactive compaction only to return doing nothing.
Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 << COMPACT_MAX_DEFER_SHIFT if the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try. With the delay between successive retries for proactive compaction is 500msec, it can result into the deferral for ~30sec with out even trying the proactive compaction.
Test scenario is that: compaction_proactiveness=50 thus the wmark_low = 50 and wmark_high = 60. System have 2 zones(Normal and Movable) with sizes 5GB and 6GB respectively. After opening some apps on the android, the weighted fragmentation scores of these zones are 47 and 49 respectively. Since the sum of these fragmentation scores are above the wmark_high which triggers the proactive compaction and there since the individual zones weighted fragmentation scores are below wmark_low, it returns without trying the proactive compaction. As a result the weighted fragmentation scores of the zones are still 47 and 49 which makes the existing logic to defer the compaction thinking that noprogress is made across the compaction.
Fix this by checking just zone fragmentation score, not the weighted, in __compact_finished() and use the zones weighted fragmentation score in fragmentation_score_node(). In the test case above, If the weighted average of is above wmark_high, then individual score (not adjusted) of atleast one zone has to be above wmark_high. Thus it avoids the unnecessary trigger and deferrals of the proactive compaction.
---
Changes in V3: Addressed suggestions from Vlastimil
Changes in V2: https://lore.kernel.org/patchwork/patch/1366862/
Changes in V1: https://lore.kernel.org/patchwork/patch/1364646/
mm/compaction.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-)
mm/compaction.c +14 -6
@@ -1925,20 +1925,28 @@ static bool kswapd_is_running(pg_data_t *pgdat)/* * A zone's fragmentation score is the external fragmentation wrt to the -* COMPACTION_HPAGE_ORDER scaled by the zone's size. It returns a value -* in the range [0, 100]. +* COMPACTION_HPAGE_ORDER. It returns a value in the range [0, 100]. +*/ +static unsigned int fragmentation_score_zone (struct zone *zone) +{ +return extfrag_for_order (zone,COMPACTION_HPAGE_ORDER ); +} + +/* +* A weighted zone's fragmentation score is the external fragmentation +* wrt to the COMPACTION_HPAGE_ORDER scaled by the zone's size. It +* returns a value in the range [0, 100]. * * The scaling factor ensures that proactive compaction focuses on larger * zones like ZONE_NORMAL, rather than smaller, specialized zones like * ZONE_DMA32. For smaller zones, the score value remains close to zero, * and thus never exceeds the high threshold for proactive compaction. */ -static unsigned int fragmentation_score_zone (struct zone *zone) +static unsigned int fragmentation_score_zone_weighted (struct zone *zone) {unsigned long score; - score = zone->present_pages * -extfrag_for_order (zone,COMPACTION_HPAGE_ORDER ); + score = zone->present_pages *fragmentation_score_zone (zone);return div64_ul (score, zone->zone_pgdat->node_present_pages +1 ); }
@@ -1958,7 +1966,7 @@ static unsigned int fragmentation_score_node(pg_data_t *pgdat)struct zone *zone; zone = &pgdat->node_zones[zoneid]; - score +=fragmentation_score_zone (zone); + score +=fragmentation_score_zone_weighted (zone); }return score;
Signature · 2 lines
QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, hosted by The Linux Foundation
Quoted 39 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try. With the delay between successive retries for proactive compaction is 500msec, it can result into the deferral for ~30sec with out even trying the proactive compaction.Test scenario is that: compaction_proactiveness=50 thus the
wmark_low= 50 andwmark_high= 60. System have 2 zones(Normal and Movable) with sizes 5GB and 6GB respectively. After opening some apps on the android, the weighted fragmentation scores of these zones are 47 and 49 respectively. Since the sum of these fragmentation scores are above thewmark_highwhich triggers the proactive compaction and there since the individual zones weighted fragmentation scores are belowwmark_low, it returns without trying the proactive compaction. As a result the weighted fragmentation scores of the zones are still 47 and 49 which makes the existing logic to defer the compaction thinking that noprogress is made across the compaction.Fix this by checking just zone fragmentation score, not the weighted, in
__compact_finished()and use the zones weighted fragmentation score infragmentation_score_node(). In the test case above, If the weighted average of is abovewmark_high, then individual score (not adjusted) of atleast one zone has to be abovewmark_high. Thus it avoids the unnecessary trigger and deferrals of the proactive compaction.
Quoted 2 lines
Fix-suggested-by Vlastimil Babka <[email protected]>Signed-off-by Charan Teja Reddy <[email protected]>
Thanks!
Quoted 92 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try. With the delay between successive retries for proactive compaction is 500msec, it can result into the deferral for ~30sec with out even trying the proactive compaction.Test scenario is that: compaction_proactiveness=50 thus the
wmark_low= 50 andwmark_high= 60. System have 2 zones(Normal and Movable) with sizes 5GB and 6GB respectively. After opening some apps on the android, the weighted fragmentation scores of these zones are 47 and 49 respectively. Since the sum of these fragmentation scores are above thewmark_highwhich triggers the proactive compaction and there since the individual zones weighted fragmentation scores are belowwmark_low, it returns without trying the proactive compaction. As a result the weighted fragmentation scores of the zones are still 47 and 49 which makes the existing logic to defer the compaction thinking that noprogress is made across the compaction.Fix this by checking just zone fragmentation score, not the weighted, in
__compact_finished()and use the zones weighted fragmentation score infragmentation_score_node(). In the test case above, If the weighted average of is abovewmark_high, then individual score (not adjusted) of atleast one zone has to be abovewmark_high. Thus it avoids the unnecessary trigger and deferrals of the proactive compaction.Fix-suggested-by Vlastimil Babka <[email protected]>Signed-off-by Charan Teja Reddy <[email protected]>---
Changes in V3: Addressed suggestions from Vlastimil
Changes in V2: https://lore.kernel.org/patchwork/patch/1366862/
Changes in V1: https://lore.kernel.org/patchwork/patch/1364646/
mm/compaction.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-)mm/compaction.c +13
-5@@ -1925,20 +1925,28 @@ static bool kswapd_is_running(pg_data_t *pgdat)/* * A zone's fragmentation score is the external fragmentation wrt to the -* COMPACTION_HPAGE_ORDER scaled by the zone's size. It returns a value -* in the range [0, 100]. +* COMPACTION_HPAGE_ORDER. It returns a value in the range [0, 100]. +*/ +static unsigned int fragmentation_score_zone (struct zone *zone) +{ +return extfrag_for_order (zone,COMPACTION_HPAGE_ORDER ); +} + +/* +* A weighted zone's fragmentation score is the external fragmentation +* wrt to the COMPACTION_HPAGE_ORDER scaled by the zone's size. It +* returns a value in the range [0, 100]. * * The scaling factor ensures that proactive compaction focuses on larger * zones like ZONE_NORMAL, rather than smaller, specialized zones like * ZONE_DMA32. For smaller zones, the score value remains close to zero, * and thus never exceeds the high threshold for proactive compaction. */ -static unsigned int fragmentation_score_zone (struct zone *zone) +static unsigned int fragmentation_score_zone_weighted (struct zone *zone) {unsigned long score; - score = zone->present_pages * -extfrag_for_order (zone,COMPACTION_HPAGE_ORDER ); + score = zone->present_pages *fragmentation_score_zone (zone);return div64_ul (score, zone->zone_pgdat->node_present_pages +1 ); }
mm/compaction.c static unsigned int fragmentation_score_node(pg_data_t *pgdat) · line 1972
Quoted 8 lines
mm/compaction.c +1
-1@@ -1958,7 +1966,7 @@ static unsigned int fragmentation_score_node(pg_data_t *pgdat)struct zone *zone; zone = &pgdat->node_zones[zoneid]; - score +=fragmentation_score_zone (zone); + score +=fragmentation_score_zone_weighted (zone); }return score;
Looks good.
Quoted 12 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.
Quoted 4 lines
Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try.
Isn't this an issue in deferred compaction as well? It seems like deferred compaction should check that work was actually performed before deferring subsequent calls to compaction.
In other words, I don't believe deferred compaction is intended to avoid checks to determine if compaction is worth it; it should only defer *additional* work that was not productive.
Thoughts?
Quoted 16 lines
With the delay between successive retries for proactive compaction is 500msec, it can result into the deferral for ~30sec with out even trying the proactive compaction.
Test scenario is that: compaction_proactiveness=50 thus the
wmark_low= 50 andwmark_high= 60. System have 2 zones(Normal and Movable) with sizes 5GB and 6GB respectively. After opening some apps on the android, the weighted fragmentation scores of these zones are 47 and 49 respectively. Since the sum of these fragmentation scores are above thewmark_highwhich triggers the proactive compaction and there since the individual zones weighted fragmentation scores are belowwmark_low, it returns without trying the proactive compaction. As a result the weighted fragmentation scores of the zones are still 47 and 49 which makes the existing logic to defer the compaction thinking that noprogress is made across the compaction.
Quoted 8 lines
Fix this by checking just zone fragmentation score, not the weighted, in
__compact_finished()and use the zones weighted fragmentation score infragmentation_score_node(). In the test case above, If the weighted average of is abovewmark_high, then individual score (not adjusted) of atleast one zone has to be abovewmark_high. Thus it avoids the unnecessary trigger and deferrals of the proactive compaction.Fix-suggested-by Vlastimil Babka <[email protected]>
Suggested-by
Quoted 1 line
Signed-off-by Charan Teja Reddy <[email protected]>
Quoted 14 lines · David Rientjes
Quoted 12 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.
Quoted 8 lines
Quoted 4 lines
Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try.Isn't this an issue in deferred compaction as well? It seems like deferred compaction should check that work was actually performed before deferring subsequent calls to compaction.
Direct compaction does, proactive not.
Quoted 3 lines
In other words, I don't believe deferred compaction is intended to avoid checks to determine if compaction is worth it; it should only defer *additional* work that was not productive.
Yeah, that should be more optimal.
Quoted 2 lines
Thoughts?
Quoted 24 lines · Vlastimil Babka
Quoted 14 lines · David Rientjes
Quoted 12 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.Quoted 8 lines
Quoted 4 lines
Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try.Isn't this an issue in deferred compaction as well? It seems like deferred compaction should check that work was actually performed before deferring subsequent calls to compaction.
Quoted 8 lines
Direct compaction does, proactive not.
Quoted 3 lines
In other words, I don't believe deferred compaction is intended to avoid checks to determine if compaction is worth it; it should only defer *additional* work that was not productive.
Yeah, that should be more optimal.
Charan, is this something you'd like to follow up on, or should I take a look instead?
Thanks!
Quoted 41 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try. With the delay between successive retries for proactive compaction is 500msec, it can result into the deferral for ~30sec with out even trying the proactive compaction.Test scenario is that: compaction_proactiveness=50 thus the
wmark_low= 50 andwmark_high= 60. System have 2 zones(Normal and Movable) with sizes 5GB and 6GB respectively. After opening some apps on the android, the weighted fragmentation scores of these zones are 47 and 49 respectively. Since the sum of these fragmentation scores are above thewmark_highwhich triggers the proactive compaction and there since the individual zones weighted fragmentation scores are belowwmark_low, it returns without trying the proactive compaction. As a result the weighted fragmentation scores of the zones are still 47 and 49 which makes the existing logic to defer the compaction thinking that noprogress is made across the compaction.Fix this by checking just zone fragmentation score, not the weighted, in
__compact_finished()and use the zones weighted fragmentation score infragmentation_score_node(). In the test case above, If the weighted average of is abovewmark_high, then individual score (not adjusted) of atleast one zone has to be abovewmark_high. Thus it avoids the unnecessary trigger and deferrals of the proactive compaction.Fix-suggested-by Vlastimil Babka <[email protected]>Signed-off-by Charan Teja Reddy <[email protected]>
Quoted 7 lines
---
Changes in V3: Addressed suggestions from Vlastimil
Changes in V2: https://lore.kernel.org/patchwork/patch/1366862/
Changes in V1: https://lore.kernel.org/patchwork/patch/1364646/
Andrew, I've noticed that v1 is still in mmotm [1] together with v3, which doesn't make sense together, please drop [1]. Thanks
Quoted 51 lines
mm/compaction.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-)mm/compaction.c +14
-6@@ -1925,20 +1925,28 @@ static bool kswapd_is_running(pg_data_t *pgdat)/* * A zone's fragmentation score is the external fragmentation wrt to the -* COMPACTION_HPAGE_ORDER scaled by the zone's size. It returns a value -* in the range [0, 100]. +* COMPACTION_HPAGE_ORDER. It returns a value in the range [0, 100]. +*/ +static unsigned int fragmentation_score_zone (struct zone *zone) +{ +return extfrag_for_order (zone,COMPACTION_HPAGE_ORDER ); +} + +/* +* A weighted zone's fragmentation score is the external fragmentation +* wrt to the COMPACTION_HPAGE_ORDER scaled by the zone's size. It +* returns a value in the range [0, 100]. * * The scaling factor ensures that proactive compaction focuses on larger * zones like ZONE_NORMAL, rather than smaller, specialized zones like * ZONE_DMA32. For smaller zones, the score value remains close to zero, * and thus never exceeds the high threshold for proactive compaction. */ -static unsigned int fragmentation_score_zone (struct zone *zone) +static unsigned int fragmentation_score_zone_weighted (struct zone *zone) {unsigned long score; - score = zone->present_pages * -extfrag_for_order (zone,COMPACTION_HPAGE_ORDER ); + score = zone->present_pages *fragmentation_score_zone (zone);return div64_ul (score, zone->zone_pgdat->node_present_pages +1 ); }@@ -1958,7 +1966,7 @@ static unsigned int fragmentation_score_node(pg_data_t *pgdat)struct zone *zone; zone = &pgdat->node_zones[zoneid]; - score +=fragmentation_score_zone (zone); + score +=fragmentation_score_zone_weighted (zone); }return score;
Quoted 32 lines · David Rientjes
Quoted 30 lines · Vlastimil Babka
Quoted 14 lines · David Rientjes
Quoted 12 lines · Charan Teja Reddy
should_proactive_compact_node()returns true when sum of the weighted fragmentation score of all the zones in the node is greater than thewmark_highof compaction, which then triggers the proactive compaction that operates on the individual zones of the node. But proactive compaction runs on the zone only when its weighted fragmentation score is greater thanwmark_low(=wmark_high - 10).This means that the sum of the weighted fragmentation scores of all the zones can exceed the
wmark_highbut individual weighted fragmentation zone scores can still be less thanwmark_lowwhich makes the unnecessary trigger of the proactive compaction only to return doing nothing.Quoted 8 lines
Quoted 4 lines
Issue with the return of proactive compaction with out even trying is its deferral. It is simply deferred for 1 <<
COMPACT_MAX_DEFER_SHIFTif the scores across the proactive compaction is same, thinking that compaction didn't make any progress but in reality it didn't even try.Isn't this an issue in deferred compaction as well? It seems like deferred compaction should check that work was actually performed before deferring subsequent calls to compaction.
Direct compaction does, proactive not.
Quoted 3 lines
In other words, I don't believe deferred compaction is intended to avoid checks to determine if compaction is worth it; it should only defer *additional* work that was not productive.
Quoted 6 lines
Quoted 2 lines
Yeah, that should be more optimal.
Charan, is this something you'd like to follow up on, or should I take a look instead?
Sure David. Happy to follow up on this. Thanks!
Quoted 2 lines
Thanks!
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project