From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id EDF10C636D6 for ; Thu, 23 Feb 2023 18:39:22 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 75F4B6B0071; Thu, 23 Feb 2023 13:39:22 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 70EC96B0072; Thu, 23 Feb 2023 13:39:22 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 5FE056B0073; Thu, 23 Feb 2023 13:39:22 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id 512966B0071 for ; Thu, 23 Feb 2023 13:39:22 -0500 (EST) Received: from smtpin30.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id 0B7E3A07CC for ; Thu, 23 Feb 2023 18:39:22 +0000 (UTC) X-FDA: 80499419364.30.4E1FB75 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf03.hostedemail.com (Postfix) with ESMTP id 47DE220024 for ; Thu, 23 Feb 2023 18:39:19 +0000 (UTC) Authentication-Results: imf03.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="k1WbLL/t"; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf03.hostedemail.com: domain of "SRS0=fgMe=6T=paulmck-ThinkPad-P17-Gen-1.home=paulmck@kernel.org" designates 139.178.84.217 as permitted sender) smtp.mailfrom="SRS0=fgMe=6T=paulmck-ThinkPad-P17-Gen-1.home=paulmck@kernel.org" ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1677177559; h=from:from:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=JgzjHxO1ZWnkpR1MFJNyrZWb6UjjR8jFGGwGzVOtbeM=; b=0wWnbhEw04RvnIhYnV12vHqSkD7XcqPKzNrGeqjyx6dR7vMLYx+IWR7vbfiP8Q8GdYMDD4 frWu5vbxey37h86kLEO/9OmZ0fzNRCtGTQbLLyvnwANwLEiGi5+mUTfzPHZ/0lnpojwjU9 fCMQME9WXw8zDrrfUhbt678OtMat2BY= ARC-Authentication-Results: i=1; imf03.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="k1WbLL/t"; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf03.hostedemail.com: domain of "SRS0=fgMe=6T=paulmck-ThinkPad-P17-Gen-1.home=paulmck@kernel.org" designates 139.178.84.217 as permitted sender) smtp.mailfrom="SRS0=fgMe=6T=paulmck-ThinkPad-P17-Gen-1.home=paulmck@kernel.org" ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1677177559; a=rsa-sha256; cv=none; b=JqX8YTBxKBplKiGZ8XECW1j6MJ3ff+zfBHIdq0Cy2DFwpYkeDwe6XmWW8c7bFdmmMzPHxs Ce+8VCV0GIsGRhhww0xFGT3mO6s9oxarO/Tsq7BWHGL7ZdBC//Vgc46Rr66pcgFqSWoJm1 JhtmiX+a2moSvL00Pjxq/zC1Q3uZnzY= Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 11B056176F; Thu, 23 Feb 2023 18:39:20 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 78F1DC433EF; Thu, 23 Feb 2023 18:39:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1677177557; bh=doLTJ2ETftqjtUwc1scT/ezCCnw14uI7u07rZHPGFeQ=; h=Date:From:To:Cc:Subject:Reply-To:References:In-Reply-To:From; b=k1WbLL/tl+Mt/nlu1jRTmFPK14CnsP7F/kaUc6xNOdfLYYmwhR1q96IKVuD5oLykb mT9+cRp7/bmecTggw6y2l3UzjuxAbODXLxT1yAZzKReNwjwZoLcnCLkHHN7tZ5HLfN yCD5CzH8czKZwI1lbN9lmiHtBDaFsCB9/vLOGjBUB2YJm4DW6EldIubWK1wQjhZNgE sPFsS7Ncw6cI+2wfEY9DBqRytRl8qw5dfM1dP00+p5CTMNzeiQ9Sm60muag1XmNdox YgOqfln7mPmKZgIanFDfcZixg/mhHCYmtZWuYY5ftmSAoiVYsaryTZDvtxl9gatdvO mDElGARGHt2wQ== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 138E45C0DBB; Thu, 23 Feb 2023 10:39:17 -0800 (PST) Date: Thu, 23 Feb 2023 10:39:17 -0800 From: "Paul E. McKenney" To: Sultan Alsawaf Cc: Qi Zheng , akpm@linux-foundation.org, tkhai@ya.ru, hannes@cmpxchg.org, shakeelb@google.com, mhocko@kernel.org, roman.gushchin@linux.dev, muchun.song@linux.dev, david@redhat.com, shy828301@gmail.com, dave@stgolabs.net, penguin-kernel@i-love.sakura.ne.jp, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v2 2/7] mm: vmscan: make global slab shrink lockless Message-ID: <20230223183917.GG2948950@paulmck-ThinkPad-P17-Gen-1> Reply-To: paulmck@kernel.org References: <20230223132725.11685-1-zhengqi.arch@bytedance.com> <20230223132725.11685-3-zhengqi.arch@bytedance.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: X-Rspamd-Queue-Id: 47DE220024 X-Rspamd-Server: rspam09 X-Rspam-User: X-Stat-Signature: 91d71adp6kgdu7u5id8qn3n9qqqn556w X-HE-Tag: 1677177559-143841 X-HE-Meta: U2FsdGVkX184KbOGMKplb6YURcyKE0LXmk0dzmiDfAlDPOzaJNfQomUPWZeMzxJL9p6VtAzUgeUlN/swrfhRGn7dI2DmaCT/z5i2DV/eyTaKc1+tTW+/17cI1C6QxZ71nBQha2YQoiwsJnOTHb+4g0J8Nd71Deq1OtC0aUUA9zt/XNNtOzuqXLIc5RNuwUJT/bChz/O4G4UxxdhR7Q6jXyEweUdJIANtHJRqfHp1mZc2xsoGPxJsWmy/LsOBFNBQvUKlfaYVPkTIamXXyJYy+l+2r7rywZMh5PARK7DcrjlPHmAVj+CbkTxZNl+LdJQBPOmABg0eAgtsNfvaiuy32XgF1iRh2/yLjOinPd8gK0wtQd1EhwUFd/1IxNikl242mnzpycG1pfQbcAhttwIO9J5Vn/vy3B36o2AvVuPeRBBXS/PcnTnOUW7HCqOMVsS6QBxJbM3j+IgfnqSezGj7se5h/fG5b1wg0lOkCxRU4zQIuPzoDW6l2JnQIoaS/9RAZFbJ0DXM5tPrZhvnlHNrNfv9YbOyRrg8vf+s3idAOBz6IPrFloilGLs33jQBRw3N3CylaIBlGBTTQcI48apGdWlM8y6OWcVemgHSQI6LUXq3poKfJpoG1WZCENxHGVqxNlu5mVuXUCgLli/Wuwz6xg84L7HO6/Kf2uQb4CIo1CsgvTKHw1AZGWxUWVUqxtYQre9xsorWwpOu9KGGHenpEfWzRHN/qZSlZSSKEek1ktaupTbIIX6+4dPHO9vCmMQF7gJUbfi6GlZWGFcpC6LS8xmkoRGsbSL+aJw4GdYw0/FdPNU4pyXNVclj0tnDKteL33hpkftl3aVzsO0hqNVP4IHnczZ6YiNLXvkGFMEuXpgZNztcu9bx3tuXoeCkDhR50S5gPs3M/FiwNtX22Ilx4lg8tVXMlgjP2yk+1zhi6FvhNmBQiSvzlilNGLTo61/68w6AxSRXPV25DzBSb8C P9aE6fb5 ZoBsvHZi5A+OJkg5anZ4DidMAsOiSkhsiAzzyae/jHGUmgvasEsELOVhyAiVI8zQimTn4Y4k3079lFSOBn5Y51scXNnw5LoBbazU6ZyzqT7q0BQLuWmFjAJAsUjEFvhn0vYs9CcT/cucuGWUSW6WTmM1KBLW1jHlZ9S8CIDU0uc3fTg68NQyT1QOjnXNa/c4dAjpdhJDviW53fey7uLq5vbTKNF94sJu8FvSUoslHuvMloSb9J8JHO48xD6xNB2GDO1MJnC5F4Bpgk90qo/KvDs533E43Zo5MP473rwhQLz4ERuYdkfb0ACDrUDroKAP6HyGSIGQwuXwtnHYAmchF5jCRNopcfJoNePN9Y4I9ozq1Ej5mvKXpLGQVi1lHwF7CqwmSifjjqTp+rue6oV16QxIWc06ddBh5jFfvbrsxJan22fyaiIn8gwxKdl50ex0VzlBUVetpIpWLrQDr2pjlR30Rjai1pYfyKv32Yif482cfXEO1Bp6xboIywTuL2tsBhNZA0krO7jLbgpLv494GqvQTPTHgFnxtgzHRCjm7+s1duR5PIQD1ULpiaNs5aqIwy2BZLB6s/0KZO+QSOJWhD020unXFKFo6f0dbO7KspsEfrN914KWLCm/b/YAXoJ5yW0yXgq9fgi/w+4OcP+C5rkAFbiGvMPdGZ0L/RZTrLKPa2oBj64Bayc27a55sCJUtpzgFQMscbm71A6A7IUN5q3NgqkeDbPy8tQrj4mwzaFW391I6jfsxv3s0sTvdbV0xkXZt9gVouGim9iC2I0OpJ7IMlEMnvhiMu9OYCut4VM+O9yUmCxNBUHdg1s7p0frQcppueOayVVuBVQoT0EucTcuY0RKy921ZbO2/+VZpjAAN5MYoGi0n2ljcqK7BzhPh+4GWiM4lM7Ld1MVse/+umOape9KvzF7DP/AlUI+420HGG26I2slJMNx0uollIEtIYhL/GXPZvd4mCPt1z4UMVCNuG/35 jh+ymylv sJPuvqDXGfvq/6LFYsKi4k2qHLuxuA1o X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: On Thu, Feb 23, 2023 at 10:24:47AM -0800, Sultan Alsawaf wrote: > On Thu, Feb 23, 2023 at 09:27:20PM +0800, Qi Zheng wrote: > > The shrinker_rwsem is a global lock in shrinkers subsystem, > > it is easy to cause blocking in the following cases: > > > > a. the write lock of shrinker_rwsem was held for too long. > > For example, there are many memcgs in the system, which > > causes some paths to hold locks and traverse it for too > > long. (e.g. expand_shrinker_info()) > > b. the read lock of shrinker_rwsem was held for too long, > > and a writer came at this time. Then this writer will be > > forced to wait and block all subsequent readers. > > For example: > > - be scheduled when the read lock of shrinker_rwsem is > > held in do_shrink_slab() > > - some shrinker are blocked for too long. Like the case > > mentioned in the patchset[1]. > > > > Therefore, many times in history ([2],[3],[4],[5]), some > > people wanted to replace shrinker_rwsem reader with SRCU, > > but they all gave up because SRCU was not unconditionally > > enabled. > > > > But now, since commit 1cd0bd06093c ("rcu: Remove CONFIG_SRCU"), > > the SRCU is unconditionally enabled. So it's time to use > > SRCU to protect readers who previously held shrinker_rwsem. > > > > [1]. https://lore.kernel.org/lkml/20191129214541.3110-1-ptikhomirov@virtuozzo.com/ > > [2]. https://lore.kernel.org/all/1437080113.3596.2.camel@stgolabs.net/ > > [3]. https://lore.kernel.org/lkml/1510609063-3327-1-git-send-email-penguin-kernel@I-love.SAKURA.ne.jp/ > > [4]. https://lore.kernel.org/lkml/153365347929.19074.12509495712735843805.stgit@localhost.localdomain/ > > [5]. https://lore.kernel.org/lkml/20210927074823.5825-1-sultan@kerneltoast.com/ > > > > Signed-off-by: Qi Zheng > > --- > > mm/vmscan.c | 27 +++++++++++---------------- > > 1 file changed, 11 insertions(+), 16 deletions(-) > > > > diff --git a/mm/vmscan.c b/mm/vmscan.c > > index 9f895ca6216c..02987a6f95d1 100644 > > --- a/mm/vmscan.c > > +++ b/mm/vmscan.c > > @@ -202,6 +202,7 @@ static void set_task_reclaim_state(struct task_struct *task, > > > > LIST_HEAD(shrinker_list); > > DECLARE_RWSEM(shrinker_rwsem); > > +DEFINE_SRCU(shrinker_srcu); > > > > #ifdef CONFIG_MEMCG > > static int shrinker_nr_max; > > @@ -706,7 +707,7 @@ void free_prealloced_shrinker(struct shrinker *shrinker) > > void register_shrinker_prepared(struct shrinker *shrinker) > > { > > down_write(&shrinker_rwsem); > > - list_add_tail(&shrinker->list, &shrinker_list); > > + list_add_tail_rcu(&shrinker->list, &shrinker_list); > > shrinker->flags |= SHRINKER_REGISTERED; > > shrinker_debugfs_add(shrinker); > > up_write(&shrinker_rwsem); > > @@ -760,13 +761,15 @@ void unregister_shrinker(struct shrinker *shrinker) > > return; > > > > down_write(&shrinker_rwsem); > > - list_del(&shrinker->list); > > + list_del_rcu(&shrinker->list); > > shrinker->flags &= ~SHRINKER_REGISTERED; > > if (shrinker->flags & SHRINKER_MEMCG_AWARE) > > unregister_memcg_shrinker(shrinker); > > debugfs_entry = shrinker_debugfs_remove(shrinker); > > up_write(&shrinker_rwsem); > > > > + synchronize_srcu(&shrinker_srcu); > > + > > debugfs_remove_recursive(debugfs_entry); > > > > kfree(shrinker->nr_deferred); > > @@ -786,6 +789,7 @@ void synchronize_shrinkers(void) > > { > > down_write(&shrinker_rwsem); > > up_write(&shrinker_rwsem); > > + synchronize_srcu(&shrinker_srcu); > > } > > EXPORT_SYMBOL(synchronize_shrinkers); > > > > @@ -996,6 +1000,7 @@ static unsigned long shrink_slab(gfp_t gfp_mask, int nid, > > { > > unsigned long ret, freed = 0; > > struct shrinker *shrinker; > > + int srcu_idx; > > > > /* > > * The root memcg might be allocated even though memcg is disabled > > @@ -1007,10 +1012,10 @@ static unsigned long shrink_slab(gfp_t gfp_mask, int nid, > > if (!mem_cgroup_disabled() && !mem_cgroup_is_root(memcg)) > > return shrink_slab_memcg(gfp_mask, nid, memcg, priority); > > > > - if (!down_read_trylock(&shrinker_rwsem)) > > - goto out; > > + srcu_idx = srcu_read_lock(&shrinker_srcu); > > > > - list_for_each_entry(shrinker, &shrinker_list, list) { > > + list_for_each_entry_srcu(shrinker, &shrinker_list, list, > > + srcu_read_lock_held(&shrinker_srcu)) { > > struct shrink_control sc = { > > .gfp_mask = gfp_mask, > > .nid = nid, > > @@ -1021,19 +1026,9 @@ static unsigned long shrink_slab(gfp_t gfp_mask, int nid, > > if (ret == SHRINK_EMPTY) > > ret = 0; > > freed += ret; > > - /* > > - * Bail out if someone want to register a new shrinker to > > - * prevent the registration from being stalled for long periods > > - * by parallel ongoing shrinking. > > - */ > > - if (rwsem_is_contended(&shrinker_rwsem)) { > > - freed = freed ? : 1; > > - break; > > - } > > } > > > > - up_read(&shrinker_rwsem); > > -out: > > + srcu_read_unlock(&shrinker_srcu, srcu_idx); > > cond_resched(); > > return freed; > > } > > -- > > 2.20.1 > > > > > > Hi Qi, > > A different problem I realized after my old attempt to use SRCU was that the > unregister_shrinker() path became quite slow due to the heavy synchronize_srcu() > call. Both register_shrinker() *and* unregister_shrinker() are called frequently > these days, and SRCU is too unfair to the unregister path IMO. > > Although I never got around to submitting it, I made a non-SRCU solution [1] > that uses fine-grained locking instead, which is fair to both the register path > and unregister path. (The patch I've linked is a version of this adapted to an > older 4.14 kernel FYI, but it can be reworked for the current kernel.) > > What do you think about the fine-grained locking approach? Another approach is to use synchronize_srcu_expedited(), which avoids the sleeps that are otherwise used to encourage sharing of grace periods among concurrent requests. It might be possible to use call_srcu(), but I don't claim to know the shrinker code well enough to say for sure. Thanx, Paul > Thanks, > Sultan > > [1] https://github.com/kerneltoast/android_kernel_google_floral/commit/012378f3173a82d2333d3ae7326691544301e76a