All of lore.kernel.org
 help / color / mirror / Atom feed
* [v3 PATCH 0/4] Make deferred split shrinker memcg aware
@ 2019-06-12 21:56 Yang Shi
  2019-06-12 21:56 ` [v3 PATCH 1/4] mm: thp: extract split_queue_* into a struct Yang Shi
                   ` (3 more replies)
  0 siblings, 4 replies; 14+ messages in thread
From: Yang Shi @ 2019-06-12 21:56 UTC (permalink / raw)
  To: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb, rientjes, akpm
  Cc: yang.shi, linux-mm, linux-kernel


Currently THP deferred split shrinker is not memcg aware, this may cause
premature OOM with some configuration. For example the below test would
run into premature OOM easily:

$ cgcreate -g memory:thp
$ echo 4G > /sys/fs/cgroup/memory/thp/memory/limit_in_bytes
$ cgexec -g memory:thp transhuge-stress 4000

transhuge-stress comes from kernel selftest.

It is easy to hit OOM, but there are still a lot THP on the deferred
split queue, memcg direct reclaim can't touch them since the deferred
split shrinker is not memcg aware.

Convert deferred split shrinker memcg aware by introducing per memcg
deferred split queue.  The THP should be on either per node or per memcg
deferred split queue if it belongs to a memcg.  When the page is
immigrated to the other memcg, it will be immigrated to the target
memcg's deferred split queue too.

Reuse the second tail page's deferred_list for per memcg list since the
same THP can't be on multiple deferred split queues.

Make deferred split shrinker not depend on memcg kmem since it is not slab.
It doesn’t make sense to not shrink THP even though memcg kmem is disabled.

With the above change the test demonstrated above doesn’t trigger OOM even
though with cgroup.memory=nokmem.


Changelog:
v3: * Adopted the suggestion from Kirill Shutemov to move mem_cgroup_uncharge()
      out of __page_cache_release() in order to handle THP free properly. 
    * Adjusted the sequence of the patches per Kirill Shutemov. Dropped the
      patch 3/4 in v2.
    * Moved enqueuing THP onto "to" memcg deferred split queue after
      page->mem_cgroup is changed in memcg account move per Kirill Tkhai.
 
v2: * Adopted the suggestion from Krill Shutemov to extract deferred split
      fields into a struct to reduce code duplication (patch 1/4).  With this
      change, the lines of change is shrunk down to 198 from 278.
    * Removed memcg_deferred_list. Use deferred_list for both global and memcg.
      With the code deduplication, it doesn't make too much sense to keep it.
      Kirill Tkhai also suggested so.
    * Fixed typo for SHRINKER_NONSLAB.


Yang Shi (4):
      mm: thp: extract split_queue_* into a struct
      mm: move mem_cgroup_uncharge out of __page_cache_release()
      mm: shrinker: make shrinker not depend on memcg kmem
      mm: thp: make deferred split shrinker memcg aware

 include/linux/huge_mm.h    |  9 ++++++++
 include/linux/memcontrol.h |  4 ++++
 include/linux/mm_types.h   |  1 +
 include/linux/mmzone.h     | 12 ++++++++---
 include/linux/shrinker.h   |  3 +--
 mm/huge_memory.c           | 80 +++++++++++++++++++++++++++++++++++++++++++++-----------------------
 mm/memcontrol.c            | 24 +++++++++++++++++++++
 mm/page_alloc.c            |  9 +++++---
 mm/swap.c                  |  2 +-
 mm/vmscan.c                | 27 ++++++-----------------
 10 files changed, 114 insertions(+), 57 deletions(-)

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

* [v3 PATCH 1/4] mm: thp: extract split_queue_* into a struct
  2019-06-12 21:56 [v3 PATCH 0/4] Make deferred split shrinker memcg aware Yang Shi
