linux-kernel.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH V5] mm: compaction: support triggering of proactive compaction by user
@ 2021-07-30 13:53 Charan Teja Reddy
  2021-07-30 14:06 ` Vlastimil Babka
                   ` (2 more replies)
  0 siblings, 3 replies; 8+ messages in thread
From: Charan Teja Reddy @ 2021-07-30 13:53 UTC (permalink / raw)
  To: akpm, mcgrof, keescook, yzaikin, dave.hansen, vbabka, mgorman,
	nigupta, corbet, rppt, khalid.aziz, rientjes
  Cc: linux-doc, linux-kernel, linux-mm, linux-fsdevel, vinmenon,
	Charan Teja Reddy

The proactive compaction[1] gets triggered for every 500msec and run
compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9)
pages based on the value set to sysctl.compaction_proactiveness.
Triggering the compaction for every 500msec in search of
COMPACTION_HPAGE_ORDER pages is not needed for all applications,
especially on the embedded system usecases which may have few MB's of
RAM. Enabling the proactive compaction in its state will endup in
running almost always on such systems.

Other side, proactive compaction can still be very much useful for
getting a set of higher order pages in some controllable
manner(controlled by using the sysctl.compaction_proactiveness). So, on
systems where enabling the proactive compaction always may proove not
required, can trigger the same from user space on write to its sysctl
interface. As an example, say app launcher decide to launch the memory
heavy application which can be launched fast if it gets more higher
order pages thus launcher can prepare the system in advance by
triggering the proactive compaction from userspace.

This triggering of proactive compaction is done on a write to
sysctl.compaction_proactiveness by user.

[1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a

Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>
---
 Changes in V5:
 	-- Avoid unnecessary wakeup of proactive compaction when it is disabled.
	-- No changes in the logic of triggering the proactive compaction.

 Changes in V4:
	-- Changed the code as the 'proactive_defer' counter is removed.
	-- No changes in the logic of triggering the proactive compaction.
	-- https://lore.kernel.org/patchwork/patch/1448777/

 Changes in V3:
        -- Fixed review comments from Valstimil and others.
        -- https://lore.kernel.org/patchwork/patch/1438211/

 Changes in V2:
	-- remove /proc/../proactive_compact_memory interface trigger for proactive compaction
        -- Intention is same that add a way to trigger proactive compaction by user.
        -- https://lore.kernel.org/patchwork/patch/1431283/

 changes in V1:
	-- Created the new /proc/sys/vm/proactive_compact_memory in
	   interface to trigger proactive compaction from user 
        -- https://lore.kernel.org/lkml/1619098678-8501-1-git-send-email-charante@codeaurora.org/

 Documentation/admin-guide/sysctl/vm.rst |  3 ++-
 include/linux/compaction.h              |  2 ++
 include/linux/mmzone.h                  |  1 +
 kernel/sysctl.c                         |  2 +-
 mm/compaction.c                         | 38 +++++++++++++++++++++++++++++++--
 5 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/Documentation/admin-guide/sysctl/vm.rst b/Documentation/admin-guide/sysctl/vm.rst
index 003d5cc..b526cf6 100644
--- a/Documentation/admin-guide/sysctl/vm.rst
+++ b/Documentation/admin-guide/sysctl/vm.rst
@@ -118,7 +118,8 @@ compaction_proactiveness
 
 This tunable takes a value in the range [0, 100] with a default value of
 20. This tunable determines how aggressively compaction is done in the
-background. Setting it to 0 disables proactive compaction.
+background. On write of non zero value to this tunable will immediately
+trigger the proactive compaction. Setting it to 0 disables proactive compaction.
 
 Note that compaction has a non-trivial system-wide impact as pages
 belonging to different processes are moved around, which could also lead
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index c24098c..34bce35 100644
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -84,6 +84,8 @@ static inline unsigned long compact_gap(unsigned int order)
 extern unsigned int sysctl_compaction_proactiveness;
 extern int sysctl_compaction_handler(struct ctl_table *table, int write,
 			void *buffer, size_t *length, loff_t *ppos);
+extern int compaction_proactiveness_sysctl_handler(struct ctl_table *table,
+		int write, void *buffer, size_t *length, loff_t *ppos);
 extern int sysctl_extfrag_threshold;
 extern int sysctl_compact_unevictable_allowed;
 
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 4610750..6a1d79d 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -853,6 +853,7 @@ typedef struct pglist_data {
 	enum zone_type kcompactd_highest_zoneidx;
 	wait_queue_head_t kcompactd_wait;
 	struct task_struct *kcompactd;
+	bool proactive_compact_trigger;
 #endif
 	/*
 	 * This is a per-node reserve of pages that are not available
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 82d6ff6..65bc6f7 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -2871,7 +2871,7 @@ static struct ctl_table vm_table[] = {
 		.data		= &sysctl_compaction_proactiveness,
 		.maxlen		= sizeof(sysctl_compaction_proactiveness),
 		.mode		= 0644,
-		.proc_handler	= proc_dointvec_minmax,
+		.proc_handler	= compaction_proactiveness_sysctl_handler,
 		.extra1		= SYSCTL_ZERO,
 		.extra2		= &one_hundred,
 	},
diff --git a/mm/compaction.c b/mm/compaction.c
index f984ad0..fbc60f9 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -2700,6 +2700,30 @@ static void compact_nodes(void)
  */
 unsigned int __read_mostly sysctl_compaction_proactiveness = 20;
 
+int compaction_proactiveness_sysctl_handler(struct ctl_table *table, int write,
+		void *buffer, size_t *length, loff_t *ppos)
+{
+	int rc, nid;
+
+	rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
+	if (rc)
+		return rc;
+
+	if (write && sysctl_compaction_proactiveness) {
+		for_each_online_node(nid) {
+			pg_data_t *pgdat = NODE_DATA(nid);
+
+			if (pgdat->proactive_compact_trigger)
+				continue;
+
+			pgdat->proactive_compact_trigger = true;
+			wake_up_interruptible(&pgdat->kcompactd_wait);
+		}
+	}
+
+	return 0;
+}
+
 /*
  * This is the entry point for compacting all nodes via
  * /proc/sys/vm/compact_memory
@@ -2744,7 +2768,8 @@ void compaction_unregister_node(struct node *node)
 
 static inline bool kcompactd_work_requested(pg_data_t *pgdat)
 {
-	return pgdat->kcompactd_max_order > 0 || kthread_should_stop();
+	return pgdat->kcompactd_max_order > 0 || kthread_should_stop() ||
+		pgdat->proactive_compact_trigger;
 }
 
 static bool kcompactd_node_suitable(pg_data_t *pgdat)
@@ -2895,9 +2920,16 @@ static int kcompactd(void *p)
 	while (!kthread_should_stop()) {
 		unsigned long pflags;
 
+		/*
+		 * Avoid the unnecessary wakeup for proactive compaction
+		 * when it is disabled.
+		 */
+		if (!sysctl_compaction_proactiveness)
+			timeout = MAX_SCHEDULE_TIMEOUT;
 		trace_mm_compaction_kcompactd_sleep(pgdat->node_id);
 		if (wait_event_freezable_timeout(pgdat->kcompactd_wait,
-			kcompactd_work_requested(pgdat), timeout)) {
+			kcompactd_work_requested(pgdat), timeout) &&
+			!pgdat->proactive_compact_trigger) {
 
 			psi_memstall_enter(&pflags);
 			kcompactd_do_work(pgdat);
@@ -2932,6 +2964,8 @@ static int kcompactd(void *p)
 				timeout =
 				   default_timeout << COMPACT_MAX_DEFER_SHIFT;
 		}
+		if (unlikely(pgdat->proactive_compact_trigger))
+			pgdat->proactive_compact_trigger = false;
 	}
 
 	return 0;
