Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1643097 > unrolled thread

[PATCH] mm: clarify why we want kmalloc before falling backto vmallock

Back to article view | Back to linux.kernel

Contents

  [PATCH] mm: clarify why we want kmalloc before falling backto vmallock Michal Hocko <mhocko@kernel.org> - 2017-05-17 10:20 +0200
    Re: [PATCH] mm: clarify why we want kmalloc before falling backto  vmallock Chris Wilson <chris@chris-wilson.co.uk> - 2017-05-17 15:10 +0200
    Re: [PATCH] mm: clarify why we want kmalloc before falling backto  vmallock Vlastimil Babka <vbabka@suse.cz> - 2017-05-18 16:10 +0200
    Re: [PATCH] mm: clarify why we want kmalloc before falling backto  vmallock John Hubbard <jhubbard@nvidia.com> - 2017-05-20 02:50 +0200
      Re: [PATCH] mm: clarify why we want kmalloc before falling backto  vmallock Michal Hocko <mhocko@kernel.org> - 2017-05-20 09:30 +0200

#1643097 — [PATCH] mm: clarify why we want kmalloc before falling backto vmallock

From: Michal Hocko <mhocko@suse.com>

While converting drm_[cm]alloc* helpers to kvmalloc* variants Chris
Wilson has wondered why we want to try kmalloc before vmalloc fallback
even for larger allocations requests. Let's clarify that one larger
physically contiguous block is less likely to fragment memory than many
scattered pages which can prevent more large blocks from being created.

Suggested-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Michal Hocko <mhocko@suse.com>
---
 mm/util.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/mm/util.c b/mm/util.c