@ 2019-06-12 21:56 ` Yang Shi
  2019-06-12 21:56 ` [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release() Yang Shi
                   ` (2 subsequent siblings)
  3 siblings, 0 replies; 14+ messages in thread
From: Yang Shi @ 2019-06-12 21:56 UTC (permalink / raw)
  To: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb, rientjes, akpm
  Cc: yang.shi, linux-mm, linux-kernel

Put split_queue, split_queue_lock and split_queue_len into a struct in
order to reduce code duplication when we convert deferred_split to memcg
aware in the later patches.

Suggested-by: "Kirill A . Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Kirill Tkhai <ktkhai@virtuozzo.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Yang Shi <yang.shi@linux.alibaba.com>
---
 include/linux/mmzone.h | 12 +++++++++---
 mm/huge_memory.c       | 45 +++++++++++++++++++++++++--------------------
 mm/page_alloc.c        |  8 +++++---
 3 files changed, 39 insertions(+), 26 deletions(-)

diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 70394ca..7799166 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -676,6 +676,14 @@ struct zonelist {
 extern struct page *mem_map;
 #endif
 
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+struct deferred_split {
+	spinlock_t split_queue_lock;
+	struct list_head split_queue;
+	unsigned long split_queue_len;
+};
+#endif
+
 /*
  * On NUMA machines, each NUMA node would have a pg_data_t to describe
  * it's memory layout. On UMA machines there is a single pglist_data which
@@ -755,9 +763,7 @@ struct zonelist {
 #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
 
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
-	spinlock_t split_queue_lock;
-	struct list_head split_queue;
-	unsigned long split_queue_len;
+	struct deferred_split deferred_split_queue;
 #endif
 
 	/* Fields commonly accessed by the page reclaim scanner */
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 9f8bce9..81cf759 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -2658,6 +2658,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
 {
 	struct page *head = compound_head(page);
 	struct pglist_data *pgdata = NODE_DATA(page_to_nid(head));
+	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
 	struct anon_vma *anon_vma = NULL;
 	struct address_space *mapping = NULL;
 	int count, mapcount, extra_pins, ret;
@@ -2744,17 +2745,17 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
 	}
 
 	/* Prevent deferred_split_scan() touching ->_refcount */
-	spin_lock(&pgdata->split_queue_lock);
+	spin_lock(&ds_queue->split_queue_lock);
 	count = page_count(head);
 	mapcount = total_mapcount(head);
 	if (!mapcount && page_ref_freeze(head, 1 + extra_pins)) {
 		if (!list_empty(page_deferred_list(head))) {
-			pgdata->split_queue_len--;
+			ds_queue->split_queue_len--;
 			list_del(page_deferred_list(head));
 		}
 		if (mapping)
 			__dec_node_page_state(page, NR_SHMEM_THPS);
-		spin_unlock(&pgdata->split_queue_lock);
+		spin_unlock(&ds_queue->split_queue_lock);
 		__split_huge_page(page, list, end, flags);
 		if (PageSwapCache(head)) {
 			swp_entry_t entry = { .val = page_private(head) };
@@ -2771,7 +2772,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
 			dump_page(page, "total_mapcount(head) > 0");
 			BUG();
 		}
-		spin_unlock(&pgdata->split_queue_lock);
+		spin_unlock(&ds_queue->split_queue_lock);
 fail:		if (mapping)
 			xa_unlock(&mapping->i_pages);
 		spin_unlock_irqrestore(&pgdata->lru_lock, flags);
@@ -2794,52 +2795,56 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
 void free_transhuge_page(struct page *page)
 {
 	struct pglist_data *pgdata = NODE_DATA(page_to_nid(page));
+	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
 	unsigned long flags;
 
-	spin_lock_irqsave(&pgdata->split_queue_lock, flags);
+	spin_lock_irqsave(&ds_queue->split_queue_lock, flags);
 	if (!list_empty(page_deferred_list(page))) {
-		pgdata->split_queue_len--;
+		ds_queue->split_queue_len--;
 		list_del(page_deferred_list(page));
 	}
-	spin_unlock_irqrestore(&pgdata->split_queue_lock, flags);
+	spin_unlock_irqrestore(&ds_queue->split_queue_lock, flags);
 	free_compound_page(page);
 }
 
 void deferred_split_huge_page(struct page *page)
 {
 	struct pglist_data *pgdata = NODE_DATA(page_to_nid(page));
+	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
 	unsigned long flags;
 
 	VM_BUG_ON_PAGE(!PageTransHuge(page), page);
 
-	spin_lock_irqsave(&pgdata->split_queue_lock, flags);
+	spin_lock_irqsave(&ds_queue->split_queue_lock, flags);
 	if (list_empty(page_deferred_list(page))) {
 		count_vm_event(THP_DEFERRED_SPLIT_PAGE);
-		list_add_tail(page_deferred_list(page), &pgdata->split_queue);
-		pgdata->split_queue_len++;
+		list_add_tail(page_deferred_list(page), &ds_queue->split_queue);
+		ds_queue->split_queue_len++;
 	}
-	spin_unlock_irqrestore(&pgdata->split_queue_lock, flags);
+	spin_unlock_irqrestore(&ds_queue->split_queue_lock, flags);
 }
 
 static unsigned long deferred_split_count(struct shrinker *shrink,
 		struct shrink_control *sc)
 {
 	struct pglist_data *pgdata = NODE_DATA(sc->nid);
-	return READ_ONCE(pgdata->split_queue_len);
+	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
+	return READ_ONCE(ds_queue->split_queue_len);
 }
 
 static unsigned long deferred_split_scan(struct shrinker *shrink,
 		struct shrink_control *sc)
 {
 	struct pglist_data *pgdata = NODE_DATA(sc->nid);
+	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
 	unsigned long flags;
 	LIST_HEAD(list), *pos, *next;
 	struct page *page;
 	int split = 0;
 
-	spin_lock_irqsave(&pgdata->split_queue_lock, flags);
+	spin_lock_irqsave(&ds_queue->split_queue_lock, flags);
 	/* Take pin on all head pages to avoid freeing them under us */
-	list_for_each_safe(pos, next, &pgdata->split_queue) {
+	list_for_each_safe(pos, next, &ds_queue->split_queue) {
 		page = list_entry((void *)pos, struct page, mapping);
 		page = compound_head(page);
 		if (get_page_unless_zero(page)) {
@@ -2847,12 +2852,12 @@ static unsigned long deferred_split_scan(struct shrinker *shrink,
 		} else {
 			/* We lost race with put_compound_page() */
 			list_del_init(page_deferred_list(page));
-			pgdata->split_queue_len--;
+			ds_queue->split_queue_len--;
 		}
 		if (!--sc->nr_to_scan)
 			break;
 	}
-	spin_unlock_irqrestore(&pgdata->split_queue_lock, flags);
+	spin_unlock_irqrestore(&ds_queue->split_queue_lock, flags);
 
 	list_for_each_safe(pos, next, &list) {
 		page = list_entry((void *)pos, struct page, mapping);
@@ -2866,15 +2871,15 @@ static unsigned long deferred_split_scan(struct shrinker *shrink,
 		put_page(page);
 	}
 
-	spin_lock_irqsave(&pgdata->split_queue_lock, flags);
-	list_splice_tail(&list, &pgdata->split_queue);
-	spin_unlock_irqrestore(&pgdata->split_queue_lock, flags);
+	spin_lock_irqsave(&ds_queue->split_queue_lock, flags);
+	list_splice_tail(&list, &ds_queue->split_queue);
+	spin_unlock_irqrestore(&ds_queue->split_queue_lock, flags);
 
 	/*
 	 * Stop shrinker if we didn't split any page, but the queue is empty.
 	 * This can happen if pages were freed under us.
 	 */
-	if (!split && list_empty(&pgdata->split_queue))
+	if (!split && list_empty(&ds_queue->split_queue))
 		return SHRINK_STOP;
 	return split;
 }
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 3b13d39..a82104a 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -6581,9 +6581,11 @@ static unsigned long __init calc_memmap_size(unsigned long spanned_pages,
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 static void pgdat_init_split_queue(struct pglist_data *pgdat)
 {
-	spin_lock_init(&pgdat->split_queue_lock);
-	INIT_LIST_HEAD(&pgdat->split_queue);
-	pgdat->split_queue_len = 0;
+	struct deferred_split *ds_queue = &pgdat->deferred_split_queue;
+
+	spin_lock_init(&ds_queue->split_queue_lock);
+	INIT_LIST_HEAD(&ds_queue->split_queue);
+	ds_queue->split_queue_len = 0;
 }
 #else
 static void pgdat_init_split_queue(struct pglist_data *pgdat) {}
-- 
1.8.3.1


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

* [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release()
  2019-06-12 21:56 [v3 PATCH 0/4] Make deferred split shrinker memcg aware Yang Shi
  2019-06-12 21:56 ` [v3 PATCH 1/4] mm: thp: extract split_queue_* into a struct Yang Shi
@ 2019-06-12 21:56 ` Yang Shi
  2019-06-13 11:39   ` Kirill A. Shutemov
  2019-06-12 21:56 ` [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem Yang Shi
  2019-06-12 21:56 ` [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware Yang Shi
  3 siblings, 1 reply; 14+ messages in thread
From: Yang Shi @ 2019-06-12 21:56 UTC (permalink / raw)
  To: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb, rientjes, akpm
  Cc: yang.shi, linux-mm, linux-kernel

The later patch would make THP deferred split shrinker memcg aware, but
it needs page->mem_cgroup information in THP destructor, which is called
after mem_cgroup_uncharge() now.

So, move mem_cgroup_uncharge() from __page_cache_release() to compound
page destructor, which is called by both THP and other compound pages
except HugeTLB.  And call it in __put_single_page() for single order
page.

Suggested-by: "Kirill A . Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Kirill Tkhai <ktkhai@virtuozzo.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Yang Shi <yang.shi@linux.alibaba.com>
---
 mm/page_alloc.c | 1 +
 mm/swap.c       | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index a82104a..7f27f4e 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -623,6 +623,7 @@ static void bad_page(struct page *page, const char *reason,
 
 void free_compound_page(struct page *page)
 {
+	mem_cgroup_uncharge(page);
 	__free_pages_ok(page, compound_order(page));
 }
 
diff --git a/mm/swap.c b/mm/swap.c
index 3a75722..982bd79 100644
--- a/mm/swap.c
+++ b/mm/swap.c
@@ -70,12 +70,12 @@ static void __page_cache_release(struct page *page)
 		spin_unlock_irqrestore(&pgdat->lru_lock, flags);
 	}
 	__ClearPageWaiters(page);
-	mem_cgroup_uncharge(page);
 }
 
 static void __put_single_page(struct page *page)
 {
 	__page_cache_release(page);
+	mem_cgroup_uncharge(page);
 	free_unref_page(page);
 }
 
-- 
1.8.3.1


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

* [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem
  2019-06-12 21:56 [v3 PATCH 0/4] Make deferred split shrinker memcg aware Yang Shi
  2019-06-12 21:56 ` [v3 PATCH 1/4] mm: thp: extract split_queue_* into a struct Yang Shi
  2019-06-12 21:56 ` [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release() Yang Shi
@ 2019-06-12 21:56 ` Yang Shi
  2019-06-25 22:14   ` Andrew Morton
  2019-06-12 21:56 ` [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware Yang Shi
  3 siblings, 1 reply; 14+ messages in thread
From: Yang Shi @ 2019-06-12 21:56 UTC (permalink / raw)
  To: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb, rientjes, akpm
  Cc: yang.shi, linux-mm, linux-kernel

Currently shrinker is just allocated and can work when memcg kmem is
enabled.  But, THP deferred split shrinker is not slab shrinker, it
doesn't make too much sense to have such shrinker depend on memcg kmem.
It should be able to reclaim THP even though memcg kmem is disabled.

Introduce a new shrinker flag, SHRINKER_NONSLAB, for non-slab shrinker.
When memcg kmem is disabled, just such shrinkers can be called in
shrinking memcg slab.

Cc: Kirill Tkhai <ktkhai@virtuozzo.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: "Kirill A . Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Yang Shi <yang.shi@linux.alibaba.com>
---
 include/linux/shrinker.h |  3 +--
 mm/vmscan.c              | 27 ++++++---------------------
 2 files changed, 7 insertions(+), 23 deletions(-)

diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
index 9443caf..e14f68e 100644
--- a/include/linux/shrinker.h
+++ b/include/linux/shrinker.h
@@ -69,10 +69,8 @@ struct shrinker {
 
 	/* These are for internal use */
 	struct list_head list;
-#ifdef CONFIG_MEMCG_KMEM
 	/* ID in shrinker_idr */
 	int id;
-#endif
 	/* objs pending delete, per node */
 	atomic_long_t *nr_deferred;
 };
@@ -81,6 +79,7 @@ struct shrinker {
 /* Flags */
 #define SHRINKER_NUMA_AWARE	(1 << 0)
 #define SHRINKER_MEMCG_AWARE	(1 << 1)
+#define SHRINKER_NONSLAB	(1 << 2)
 
 extern int prealloc_shrinker(struct shrinker *shrinker);
 extern void register_shrinker_prepared(struct shrinker *shrinker);
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 7acd0af..62000ae 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -174,8 +174,6 @@ struct scan_control {
 static LIST_HEAD(shrinker_list);
 static DECLARE_RWSEM(shrinker_rwsem);
 
-#ifdef CONFIG_MEMCG_KMEM
-
 /*
  * We allow subsystems to populate their shrinker-related
  * LRU lists before register_shrinker_prepared() is called
@@ -227,16 +225,6 @@ static void unregister_memcg_shrinker(struct shrinker *shrinker)
 	idr_remove(&shrinker_idr, id);
 	up_write(&shrinker_rwsem);
 }
-#else /* CONFIG_MEMCG_KMEM */
-static int prealloc_memcg_shrinker(struct shrinker *shrinker)
-{
-	return 0;
-}
-
-static void unregister_memcg_shrinker(struct shrinker *shrinker)
-{
-}
-#endif /* CONFIG_MEMCG_KMEM */
 
 #ifdef CONFIG_MEMCG
 static bool global_reclaim(struct scan_control *sc)
@@ -579,7 +567,6 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
 	return freed;
 }
 
-#ifdef CONFIG_MEMCG_KMEM
 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
 			struct mem_cgroup *memcg, int priority)
 {
@@ -587,7 +574,7 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
 	unsigned long ret, freed = 0;
 	int i;
 
-	if (!memcg_kmem_enabled() || !mem_cgroup_online(memcg))
+	if (!mem_cgroup_online(memcg))
 		return 0;
 
 	if (!down_read_trylock(&shrinker_rwsem))
@@ -613,6 +600,11 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
 			continue;
 		}
 
+		/* Call non-slab shrinkers even though kmem is disabled */
+		if (!memcg_kmem_enabled() &&
+		    !(shrinker->flags & SHRINKER_NONSLAB))
+			continue;
+
 		ret = do_shrink_slab(&sc, shrinker, priority);
 		if (ret == SHRINK_EMPTY) {
 			clear_bit(i, map->map);
@@ -649,13 +641,6 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
 	up_read(&shrinker_rwsem);
 	return freed;
 }
-#else /* CONFIG_MEMCG_KMEM */
-static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
-			struct mem_cgroup *memcg, int priority)
-{
-	return 0;
-}
-#endif /* CONFIG_MEMCG_KMEM */
 
 /**
  * shrink_slab - shrink slab caches
-- 
1.8.3.1


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

* [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware
  2019-06-12 21:56 [v3 PATCH 0/4] Make deferred split shrinker memcg aware Yang Shi
                   ` (2 preceding siblings ...)
  2019-06-12 21:56 ` [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem Yang Shi
@ 2019-06-12 21:56 ` Yang Shi
  2019-06-25 22:00   ` Andrew Morton
  3 siblings, 1 reply; 14+ messages in thread
From: Yang Shi @ 2019-06-12 21:56 UTC (permalink / raw)
  To: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb, rientjes, akpm
  Cc: yang.shi, linux-mm, linux-kernel

Currently THP deferred split shrinker is not memcg aware, this may cause
premature OOM with some configuration. For example the below test would
run into premature OOM easily:

$ cgcreate -g memory:thp
$ echo 4G > /sys/fs/cgroup/memory/thp/memory/limit_in_bytes
$ cgexec -g memory:thp transhuge-stress 4000

transhuge-stress comes from kernel selftest.

It is easy to hit OOM, but there are still a lot THP on the deferred
split queue, memcg direct reclaim can't touch them since the deferred
split shrinker is not memcg aware.

Convert deferred split shrinker memcg aware by introducing per memcg
deferred split queue.  The THP should be on either per node or per memcg
deferred split queue if it belongs to a memcg.  When the page is
immigrated to the other memcg, it will be immigrated to the target
memcg's deferred split queue too.

Reuse the second tail page's deferred_list for per memcg list since the
same THP can't be on multiple deferred split queues.

Cc: Kirill Tkhai <ktkhai@virtuozzo.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: "Kirill A . Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Yang Shi <yang.shi@linux.alibaba.com>
---
 include/linux/huge_mm.h    |  9 +++++++++
 include/linux/memcontrol.h |  4 ++++
 include/linux/mm_types.h   |  1 +
 mm/huge_memory.c           | 45 +++++++++++++++++++++++++++++++++------------
 mm/memcontrol.c            | 24 ++++++++++++++++++++++++
 5 files changed, 71 insertions(+), 12 deletions(-)

diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 7cd5c15..7738509 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -250,6 +250,15 @@ static inline bool thp_migration_supported(void)
 	return IS_ENABLED(CONFIG_ARCH_ENABLE_THP_MIGRATION);
 }
 
+static inline struct list_head *page_deferred_list(struct page *page)
+{
+	/*
+	 * Global or memcg deferred list in the second tail pages is
+	 * occupied by compound_head.
+	 */
+	return &page[2].deferred_list;
+}
+
 #else /* CONFIG_TRANSPARENT_HUGEPAGE */
 #define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; })
 #define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; })
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index bc74d6a..5d3c10c 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -316,6 +316,10 @@ struct mem_cgroup {
 	struct list_head event_list;
 	spinlock_t event_list_lock;
 
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+	struct deferred_split deferred_split_queue;
+#endif
+
 	struct mem_cgroup_per_node *nodeinfo[0];
 	/* WARNING: nodeinfo must be the last member here */
 };
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 8ec38b1..4eabf80 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -139,6 +139,7 @@ struct page {
 		struct {	/* Second tail page of compound page */
 			unsigned long _compound_pad_1;	/* compound_head */
 			unsigned long _compound_pad_2;
+			/* For both global and memcg */
 			struct list_head deferred_list;
 		};
 		struct {	/* Page table pages */
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 81cf759..4f20273 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -492,10 +492,15 @@ pmd_t maybe_pmd_mkwrite(pmd_t pmd, struct vm_area_struct *vma)
 	return pmd;
 }
 
-static inline struct list_head *page_deferred_list(struct page *page)
+static inline struct deferred_split *get_deferred_split_queue(struct page *page)
 {
-	/* ->lru in the tail pages is occupied by compound_head. */
-	return &page[2].deferred_list;
+	struct mem_cgroup *memcg = compound_head(page)->mem_cgroup;
+	struct pglist_data *pgdat = NODE_DATA(page_to_nid(page));
+
+	if (memcg)
+		return &memcg->deferred_split_queue;
+	else
+		return &pgdat->deferred_split_queue;
 }
 
 void prep_transhuge_page(struct page *page)
@@ -2658,7 +2663,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
 {
 	struct page *head = compound_head(page);
 	struct pglist_data *pgdata = NODE_DATA(page_to_nid(head));
-	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
+	struct deferred_split *ds_queue = get_deferred_split_queue(page);
 	struct anon_vma *anon_vma = NULL;
 	struct address_space *mapping = NULL;
 	int count, mapcount, extra_pins, ret;
@@ -2794,8 +2799,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
 
 void free_transhuge_page(struct page *page)
 {
-	struct pglist_data *pgdata = NODE_DATA(page_to_nid(page));
-	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
+	struct deferred_split *ds_queue = get_deferred_split_queue(page);
 	unsigned long flags;
 
 	spin_lock_irqsave(&ds_queue->split_queue_lock, flags);
@@ -2809,8 +2813,8 @@ void free_transhuge_page(struct page *page)
 
 void deferred_split_huge_page(struct page *page)
 {
-	struct pglist_data *pgdata = NODE_DATA(page_to_nid(page));
-	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
+	struct deferred_split *ds_queue = get_deferred_split_queue(page);
+	struct mem_cgroup *memcg = compound_head(page)->mem_cgroup;
 	unsigned long flags;
 
 	VM_BUG_ON_PAGE(!PageTransHuge(page), page);
@@ -2820,6 +2824,9 @@ void deferred_split_huge_page(struct page *page)
 		count_vm_event(THP_DEFERRED_SPLIT_PAGE);
 		list_add_tail(page_deferred_list(page), &ds_queue->split_queue);
 		ds_queue->split_queue_len++;
+		if (memcg)
+			memcg_set_shrinker_bit(memcg, page_to_nid(page),
+					       deferred_split_shrinker.id);
 	}
 	spin_unlock_irqrestore(&ds_queue->split_queue_lock, flags);
 }
@@ -2827,8 +2834,16 @@ void deferred_split_huge_page(struct page *page)
 static unsigned long deferred_split_count(struct shrinker *shrink,
 		struct shrink_control *sc)
 {
-	struct pglist_data *pgdata = NODE_DATA(sc->nid);
-	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
+	struct deferred_split *ds_queue;
+
+	if (!sc->memcg) {
+		struct pglist_data *pgdata = NODE_DATA(sc->nid);
+
+		ds_queue = &pgdata->deferred_split_queue;
+		return READ_ONCE(ds_queue->split_queue_len);
+	}
+
+	ds_queue = &sc->memcg->deferred_split_queue;
 	return READ_ONCE(ds_queue->split_queue_len);
 }
 
@@ -2836,12 +2851,17 @@ static unsigned long deferred_split_scan(struct shrinker *shrink,
 		struct shrink_control *sc)
 {
 	struct pglist_data *pgdata = NODE_DATA(sc->nid);
-	struct deferred_split *ds_queue = &pgdata->deferred_split_queue;
+	struct deferred_split *ds_queue;
 	unsigned long flags;
 	LIST_HEAD(list), *pos, *next;
 	struct page *page;
 	int split = 0;
 
+	if (sc->memcg)
+		ds_queue = &sc->memcg->deferred_split_queue;
+	else
+		ds_queue = &pgdata->deferred_split_queue;
+
 	spin_lock_irqsave(&ds_queue->split_queue_lock, flags);
 	/* Take pin on all head pages to avoid freeing them under us */
 	list_for_each_safe(pos, next, &ds_queue->split_queue) {
@@ -2888,7 +2908,8 @@ static unsigned long deferred_split_scan(struct shrinker *shrink,
 	.count_objects = deferred_split_count,
 	.scan_objects = deferred_split_scan,
 	.seeks = DEFAULT_SEEKS,
-	.flags = SHRINKER_NUMA_AWARE,
+	.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE |
+		 SHRINKER_NONSLAB,
 };
 
 #ifdef CONFIG_DEBUG_FS
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index e50a2db..16f9390 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -4579,6 +4579,11 @@ static struct mem_cgroup *mem_cgroup_alloc(void)
 #ifdef CONFIG_CGROUP_WRITEBACK
 	INIT_LIST_HEAD(&memcg->cgwb_list);
 #endif
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+	spin_lock_init(&memcg->deferred_split_queue.split_queue_lock);
+	INIT_LIST_HEAD(&memcg->deferred_split_queue.split_queue);
+	memcg->deferred_split_queue.split_queue_len = 0;
+#endif
 	idr_replace(&mem_cgroup_idr, memcg, memcg->id.id);
 	return memcg;
 fail:
@@ -4949,6 +4954,14 @@ static int mem_cgroup_move_account(struct page *page,
 		__mod_memcg_state(to, NR_WRITEBACK, nr_pages);
 	}
 
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+	if (compound && !list_empty(page_deferred_list(page))) {
+		spin_lock(&from->deferred_split_queue.split_queue_lock);
+		list_del(page_deferred_list(page));
+		from->deferred_split_queue.split_queue_len--;
+		spin_unlock(&from->deferred_split_queue.split_queue_lock);
+	}
+#endif
 	/*
 	 * It is safe to change page->mem_cgroup here because the page
 	 * is referenced, charged, and isolated - we can't race with
@@ -4957,6 +4970,17 @@ static int mem_cgroup_move_account(struct page *page,
 
 	/* caller should have done css_get */
 	page->mem_cgroup = to;
+
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+	if (compound && list_empty(page_deferred_list(page))) {
+		spin_lock(&to->deferred_split_queue.split_queue_lock);
+		list_add_tail(page_deferred_list(page),
+			      &to->deferred_split_queue.split_queue);
+		to->deferred_split_queue.split_queue_len++;
+		spin_unlock(&to->deferred_split_queue.split_queue_lock);
+	}
+#endif
+
 	spin_unlock_irqrestore(&from->move_lock, flags);
 
 	ret = 0;
-- 
1.8.3.1


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

* Re: [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release()
  2019-06-12 21:56 ` [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release() Yang Shi
@ 2019-06-13 11:39   ` Kirill A. Shutemov
  2019-06-13 17:13     ` Yang Shi
  0 siblings, 1 reply; 14+ messages in thread
From: Kirill A. Shutemov @ 2019-06-13 11:39 UTC (permalink / raw)
  To: Yang Shi
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, akpm, linux-mm, linux-kernel

On Thu, Jun 13, 2019 at 05:56:47AM +0800, Yang Shi wrote:
> The later patch would make THP deferred split shrinker memcg aware, but
> it needs page->mem_cgroup information in THP destructor, which is called
> after mem_cgroup_uncharge() now.
> 
> So, move mem_cgroup_uncharge() from __page_cache_release() to compound
> page destructor, which is called by both THP and other compound pages
> except HugeTLB.  And call it in __put_single_page() for single order
> page.


If I read the patch correctly, it will change behaviour for pages with
NULL_COMPOUND_DTOR. Have you considered it? Are you sure it will not break
anything?

-- 
 Kirill A. Shutemov

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

* Re: [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release()
  2019-06-13 11:39   ` Kirill A. Shutemov
@ 2019-06-13 17:13     ` Yang Shi
  2019-06-24 16:54       ` Yang Shi
  0 siblings, 1 reply; 14+ messages in thread
From: Yang Shi @ 2019-06-13 17:13 UTC (permalink / raw)
  To: Kirill A. Shutemov
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, akpm, linux-mm, linux-kernel



On 6/13/19 4:39 AM, Kirill A. Shutemov wrote:
> On Thu, Jun 13, 2019 at 05:56:47AM +0800, Yang Shi wrote:
>> The later patch would make THP deferred split shrinker memcg aware, but
>> it needs page->mem_cgroup information in THP destructor, which is called
>> after mem_cgroup_uncharge() now.
>>
>> So, move mem_cgroup_uncharge() from __page_cache_release() to compound
>> page destructor, which is called by both THP and other compound pages
>> except HugeTLB.  And call it in __put_single_page() for single order
>> page.
>
> If I read the patch correctly, it will change behaviour for pages with
> NULL_COMPOUND_DTOR. Have you considered it? Are you sure it will not break
> anything?

So far a quick search shows NULL_COMPOUND_DTOR is not used by any type 
of compound page. The HugeTLB code sets destructor to NULL_COMPOUND_DTOR 
when freeing hugetlb pages via hugetlb specific destructor.

The prep_new_page() would call prep_compound_page() if __GFP_COMP is 
used, which sets dtor to COMPOUND_PAGE_DTOR by default.  Just hugetlb 
and THP set their specific dtors.

And, it looks __put_compound_page() doesn't check if dtor is NULL or not 
at all.

>


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

* Re: [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release()
  2019-06-13 17:13     ` Yang Shi
@ 2019-06-24 16:54       ` Yang Shi
  2019-06-25  9:35         ` Kirill A. Shutemov
  0 siblings, 1 reply; 14+ messages in thread
From: Yang Shi @ 2019-06-24 16:54 UTC (permalink / raw)
  To: Kirill A. Shutemov
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, akpm, linux-mm, linux-kernel



On 6/13/19 10:13 AM, Yang Shi wrote:
>
>
> On 6/13/19 4:39 AM, Kirill A. Shutemov wrote:
>> On Thu, Jun 13, 2019 at 05:56:47AM +0800, Yang Shi wrote:
>>> The later patch would make THP deferred split shrinker memcg aware, but
>>> it needs page->mem_cgroup information in THP destructor, which is 
>>> called
>>> after mem_cgroup_uncharge() now.
>>>
>>> So, move mem_cgroup_uncharge() from __page_cache_release() to compound
>>> page destructor, which is called by both THP and other compound pages
>>> except HugeTLB.  And call it in __put_single_page() for single order
>>> page.
>>
>> If I read the patch correctly, it will change behaviour for pages with
>> NULL_COMPOUND_DTOR. Have you considered it? Are you sure it will not 
>> break
>> anything?
>

Hi Kirill,

Did this solve your concern? Any more comments on this series?

Thanks,
Yang

> So far a quick search shows NULL_COMPOUND_DTOR is not used by any type 
> of compound page. The HugeTLB code sets destructor to 
> NULL_COMPOUND_DTOR when freeing hugetlb pages via hugetlb specific 
> destructor.
>
> The prep_new_page() would call prep_compound_page() if __GFP_COMP is 
> used, which sets dtor to COMPOUND_PAGE_DTOR by default.  Just hugetlb 
> and THP set their specific dtors.
>
> And, it looks __put_compound_page() doesn't check if dtor is NULL or 
> not at all.
>
>>
>


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

* Re: [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release()
  2019-06-24 16:54       ` Yang Shi
@ 2019-06-25  9:35         ` Kirill A. Shutemov
  2019-06-25 15:49           ` Yang Shi
  0 siblings, 1 reply; 14+ messages in thread
From: Kirill A. Shutemov @ 2019-06-25  9:35 UTC (permalink / raw)
  To: Yang Shi
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, akpm, linux-mm, linux-kernel

On Mon, Jun 24, 2019 at 09:54:05AM -0700, Yang Shi wrote:
> 
> 
> On 6/13/19 10:13 AM, Yang Shi wrote:
> > 
> > 
> > On 6/13/19 4:39 AM, Kirill A. Shutemov wrote:
> > > On Thu, Jun 13, 2019 at 05:56:47AM +0800, Yang Shi wrote:
> > > > The later patch would make THP deferred split shrinker memcg aware, but
> > > > it needs page->mem_cgroup information in THP destructor, which
> > > > is called
> > > > after mem_cgroup_uncharge() now.
> > > > 
> > > > So, move mem_cgroup_uncharge() from __page_cache_release() to compound
> > > > page destructor, which is called by both THP and other compound pages
> > > > except HugeTLB.  And call it in __put_single_page() for single order
> > > > page.
> > > 
> > > If I read the patch correctly, it will change behaviour for pages with
> > > NULL_COMPOUND_DTOR. Have you considered it? Are you sure it will not
> > > break
> > > anything?
> > 
> 
> Hi Kirill,
> 
> Did this solve your concern? Any more comments on this series?

Everyting looks good now. You can use my

Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>

for the series.

-- 
 Kirill A. Shutemov

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

* Re: [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release()
  2019-06-25  9:35         ` Kirill A. Shutemov
@ 2019-06-25 15:49           ` Yang Shi
  0 siblings, 0 replies; 14+ messages in thread
From: Yang Shi @ 2019-06-25 15:49 UTC (permalink / raw)
  To: Kirill A. Shutemov
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, akpm, linux-mm, linux-kernel



On 6/25/19 2:35 AM, Kirill A. Shutemov wrote:
> On Mon, Jun 24, 2019 at 09:54:05AM -0700, Yang Shi wrote:
>>
>> On 6/13/19 10:13 AM, Yang Shi wrote:
>>>
>>> On 6/13/19 4:39 AM, Kirill A. Shutemov wrote:
>>>> On Thu, Jun 13, 2019 at 05:56:47AM +0800, Yang Shi wrote:
>>>>> The later patch would make THP deferred split shrinker memcg aware, but
>>>>> it needs page->mem_cgroup information in THP destructor, which
>>>>> is called
>>>>> after mem_cgroup_uncharge() now.
>>>>>
>>>>> So, move mem_cgroup_uncharge() from __page_cache_release() to compound
>>>>> page destructor, which is called by both THP and other compound pages
>>>>> except HugeTLB.  And call it in __put_single_page() for single order
>>>>> page.
>>>> If I read the patch correctly, it will change behaviour for pages with
>>>> NULL_COMPOUND_DTOR. Have you considered it? Are you sure it will not
>>>> break
>>>> anything?
>> Hi Kirill,
>>
>> Did this solve your concern? Any more comments on this series?
> Everyting looks good now. You can use my
>
> Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
>
> for the series.

Thanks!

>


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

* Re: [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware
  2019-06-12 21:56 ` [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware Yang Shi
@ 2019-06-25 22:00   ` Andrew Morton
  2019-06-25 22:33     ` Yang Shi
  0 siblings, 1 reply; 14+ messages in thread
From: Andrew Morton @ 2019-06-25 22:00 UTC (permalink / raw)
  To: Yang Shi
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, linux-mm, linux-kernel

On Thu, 13 Jun 2019 05:56:49 +0800 Yang Shi <yang.shi@linux.alibaba.com> wrote:

> Currently THP deferred split shrinker is not memcg aware, this may cause
> premature OOM with some configuration. For example the below test would
> run into premature OOM easily:
> 
> $ cgcreate -g memory:thp
> $ echo 4G > /sys/fs/cgroup/memory/thp/memory/limit_in_bytes
> $ cgexec -g memory:thp transhuge-stress 4000
> 
> transhuge-stress comes from kernel selftest.
> 
> It is easy to hit OOM, but there are still a lot THP on the deferred
> split queue, memcg direct reclaim can't touch them since the deferred
> split shrinker is not memcg aware.
> 
> Convert deferred split shrinker memcg aware by introducing per memcg
> deferred split queue.  The THP should be on either per node or per memcg
> deferred split queue if it belongs to a memcg.  When the page is
> immigrated to the other memcg, it will be immigrated to the target
> memcg's deferred split queue too.
> 
> Reuse the second tail page's deferred_list for per memcg list since the
> same THP can't be on multiple deferred split queues.
> 
> ...
>
> --- a/mm/memcontrol.c
> +++ b/mm/memcontrol.c
> @@ -4579,6 +4579,11 @@ static struct mem_cgroup *mem_cgroup_alloc(void)
>  #ifdef CONFIG_CGROUP_WRITEBACK
>  	INIT_LIST_HEAD(&memcg->cgwb_list);
>  #endif
> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE
> +	spin_lock_init(&memcg->deferred_split_queue.split_queue_lock);
> +	INIT_LIST_HEAD(&memcg->deferred_split_queue.split_queue);
> +	memcg->deferred_split_queue.split_queue_len = 0;
> +#endif
>  	idr_replace(&mem_cgroup_idr, memcg, memcg->id.id);
>  	return memcg;
>  fail:
> @@ -4949,6 +4954,14 @@ static int mem_cgroup_move_account(struct page *page,
>  		__mod_memcg_state(to, NR_WRITEBACK, nr_pages);
>  	}
>  
> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE
> +	if (compound && !list_empty(page_deferred_list(page))) {
> +		spin_lock(&from->deferred_split_queue.split_queue_lock);
> +		list_del(page_deferred_list(page));

It's worrisome that this page still appears to be on the deferred_list
and that the above if() would still succeed.  Should this be
list_del_init()?

> +		from->deferred_split_queue.split_queue_len--;
> +		spin_unlock(&from->deferred_split_queue.split_queue_lock);
> +	}
> +#endif


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

* Re: [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem
  2019-06-12 21:56 ` [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem Yang Shi
@ 2019-06-25 22:14   ` Andrew Morton
  2019-06-25 22:30     ` Yang Shi
  0 siblings, 1 reply; 14+ messages in thread
From: Andrew Morton @ 2019-06-25 22:14 UTC (permalink / raw)
  To: Yang Shi
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, linux-mm, linux-kernel

On Thu, 13 Jun 2019 05:56:48 +0800 Yang Shi <yang.shi@linux.alibaba.com> wrote:

> Currently shrinker is just allocated and can work when memcg kmem is
> enabled.  But, THP deferred split shrinker is not slab shrinker, it
> doesn't make too much sense to have such shrinker depend on memcg kmem.
> It should be able to reclaim THP even though memcg kmem is disabled.
> 
> Introduce a new shrinker flag, SHRINKER_NONSLAB, for non-slab shrinker.
> When memcg kmem is disabled, just such shrinkers can be called in
> shrinking memcg slab.

This causes a couple of compile errors with an allnoconfig build. 
Please fix that and test any other Kconfig combinations which might
trip things up.

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

* Re: [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem
  2019-06-25 22:14   ` Andrew Morton
@ 2019-06-25 22:30     ` Yang Shi
  0 siblings, 0 replies; 14+ messages in thread
From: Yang Shi @ 2019-06-25 22:30 UTC (permalink / raw)
  To: Andrew Morton
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, linux-mm, linux-kernel



On 6/25/19 3:14 PM, Andrew Morton wrote:
> On Thu, 13 Jun 2019 05:56:48 +0800 Yang Shi <yang.shi@linux.alibaba.com> wrote:
>
>> Currently shrinker is just allocated and can work when memcg kmem is
>> enabled.  But, THP deferred split shrinker is not slab shrinker, it
>> doesn't make too much sense to have such shrinker depend on memcg kmem.
>> It should be able to reclaim THP even though memcg kmem is disabled.
>>
>> Introduce a new shrinker flag, SHRINKER_NONSLAB, for non-slab shrinker.
>> When memcg kmem is disabled, just such shrinkers can be called in
>> shrinking memcg slab.
> This causes a couple of compile errors with an allnoconfig build.
> Please fix that and test any other Kconfig combinations which might
> trip things up.

I just tested !CONFIG_TRANSPARENT_HUGEPAGE, but I didn't test 
!CONFIG_MEMCG. It looks we need keep the code for !CONFIG_MEMCG, will 
post the corrected patches soon.



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

* Re: [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware
  2019-06-25 22:00   ` Andrew Morton
@ 2019-06-25 22:33     ` Yang Shi
  0 siblings, 0 replies; 14+ messages in thread
From: Yang Shi @ 2019-06-25 22:33 UTC (permalink / raw)
  To: Andrew Morton
  Cc: ktkhai, kirill.shutemov, hannes, mhocko, hughd, shakeelb,
	rientjes, linux-mm, linux-kernel



On 6/25/19 3:00 PM, Andrew Morton wrote:
> On Thu, 13 Jun 2019 05:56:49 +0800 Yang Shi <yang.shi@linux.alibaba.com> wrote:
>
>> Currently THP deferred split shrinker is not memcg aware, this may cause
>> premature OOM with some configuration. For example the below test would
>> run into premature OOM easily:
>>
>> $ cgcreate -g memory:thp
>> $ echo 4G > /sys/fs/cgroup/memory/thp/memory/limit_in_bytes
>> $ cgexec -g memory:thp transhuge-stress 4000
>>
>> transhuge-stress comes from kernel selftest.
>>
>> It is easy to hit OOM, but there are still a lot THP on the deferred
>> split queue, memcg direct reclaim can't touch them since the deferred
>> split shrinker is not memcg aware.
>>
>> Convert deferred split shrinker memcg aware by introducing per memcg
>> deferred split queue.  The THP should be on either per node or per memcg
>> deferred split queue if it belongs to a memcg.  When the page is
>> immigrated to the other memcg, it will be immigrated to the target
>> memcg's deferred split queue too.
>>
>> Reuse the second tail page's deferred_list for per memcg list since the
>> same THP can't be on multiple deferred split queues.
>>
>> ...
>>
>> --- a/mm/memcontrol.c
>> +++ b/mm/memcontrol.c
>> @@ -4579,6 +4579,11 @@ static struct mem_cgroup *mem_cgroup_alloc(void)
>>   #ifdef CONFIG_CGROUP_WRITEBACK
>>   	INIT_LIST_HEAD(&memcg->cgwb_list);
>>   #endif
>> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE
>> +	spin_lock_init(&memcg->deferred_split_queue.split_queue_lock);
>> +	INIT_LIST_HEAD(&memcg->deferred_split_queue.split_queue);
>> +	memcg->deferred_split_queue.split_queue_len = 0;
>> +#endif
>>   	idr_replace(&mem_cgroup_idr, memcg, memcg->id.id);
>>   	return memcg;
>>   fail:
>> @@ -4949,6 +4954,14 @@ static int mem_cgroup_move_account(struct page *page,
>>   		__mod_memcg_state(to, NR_WRITEBACK, nr_pages);
>>   	}
>>   
>> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE
>> +	if (compound && !list_empty(page_deferred_list(page))) {
>> +		spin_lock(&from->deferred_split_queue.split_queue_lock);
>> +		list_del(page_deferred_list(page));
> It's worrisome that this page still appears to be on the deferred_list
> and that the above if() would still succeed.  Should this be
> list_del_init()?

list_del_init() sounds safe although I'm not quite sure this is 
possible. Will update this with fixing build issue together.

>
>> +		from->deferred_split_queue.split_queue_len--;
>> +		spin_unlock(&from->deferred_split_queue.split_queue_lock);
>> +	}
>> +#endif


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

end of thread, other threads:[~2019-06-25 22:33 UTC | newest]

Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-06-12 21:56 [v3 PATCH 0/4] Make deferred split shrinker memcg aware Yang Shi
2019-06-12 21:56 ` [v3 PATCH 1/4] mm: thp: extract split_queue_* into a struct Yang Shi
2019-06-12 21:56 ` [v3 PATCH 2/4] mm: move mem_cgroup_uncharge out of __page_cache_release() Yang Shi
2019-06-13 11:39   ` Kirill A. Shutemov
2019-06-13 17:13     ` Yang Shi
2019-06-24 16:54       ` Yang Shi
2019-06-25  9:35         ` Kirill A. Shutemov
2019-06-25 15:49           ` Yang Shi
2019-06-12 21:56 ` [v3 PATCH 3/4] mm: shrinker: make shrinker not depend on memcg kmem Yang Shi
2019-06-25 22:14   ` Andrew Morton
2019-06-25 22:30     ` Yang Shi
2019-06-12 21:56 ` [v3 PATCH 4/4] mm: thp: make deferred split shrinker memcg aware Yang Shi
2019-06-25 22:00   ` Andrew Morton
2019-06-25 22:33     ` Yang Shi

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.