-- 
QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a
member of the Code Aurora Forum, hosted by The Linux Foundation


^ permalink raw reply related	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-07-30 13:53 [PATCH V5] mm: compaction: support triggering of proactive compaction by user Charan Teja Reddy
@ 2021-07-30 14:06 ` Vlastimil Babka
  2021-07-30 14:46   ` Charan Teja Kalla
  2021-07-30 19:31 ` Mike Rapoport
  2021-08-04 21:11 ` Rafael Aquini
  2 siblings, 1 reply; 8+ messages in thread
From: Vlastimil Babka @ 2021-07-30 14:06 UTC (permalink / raw)
  To: Charan Teja Reddy, akpm, mcgrof, keescook, yzaikin, dave.hansen,
	mgorman, nigupta, corbet, rppt, khalid.aziz, rientjes
  Cc: linux-doc, linux-kernel, linux-mm, linux-fsdevel, vinmenon

On 7/30/21 3:53 PM, Charan Teja Reddy wrote:
> The proactive compaction[1] gets triggered for every 500msec and run
> compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9)
> pages based on the value set to sysctl.compaction_proactiveness.
> Triggering the compaction for every 500msec in search of
> COMPACTION_HPAGE_ORDER pages is not needed for all applications,
> especially on the embedded system usecases which may have few MB's of
> RAM. Enabling the proactive compaction in its state will endup in
> running almost always on such systems.
> 
> Other side, proactive compaction can still be very much useful for
> getting a set of higher order pages in some controllable
> manner(controlled by using the sysctl.compaction_proactiveness). So, on
> systems where enabling the proactive compaction always may proove not
> required, can trigger the same from user space on write to its sysctl
> interface. As an example, say app launcher decide to launch the memory
> heavy application which can be launched fast if it gets more higher
> order pages thus launcher can prepare the system in advance by
> triggering the proactive compaction from userspace.
> 
> This triggering of proactive compaction is done on a write to
> sysctl.compaction_proactiveness by user.
> 
> [1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a
> 
> Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>

Acked-by: Vlastimil Babka <vbabka@suse.cz>

> @@ -2895,9 +2920,16 @@ static int kcompactd(void *p)
>  	while (!kthread_should_stop()) {
>  		unsigned long pflags;
>  
> +		/*
> +		 * Avoid the unnecessary wakeup for proactive compaction
> +		 * when it is disabled.
> +		 */
> +		if (!sysctl_compaction_proactiveness)
> +			timeout = MAX_SCHEDULE_TIMEOUT;

Does this part actually logically belong more to your previous patch that
optimized the deferred timeouts?

>  		trace_mm_compaction_kcompactd_sleep(pgdat->node_id);
>  		if (wait_event_freezable_timeout(pgdat->kcompactd_wait,
> -			kcompactd_work_requested(pgdat), timeout)) {
> +			kcompactd_work_requested(pgdat), timeout) &&
> +			!pgdat->proactive_compact_trigger) {
>  
>  			psi_memstall_enter(&pflags);
>  			kcompactd_do_work(pgdat);
> @@ -2932,6 +2964,8 @@ static int kcompactd(void *p)
>  				timeout =
>  				   default_timeout << COMPACT_MAX_DEFER_SHIFT;
>  		}
> +		if (unlikely(pgdat->proactive_compact_trigger))
> +			pgdat->proactive_compact_trigger = false;
>  	}
>  
>  	return 0;
> 