index 464df3489903..87499f8119f2 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -357,7 +357,10 @@ void *kvmalloc_node(size_t size, gfp_t flags, int node)
 	WARN_ON_ONCE((flags & GFP_KERNEL) != GFP_KERNEL);
 
 	/*
-	 * Make sure that larger requests are not too disruptive - no OOM
+	 * We want to attempt a large physically contiguous block first because
+	 * it is less likely to fragment multiple larger blocks and therefore
+	 * contribute to a long term fragmentation less than vmalloc fallback.
+	 * However make sure that larger requests are not too disruptive - no OOM
 	 * killer and no allocation failure warnings as we have a fallback
 	 */
 	if (size > PAGE_SIZE) {
-- 
2.11.0

[toc] | [next] | [standalone]

#1643350 — Re: [PATCH] mm: clarify why we want kmalloc before falling backto vmallock

subject s/vmallock/vmalloc/

On Wed, May 17, 2017 at 10:09:32AM +0200, Michal Hocko wrote:
> From: Michal Hocko <mhocko@suse.com>
> 
> While converting drm_[cm]alloc* helpers to kvmalloc* variants Chris
> Wilson has wondered why we want to try kmalloc before vmalloc fallback
> even for larger allocations requests. Let's clarify that one larger
> physically contiguous block is less likely to fragment memory than many
> scattered pages which can prevent more large blocks from being created.
> 
> Suggested-by: Chris Wilson <chris@chris-wilson.co.uk>
> Signed-off-by: Michal Hocko <mhocko@suse.com>

It helped me understand the decisions made by the code, so
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
-Chris

-- 
Chris Wilson, Intel Open Source Technology Centre

[toc] | [prev] | [next] | [standalone]

#1644578 — Re: [PATCH] mm: clarify why we want kmalloc before falling backto vmallock

On 05/17/2017 10:09 AM, Michal Hocko wrote:
> From: Michal Hocko <mhocko@suse.com>
> 
> While converting drm_[cm]alloc* helpers to kvmalloc* variants Chris
> Wilson has wondered why we want to try kmalloc before vmalloc fallback
> even for larger allocations requests. Let's clarify that one larger
> physically contiguous block is less likely to fragment memory than many
> scattered pages which can prevent more large blocks from being created.
> 
> Suggested-by: Chris Wilson <chris@chris-wilson.co.uk>
> Signed-off-by: Michal Hocko <mhocko@suse.com>

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

> ---
>  mm/util.c | 5 ++++-
>  1 file changed, 4 insertions(+), 1 deletion(-)
> 
> diff --git a/mm/util.c b/mm/util.c
> index 464df3489903..87499f8119f2 100644
> --- a/mm/util.c
> +++ b/mm/util.c
> @@ -357,7 +357,10 @@ void *kvmalloc_node(size_t size, gfp_t flags, int node)
>  	WARN_ON_ONCE((flags & GFP_KERNEL) != GFP_KERNEL);
>  
>  	/*
> -	 * Make sure that larger requests are not too disruptive - no OOM
> +	 * We want to attempt a large physically contiguous block first because
> +	 * it is less likely to fragment multiple larger blocks and therefore
> +	 * contribute to a long term fragmentation less than vmalloc fallback.
> +	 * However make sure that larger requests are not too disruptive - no OOM
>  	 * killer and no allocation failure warnings as we have a fallback
>  	 */
>  	if (size > PAGE_SIZE) {
> 

[toc] | [prev] | [next] | [standalone]

#1646037 — Re: [PATCH] mm: clarify why we want kmalloc before falling backto vmallock

On 05/17/2017 01:09 AM, Michal Hocko wrote:
> From: Michal Hocko <mhocko@suse.com>
> 
> While converting drm_[cm]alloc* helpers to kvmalloc* variants Chris
> Wilson has wondered why we want to try kmalloc before vmalloc fallback
> even for larger allocations requests. Let's clarify that one larger
> physically contiguous block is less likely to fragment memory than many
> scattered pages which can prevent more large blocks from being created.
> 
> Suggested-by: Chris Wilson <chris@chris-wilson.co.uk>
> Signed-off-by: Michal Hocko <mhocko@suse.com>
> ---
>   mm/util.c | 5 ++++-
>   1 file changed, 4 insertions(+), 1 deletion(-)
> 
> diff --git a/mm/util.c b/mm/util.c
> index 464df3489903..87499f8119f2 100644
> --- a/mm/util.c
> +++ b/mm/util.c
> @@ -357,7 +357,10 @@ void *kvmalloc_node(size_t size, gfp_t flags, int node)
>   	WARN_ON_ONCE((flags & GFP_KERNEL) != GFP_KERNEL);
>   
>   	/*
> -	 * Make sure that larger requests are not too disruptive - no OOM
> +	 * We want to attempt a large physically contiguous block first because
> +	 * it is less likely to fragment multiple larger blocks and therefore
> +	 * contribute to a long term fragmentation less than vmalloc fallback.
> +	 * However make sure that larger requests are not too disruptive - no OOM
>   	 * killer and no allocation failure warnings as we have a fallback
>   	 */

Thanks for adding this, it's great to have. Here's a slightly polished version of your words, if you 
like:

	/*
	 * We want to attempt a large physically contiguous block first because
	 * it is less likely to fragment multiple larger blocks. This approach
	 * therefore contributes less to long term fragmentation than a vmalloc
	 * fallback would. However, make sure that larger requests are not too
	 * disruptive: no OOM killer and no allocation failure warnings, as we
	 * have a fallback.
	 */

thanks,
john h

>   	if (size > PAGE_SIZE) {
> -- 
> 2.11.0
> 
> --
> 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>
> 

[toc] | [prev] | [next] | [standalone]

#1646077 — Re: [PATCH] mm: clarify why we want kmalloc before falling backto vmallock

On Fri 19-05-17 17:46:58, John Hubbard wrote:
> On 05/17/2017 01:09 AM, Michal Hocko wrote:
> >From: Michal Hocko <mhocko@suse.com>
> >
> >While converting drm_[cm]alloc* helpers to kvmalloc* variants Chris
> >Wilson has wondered why we want to try kmalloc before vmalloc fallback
> >even for larger allocations requests. Let's clarify that one larger
> >physically contiguous block is less likely to fragment memory than many
> >scattered pages which can prevent more large blocks from being created.
> >
> >Suggested-by: Chris Wilson <chris@chris-wilson.co.uk>
> >Signed-off-by: Michal Hocko <mhocko@suse.com>
> >---
> >  mm/util.c | 5 ++++-
> >  1 file changed, 4 insertions(+), 1 deletion(-)
> >
> >diff --git a/mm/util.c b/mm/util.c
> >index 464df3489903..87499f8119f2 100644
> >--- a/mm/util.c
> >+++ b/mm/util.c
> >@@ -357,7 +357,10 @@ void *kvmalloc_node(size_t size, gfp_t flags, int node)
> >  	WARN_ON_ONCE((flags & GFP_KERNEL) != GFP_KERNEL);
> >  	/*
> >-	 * Make sure that larger requests are not too disruptive - no OOM
> >+	 * We want to attempt a large physically contiguous block first because
> >+	 * it is less likely to fragment multiple larger blocks and therefore
> >+	 * contribute to a long term fragmentation less than vmalloc fallback.
> >+	 * However make sure that larger requests are not too disruptive - no OOM
> >  	 * killer and no allocation failure warnings as we have a fallback
> >  	 */
> 
> Thanks for adding this, it's great to have. Here's a slightly polished
> version of your words, if you like:
> 
> 	/*
> 	 * We want to attempt a large physically contiguous block first because
> 	 * it is less likely to fragment multiple larger blocks. This approach
> 	 * therefore contributes less to long term fragmentation than a vmalloc
> 	 * fallback would. However, make sure that larger requests are not too
> 	 * disruptive: no OOM killer and no allocation failure warnings, as we
> 	 * have a fallback.
> 	 */

Looks ok to me.

-- 
Michal Hocko
SUSE Labs

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web