Received: by 2002:a05:6a10:8c0a:0:0:0:0 with SMTP id go10csp6095431pxb; Tue, 16 Feb 2021 16:21:26 -0800 (PST) X-Google-Smtp-Source: ABdhPJys5AMxOfEMDp9sPBMRUxPLFxVnrq20bTi7GjV2Ny8tpZDXOC0PLoLqXzCW5NVs8rAPYGz/ X-Received: by 2002:aa7:dc0d:: with SMTP id b13mr24031620edu.170.1613521286571; Tue, 16 Feb 2021 16:21:26 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1613521286; cv=none; d=google.com; s=arc-20160816; b=DKhfbhmQsrBVzvJDcFkNEFtx8aiNK38OoGl5t5+yM5aIEnHneIo0A6Lha0y1YZEVLY fBQQy0HvVv4myhegIzJuMyQPZVvqxqW3a12g5Fffgg9qOB6T2jFfkMb2Zwa8BxhuSNDG zLvYtn2FCCB8V/dumY2gUWFh8NH8jz8R3zt5p/6xsuamzh5iQWjcOW+a4A/pwF4whdww J0upgbUnWmEKwENFicsIuAXhIJHnw2pJiQvYoKnnpjwsteEoslEJ9cOHN3MdvP3VRrHp pw8jpttkkKMbGdrJS6Q0xsM8TKKppGnZ4pBbzgzlIZDd8/7DZ/d74TF+NOG5ohSQQE+Y LAwg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=BeUPvhEAKyX9E/ec80pKz9hYSPF2D+uBDSObIq3Mzk0=; b=XPbU+bez9MKPvhplXr6k/GbsZg/EO3i0Wc6KMX0eXXMLpibgOSZDIw9NMwf3xjTY04 aybwIAVYFwGxgvKNBKD+LeeTJqUm8s2Y/UxI9ffmCJRGARP8Wm2IWAQ37MwyItrIeoer UUvuTZKdnvWQlxF3CW5mZKIJG8Vm3dCMM7EFWJFwdCzG8wLqwZ2sauPHo8G56HFgOmDz UdOFb22K57VnD0azMTATyfuvOQkx3VB9YM6jBqeUwEeNQxdi0DxSJI/VlIO6AL7eFw5C SyYGI4iY6dFJXvwaP6pRx7QhlZ3z3Wibq2vrOuhQB3IJcF21dhTRf9BTUaSRUqT3z3nt w3wg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=l5jGtCzn; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id h24si418357ejt.89.2021.02.16.16.21.03; Tue, 16 Feb 2021 16:21:26 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=l5jGtCzn; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231444AbhBQARU (ORCPT + 99 others); Tue, 16 Feb 2021 19:17:20 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35840 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231387AbhBQAOz (ORCPT ); Tue, 16 Feb 2021 19:14:55 -0500 Received: from mail-pl1-x629.google.com (mail-pl1-x629.google.com [IPv6:2607:f8b0:4864:20::629]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6AA89C061794; Tue, 16 Feb 2021 16:13:49 -0800 (PST) Received: by mail-pl1-x629.google.com with SMTP id b8so6405128plh.12; Tue, 16 Feb 2021 16:13:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=BeUPvhEAKyX9E/ec80pKz9hYSPF2D+uBDSObIq3Mzk0=; b=l5jGtCznVK0NVwkC43TLcjy6EyPzdWSDomF/6MCFY8gOAwNC3+VwMtOM94S+yqhKbt UPbavFhbVYtbOOEMITEO4aYXRfIC9FAqrj3xFADx5Dy6K+xpNPcROM6grZ9sx9+3/I2v BrIhDi9BAlb8c//c+0R6c/mVlKu45hhx1eqkOkom91W0TDCBvrJV8jdiI8vkXsVtr7uR 8QuL319HGFDPYH0JGzGgodQgk4+Z2ww8t+5katwqDidIc7PrJUGCF1Gl/vMTpknE+wh6 2mDy2SGwTxLI2Qtnxuv5OVoEVNmD2ETZjpBe01AiCiZrg0a49co8chiz941kd/8SLGhR NqPg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=BeUPvhEAKyX9E/ec80pKz9hYSPF2D+uBDSObIq3Mzk0=; b=SPEOPAqBSHTisSwtWn1TgdcuOpdQK4gPVubnBhf+X42GjDoNUKVTAUihCZBoIXKUEc Ay4ZQgpVnfsiGNCC2yC2GNUDI6M9CRJuqszWSJwL0t053/KmpPDUn20AP4j9sApzr+m+ Y98JFcjVpTUTfrXH6PMuHY0laF4baZ1KAO9QkoIyw2tgpH4hWcr8yWeJwWw3V30iYqC1 xarQVFJ1Abhpn3VpFKVM26eLCxKHxTriM1g+tuh/S7D8nmPVcP1OroYoj2+4RPZ329Ek L4bU0LhezitS3HqBs8mKNZZBIVMMLBzNSi707ryxq0/fldvfN+SXSVXPlFzcn5Vtxvre +fog== X-Gm-Message-State: AOAM532jEhaXUb61xs1TvNfmfzhhS0fuQeH8Aag+dnHku6hJ4rvA/ir5 QipKHNp2dQdKDB4Ph+NAVHE= X-Received: by 2002:a17:90a:4f83:: with SMTP id q3mr6548785pjh.38.1613520828992; Tue, 16 Feb 2021 16:13:48 -0800 (PST) Received: from localhost.localdomain (c-73-93-239-127.hsd1.ca.comcast.net. [73.93.239.127]) by smtp.gmail.com with ESMTPSA id y12sm99220pjc.56.2021.02.16.16.13.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 16 Feb 2021 16:13:48 -0800 (PST) From: Yang Shi To: guro@fb.com, ktkhai@virtuozzo.com, vbabka@suse.cz, shakeelb@google.com, david@fromorbit.com, hannes@cmpxchg.org, mhocko@suse.com, akpm@linux-foundation.org Cc: shy828301@gmail.com, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [v8 PATCH 09/13] mm: vmscan: add per memcg shrinker nr_deferred Date: Tue, 16 Feb 2021 16:13:18 -0800 Message-Id: <20210217001322.2226796-10-shy828301@gmail.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20210217001322.2226796-1-shy828301@gmail.com> References: <20210217001322.2226796-1-shy828301@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Currently the number of deferred objects are per shrinker, but some slabs, for example, vfs inode/dentry cache are per memcg, this would result in poor isolation among memcgs. The deferred objects typically are generated by __GFP_NOFS allocations, one memcg with excessive __GFP_NOFS allocations may blow up deferred objects, then other innocent memcgs may suffer from over shrink, excessive reclaim latency, etc. For example, two workloads run in memcgA and memcgB respectively, workload in B is vfs heavy workload. Workload in A generates excessive deferred objects, then B's vfs cache might be hit heavily (drop half of caches) by B's limit reclaim or global reclaim. We observed this hit in our production environment which was running vfs heavy workload shown as the below tracing log: <...>-409454 [016] .... 28286961.747146: mm_shrink_slab_start: super_cache_scan+0x0/0x1a0 ffff9a83046f3458: nid: 1 objects to shrink 3641681686040 gfp_flags GFP_HIGHUSER_MOVABLE|__GFP_ZERO pgs_scanned 1 lru_pgs 15721 cache items 246404277 delta 31345 total_scan 123202138 <...>-409454 [022] .... 28287105.928018: mm_shrink_slab_end: super_cache_scan+0x0/0x1a0 ffff9a83046f3458: nid: 1 unused scan count 3641681686040 new scan count 3641798379189 total_scan 602 last shrinker return val 123186855 The vfs cache and page cache ratio was 10:1 on this machine, and half of caches were dropped. This also resulted in significant amount of page caches were dropped due to inodes eviction. Make nr_deferred per memcg for memcg aware shrinkers would solve the unfairness and bring better isolation. When memcg is not enabled (!CONFIG_MEMCG or memcg disabled), the shrinker's nr_deferred would be used. And non memcg aware shrinkers use shrinker's nr_deferred all the time. Signed-off-by: Yang Shi --- include/linux/memcontrol.h | 7 +++-- mm/vmscan.c | 60 ++++++++++++++++++++++++++------------ 2 files changed, 46 insertions(+), 21 deletions(-) diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index 4c9253896e25..c457fc7bc631 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -93,12 +93,13 @@ struct lruvec_stat { }; /* - * Bitmap of shrinker::id corresponding to memcg-aware shrinkers, - * which have elements charged to this memcg. + * Bitmap and deferred work of shrinker::id corresponding to memcg-aware + * shrinkers, which have elements charged to this memcg. */ struct shrinker_info { struct rcu_head rcu; - unsigned long map[]; + atomic_long_t *nr_deferred; + unsigned long *map; }; /* diff --git a/mm/vmscan.c b/mm/vmscan.c index a1047ea60ecf..fcb399e18fc3 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -187,11 +187,17 @@ static DECLARE_RWSEM(shrinker_rwsem); #ifdef CONFIG_MEMCG static int shrinker_nr_max; +/* The shrinker_info is expanded in a batch of BITS_PER_LONG */ static inline int shrinker_map_size(int nr_items) { return (DIV_ROUND_UP(nr_items, BITS_PER_LONG) * sizeof(unsigned long)); } +static inline int shrinker_defer_size(int nr_items) +{ + return (round_up(nr_items, BITS_PER_LONG) * sizeof(atomic_long_t)); +} + static struct shrinker_info *shrinker_info_protected(struct mem_cgroup *memcg, int nid) { @@ -200,10 +206,12 @@ static struct shrinker_info *shrinker_info_protected(struct mem_cgroup *memcg, } static int expand_one_shrinker_info(struct mem_cgroup *memcg, - int size, int old_size) + int map_size, int defer_size, + int old_map_size, int old_defer_size) { struct shrinker_info *new, *old; int nid; + int size = map_size + defer_size; for_each_node(nid) { old = shrinker_info_protected(memcg, nid); @@ -215,9 +223,16 @@ static int expand_one_shrinker_info(struct mem_cgroup *memcg, if (!new) return -ENOMEM; - /* Set all old bits, clear all new bits */ - memset(new->map, (int)0xff, old_size); - memset((void *)new->map + old_size, 0, size - old_size); + new->nr_deferred = (atomic_long_t *)(new + 1); + new->map = (void *)new->nr_deferred + defer_size; + + /* map: set all old bits, clear all new bits */ + memset(new->map, (int)0xff, old_map_size); + memset((void *)new->map + old_map_size, 0, map_size - old_map_size); + /* nr_deferred: copy old values, clear all new values */ + memcpy(new->nr_deferred, old->nr_deferred, old_defer_size); + memset((void *)new->nr_deferred + old_defer_size, 0, + defer_size - old_defer_size); rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_info, new); kvfree_rcu(old); @@ -232,9 +247,6 @@ void free_shrinker_info(struct mem_cgroup *memcg) struct shrinker_info *info; int nid; - if (mem_cgroup_is_root(memcg)) - return; - for_each_node(nid) { pn = mem_cgroup_nodeinfo(memcg, nid); info = shrinker_info_protected(memcg, nid); @@ -247,12 +259,12 @@ int alloc_shrinker_info(struct mem_cgroup *memcg) { struct shrinker_info *info; int nid, size, ret = 0; - - if (mem_cgroup_is_root(memcg)) - return 0; + int map_size, defer_size = 0; down_write(&shrinker_rwsem); - size = shrinker_map_size(shrinker_nr_max); + map_size = shrinker_map_size(shrinker_nr_max); + defer_size = shrinker_defer_size(shrinker_nr_max); + size = map_size + defer_size; for_each_node(nid) { info = kvzalloc_node(sizeof(*info) + size, GFP_KERNEL, nid); if (!info) { @@ -260,6 +272,8 @@ int alloc_shrinker_info(struct mem_cgroup *memcg) ret = -ENOMEM; break; } + info->nr_deferred = (atomic_long_t *)(info + 1); + info->map = (void *)info->nr_deferred + defer_size; rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_info, info); } up_write(&shrinker_rwsem); @@ -267,15 +281,21 @@ int alloc_shrinker_info(struct mem_cgroup *memcg) return ret; } +static inline bool need_expand(int nr_max) +{ + return round_up(nr_max, BITS_PER_LONG) > + round_up(shrinker_nr_max, BITS_PER_LONG); +} + static int expand_shrinker_info(int new_id) { - int size, old_size, ret = 0; + int ret = 0; int new_nr_max = new_id + 1; + int map_size, defer_size = 0; + int old_map_size, old_defer_size = 0; struct mem_cgroup *memcg; - size = shrinker_map_size(new_nr_max); - old_size = shrinker_map_size(shrinker_nr_max); - if (size <= old_size) + if (!need_expand(new_nr_max)) goto out; if (!root_mem_cgroup) @@ -283,11 +303,15 @@ static int expand_shrinker_info(int new_id) lockdep_assert_held(&shrinker_rwsem); + map_size = shrinker_map_size(new_nr_max); + defer_size = shrinker_defer_size(new_nr_max); + old_map_size = shrinker_map_size(shrinker_nr_max); + old_defer_size = shrinker_defer_size(shrinker_nr_max); + memcg = mem_cgroup_iter(NULL, NULL, NULL); do { - if (mem_cgroup_is_root(memcg)) - continue; - ret = expand_one_shrinker_info(memcg, size, old_size); + ret = expand_one_shrinker_info(memcg, map_size, defer_size, + old_map_size, old_defer_size); if (ret) { mem_cgroup_iter_break(NULL, memcg); goto out; -- 2.26.2