^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-07-30 14:06 ` Vlastimil Babka
@ 2021-07-30 14:46   ` Charan Teja Kalla
  2021-07-30 14:47     ` Vlastimil Babka
  0 siblings, 1 reply; 8+ messages in thread
From: Charan Teja Kalla @ 2021-07-30 14:46 UTC (permalink / raw)
  To: Vlastimil Babka, akpm, mcgrof, keescook, yzaikin, dave.hansen,
	mgorman, nigupta, corbet, rppt, khalid.aziz, rientjes
  Cc: linux-doc, linux-kernel, linux-mm, linux-fsdevel, vinmenon

Thanks Vlastimil!!

On 7/30/2021 7:36 PM, Vlastimil Babka wrote:
>> The proactive compaction[1] gets triggered for every 500msec and run
>> compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9)
>> pages based on the value set to sysctl.compaction_proactiveness.
>> Triggering the compaction for every 500msec in search of
>> COMPACTION_HPAGE_ORDER pages is not needed for all applications,
>> especially on the embedded system usecases which may have few MB's of
>> RAM. Enabling the proactive compaction in its state will endup in
>> running almost always on such systems.
>>
>> Other side, proactive compaction can still be very much useful for
>> getting a set of higher order pages in some controllable
>> manner(controlled by using the sysctl.compaction_proactiveness). So, on
>> systems where enabling the proactive compaction always may proove not
>> required, can trigger the same from user space on write to its sysctl
>> interface. As an example, say app launcher decide to launch the memory
>> heavy application which can be launched fast if it gets more higher
>> order pages thus launcher can prepare the system in advance by
>> triggering the proactive compaction from userspace.
>>
>> This triggering of proactive compaction is done on a write to
>> sysctl.compaction_proactiveness by user.
>>
>> [1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a
>>
>> Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>
> Acked-by: Vlastimil Babka <vbabka@suse.cz>

Thanks for the tag here.

> 
>> @@ -2895,9 +2920,16 @@ static int kcompactd(void *p)
>>  	while (!kthread_should_stop()) {
>>  		unsigned long pflags;
>>  
>> +		/*
>> +		 * Avoid the unnecessary wakeup for proactive compaction
>> +		 * when it is disabled.
>> +		 */
>> +		if (!sysctl_compaction_proactiveness)
>> +			timeout = MAX_SCHEDULE_TIMEOUT;
> Does this part actually logically belong more to your previous patch that
> optimized the deferred timeouts?

IMO, it won't fit there. Reason is that when user writes
sysctl_compaction_proactiveness = 0, it will goes to sleep with
MAX_SCHEDULE_TIMEOUT. Say now user writes non-zero value to
sysctl_compaction_proactiveness then no condition is there to wake it up
for proactive compaction, means, it will still be in sleep with
MAX_SCHEDULE_TIMEOUT.

Thus this logic is put in this patch, where, proactive compaction work
will be scheduled immediately on switch of proactiveness value from zero
to a non-zero.

> 

-- 
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum, a Linux Foundation Collaborative Project

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-07-30 14:46   ` Charan Teja Kalla
@ 2021-07-30 14:47     ` Vlastimil Babka
  0 siblings, 0 replies; 8+ messages in thread
From: Vlastimil Babka @ 2021-07-30 14:47 UTC (permalink / raw)
  To: Charan Teja Kalla, akpm, mcgrof, keescook, yzaikin, dave.hansen,
	mgorman, nigupta, corbet, rppt, khalid.aziz, rientjes
  Cc: linux-doc, linux-kernel, linux-mm, linux-fsdevel, vinmenon

On 7/30/21 4:46 PM, Charan Teja Kalla wrote:
> Thanks Vlastimil!!
> 
> On 7/30/2021 7:36 PM, Vlastimil Babka wrote:
>>> The proactive compaction[1] gets triggered for every 500msec and run
>>> compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9)
>>> pages based on the value set to sysctl.compaction_proactiveness.
>>> Triggering the compaction for every 500msec in search of
>>> COMPACTION_HPAGE_ORDER pages is not needed for all applications,
>>> especially on the embedded system usecases which may have few MB's of
>>> RAM. Enabling the proactive compaction in its state will endup in
>>> running almost always on such systems.
>>>
>>> Other side, proactive compaction can still be very much useful for
>>> getting a set of higher order pages in some controllable
>>> manner(controlled by using the sysctl.compaction_proactiveness). So, on
>>> systems where enabling the proactive compaction always may proove not
>>> required, can trigger the same from user space on write to its sysctl
>>> interface. As an example, say app launcher decide to launch the memory
>>> heavy application which can be launched fast if it gets more higher
>>> order pages thus launcher can prepare the system in advance by
>>> triggering the proactive compaction from userspace.
>>>
>>> This triggering of proactive compaction is done on a write to
>>> sysctl.compaction_proactiveness by user.
>>>
>>> [1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a
>>>
>>> Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>
>> Acked-by: Vlastimil Babka <vbabka@suse.cz>
> 
> Thanks for the tag here.

Np.

>> 
>>> @@ -2895,9 +2920,16 @@ static int kcompactd(void *p)
>>>  	while (!kthread_should_stop()) {
>>>  		unsigned long pflags;
>>>  
>>> +		/*
>>> +		 * Avoid the unnecessary wakeup for proactive compaction
>>> +		 * when it is disabled.
>>> +		 */
>>> +		if (!sysctl_compaction_proactiveness)
>>> +			timeout = MAX_SCHEDULE_TIMEOUT;
>> Does this part actually logically belong more to your previous patch that
>> optimized the deferred timeouts?
> 
> IMO, it won't fit there. Reason is that when user writes
> sysctl_compaction_proactiveness = 0, it will goes to sleep with
> MAX_SCHEDULE_TIMEOUT. Say now user writes non-zero value to
> sysctl_compaction_proactiveness then no condition is there to wake it up
> for proactive compaction, means, it will still be in sleep with
> MAX_SCHEDULE_TIMEOUT.

Good point!

> Thus this logic is put in this patch, where, proactive compaction work
> will be scheduled immediately on switch of proactiveness value from zero
> to a non-zero.

Agreed. Thanks!

>> 
> 


^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-07-30 13:53 [PATCH V5] mm: compaction: support triggering of proactive compaction by user Charan Teja Reddy
  2021-07-30 14:06 ` Vlastimil Babka
