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

Groups > linux.kernel > #1443896 > unrolled thread

[PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

Back to article view | Back to linux.kernel

Contents

  [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() Xishi Qiu <qiuxishi@huawei.com> - 2016-07-15 04:50 +0200
    [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target() Xishi Qiu <qiuxishi@huawei.com> - 2016-07-15 05:00 +0200
      Re: [PATCH 2/2] mem-hotplug: use different mempolicy in  alloc_migrate_target() Vlastimil Babka <vbabka@suse.cz> - 2016-07-18 10:10 +0200
    Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in,  alloc_migrate_target() Joonsoo Kim <iamjoonsoo.kim@lge.com> - 2016-07-18 07:50 +0200
      Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in,  alloc_migrate_target() Vlastimil Babka <vbabka@suse.cz> - 2016-07-18 09:50 +0200
      Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() Xishi Qiu <qiuxishi@huawei.com> - 2016-07-18 10:10 +0200
        Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in,  alloc_migrate_target() Vlastimil Babka <vbabka@suse.cz> - 2016-07-18 10:10 +0200
          Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() Xishi Qiu <qiuxishi@huawei.com> - 2016-07-18 10:40 +0200
            Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in,  alloc_migrate_target() Joonsoo Kim <iamjoonsoo.kim@lge.com> - 2016-07-19 08:50 +0200
              Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() Xishi Qiu <qiuxishi@huawei.com> - 2016-07-19 09:20 +0200
                Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in,  alloc_migrate_target() David Rientjes <rientjes@google.com> - 2016-07-19 21:10 +0200

#1443896 — [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

alloc_migrate_target() is called from migrate_pages(), and the page
is always from user space, so we can add __GFP_HIGHMEM directly.

Signed-off-by: Xishi Qiu <qiuxishi@huawei.com>
---
 mm/page_isolation.c | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/mm/page_isolation.c b/mm/page_isolation.c
index 612122b..4f32c9f 100644
--- a/mm/page_isolation.c
+++ b/mm/page_isolation.c
@@ -282,8 +282,6 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
 struct page *alloc_migrate_target(struct page *page, unsigned long private,
 				  int **resultp)
 {
-	gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;
-
 	/*
 	 * TODO: allocate a destination hugepage from a nearest neighbor node,
 	 * accordance with memory policy of the user process if possible. For
@@ -293,9 +291,6 @@ struct page *alloc_migrate_target(struct page *page, unsigned long private,
 		return alloc_huge_page_node(page_hstate(compound_head(page)),
 					    next_node_in(page_to_nid(page),
 							 node_online_map));
-
-	if (PageHighMem(page))
-		gfp_mask |= __GFP_HIGHMEM;
-
-	return alloc_page(gfp_mask);
+	else
+		return alloc_page(GFP_HIGHUSER_MOVABLE);
 }
-- 
1.8.3.1

[toc] | [next] | [standalone]

#1443902 — [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target()

When we offline a node, the new page should alloced from other
nodes instead of the current node, because re-migrate is a waste of
time.
So use prefer mempolicy for hotplug, use default mempolicy for cma.

Signed-off-by: Xishi Qiu <qiuxishi@huawei.com>
---
 include/linux/page-isolation.h | 2 +-
 mm/memory_hotplug.c            | 5 ++++-
 mm/page_alloc.c                | 2 +-
 mm/page_isolation.c            | 8 +++++---
 4 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h
index 047d647..c163de3 100644
--- a/include/linux/page-isolation.h
+++ b/include/linux/page-isolation.h
@@ -65,7 +65,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
 int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
 			bool skip_hwpoisoned_pages);
 
-struct page *alloc_migrate_target(struct page *page, unsigned long private,
+struct page *alloc_migrate_target(struct page *page, unsigned long nid,
 				int **resultp);
 
 #endif
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index e3cbdca..b5963bf 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -1510,12 +1510,15 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
 	int move_pages = NR_OFFLINE_AT_ONCE_PAGES;
 	int not_managed = 0;
 	int ret = 0;
+	int nid = NUMA_NO_NODE;
 	LIST_HEAD(source);
 
 	for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) {
 		if (!pfn_valid(pfn))
 			continue;
 		page = pfn_to_page(pfn);
+		if (nid == NUMA_NO_NODE)
+			nid = next_node_in(page_to_nid(page), node_online_map);
 
 		if (PageHuge(page)) {
 			struct page *head = compound_head(page);
@@ -1568,7 +1571,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
 		 * alloc_migrate_target should be improooooved!!
 		 * migrate_pages returns # of failed pages.
 		 */
-		ret = migrate_pages(&source, alloc_migrate_target, NULL, 0,
+		ret = migrate_pages(&source, alloc_migrate_target, NULL, nid,
 					MIGRATE_SYNC, MR_MEMORY_HOTPLUG);
 		if (ret)
 			putback_movable_pages(&source);
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 6903b69..b99f1c2 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -7322,7 +7322,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
 		cc->nr_migratepages -= nr_reclaimed;
 
 		ret = migrate_pages(&cc->migratepages, alloc_migrate_target,
-				    NULL, 0, cc->mode, MR_CMA);
+				    NULL, NUMA_NO_NODE, cc->mode, MR_CMA);
 	}
 	if (ret < 0) {
 		putback_movable_pages(&cc->migratepages);
diff --git a/mm/page_isolation.c b/mm/page_isolation.c
index 4f32c9f..f471be6 100644
--- a/mm/page_isolation.c
+++ b/mm/page_isolation.c
@@ -279,18 +279,20 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
 	return pfn < end_pfn ? -EBUSY : 0;
 }
 
-struct page *alloc_migrate_target(struct page *page, unsigned long private,
+struct page *alloc_migrate_target(struct page *page, unsigned long nid,
 				  int **resultp)
 {
 	/*
-	 * TODO: allocate a destination hugepage from a nearest neighbor node,
+	 * hugeTLB: allocate a destination page from a nearest neighbor node,
 	 * accordance with memory policy of the user process if possible. For
 	 * now as a simple work-around, we use the next node for destination.
+	 * Normal page: use prefer mempolicy for destination if called by
+	 * hotplug, use default mempolicy for destination if called by cma.
 	 */
 	if (PageHuge(page))
 		return alloc_huge_page_node(page_hstate(compound_head(page)),
 					    next_node_in(page_to_nid(page),
 							 node_online_map));
 	else
-		return alloc_page(GFP_HIGHUSER_MOVABLE);
+		return alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);
 }
-- 
1.8.3.1

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

#1445288 — Re: [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target()

On 07/15/2016 04:51 AM, Xishi Qiu wrote:
> When we offline a node, the new page should alloced from other
> nodes instead of the current node, because re-migrate is a waste of
> time.

Ugh, I'm surprised that it's not the case already. Maybe the allocation 
from same node is already prevented indirectly somehow?

> So use prefer mempolicy for hotplug, use default mempolicy for cma.

IMHO CMA should prefer the same node as the migrated page, if anything. 
Current task's mempolicy shouldn't restrict it (it's likely migrating 
pages of somebody else) or even guide its preferences. Ideally it would 
keep the original page's mempolicy, but we can't afford to track that...

> Signed-off-by: Xishi Qiu <qiuxishi@huawei.com>
> ---
>  include/linux/page-isolation.h | 2 +-
>  mm/memory_hotplug.c            | 5 ++++-
>  mm/page_alloc.c                | 2 +-
>  mm/page_isolation.c            | 8 +++++---
>  4 files changed, 11 insertions(+), 6 deletions(-)
>
> diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h
> index 047d647..c163de3 100644
> --- a/include/linux/page-isolation.h
> +++ b/include/linux/page-isolation.h
> @@ -65,7 +65,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
>  int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
>  			bool skip_hwpoisoned_pages);
>
> -struct page *alloc_migrate_target(struct page *page, unsigned long private,
> +struct page *alloc_migrate_target(struct page *page, unsigned long nid,
>  				int **resultp);
>
>  #endif
> diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
> index e3cbdca..b5963bf 100644
> --- a/mm/memory_hotplug.c
> +++ b/mm/memory_hotplug.c
> @@ -1510,12 +1510,15 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
>  	int move_pages = NR_OFFLINE_AT_ONCE_PAGES;
>  	int not_managed = 0;
>  	int ret = 0;
> +	int nid = NUMA_NO_NODE;
>  	LIST_HEAD(source);
>
>  	for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) {
>  		if (!pfn_valid(pfn))
>  			continue;
>  		page = pfn_to_page(pfn);
> +		if (nid == NUMA_NO_NODE)
> +			nid = next_node_in(page_to_nid(page), node_online_map);
>
>  		if (PageHuge(page)) {
>  			struct page *head = compound_head(page);
> @@ -1568,7 +1571,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
>  		 * alloc_migrate_target should be improooooved!!

So, is this patch improooooving it enough that we can delete the 
comment? If not, could the patch be improooooved? :)

>  		 * migrate_pages returns # of failed pages.
>  		 */
> -		ret = migrate_pages(&source, alloc_migrate_target, NULL, 0,
> +		ret = migrate_pages(&source, alloc_migrate_target, NULL, nid,
>  					MIGRATE_SYNC, MR_MEMORY_HOTPLUG);
>  		if (ret)
>  			putback_movable_pages(&source);
> diff --git a/mm/page_alloc.c b/mm/page_alloc.c
> index 6903b69..b99f1c2 100644
> --- a/mm/page_alloc.c
> +++ b/mm/page_alloc.c
> @@ -7322,7 +7322,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
>  		cc->nr_migratepages -= nr_reclaimed;
>
>  		ret = migrate_pages(&cc->migratepages, alloc_migrate_target,
> -				    NULL, 0, cc->mode, MR_CMA);
> +				    NULL, NUMA_NO_NODE, cc->mode, MR_CMA);
>  	}
>  	if (ret < 0) {
>  		putback_movable_pages(&cc->migratepages);
> diff --git a/mm/page_isolation.c b/mm/page_isolation.c
> index 4f32c9f..f471be6 100644
> --- a/mm/page_isolation.c
> +++ b/mm/page_isolation.c
> @@ -279,18 +279,20 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
>  	return pfn < end_pfn ? -EBUSY : 0;
>  }
>
> -struct page *alloc_migrate_target(struct page *page, unsigned long private,
> +struct page *alloc_migrate_target(struct page *page, unsigned long nid,
>  				  int **resultp)
>  {
>  	/*
> -	 * TODO: allocate a destination hugepage from a nearest neighbor node,
> +	 * hugeTLB: allocate a destination page from a nearest neighbor node,

for hugeTLB it's still a TODO, by removing the word the rest of comment 
doesn't make much sense

>  	 * accordance with memory policy of the user process if possible. For
>  	 * now as a simple work-around, we use the next node for destination.
> +	 * Normal page: use prefer mempolicy for destination if called by
> +	 * hotplug, use default mempolicy for destination if called by cma.
>  	 */
>  	if (PageHuge(page))
>  		return alloc_huge_page_node(page_hstate(compound_head(page)),
>  					    next_node_in(page_to_nid(page),
>  							 node_online_map));
>  	else
> -		return alloc_page(GFP_HIGHUSER_MOVABLE);
> +		return alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);
>  }
>

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

#1445220 — Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
> alloc_migrate_target() is called from migrate_pages(), and the page
> is always from user space, so we can add __GFP_HIGHMEM directly.

No, all migratable pages are not from user space. For example,
blockdev file cache has __GFP_MOVABLE and migratable but it has no
__GFP_HIGHMEM and __GFP_USER.

And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.

Thanks.

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

#1445281 — Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

On 07/18/2016 07:51 AM, Joonsoo Kim wrote:
> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
>> alloc_migrate_target() is called from migrate_pages(), and the page
>> is always from user space, so we can add __GFP_HIGHMEM directly.
>
> No, all migratable pages are not from user space. For example,
> blockdev file cache has __GFP_MOVABLE and migratable but it has no
> __GFP_HIGHMEM and __GFP_USER.
>
> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.

Right, and there's also Minchan's series for arbitrary driver page 
migration...

> Thanks.
>

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

#1445285

On 2016/7/18 13:51, Joonsoo Kim wrote:

> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
>> alloc_migrate_target() is called from migrate_pages(), and the page
>> is always from user space, so we can add __GFP_HIGHMEM directly.
> 
> No, all migratable pages are not from user space. For example,
> blockdev file cache has __GFP_MOVABLE and migratable but it has no
> __GFP_HIGHMEM and __GFP_USER.
> 

Hi Joonsoo,

So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;"
is not correct?

> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.
> 

Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing
mem-hotplug?

Thanks,
Xishi Qiu

> Thanks.
> 
> 
> .
> 

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

#1445286 — Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

On 07/18/2016 10:00 AM, Xishi Qiu wrote:
> On 2016/7/18 13:51, Joonsoo Kim wrote:
>
>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
>>> alloc_migrate_target() is called from migrate_pages(), and the page
>>> is always from user space, so we can add __GFP_HIGHMEM directly.
>>
>> No, all migratable pages are not from user space. For example,
>> blockdev file cache has __GFP_MOVABLE and migratable but it has no
>> __GFP_HIGHMEM and __GFP_USER.
>>
>
> Hi Joonsoo,
>
> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;"
> is not correct?

It's not incorrect. GFP_USER just specifies some reclaim flags, and may 
perhaps restrict allocation through __GFP_HARDWALL, where the original
page could have been allocated without the restriction. But it doesn't 
put the place in an unexpected address range, as placing a non-highmem 
page into highmem could. __GFP_MOVABLE then just controls a heuristic 
for placement within a zone.

>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.
>>
>
> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing
> mem-hotplug?

I don't understand the question here, can you rephrase with more detail? 
Thanks.

> Thanks,
> Xishi Qiu
>
>> Thanks.
>>
>>
>> .
>>
>
>
>

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

#1445304

On 2016/7/18 16:05, Vlastimil Babka wrote:

> On 07/18/2016 10:00 AM, Xishi Qiu wrote:
>> On 2016/7/18 13:51, Joonsoo Kim wrote:
>>
>>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
>>>> alloc_migrate_target() is called from migrate_pages(), and the page
>>>> is always from user space, so we can add __GFP_HIGHMEM directly.
>>>
>>> No, all migratable pages are not from user space. For example,
>>> blockdev file cache has __GFP_MOVABLE and migratable but it has no
>>> __GFP_HIGHMEM and __GFP_USER.
>>>
>>
>> Hi Joonsoo,
>>
>> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;"
>> is not correct?
> 
> It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original
> page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone.
> 
>>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.
>>>
>>
>> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing
>> mem-hotplug?
> 
> I don't understand the question here, can you rephrase with more detail? Thanks.
> 

Hi Joonsoo,

When we do memory offline, and the zone is movable zone,
can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a
new page? the nid is the next node.

Thanks,
Xishi Qiu

>> Thanks,
>> Xishi Qiu
>>
>>> Thanks.
>>>
>>>
>>> .
>>>
>>
>>
>>
> 
> 
> .
> 

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

#1446069 — Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

On Mon, Jul 18, 2016 at 04:31:11PM +0800, Xishi Qiu wrote:
> On 2016/7/18 16:05, Vlastimil Babka wrote:
> 
> > On 07/18/2016 10:00 AM, Xishi Qiu wrote:
> >> On 2016/7/18 13:51, Joonsoo Kim wrote:
> >>
> >>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
> >>>> alloc_migrate_target() is called from migrate_pages(), and the page
> >>>> is always from user space, so we can add __GFP_HIGHMEM directly.
> >>>
> >>> No, all migratable pages are not from user space. For example,
> >>> blockdev file cache has __GFP_MOVABLE and migratable but it has no
> >>> __GFP_HIGHMEM and __GFP_USER.
> >>>
> >>
> >> Hi Joonsoo,
> >>
> >> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;"
> >> is not correct?
> > 
> > It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original
> > page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone.
> > 
> >>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.
> >>>
> >>
> >> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing
> >> mem-hotplug?
> > 
> > I don't understand the question here, can you rephrase with more detail? Thanks.
> > 
> 
> Hi Joonsoo,

Above is answered by Vlastimil. :)

> When we do memory offline, and the zone is movable zone,
> can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a
> new page? the nid is the next node.

I don't know much about memory offline, but, AFAIK, memory offline
could happen on non-movable zone like as ZONE_NORMAL. Perhaps, you can add
"if zone of the page is movable zone then alloc with GFP_HIGHUSER_MOVABLE".

Thanks.

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

#1446143

On 2016/7/19 14:50, Joonsoo Kim wrote:

> On Mon, Jul 18, 2016 at 04:31:11PM +0800, Xishi Qiu wrote:
>> On 2016/7/18 16:05, Vlastimil Babka wrote:
>>
>>> On 07/18/2016 10:00 AM, Xishi Qiu wrote:
>>>> On 2016/7/18 13:51, Joonsoo Kim wrote:
>>>>
>>>>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote:
>>>>>> alloc_migrate_target() is called from migrate_pages(), and the page
>>>>>> is always from user space, so we can add __GFP_HIGHMEM directly.
>>>>>
>>>>> No, all migratable pages are not from user space. For example,
>>>>> blockdev file cache has __GFP_MOVABLE and migratable but it has no
>>>>> __GFP_HIGHMEM and __GFP_USER.
>>>>>
>>>>
>>>> Hi Joonsoo,
>>>>
>>>> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;"
>>>> is not correct?
>>>
>>> It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original
>>> page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone.
>>>
>>>>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE.
>>>>>
>>>>
>>>> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing
>>>> mem-hotplug?
>>>
>>> I don't understand the question here, can you rephrase with more detail? Thanks.
>>>
>>
>> Hi Joonsoo,
> 
> Above is answered by Vlastimil. :)
> 
>> When we do memory offline, and the zone is movable zone,
>> can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a
>> new page? the nid is the next node.
> 
> I don't know much about memory offline, but, AFAIK, memory offline
> could happen on non-movable zone like as ZONE_NORMAL. Perhaps, you can add
> "if zone of the page is movable zone then alloc with GFP_HIGHUSER_MOVABLE".
> 
> Thanks.
> 

Hi Joonsoo and Vlastimil,

Memory offline could happen on both movable zone and non-movable zone, and we
can offline the whole node if the zone is movable_zone(the node only has one
movable_zone), and if the zone is normal_zone, we cannot offline the whole node,
because some kernel memory can't be migrated.

So how about change alloc_migrate_target() to alloc memory from the next node
with GFP_HIGHUSER_MOVABLE, if the offline zone is movable_zone.

And if the offline zone is normal_zone, we don't change anything, that means
the new page may be from the same node.

Thanks,
Xishi Qiu

> .
> 

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

#1446678 — Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target()

On Tue, 19 Jul 2016, Xishi Qiu wrote:

> Memory offline could happen on both movable zone and non-movable zone, and we
> can offline the whole node if the zone is movable_zone(the node only has one
> movable_zone), and if the zone is normal_zone, we cannot offline the whole node,
> because some kernel memory can't be migrated.
> 
> So how about change alloc_migrate_target() to alloc memory from the next node
> with GFP_HIGHUSER_MOVABLE, if the offline zone is movable_zone.
> 

I think sharing alloc_migrate_target as a migration callback may not be 
worth it; CMA and memory offline are distinct usecases and probably 
deserve their own callbacks.

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web