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 X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9A28FFA372B for ; Wed, 9 Oct 2019 03:21:49 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 5C265218DE for ; Wed, 9 Oct 2019 03:21:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5C265218DE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=fromorbit.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 53C528E000F; Tue, 8 Oct 2019 23:21:33 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 4DAA78E000D; Tue, 8 Oct 2019 23:21:33 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 244318E000F; Tue, 8 Oct 2019 23:21:33 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0040.hostedemail.com [216.40.44.40]) by kanga.kvack.org (Postfix) with ESMTP id D56308E000D for ; Tue, 8 Oct 2019 23:21:32 -0400 (EDT) Received: from smtpin12.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay01.hostedemail.com (Postfix) with SMTP id 7A8BF180AD803 for ; Wed, 9 Oct 2019 03:21:32 +0000 (UTC) X-FDA: 76022796024.12.top44_2a77a5e3e2a58 X-HE-Tag: top44_2a77a5e3e2a58 X-Filterd-Recvd-Size: 7381 Received: from mail104.syd.optusnet.com.au (mail104.syd.optusnet.com.au [211.29.132.246]) by imf39.hostedemail.com (Postfix) with ESMTP for ; Wed, 9 Oct 2019 03:21:31 +0000 (UTC) Received: from dread.disaster.area (pa49-181-226-196.pa.nsw.optusnet.com.au [49.181.226.196]) by mail104.syd.optusnet.com.au (Postfix) with ESMTPS id 564DF43ECAB; Wed, 9 Oct 2019 14:21:27 +1100 (AEDT) Received: from discord.disaster.area ([192.168.253.110]) by dread.disaster.area with esmtp (Exim 4.92.2) (envelope-from ) id 1iI2XW-0006BU-VF; Wed, 09 Oct 2019 14:21:26 +1100 Received: from dave by discord.disaster.area with local (Exim 4.92) (envelope-from ) id 1iI2XW-00039N-TH; Wed, 09 Oct 2019 14:21:26 +1100 From: Dave Chinner To: linux-xfs@vger.kernel.org Cc: linux-mm@kvack.org, linux-fsdevel@vger.kernel.org Subject: [PATCH 10/26] mm: factor shrinker work calculations Date: Wed, 9 Oct 2019 14:21:08 +1100 Message-Id: <20191009032124.10541-11-david@fromorbit.com> X-Mailer: git-send-email 2.23.0.rc1 In-Reply-To: <20191009032124.10541-1-david@fromorbit.com> References: <20191009032124.10541-1-david@fromorbit.com> MIME-Version: 1.0 X-Optus-CM-Score: 0 X-Optus-CM-Analysis: v=2.2 cv=FNpr/6gs c=1 sm=1 tr=0 a=dRuLqZ1tmBNts2YiI0zFQg==:117 a=dRuLqZ1tmBNts2YiI0zFQg==:17 a=jpOVt7BSZ2e4Z31A5e1TngXxSK0=:19 a=XobE76Q3jBoA:10 a=20KFwNOVAAAA:8 a=rQ5XUWRrd7byYprixfUA:9 a=FbgdKT8UfCh_ZLh5:21 a=DSgJKIrDGFEhNJPj:21 Content-Transfer-Encoding: quoted-printable 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: From: Dave Chinner Start to clean up the shrinker code by factoring out the calculation that determines how much work to do. This separates the calculation from clamping and other adjustments that are done before the shrinker work is run. Document the scan batch size calculation better while we are there. Also convert the calculation for the amount of work to be done to use 64 bit logic so we don't have to keep jumping through hoops to keep calculations within 32 bits on 32 bit systems. Signed-off-by: Dave Chinner --- mm/vmscan.c | 97 ++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 70 insertions(+), 27 deletions(-) diff --git a/mm/vmscan.c b/mm/vmscan.c index 1445bc7578c0..de6b09ad97ed 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -458,13 +458,68 @@ EXPORT_SYMBOL(unregister_shrinker); =20 #define SHRINK_BATCH 128 =20 +/* + * Calculate the number of new objects to scan this time around. Return + * the work to be done. If there are freeable objects, return that numbe= r in + * @freeable_objects. + */ +static int64_t shrink_scan_count(struct shrink_control *shrinkctl, + struct shrinker *shrinker, int priority, + int64_t *freeable_objects) +{ + int64_t delta; + int64_t freeable; + + freeable =3D shrinker->count_objects(shrinker, shrinkctl); + if (freeable =3D=3D 0 || freeable =3D=3D SHRINK_EMPTY) + return freeable; + + if (shrinker->seeks) { + /* + * shrinker->seeks is a measure of how much IO is required to + * reinstantiate the object in memory. The default value is 2 + * which is typical for a cold inode requiring a directory read + * and an inode read to re-instantiate. + * + * The scan batch size is defined by the shrinker priority, but + * to be able to bias the reclaim we increase the default batch + * size by 4. Hence we end up with a scan batch multipler that + * scales like so: + * + * ->seeks scan batch multiplier + * 1 4.00x + * 2 2.00x + * 3 1.33x + * 4 1.00x + * 8 0.50x + * + * IOWs, the more seeks it takes to pull the item into cache, + * the smaller the reclaim scan batch. Hence we put more reclaim + * pressure on caches that are fast to repopulate and to keep a + * rough balance between caches that have different costs. + */ + delta =3D freeable >> (priority - 2); + do_div(delta, shrinker->seeks); + } else { + /* + * These objects don't require any IO to create. Trim them + * aggressively under memory pressure to keep them from causing + * refetches in the IO caches. + */ + delta =3D freeable / 2; + } + + *freeable_objects =3D freeable; + return delta > 0 ? delta : 0; +} + static unsigned long do_shrink_slab(struct shrink_control *shrinkctl, struct shrinker *shrinker, int priority) { unsigned long freed =3D 0; - unsigned long long delta; long total_scan; - long freeable; + int64_t freeable_objects =3D 0; + int64_t scan_count; long nr; long new_nr; int nid =3D shrinkctl->nid; @@ -475,9 +530,10 @@ static unsigned long do_shrink_slab(struct shrink_co= ntrol *shrinkctl, if (!(shrinker->flags & SHRINKER_NUMA_AWARE)) nid =3D 0; =20 - freeable =3D shrinker->count_objects(shrinker, shrinkctl); - if (freeable =3D=3D 0 || freeable =3D=3D SHRINK_EMPTY) - return freeable; + scan_count =3D shrink_scan_count(shrinkctl, shrinker, priority, + &freeable_objects); + if (scan_count =3D=3D 0 || scan_count =3D=3D SHRINK_EMPTY) + return scan_count; =20 /* * copy the current shrinker scan count into a local variable @@ -486,25 +542,11 @@ static unsigned long do_shrink_slab(struct shrink_c= ontrol *shrinkctl, */ nr =3D atomic_long_xchg(&shrinker->nr_deferred[nid], 0); =20 - total_scan =3D nr; - if (shrinker->seeks) { - delta =3D freeable >> priority; - delta *=3D 4; - do_div(delta, shrinker->seeks); - } else { - /* - * These objects don't require any IO to create. Trim - * them aggressively under memory pressure to keep - * them from causing refetches in the IO caches. - */ - delta =3D freeable / 2; - } - - total_scan +=3D delta; + total_scan =3D nr + scan_count; if (total_scan < 0) { pr_err("shrink_slab: %pS negative objects to delete nr=3D%ld\n", shrinker->scan_objects, total_scan); - total_scan =3D freeable; + total_scan =3D scan_count; next_deferred =3D nr; } else next_deferred =3D total_scan; @@ -521,19 +563,20 @@ static unsigned long do_shrink_slab(struct shrink_c= ontrol *shrinkctl, * Hence only allow the shrinker to scan the entire cache when * a large delta change is calculated directly. */ - if (delta < freeable / 4) - total_scan =3D min(total_scan, freeable / 2); + if (scan_count < freeable_objects / 4) + total_scan =3D min_t(long, total_scan, freeable_objects / 2); =20 /* * Avoid risking looping forever due to too large nr value: * never try to free more than twice the estimate number of * freeable entries. */ - if (total_scan > freeable * 2) - total_scan =3D freeable * 2; + if (total_scan > freeable_objects * 2) + total_scan =3D freeable_objects * 2; =20 trace_mm_shrink_slab_start(shrinker, shrinkctl, nr, - freeable, delta, total_scan, priority); + freeable_objects, scan_count, + total_scan, priority); =20 /* * If the shrinker can't run (e.g. due to gfp_mask constraints), then @@ -558,7 +601,7 @@ static unsigned long do_shrink_slab(struct shrink_con= trol *shrinkctl, * possible. */ while (total_scan >=3D batch_size || - total_scan >=3D freeable) { + total_scan >=3D freeable_objects) { unsigned long ret; unsigned long nr_to_scan =3D min(batch_size, total_scan); =20 --=20 2.23.0.rc1