@ 2021-07-30 19:31 ` Mike Rapoport
  2021-08-02 12:00   ` Charan Teja Kalla
  2021-08-04 21:11 ` Rafael Aquini
  2 siblings, 1 reply; 8+ messages in thread
From: Mike Rapoport @ 2021-07-30 19:31 UTC (permalink / raw)
  To: Charan Teja Reddy
  Cc: akpm, mcgrof, keescook, yzaikin, dave.hansen, vbabka, mgorman,
	nigupta, corbet, khalid.aziz, rientjes, linux-doc, linux-kernel,
	linux-mm, linux-fsdevel, vinmenon

On Fri, Jul 30, 2021 at 07:23:27PM +0530, Charan Teja Reddy wrote:
> The proactive compaction[1] gets triggered for every 500msec and run
> compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9)
> pages based on the value set to sysctl.compaction_proactiveness.
> Triggering the compaction for every 500msec in search of
> COMPACTION_HPAGE_ORDER pages is not needed for all applications,
> especially on the embedded system usecases which may have few MB's of
> RAM. Enabling the proactive compaction in its state will endup in
> running almost always on such systems.
> 
> Other side, proactive compaction can still be very much useful for
> getting a set of higher order pages in some controllable
> manner(controlled by using the sysctl.compaction_proactiveness). So, on
> systems where enabling the proactive compaction always may proove not
> required, can trigger the same from user space on write to its sysctl
> interface. As an example, say app launcher decide to launch the memory
> heavy application which can be launched fast if it gets more higher
> order pages thus launcher can prepare the system in advance by
> triggering the proactive compaction from userspace.
> 
> This triggering of proactive compaction is done on a write to
> sysctl.compaction_proactiveness by user.
> 
> [1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a
> 
> Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>
> ---
>  Changes in V5:
>  	-- Avoid unnecessary wakeup of proactive compaction when it is disabled.
> 	-- No changes in the logic of triggering the proactive compaction.
> 
>  Changes in V4:
> 	-- Changed the code as the 'proactive_defer' counter is removed.
> 	-- No changes in the logic of triggering the proactive compaction.
> 	-- https://lore.kernel.org/patchwork/patch/1448777/
> 
>  Changes in V3:
>         -- Fixed review comments from Valstimil and others.
>         -- https://lore.kernel.org/patchwork/patch/1438211/
> 
>  Changes in V2:
> 	-- remove /proc/../proactive_compact_memory interface trigger for proactive compaction
>         -- Intention is same that add a way to trigger proactive compaction by user.
>         -- https://lore.kernel.org/patchwork/patch/1431283/
> 
>  changes in V1:
> 	-- Created the new /proc/sys/vm/proactive_compact_memory in
> 	   interface to trigger proactive compaction from user 
>         -- https://lore.kernel.org/lkml/1619098678-8501-1-git-send-email-charante@codeaurora.org/
> 
>  Documentation/admin-guide/sysctl/vm.rst |  3 ++-
>  include/linux/compaction.h              |  2 ++
>  include/linux/mmzone.h                  |  1 +
>  kernel/sysctl.c                         |  2 +-
>  mm/compaction.c                         | 38 +++++++++++++++++++++++++++++++--
>  5 files changed, 42 insertions(+), 4 deletions(-)
> 
> diff --git a/Documentation/admin-guide/sysctl/vm.rst b/Documentation/admin-guide/sysctl/vm.rst
> index 003d5cc..b526cf6 100644
> --- a/Documentation/admin-guide/sysctl/vm.rst
> +++ b/Documentation/admin-guide/sysctl/vm.rst
> @@ -118,7 +118,8 @@ compaction_proactiveness
>  
>  This tunable takes a value in the range [0, 100] with a default value of
>  20. This tunable determines how aggressively compaction is done in the
> -background. Setting it to 0 disables proactive compaction.
> +background. On write of non zero value to this tunable will immediately

Nit: I think "Write of non zero ..."

> +trigger the proactive compaction. Setting it to 0 disables proactive compaction.
>  
>  Note that compaction has a non-trivial system-wide impact as pages
>  belonging to different processes are moved around, which could also lead
> diff --git a/include/linux/compaction.h b/include/linux/compaction.h
> index c24098c..34bce35 100644
> --- a/include/linux/compaction.h
> +++ b/include/linux/compaction.h
> @@ -84,6 +84,8 @@ static inline unsigned long compact_gap(unsigned int order)
>  extern unsigned int sysctl_compaction_proactiveness;
>  extern int sysctl_compaction_handler(struct ctl_table *table, int write,
>  			void *buffer, size_t *length, loff_t *ppos);
> +extern int compaction_proactiveness_sysctl_handler(struct ctl_table *table,
> +		int write, void *buffer, size_t *length, loff_t *ppos);
>  extern int sysctl_extfrag_threshold;
>  extern int sysctl_compact_unevictable_allowed;
>  
> diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
> index 4610750..6a1d79d 100644
> --- a/include/linux/mmzone.h
> +++ b/include/linux/mmzone.h
> @@ -853,6 +853,7 @@ typedef struct pglist_data {
>  	enum zone_type kcompactd_highest_zoneidx;
>  	wait_queue_head_t kcompactd_wait;
>  	struct task_struct *kcompactd;
> +	bool proactive_compact_trigger;
>  #endif
>  	/*
>  	 * This is a per-node reserve of pages that are not available
> diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> index 82d6ff6..65bc6f7 100644
> --- a/kernel/sysctl.c
> +++ b/kernel/sysctl.c
> @@ -2871,7 +2871,7 @@ static struct ctl_table vm_table[] = {
>  		.data		= &sysctl_compaction_proactiveness,
>  		.maxlen		= sizeof(sysctl_compaction_proactiveness),
>  		.mode		= 0644,
> -		.proc_handler	= proc_dointvec_minmax,
> +		.proc_handler	= compaction_proactiveness_sysctl_handler,
>  		.extra1		= SYSCTL_ZERO,
>  		.extra2		= &one_hundred,
>  	},
> diff --git a/mm/compaction.c b/mm/compaction.c
> index f984ad0..fbc60f9 100644
> --- a/mm/compaction.c
> +++ b/mm/compaction.c
> @@ -2700,6 +2700,30 @@ static void compact_nodes(void)
>   */
>  unsigned int __read_mostly sysctl_compaction_proactiveness = 20;
>  
> +int compaction_proactiveness_sysctl_handler(struct ctl_table *table, int write,
> +		void *buffer, size_t *length, loff_t *ppos)
> +{
> +	int rc, nid;
> +
> +	rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
> +	if (rc)
> +		return rc;
> +
> +	if (write && sysctl_compaction_proactiveness) {
> +		for_each_online_node(nid) {
> +			pg_data_t *pgdat = NODE_DATA(nid);
> +
> +			if (pgdat->proactive_compact_trigger)
> +				continue;
> +
> +			pgdat->proactive_compact_trigger = true;
> +			wake_up_interruptible(&pgdat->kcompactd_wait);
> +		}
> +	}
> +
> +	return 0;
> +}
> +
>  /*
>   * This is the entry point for compacting all nodes via
>   * /proc/sys/vm/compact_memory
> @@ -2744,7 +2768,8 @@ void compaction_unregister_node(struct node *node)
>  
>  static inline bool kcompactd_work_requested(pg_data_t *pgdat)
>  {
> -	return pgdat->kcompactd_max_order > 0 || kthread_should_stop();
> +	return pgdat->kcompactd_max_order > 0 || kthread_should_stop() ||
> +		pgdat->proactive_compact_trigger;
>  }
>  
>  static bool kcompactd_node_suitable(pg_data_t *pgdat)
> @@ -2895,9 +2920,16 @@ static int kcompactd(void *p)
>  	while (!kthread_should_stop()) {
>  		unsigned long pflags;
>  
> +		/*
> +		 * Avoid the unnecessary wakeup for proactive compaction
> +		 * when it is disabled.
> +		 */
> +		if (!sysctl_compaction_proactiveness)
> +			timeout = MAX_SCHEDULE_TIMEOUT;
>  		trace_mm_compaction_kcompactd_sleep(pgdat->node_id);
>  		if (wait_event_freezable_timeout(pgdat->kcompactd_wait,
> -			kcompactd_work_requested(pgdat), timeout)) {
> +			kcompactd_work_requested(pgdat), timeout) &&
> +			!pgdat->proactive_compact_trigger) {
>  
>  			psi_memstall_enter(&pflags);
>  			kcompactd_do_work(pgdat);
> @@ -2932,6 +2964,8 @@ static int kcompactd(void *p)
>  				timeout =
>  				   default_timeout << COMPACT_MAX_DEFER_SHIFT;
>  		}
> +		if (unlikely(pgdat->proactive_compact_trigger))
> +			pgdat->proactive_compact_trigger = false;
>  	}
>  
>  	return 0;
> -- 
> QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a
> member of the Code Aurora Forum, hosted by The Linux Foundation
> 
> 

-- 
Sincerely yours,
Mike.

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-07-30 19:31 ` Mike Rapoport
@ 2021-08-02 12:00   ` Charan Teja Kalla
  2021-08-02 20:41     ` Andrew Morton
  0 siblings, 1 reply; 8+ messages in thread
