OrgACRN
/
acrn-kernel
mirror of https://github.com/projectacrn/acrn-kernel.git
1
0
Fork 0
Code Issues Releases Wiki Activity

zsmalloc: allow only one active pool compaction context 

commit d2658f2052 upstream.

zsmalloc pool can be compacted concurrently by many contexts,
e.g.

 cc1 handle_mm_fault()
      do_anonymous_page()
       __alloc_pages_slowpath()
        try_to_free_pages()
         do_try_to_free_pages(
          lru_gen_shrink_node()
           shrink_slab()
            do_shrink_slab()
             zs_shrinker_scan()
              zs_compact()

Pool compaction is currently (basically) single-threaded as
it is performed under pool->lock. Having multiple compaction
threads results in unnecessary contention, as each thread
competes for pool->lock. This, in turn, affects all zsmalloc
operations such as zs_malloc(), zs_map_object(), zs_free(), etc.

Introduce the pool->compaction_in_progress atomic variable,
which ensures that only one compaction context can run at a
time. This reduces overall pool->lock contention in (corner)
cases when many contexts attempt to shrink zspool simultaneously.

Link: https://lkml.kernel.org/r/20230418074639.1903197-1-senozhatsky@chromium.org
Fixes: c0547d0b6a ("zsmalloc: consolidate zs_pool's migrate_lock and size_class's locks")
Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org>
Reviewed-by: Yosry Ahmed <yosryahmed@google.com>
Cc: Minchan Kim <minchan@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Sergey Senozhatsky 2023-04-18 16:46:39 +09:00 committed by Greg Kroah-Hartman
parent d4008eadfc
commit 5274bf1f74
1 changed files with 12 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
mm/zsmalloc.c
View File

@ -246,6 +246,7 @@ struct zs_pool {
struct work_struct free_work; struct work_struct free_work;
#endif #endif
spinlock_t lock; spinlock_t lock;
atomic_t compaction_in_progress;
}; };
struct zspage { struct zspage {
@ -2100,6 +2101,15 @@ unsigned long zs_compact(struct zs_pool *pool)
struct size_class *class; struct size_class *class;
unsigned long pages_freed = 0; unsigned long pages_freed = 0;
/*
* Pool compaction is performed under pool->lock so it is basically
* single-threaded. Having more than one thread in __zs_compact()
* will increase pool->lock contention, which will impact other
* zsmalloc operations that need pool->lock.
*/
if (atomic_xchg(&pool->compaction_in_progress, 1))
return 0;
for (i = ZS_SIZE_CLASSES - 1; i >= 0; i--) { for (i = ZS_SIZE_CLASSES - 1; i >= 0; i--) {
class = pool->size_class[i]; class = pool->size_class[i];
if (class->index != i) if (class->index != i)
@ -2107,6 +2117,7 @@ unsigned long zs_compact(struct zs_pool *pool)
pages_freed += __zs_compact(pool, class); pages_freed += __zs_compact(pool, class);
} }
atomic_long_add(pages_freed, &pool->stats.pages_compacted); atomic_long_add(pages_freed, &pool->stats.pages_compacted);
atomic_set(&pool->compaction_in_progress, 0);
return pages_freed; return pages_freed;
} }
@ -2193,6 +2204,7 @@ struct zs_pool *zs_create_pool(const char *name)
init_deferred_free(pool); init_deferred_free(pool);
spin_lock_init(&pool->lock); spin_lock_init(&pool->lock);
atomic_set(&pool->compaction_in_progress, 0);
pool->name = kstrdup(name, GFP_KERNEL); pool->name = kstrdup(name, GFP_KERNEL);
if (!pool->name) if (!pool->name)