Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67;
Date:   Mon, 4 Nov 2019 10:29:39 -0500
From:   Brian Foster <bfoster@redhat.com>
To:     Dave Chinner <david@fromorbit.com>
Cc:     linux-xfs@vger.kernel.org, linux-fsdevel@vger.kernel.org,
        linux-mm@kvack.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH 11/28] mm: factor shrinker work calculations
Message-ID: <20191104152939.GB10665@bfoster>
References: <20191031234618.15403-1-david@fromorbit.com>
 <20191031234618.15403-12-david@fromorbit.com>
MIME-Version: 1.0
In-Reply-To: <20191031234618.15403-12-david@fromorbit.com>
User-Agent: Mutt/1.12.1 (2019-06-15)
Content-Type: text/plain; charset=WINDOWS-1252
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline
Sender: linux-kernel-owner@vger.kernel.org
Precedence: bulk

On Fri, Nov 01, 2019 at 10:46:01AM +1100, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
>=20
> 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.
>=20
> 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.
>=20
> Signed-off-by: Dave Chinner <dchinner@redhat.com>
> ---

I assume the kbuild warning thing will be fixed up...

>  mm/vmscan.c | 97 ++++++++++++++++++++++++++++++++++++++---------------
>  1 file changed, 70 insertions(+), 27 deletions(-)
>=20
> diff --git a/mm/vmscan.c b/mm/vmscan.c
> index a215d71d9d4b..2d39ec37c04d 100644
> --- a/mm/vmscan.c
> +++ b/mm/vmscan.c
> @@ -459,13 +459,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,
> +=09=09=09    struct shrinker *shrinker, int priority,
> +=09=09=09    int64_t *freeable_objects)
> +{
> +=09int64_t delta;
> +=09int64_t freeable;
> +
> +=09freeable =3D shrinker->count_objects(shrinker, shrinkctl);
> +=09if (freeable =3D=3D 0 || freeable =3D=3D SHRINK_EMPTY)
> +=09=09return freeable;
> +
> +=09if (shrinker->seeks) {
> +=09=09/*
> +=09=09 * shrinker->seeks is a measure of how much IO is required to
> +=09=09 * reinstantiate the object in memory. The default value is 2
> +=09=09 * which is typical for a cold inode requiring a directory read
> +=09=09 * and an inode read to re-instantiate.
> +=09=09 *
> +=09=09 * The scan batch size is defined by the shrinker priority, but
> +=09=09 * to be able to bias the reclaim we increase the default batch
> +=09=09 * size by 4. Hence we end up with a scan batch multipler that
> +=09=09 * scales like so:
> +=09=09 *
> +=09=09 * ->seeks=09scan batch multiplier
> +=09=09 *    1=09=09      4.00x
> +=09=09 *    2               2.00x
> +=09=09 *    3               1.33x
> +=09=09 *    4               1.00x
> +=09=09 *    8               0.50x
> +=09=09 *
> +=09=09 * IOWs, the more seeks it takes to pull the item into cache,
> +=09=09 * the smaller the reclaim scan batch. Hence we put more reclaim
> +=09=09 * pressure on caches that are fast to repopulate and to keep a
> +=09=09 * rough balance between caches that have different costs.
> +=09=09 */
> +=09=09delta =3D freeable >> (priority - 2);

Does anything prevent priority < 2 here?

> +=09=09do_div(delta, shrinker->seeks);
> +=09} else {
> +=09=09/*
> +=09=09 * These objects don't require any IO to create. Trim them
> +=09=09 * aggressively under memory pressure to keep them from causing
> +=09=09 * refetches in the IO caches.
> +=09=09 */
> +=09=09delta =3D freeable / 2;
> +=09}
> +
> +=09*freeable_objects =3D freeable;
> +=09return delta > 0 ? delta : 0;
> +}
> +
>  static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
>  =09=09=09=09    struct shrinker *shrinker, int priority)
>  {
>  =09unsigned long freed =3D 0;
> -=09unsigned long long delta;
>  =09long total_scan;
> -=09long freeable;
> +=09int64_t freeable_objects =3D 0;
> +=09int64_t scan_count;
>  =09long nr;
>  =09long new_nr;
>  =09int nid =3D shrinkctl->nid;
...
> @@ -487,25 +543,11 @@ static unsigned long do_shrink_slab(struct shrink_c=
ontrol *shrinkctl,
>  =09 */
>  =09nr =3D atomic_long_xchg(&shrinker->nr_deferred[nid], 0);
> =20
> -=09total_scan =3D nr;
> -=09if (shrinker->seeks) {
> -=09=09delta =3D freeable >> priority;
> -=09=09delta *=3D 4;
> -=09=09do_div(delta, shrinker->seeks);
> -=09} else {
> -=09=09/*
> -=09=09 * These objects don't require any IO to create. Trim
> -=09=09 * them aggressively under memory pressure to keep
> -=09=09 * them from causing refetches in the IO caches.
> -=09=09 */
> -=09=09delta =3D freeable / 2;
> -=09}
> -
> -=09total_scan +=3D delta;
> +=09total_scan =3D nr + scan_count;
>  =09if (total_scan < 0) {
>  =09=09pr_err("shrink_slab: %pS negative objects to delete nr=3D%ld\n",
>  =09=09       shrinker->scan_objects, total_scan);
> -=09=09total_scan =3D freeable;
> +=09=09total_scan =3D scan_count;

Same question as before: why the change in assignment? freeable was the
->count_objects() return value, which is now stored in freeable_objects.

FWIW, the change seems to make sense in that it just factors out the
deferred count, but it's not clear if it's intentional...

Brian

>  =09=09next_deferred =3D nr;
>  =09} else
>  =09=09next_deferred =3D total_scan;
> @@ -522,19 +564,20 @@ static unsigned long do_shrink_slab(struct shrink_c=
ontrol *shrinkctl,
>  =09 * Hence only allow the shrinker to scan the entire cache when
>  =09 * a large delta change is calculated directly.
>  =09 */
> -=09if (delta < freeable / 4)
> -=09=09total_scan =3D min(total_scan, freeable / 2);
> +=09if (scan_count < freeable_objects / 4)
> +=09=09total_scan =3D min_t(long, total_scan, freeable_objects / 2);
> =20
>  =09/*
>  =09 * Avoid risking looping forever due to too large nr value:
>  =09 * never try to free more than twice the estimate number of
>  =09 * freeable entries.
>  =09 */
> -=09if (total_scan > freeable * 2)
> -=09=09total_scan =3D freeable * 2;
> +=09if (total_scan > freeable_objects * 2)
> +=09=09total_scan =3D freeable_objects * 2;
> =20
>  =09trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,
> -=09=09=09=09   freeable, delta, total_scan, priority);
> +=09=09=09=09   freeable_objects, scan_count,
> +=09=09=09=09   total_scan, priority);
> =20
>  =09/*
>  =09 * If the shrinker can't run (e.g. due to gfp_mask constraints), then
> @@ -559,7 +602,7 @@ static unsigned long do_shrink_slab(struct shrink_con=
trol *shrinkctl,
>  =09 * possible.
>  =09 */
>  =09while (total_scan >=3D batch_size ||
> -=09       total_scan >=3D freeable) {
> +=09       total_scan >=3D freeable_objects) {
>  =09=09unsigned long ret;
>  =09=09unsigned long nr_to_scan =3D min(batch_size, total_scan);
> =20
> --=20
> 2.24.0.rc0
>=20