From: Charan Teja Kalla @ 2021-08-02 12:00 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: akpm, mcgrof, keescook, yzaikin, dave.hansen, vbabka, mgorman,
	nigupta, corbet, khalid.aziz, rientjes, linux-doc, linux-kernel,
	linux-mm, linux-fsdevel, vinmenon

Thanks Mike for the review!!

On 7/31/2021 1:01 AM, Mike Rapoport wrote:
>> diff --git a/Documentation/admin-guide/sysctl/vm.rst b/Documentation/admin-guide/sysctl/vm.rst
>> index 003d5cc..b526cf6 100644
>> --- a/Documentation/admin-guide/sysctl/vm.rst
>> +++ b/Documentation/admin-guide/sysctl/vm.rst
>> @@ -118,7 +118,8 @@ compaction_proactiveness
>>  
>>  This tunable takes a value in the range [0, 100] with a default value of
>>  20. This tunable determines how aggressively compaction is done in the
>> -background. Setting it to 0 disables proactive compaction.
>> +background. On write of non zero value to this tunable will immediately
> Nit: I think "Write of non zero ..."

Can Andrew change it while applying the patch ?

> 

-- 
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum, a Linux Foundation Collaborative Project

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-08-02 12:00   ` Charan Teja Kalla
@ 2021-08-02 20:41     ` Andrew Morton
  0 siblings, 0 replies; 8+ messages in thread
From: Andrew Morton @ 2021-08-02 20:41 UTC (permalink / raw)
  To: Charan Teja Kalla
  Cc: Mike Rapoport, mcgrof, keescook, yzaikin, dave.hansen, vbabka,
	mgorman, nigupta, corbet, khalid.aziz, rientjes, linux-doc,
	linux-kernel, linux-mm, linux-fsdevel, vinmenon

On Mon, 2 Aug 2021 17:30:16 +0530 Charan Teja Kalla <charante@codeaurora.org> wrote:

> Thanks Mike for the review!!
> 
> On 7/31/2021 1:01 AM, Mike Rapoport wrote:
> >> diff --git a/Documentation/admin-guide/sysctl/vm.rst b/Documentation/admin-guide/sysctl/vm.rst
> >> index 003d5cc..b526cf6 100644
> >> --- a/Documentation/admin-guide/sysctl/vm.rst
> >> +++ b/Documentation/admin-guide/sysctl/vm.rst
> >> @@ -118,7 +118,8 @@ compaction_proactiveness
> >>  
> >>  This tunable takes a value in the range [0, 100] with a default value of
> >>  20. This tunable determines how aggressively compaction is done in the
> >> -background. Setting it to 0 disables proactive compaction.
> >> +background. On write of non zero value to this tunable will immediately
> > Nit: I think "Write of non zero ..."
> 
> Can Andrew change it while applying the patch ?

I have done so, thanks.

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH V5] mm: compaction: support triggering of proactive compaction by user
  2021-07-30 13:53 [PATCH V5] mm: compaction: support triggering of proactive compaction by user Charan Teja Reddy
  2021-07-30 14:06 ` Vlastimil Babka
  2021-07-30 19:31 ` Mike Rapoport
@ 2021-08-04 21:11 ` Rafael Aquini
  2 siblings, 0 replies; 8+ messages in thread
From: Rafael Aquini @ 2021-08-04 21:11 UTC (permalink / raw)
  To: Charan Teja Reddy
  Cc: akpm, mcgrof, keescook, yzaikin, dave.hansen, vbabka, mgorman,
	nigupta, corbet, rppt, khalid.aziz, rientjes, linux-doc,
	linux-kernel, linux-mm, linux-fsdevel, vinmenon

On Fri, Jul 30, 2021 at 07:23:27PM +0530, Charan Teja Reddy wrote:
> The proactive compaction[1] gets triggered for every 500msec and run
> compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9)
> pages based on the value set to sysctl.compaction_proactiveness.
> Triggering the compaction for every 500msec in search of
> COMPACTION_HPAGE_ORDER pages is not needed for all applications,
> especially on the embedded system usecases which may have few MB's of
> RAM. Enabling the proactive compaction in its state will endup in
> running almost always on such systems.
> 
> Other side, proactive compaction can still be very much useful for
> getting a set of higher order pages in some controllable
> manner(controlled by using the sysctl.compaction_proactiveness). So, on
> systems where enabling the proactive compaction always may proove not
> required, can trigger the same from user space on write to its sysctl
> interface. As an example, say app launcher decide to launch the memory
> heavy application which can be launched fast if it gets more higher
> order pages thus launcher can prepare the system in advance by
> triggering the proactive compaction from userspace.
> 
> This triggering of proactive compaction is done on a write to
> sysctl.compaction_proactiveness by user.
> 
> [1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a
> 
> Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>

Acked-by: Rafael Aquini <aquini@redhat.com>

> ---
>  Changes in V5:
>  	-- Avoid unnecessary wakeup of proactive compaction when it is disabled.
> 	-- No changes in the logic of triggering the proactive compaction.
> 
>  Changes in V4:
> 	-- Changed the code as the 'proactive_defer' counter is removed.
> 	-- No changes in the logic of triggering the proactive compaction.
> 	-- https://lore.kernel.org/patchwork/patch/1448777/
> 
>  Changes in V3:
>         -- Fixed review comments from Valstimil and others.
>         -- https://lore.kernel.org/patchwork/patch/1438211/
> 
>  Changes in V2:
> 	-- remove /proc/../proactive_compact_memory interface trigger for proactive compaction
>         -- Intention is same that add a way to trigger proactive compaction by user.
>         -- https://lore.kernel.org/patchwork/patch/1431283/
> 
>  changes in V1:
> 	-- Created the new /proc/sys/vm/proactive_compact_memory in
> 	   interface to trigger proactive compaction from user 
>         -- https://lore.kernel.org/lkml/1619098678-8501-1-git-send-email-charante@codeaurora.org/
> 
>  Documentation/admin-guide/sysctl/vm.rst |  3 ++-
>  include/linux/compaction.h              |  2 ++
>  include/linux/mmzone.h                  |  1 +
>  kernel/sysctl.c                         |  2 +-
>  mm/compaction.c                         | 38 +++++++++++++++++++++++++++++++--
>  5 files changed, 42 insertions(+), 4 deletions(-)
> 
> diff --git a/Documentation/admin-guide/sysctl/vm.rst b/Documentation/admin-guide/sysctl/vm.rst
> index 003d5cc..b526cf6 100644
> --- a/Documentation/admin-guide/sysctl/vm.rst
> +++ b/Documentation/admin-guide/sysctl/vm.rst
> @@ -118,7 +118,8 @@ compaction_proactiveness
>  
>  This tunable takes a value in the range [0, 100] with a default value of
>  20. This tunable determines how aggressively compaction is done in the
> -background. Setting it to 0 disables proactive compaction.
> +background. On write of non zero value to this tunable will immediately
> +trigger the proactive compaction. Setting it to 0 disables proactive compaction.
>  
>  Note that compaction has a non-trivial system-wide impact as pages
>  belonging to different processes are moved around, which could also lead
> diff --git a/include/linux/compaction.h b/include/linux/compaction.h
> index c24098c..34bce35 100644
> --- a/include/linux/compaction.h
> +++ b/include/linux/compaction.h
> @@ -84,6 +84,8 @@ static inline unsigned long compact_gap(unsigned int order)
>  extern unsigned int sysctl_compaction_proactiveness;
>  extern int sysctl_compaction_handler(struct ctl_table *table, int write,
>  			void *buffer, size_t *length, loff_t *ppos);
> +extern int compaction_proactiveness_sysctl_handler(struct ctl_table *table,
> +		int write, void *buffer, size_t *length, loff_t *ppos);
>  extern int sysctl_extfrag_threshold;
>  extern int sysctl_compact_unevictable_allowed;
>  
> diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
> index 4610750..6a1d79d 100644
> --- a/include/linux/mmzone.h
> +++ b/include/linux/mmzone.h
> @@ -853,6 +853,7 @@ typedef struct pglist_data {
>  	enum zone_type kcompactd_highest_zoneidx;
>  	wait_queue_head_t kcompactd_wait;
>  	struct task_struct *kcompactd;
> +	bool proactive_compact_trigger;
>  #endif
>  	/*
>  	 * This is a per-node reserve of pages that are not available
> diff --git a/kernel/sysctl.c b/kernel/sysctl.c
> index 82d6ff6..65bc6f7 100644
> --- a/kernel/sysctl.c
> +++ b/kernel/sysctl.c
> @@ -2871,7 +2871,7 @@ static struct ctl_table vm_table[] = {
>  		.data		= &sysctl_compaction_proactiveness,
>  		.maxlen		= sizeof(sysctl_compaction_proactiveness),
>  		.mode		= 0644,
> -		.proc_handler	= proc_dointvec_minmax,
> +		.proc_handler	= compaction_proactiveness_sysctl_handler,
>  		.extra1		= SYSCTL_ZERO,
>  		.extra2		= &one_hundred,
>  	},
> diff --git a/mm/compaction.c b/mm/compaction.c
> index f984ad0..fbc60f9 100644
> --- a/mm/compaction.c
> +++ b/mm/compaction.c
> @@ -2700,6 +2700,30 @@ static void compact_nodes(void)
>   */
>  unsigned int __read_mostly sysctl_compaction_proactiveness = 20;
>  
> +int compaction_proactiveness_sysctl_handler(struct ctl_table *table, int write,
> +		void *buffer, size_t *length, loff_t *ppos)
> +{
> +	int rc, nid;
> +
> +	rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
> +	if (rc)
> +		return rc;
> +
> +	if (write && sysctl_compaction_proactiveness) {
> +		for_each_online_node(nid) {
> +			pg_data_t *pgdat = NODE_DATA(nid);
> +
> +			if (pgdat->proactive_compact_trigger)
> +				continue;
> +
> +			pgdat->proactive_compact_trigger = true;
> +			wake_up_interruptible(&pgdat->kcompactd_wait);
> +		}
> +	}
> +
> +	return 0;
> +}
> +
>  /*
>   * This is the entry point for compacting all nodes via
>   * /proc/sys/vm/compact_memory
> @@ -2744,7 +2768,8 @@ void compaction_unregister_node(struct node *node)
>  
>  static inline bool kcompactd_work_requested(pg_data_t *pgdat)
>  {
> -	return pgdat->kcompactd_max_order > 0 || kthread_should_stop();
> +	return pgdat->kcompactd_max_order > 0 || kthread_should_stop() ||
> +		pgdat->proactive_compact_trigger;
>  }
>  
>  static bool kcompactd_node_suitable(pg_data_t *pgdat)
> @@ -2895,9 +2920,16 @@ static int kcompactd(void *p)
>  	while (!kthread_should_stop()) {
>  		unsigned long pflags;
>  
> +		/*
> +		 * Avoid the unnecessary wakeup for proactive compaction
> +		 * when it is disabled.
> +		 */
> +		if (!sysctl_compaction_proactiveness)
> +			timeout = MAX_SCHEDULE_TIMEOUT;
>  		trace_mm_compaction_kcompactd_sleep(pgdat->node_id);
>  		if (wait_event_freezable_timeout(pgdat->kcompactd_wait,
> -			kcompactd_work_requested(pgdat), timeout)) {
> +			kcompactd_work_requested(pgdat), timeout) &&
> +			!pgdat->proactive_compact_trigger) {
>  
>  			psi_memstall_enter(&pflags);
>  			kcompactd_do_work(pgdat);
> @@ -2932,6 +2964,8 @@ static int kcompactd(void *p)
>  				timeout =
>  				   default_timeout << COMPACT_MAX_DEFER_SHIFT;
>  		}
> +		if (unlikely(pgdat->proactive_compact_trigger))
> +			pgdat->proactive_compact_trigger = false;
>  	}
>  
>  	return 0;
> -- 
> QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a
> member of the Code Aurora Forum, hosted by The Linux Foundation
> 
> 


^ permalink raw reply	[flat|nested] 8+ messages in thread

end of thread, other threads:[~2021-08-04 21:11 UTC | newest]

Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-07-30 13:53 [PATCH V5] mm: compaction: support triggering of proactive compaction by user Charan Teja Reddy
2021-07-30 14:06 ` Vlastimil Babka
2021-07-30 14:46   ` Charan Teja Kalla
2021-07-30 14:47     ` Vlastimil Babka
2021-07-30 19:31 ` Mike Rapoport
2021-08-02 12:00   ` Charan Teja Kalla
2021-08-02 20:41     ` Andrew Morton
2021-08-04 21:11 ` Rafael Aquini

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).