From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8387C22C325; Mon, 3 Mar 2025 22:17:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040253; cv=none; b=s/BbyPyCquEEfjOu5dEE4lKVBvmQyJWbCGiPUXVZ5mrhBvVfNVQ39RQk/W9yHENRAK0UK4jvUgGB87reiMgVQ9utanuAE6QHDdCIjiLwWR6JWquObhqsg8KL8DVVDAKKVL59BxbmWYs+ZyPx6XYCti3921OIkLUtRF1ndZG1Kvk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040253; c=relaxed/simple; bh=iSBVb6PukRtPBydpg/2aD8QyTDEBPd4vfWzy9ndeL3Y=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=oTKMI78Ts+uLrNgM89sWmImBKCqemn0IGII+956Im3km2pVGF4S79trcwQzugfBZbE5ZuIXJz56YaM55fi/uWgjFFxcqFrIAy1pUOFYr4rgiXaihrDBqUkpHpipzNKJKCBJTCges0DUuN3XsW1GIIbhrWd1c6aBF5LsPBV6q7b0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=orStVIpc; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="orStVIpc" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D34F0C4CED6; Mon, 3 Mar 2025 22:17:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040253; bh=iSBVb6PukRtPBydpg/2aD8QyTDEBPd4vfWzy9ndeL3Y=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=orStVIpcjoJT1F6q/41W0z31q4TLWCnp1EuAFrsPs+gh9TtHFH/XXTbQx2bhxl8ql 4tcYU6baJ/m1Eh/86PgFc44ZT6xqCDUqcKWp73qgpz1lW47mOqJ1ssHY7MzjgSP5hl cKEmNtyT5XCs8Ex54DEOpsE4J/KuAwfqlXfzldCEYOGyxcoRX138EpkuXOnrdkWhqh MLVE6+9Sx1jWwBaF8zhMiVxjSszYhKBawGweYEHRvTPy+pRhlsa678qLsyr0bduuQE e1ZBmlvS+Zw+NpnMPuQEheCovxLF129gH1ra6fGo5Jum7LER4LhNFfw5C/oq1CED8q YLt5O+Ce5GMLw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 1/8] mm/damon: add data structure for monitoring intervals auto-tuning Date: Mon, 3 Mar 2025 14:17:19 -0800 Message-Id: <20250303221726.484227-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add data structures for DAMON sampling and aggregation intervals automatic tuning that aims specific amount of DAMON-observed access events per snapshot. In more detail, define the data structure for the tuning goal, link it to the monitoring attributes data structure so that DAMON kernel API callers can make the request, and update parameters setup DAMON function to respect the new parameter. Signed-off-by: SeongJae Park --- include/linux/damon.h | 27 +++++++++++++++++++++++++++ mm/damon/core.c | 22 ++++++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 242910b190c9..5f2609f24761 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -659,12 +659,38 @@ struct damon_call_control { bool canceled; }; =20 +/** + * struct damon_intervals_goal - Monitoring intervals auto-tuning goal. + * + * @access_bp: Access events observation ratio to achieve in bp. + * @aggrs: Number of aggregations to acheive @access_bp within. + * @min_sample_us: Minimum resulting sampling interval in microseconds. + * @max_sample_us: Maximum resulting sampling interval in microseconds. + * + * DAMON automatically tunes &damon_attrs->sample_interval and + * &damon_attrs->aggr_interval aiming the ratio in bp (1/10,000) of + * DAMON-observed access events to theoretical maximum amount within @aggrs + * aggregations be same to @access_bp. The logic increases + * &damon_attrs->aggr_interval and &damon_attrs->sampling_interval in same + * ratio if the current access events observation ratio is lower than the + * target for each @aggrs aggregations, and vice versa. + * + * If @aggrs is zero, the tuning is disabled and hence this struct is igno= red. + */ +struct damon_intervals_goal { + unsigned long access_bp; + unsigned long aggrs; + unsigned long min_sample_us; + unsigned long max_sample_us; +}; + /** * struct damon_attrs - Monitoring attributes for accuracy/overhead contro= l. * * @sample_interval: The time between access samplings. * @aggr_interval: The time between monitor results aggregations. * @ops_update_interval: The time between monitoring operations updates. + * @intervals_goal: Intervals auto-tuning goal. * @min_nr_regions: The minimum number of adaptive monitoring * regions. * @max_nr_regions: The maximum number of adaptive monitoring @@ -684,6 +710,7 @@ struct damon_attrs { unsigned long sample_interval; unsigned long aggr_interval; unsigned long ops_update_interval; + struct damon_intervals_goal intervals_goal; unsigned long min_nr_regions; unsigned long max_nr_regions; }; diff --git a/mm/damon/core.c b/mm/damon/core.c index b1ce072b56f2..ad3b5c065cb8 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -615,6 +615,25 @@ static void damon_update_monitoring_results(struct dam= on_ctx *ctx, r, old_attrs, new_attrs); } =20 +/* + * damon_valid_intervals_goal() - return if the intervals goal of @attrs is + * valid. + */ +static bool damon_valid_intervals_goal(struct damon_attrs *attrs) +{ + struct damon_intervals_goal *goal =3D &attrs->intervals_goal; + + /* tuning is disabled */ + if (!goal->aggrs) + return true; + if (goal->min_sample_us > goal->max_sample_us) + return false; + if (attrs->sample_interval < goal->min_sample_us || + goal->max_sample_us < attrs->sample_interval) + return false; + return true; +} + /** * damon_set_attrs() - Set attributes for the monitoring. * @ctx: monitoring context @@ -635,6 +654,9 @@ int damon_set_attrs(struct damon_ctx *ctx, struct damon= _attrs *attrs) attrs->sample_interval : 1; struct damos *s; =20 + if (!damon_valid_intervals_goal(attrs)) + return -EINVAL; + if (attrs->min_nr_regions < 3) return -EINVAL; if (attrs->min_nr_regions > attrs->max_nr_regions) --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BF725237702; Mon, 3 Mar 2025 22:17:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040254; cv=none; b=SrUYj5ZF5+hrn2YVFIijp+RZppZs6Rs40WgYnyc4aHB9jPzwlc6G9f0X0ooeHrcYEj1Lb09BlqlPz2T8+0g3gx/8MVgNJjIRCwaAP8QXnBaekkbiMfRBfO46rX6YuW2Z+pyCPzaLSelxbJzZWspu24nq5YKJR6u29GpoEmAt7hU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040254; c=relaxed/simple; bh=nNrODnOa9RS2rW/W7BbbOd+/X+ZlX/z8fAm6OpZQMuM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=l/zd+/o6tHpwXpoROdZMS087AbDhcK8au6HqONKUDvc8FkuM4sqRMs3RakShjny0yX9FsXqyNHr5pAiDex9JYLPYoPhlel9XF5L3sbKsGNNH21oaaYqjJEr/WpvZ0DhXoD/CBMPfHxrmx8CnPZaerKBscTb9h/SJeGEx5zPaWoQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=YQZOp2wi; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="YQZOp2wi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EEAF7C4CEE6; Mon, 3 Mar 2025 22:17:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040254; bh=nNrODnOa9RS2rW/W7BbbOd+/X+ZlX/z8fAm6OpZQMuM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=YQZOp2wi8QtcDcLx4CehWUfk8pKN1UIgYZ/j5qo/V2J5h5A+GDFVKRKrv7EjHdl9v 3vyvJRlzucFIzqJbwAOWT3fk3QqNzMjhlc6B+k6bkH2sDz/7kgow9Tx8t9l+UyuVe1 mPRha08uIuKPjp3NfS7Yr1znR7hrosDgbPQbje9al72s2j9TV6Fi7kPNmxf3pqAW2n awoPprDyb6B+JAvh1E3l6exNEhTZSuLb0RE6FhQsJD4mX04lzUTNOlQw9MFSJomVc0 NrqsvWlo5i8P5HIoXed8N+oYnRTVgQXlHsySAB+HtgntJTEoNrn9De/kIhwzgW8uK0 99F3Cd+AAoZfA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 2/8] mm/damon/core: implement intervals auto-tuning Date: Mon, 3 Mar 2025 14:17:20 -0800 Message-Id: <20250303221726.484227-3-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Implement the DAMON sampling and aggregation intervals auto-tuning mechanism as briefly described on 'struct damon_intervals_goal'. The core part for deciding the direction and amount of the changes is implemented reusing the feedback loop function which is being used for DAMOS quotas auto-tuning. Unlike the DAMOS quotas auto-tuning use case, limit the maximum decreasing amount after the adjustment to 50% of the current value, though. This is because the intervals have no good merits at rapid reductions since it could unnecessarily increase the monitoring overhead. Signed-off-by: SeongJae Park --- include/linux/damon.h | 16 +++++++++ mm/damon/core.c | 76 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 5f2609f24761..b3e2c793c1f4 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -713,6 +713,17 @@ struct damon_attrs { struct damon_intervals_goal intervals_goal; unsigned long min_nr_regions; unsigned long max_nr_regions; +/* private: internal use only */ + /* + * @aggr_interval to @sample_interval ratio. + * Core-external components call damon_set_attrs() with &damon_attrs + * that this field is unset. In the case, damon_set_attrs() sets this + * field of resulting &damon_attrs. Core-internal components such as + * kdamond_tune_intervals() calls damon_set_attrs() with &damon_attrs + * that this field is set. In the case, damon_set_attrs() just keep + * it. + */ + unsigned long aggr_samples; }; =20 /** @@ -761,6 +772,11 @@ struct damon_ctx { * update */ unsigned long next_ops_update_sis; + /* + * number of sample intervals that should be passed before next + * intervals tuning + */ + unsigned long next_intervals_tune_sis; /* for waiting until the execution of the kdamond_fn is started */ struct completion kdamond_started; /* for scheme quotas prioritization */ diff --git a/mm/damon/core.c b/mm/damon/core.c index ad3b5c065cb8..9d37d3664030 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -664,6 +664,10 @@ int damon_set_attrs(struct damon_ctx *ctx, struct damo= n_attrs *attrs) if (attrs->sample_interval > attrs->aggr_interval) return -EINVAL; =20 + /* calls from core-external doesn't set this. */ + if (!attrs->aggr_samples) + attrs->aggr_samples =3D attrs->aggr_interval / sample_interval; + ctx->next_aggregation_sis =3D ctx->passed_sample_intervals + attrs->aggr_interval / sample_interval; ctx->next_ops_update_sis =3D ctx->passed_sample_intervals + @@ -1301,6 +1305,65 @@ static void kdamond_reset_aggregated(struct damon_ct= x *c) } } =20 +static unsigned long damon_get_intervals_score(struct damon_ctx *c) +{ + struct damon_target *t; + struct damon_region *r; + unsigned long sz_region, max_access_events =3D 0, access_events =3D 0; + unsigned long target_access_events; + unsigned long goal_bp =3D c->attrs.intervals_goal.access_bp; + + damon_for_each_target(t, c) { + damon_for_each_region(r, t) { + sz_region =3D damon_sz_region(r); + max_access_events +=3D sz_region * c->attrs.aggr_samples; + access_events +=3D sz_region * r->nr_accesses; + } + } + target_access_events =3D max_access_events * goal_bp / 10000; + return access_events * 10000 / target_access_events; +} + +static unsigned long damon_feed_loop_next_input(unsigned long last_input, + unsigned long score); + +static unsigned long damon_get_intervals_adaptation_bp(struct damon_ctx *c) +{ + unsigned long score_bp, adaptation_bp; + + score_bp =3D damon_get_intervals_score(c); + adaptation_bp =3D damon_feed_loop_next_input(100000000, score_bp) / + 10000; + /* + * adaptaion_bp ranges from 1 to 20,000. Avoid too rapid reduction of + * the intervals by rescaling [1,10,000] to [5000, 10,000]. + */ + if (adaptation_bp <=3D 10000) + adaptation_bp =3D 5000 + adaptation_bp / 2; + return adaptation_bp; +} + +static void kdamond_tune_intervals(struct damon_ctx *c) +{ + unsigned long adaptation_bp; + struct damon_attrs new_attrs; + struct damon_intervals_goal *goal; + + adaptation_bp =3D damon_get_intervals_adaptation_bp(c); + if (adaptation_bp =3D=3D 10000) + return; + + new_attrs =3D c->attrs; + goal =3D &c->attrs.intervals_goal; + new_attrs.sample_interval =3D min(goal->max_sample_us, + c->attrs.sample_interval * adaptation_bp / 10000); + new_attrs.sample_interval =3D max(goal->min_sample_us, + new_attrs.sample_interval); + new_attrs.aggr_interval =3D new_attrs.sample_interval * + c->attrs.aggr_samples; + damon_set_attrs(c, &new_attrs); +} + static void damon_split_region_at(struct damon_target *t, struct damon_region *r, unsigned long sz_r); =20 @@ -2209,6 +2272,8 @@ static void kdamond_init_intervals_sis(struct damon_c= tx *ctx) ctx->next_aggregation_sis =3D ctx->attrs.aggr_interval / sample_interval; ctx->next_ops_update_sis =3D ctx->attrs.ops_update_interval / sample_interval; + ctx->next_intervals_tune_sis =3D ctx->next_aggregation_sis * + ctx->attrs.intervals_goal.aggrs; =20 damon_for_each_scheme(scheme, ctx) { apply_interval =3D scheme->apply_interval_us ? @@ -2293,6 +2358,17 @@ static int kdamond_fn(void *data) sample_interval =3D ctx->attrs.sample_interval ? ctx->attrs.sample_interval : 1; if (ctx->passed_sample_intervals >=3D next_aggregation_sis) { + if (ctx->attrs.intervals_goal.aggrs && + ctx->passed_sample_intervals >=3D + ctx->next_intervals_tune_sis) { + ctx->next_intervals_tune_sis +=3D + ctx->attrs.aggr_samples * + ctx->attrs.intervals_goal.aggrs; + kdamond_tune_intervals(ctx); + sample_interval =3D ctx->attrs.sample_interval ? + ctx->attrs.sample_interval : 1; + + } ctx->next_aggregation_sis =3D next_aggregation_sis + ctx->attrs.aggr_interval / sample_interval; =20 --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DA6A823957C; Mon, 3 Mar 2025 22:17:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040255; cv=none; b=ksEHxMMna3yWFKXo5IyWCV8vNJRjmWoYVKV7vDLUWka+bpeQ4FjveB74wf7GvISHN2dnnV2Z515kdFJS/Z4OXpTPbUcEBbeNdAshpCvlBjOsMZvk6f4Zfdlfv8gH7lOSmFyb42LtxxJFNbMs9dz62OAhzqg+Os2ANTs918cnW/I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040255; c=relaxed/simple; bh=oYTrlxmiR5BNoFrioFop/hpnftvDsKcm3PmL/H0/UqA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=mI2oaJtznHKNymVvSB3O1bu48B0K2TL0Wk/G3Z9OtvACTFMqb+CpIebDTfGl+kjC5PhZM7N1GznV/bVqtiZivAU4b4nH9iKMZwTPUzn+qqPG0c87nTE4RBIeIeQ9THqWuxDkfTwOFpoNyoAEL6oVpPnvEfBa7PU9hY5jKrbe230= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Soi9THCj; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Soi9THCj" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1C63DC4CED6; Mon, 3 Mar 2025 22:17:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040255; bh=oYTrlxmiR5BNoFrioFop/hpnftvDsKcm3PmL/H0/UqA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Soi9THCj2vEwCsPhfxxhbpnWH+DVFLPZsuCOYAcBSoInfDeSLhlJZDv24GLuUGw5W a2NOwqyU4qvSt+5s828s9NElO2yk9Ead4EfEC07tplzZBHpUDUmEVJlzAPHR7nA3YO IBJUYVhP64Ofv/tcQ3HrufgwhxzsB9mgYeoJ2sri319uJnS/2fjG95acUTeCnmJyvv CfOElNg8IijVJ/uEB4CKfT+7O5zMbf3VQPfqKpcZGT57mO9UBsIx0kY/CADLhPI/oZ SNGeJ+rbJk3Pbe4+vTX5b8zQdtyNMmHd6v5616QfD5Nshzp8ZITkND+USL0rVp5H4k YhwvrbXH2TU9A== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 3/8] mm/damon/sysfs: implement intervals tuning goal directory Date: Mon, 3 Mar 2025 14:17:21 -0800 Message-Id: <20250303221726.484227-4-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Implement DAMON sysfs interface directory and its files for setting DAMON sampling and aggregation intervals auto-tuning goal. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 189 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index deeab04d3b46..a772060300b4 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -408,6 +408,164 @@ static const struct kobj_type damon_sysfs_targets_kty= pe =3D { .default_groups =3D damon_sysfs_targets_groups, }; =20 +/* + * intervals goal directory + */ + +struct damon_sysfs_intervals_goal { + struct kobject kobj; + unsigned long access_bp; + unsigned long aggrs; + unsigned long min_sample_us; + unsigned long max_sample_us; +}; + +static struct damon_sysfs_intervals_goal *damon_sysfs_intervals_goal_alloc( + unsigned long access_bp, unsigned long aggrs, + unsigned long min_sample_us, unsigned long max_sample_us) +{ + struct damon_sysfs_intervals_goal *goal =3D kmalloc(sizeof(*goal), + GFP_KERNEL); + + if (!goal) + return NULL; + + goal->kobj =3D (struct kobject){}; + goal->access_bp =3D access_bp; + goal->aggrs =3D aggrs; + goal->min_sample_us =3D min_sample_us; + goal->max_sample_us =3D max_sample_us; + return goal; +} + +static ssize_t access_bp_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + + return sysfs_emit(buf, "%lu\n", goal->access_bp); +} + +static ssize_t access_bp_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err =3D kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->access_bp =3D nr; + return count; +} + +static ssize_t aggrs_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + + return sysfs_emit(buf, "%lu\n", goal->aggrs); +} + +static ssize_t aggrs_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err =3D kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->aggrs =3D nr; + return count; +} + +static ssize_t min_sample_us_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + + return sysfs_emit(buf, "%lu\n", goal->min_sample_us); +} + +static ssize_t min_sample_us_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err =3D kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->min_sample_us =3D nr; + return count; +} + +static ssize_t max_sample_us_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + + return sysfs_emit(buf, "%lu\n", goal->max_sample_us); +} + +static ssize_t max_sample_us_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_intervals_goal *goal =3D container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err =3D kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->max_sample_us =3D nr; + return count; +} + +static void damon_sysfs_intervals_goal_release(struct kobject *kobj) +{ + kfree(container_of(kobj, struct damon_sysfs_intervals_goal, kobj)); +} + +static struct kobj_attribute damon_sysfs_intervals_goal_access_bp_attr =3D + __ATTR_RW_MODE(access_bp, 0600); + +static struct kobj_attribute damon_sysfs_intervals_goal_aggrs_attr =3D + __ATTR_RW_MODE(aggrs, 0600); + +static struct kobj_attribute damon_sysfs_intervals_goal_min_sample_us_attr= =3D + __ATTR_RW_MODE(min_sample_us, 0600); + +static struct kobj_attribute damon_sysfs_intervals_goal_max_sample_us_attr= =3D + __ATTR_RW_MODE(max_sample_us, 0600); + +static struct attribute *damon_sysfs_intervals_goal_attrs[] =3D { + &damon_sysfs_intervals_goal_access_bp_attr.attr, + &damon_sysfs_intervals_goal_aggrs_attr.attr, + &damon_sysfs_intervals_goal_min_sample_us_attr.attr, + &damon_sysfs_intervals_goal_max_sample_us_attr.attr, + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_intervals_goal); + +static const struct kobj_type damon_sysfs_intervals_goal_ktype =3D { + .release =3D damon_sysfs_intervals_goal_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_intervals_goal_groups, +}; + /* * intervals directory */ @@ -417,6 +575,7 @@ struct damon_sysfs_intervals { unsigned long sample_us; unsigned long aggr_us; unsigned long update_us; + struct damon_sysfs_intervals_goal *intervals_goal; }; =20 static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc( @@ -436,6 +595,32 @@ static struct damon_sysfs_intervals *damon_sysfs_inter= vals_alloc( return intervals; } =20 +static int damon_sysfs_intervals_add_dirs(struct damon_sysfs_intervals *in= tervals) +{ + struct damon_sysfs_intervals_goal *goal; + int err; + + goal =3D damon_sysfs_intervals_goal_alloc(0, 0, 0, 0); + if (!goal) + return -ENOMEM; + + err =3D kobject_init_and_add(&goal->kobj, + &damon_sysfs_intervals_goal_ktype, &intervals->kobj, + "intervals_goal"); + if (err) { + kobject_put(&goal->kobj); + intervals->intervals_goal =3D NULL; + return err; + } + intervals->intervals_goal =3D goal; + return 0; +} + +static void damon_sysfs_intervals_rm_dirs(struct damon_sysfs_intervals *in= tervals) +{ + kobject_put(&intervals->intervals_goal->kobj); +} + static ssize_t sample_us_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { @@ -569,6 +754,9 @@ static int damon_sysfs_attrs_add_dirs(struct damon_sysf= s_attrs *attrs) err =3D kobject_init_and_add(&intervals->kobj, &damon_sysfs_intervals_ktype, &attrs->kobj, "intervals"); + if (err) + goto put_intervals_out; + err =3D damon_sysfs_intervals_add_dirs(intervals); if (err) goto put_intervals_out; attrs->intervals =3D intervals; @@ -599,6 +787,7 @@ static int damon_sysfs_attrs_add_dirs(struct damon_sysf= s_attrs *attrs) static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs) { kobject_put(&attrs->nr_regions_range->kobj); + damon_sysfs_intervals_rm_dirs(attrs->intervals); kobject_put(&attrs->intervals->kobj); } =20 --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AC3E922C325; Mon, 3 Mar 2025 22:17:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040256; cv=none; b=b5edyrjCLJofgtPSQSiHy6IO5lTmJIdexf8Y3UBLBhX6u3qvVWcQpTUgfKPvXxzQlhrd6HVV7GTRoLuiLWWkDefsMXBZdhX18t1UFT0aLBQtwm+JcUZxspkJ1Fq+RLYCjs8EPWQbU4/z3MwCCANZJhz4qLBiNyW5GO1UGydzWGk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040256; c=relaxed/simple; bh=0K6yd3M1vKE/q1zzJCXy7CoQ3azMzfYHIkHl3bOjRxs=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=VqKdDZ+WkM2r0prqW1rGh624GdKKOaZJDyLuq/dT5N7Omw5kSQaPMfMcS/L1o9wxfMepiWuUri0X+trFP0GlXw+V8bRVaGCvBxKOpqdwYZTu3QQaPhGUbJ3lWasyluUx0cUjN3KnIg8chQ6+mhq18VuKC+kqmEs1E/MURRM8+Y8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=kK4rXPux; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="kK4rXPux" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5E13CC4CEEF; Mon, 3 Mar 2025 22:17:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040256; bh=0K6yd3M1vKE/q1zzJCXy7CoQ3azMzfYHIkHl3bOjRxs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=kK4rXPuxpNviA59kQsLkirdxt+l1qKS/vAADRvPpMds0Qr4aQ7YDpiCbIY+dMDzTV X1LFXjyyk7uHgFOl1bV4WylbXUuJZKaXgWIa1QQdLQfogGFQrf5DpNf9tmtWkIzlxl g8/ocZWZJ2HRTWRHiaMe64JxsUK350bpmyi594RGUn/93wr4vrVa++ZsgPa9kBrSyY a66jlImRvAPLzueiEfCjsnln3kglSOsBccuYnugtve4e0V2mUo7snHRBIWnPAPZMSf /tTY31SzCeiVP9Bc6aYbYsWM5BWfmm2ugTimG0aHI9stWobSvDgoN0npC0+5ShEIK9 6bu4r6JrTh4fA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 4/8] mm/damon/sysfs: commit intervals tuning goal Date: Mon, 3 Mar 2025 14:17:22 -0800 Message-Id: <20250303221726.484227-5-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Connect DAMON sysfs interface for sampling and aggregation intervals auto-tuning with DAMON core API, so that users can really use the feature using the sysfs files. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index a772060300b4..fa5f004f0670 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1273,11 +1273,18 @@ static int damon_sysfs_set_attrs(struct damon_ctx *= ctx, struct damon_sysfs_attrs *sys_attrs) { struct damon_sysfs_intervals *sys_intervals =3D sys_attrs->intervals; + struct damon_sysfs_intervals_goal *sys_goal =3D + sys_intervals->intervals_goal; struct damon_sysfs_ul_range *sys_nr_regions =3D sys_attrs->nr_regions_range; struct damon_attrs attrs =3D { .sample_interval =3D sys_intervals->sample_us, .aggr_interval =3D sys_intervals->aggr_us, + .intervals_goal =3D { + .access_bp =3D sys_goal->access_bp, + .aggrs =3D sys_goal->aggrs, + .min_sample_us =3D sys_goal->min_sample_us, + .max_sample_us =3D sys_goal->max_sample_us}, .ops_update_interval =3D sys_intervals->update_us, .min_nr_regions =3D sys_nr_regions->min, .max_nr_regions =3D sys_nr_regions->max, --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F1F9D23BFA6; Mon, 3 Mar 2025 22:17:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040258; cv=none; b=p+5g1lcfiSaaURBhJSvq3hiZy2KhW4UE/DtVEf6yrcI/5Crw5wgS1zKcMEC0VbQUUF/OZGEfRbmUJqfHMvCEvLaF/xQyqKbH1W+8q+za7wv1ZXQ51R3iMQvhaiMYiNjAgX1kKW2/13/aSYOSKCcIAjD/K4iDRh1bO0MiYIIUYcE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040258; c=relaxed/simple; bh=LSjpeMzXWVkQm84u7Pg3DRD/aAE+XvDLQxgeGEMx2JU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Z0mI4ngt3pzXCquLxc1Pv3D8Q+EMyOkR6YpfosOiZQmCt72o18aNyH208YJMrHbjRvsscnl4KAPGutFTZi4BJbX01nNXRo8pYVB2hcnyFniSNneolhybkQJ6Mu329i9IGacSv1TMfsQLIVXrq5sgu6LWQ4JzVmMKykTCkvRFGCo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=K3yMVWuR; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="K3yMVWuR" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 92DF7C4CEE5; Mon, 3 Mar 2025 22:17:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040257; bh=LSjpeMzXWVkQm84u7Pg3DRD/aAE+XvDLQxgeGEMx2JU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=K3yMVWuRfTjd+OyCEQ1rThotSmYg5rgYu57djwTjR90VhkqveAnxODI3I0Pj4atbc j3HFSGmVorGtEjAkBwVCQqmyVl658yX+bMgKswz48VI1lXTx42RxuJ2g4SgDYWPFZy yvILiydHL10R9iiy+aARh+LsJ/oIfEOJyrnGyN2OKhsLLfqYlXRs9iJ0jiEAkKZXt+ vcG0ed+tEQ/o2YcJKlB9E+1A48j8Yw8lKAQZyiydaRBTPwNbc0noFrAs1fXFyzqVQU q6O0BUlIqc3ns5CY4NALEzVr+EUdusKWYmRzW4MgM1hF2U+Q8AAaDjRVw8hsGz0w+o e1nfPi6+CEJjg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 5/8] mm/damon/sysfs: implement a command to update auto-tuned monitoring intervals Date: Mon, 3 Mar 2025 14:17:23 -0800 Message-Id: <20250303221726.484227-6-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DAMON kernel API callers can show auto-tuned sampling and aggregation intervals from the monmitoring attributes data structure. That can be useful for debugging or tuning of the feature. DAMON user-space ABI users has no way to see that, though. Implement a new DAMON sysfs interface command, namely 'update_tuned_intervals', for the purpose. If the command is written to the kdamond state file, the tuned sampling and aggregation intervals will be updated to the corresponding sysfs interface files. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index fa5f004f0670..ccd435d234b9 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1213,6 +1213,11 @@ enum damon_sysfs_cmd { * effective size quota of the scheme in bytes. */ DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS, + /* + * @DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: Update the tuned monitoring + * intevals. + */ + DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS, /* * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands. */ @@ -1230,6 +1235,7 @@ static const char * const damon_sysfs_cmd_strs[] =3D { "update_schemes_tried_regions", "clear_schemes_tried_regions", "update_schemes_effective_quotas", + "update_tuned_intervals", }; =20 /* @@ -1502,6 +1508,17 @@ static int damon_sysfs_upd_schemes_effective_quotas(= void *data) return 0; } =20 +static int damon_sysfs_upd_tuned_intervals(void *data) +{ + struct damon_sysfs_kdamond *kdamond =3D data; + struct damon_ctx *ctx =3D kdamond->damon_ctx; + + kdamond->contexts->contexts_arr[0]->attrs->intervals->sample_us =3D + ctx->attrs.sample_interval; + kdamond->contexts->contexts_arr[0]->attrs->intervals->aggr_us =3D + ctx->attrs.aggr_interval; + return 0; +} =20 /* * damon_sysfs_cmd_request_callback() - DAMON callback for handling reques= ts. @@ -1723,6 +1740,9 @@ static int damon_sysfs_handle_cmd(enum damon_sysfs_cm= d cmd, return damon_sysfs_damon_call( damon_sysfs_upd_schemes_effective_quotas, kdamond); + case DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: + return damon_sysfs_damon_call( + damon_sysfs_upd_tuned_intervals, kdamond); default: break; } --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6E75523C8C5; Mon, 3 Mar 2025 22:17:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040259; cv=none; b=qh1pMiXpaReONrSPb03eAwq8G6Pg6K+s+an1yVuK1eHvnbmVM4Hgbs/gVztXDgnFNVCY8f8S1rKk/2XR5p0pK81QNumwavTYJV9rI9/dIoNPvkafgBjZZn5uUftQWOffcbLZXmtjAO2acgochVzTfDi3+x9bFOqqdWfsU83qU2k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040259; c=relaxed/simple; bh=LMPGQQlkmlc7oVmDROz8XiqF7P/8GVFp76QyeCU2ENk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=HauJ3tstWFpdt9VwBuY2c5iwPBdsv9yjNpDu/UHwXhwlLCSig9eYSzqqCWKgk56N7u4sfvQVFLg+ds0SbkFezE4NJMlGSP8iDrCI5h5uumnMX8FmSgefGzrGk0r5sc++OW8tSIW/eI8qM/aPDD0/QP/XexmdBROflXPlwpe06Dg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Ew3153Bk; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Ew3153Bk" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B9184C4CEE9; Mon, 3 Mar 2025 22:17:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040258; bh=LMPGQQlkmlc7oVmDROz8XiqF7P/8GVFp76QyeCU2ENk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Ew3153Bkz/qxViCicAwx/SFps15sAAj5PmKnsoDtHn315GlNdykMREPudSZZ6nR31 jJN/cH18UFfaV2Va1eipv8RD9qWjVteCcoNWZG5M/1X3WuTiSi6KEr8DBcQd65Qbhf XntXeBf/VKlAeHyWEGdP+DpTwTRoIhxBdGvQ03vo5P9YR9ic/6WcQVU8Da6jhTKEJU kbd1YWhn4+pkfgJdzDeDcbIG5Gbxs1cZ4mvIbgNThflnMbnrpEFXLoFk4PrlPXhV2A dAmYkbVWCrA2mpP/jVmQ0WLjWfYWbTkJzVZQwAUtlH8OyDHtwxEwhmO0TK8aelxnQL DH1jB4tIGO+nA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , Jonathan Corbet , damon@lists.linux.dev, kernel-team@meta.com, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 6/8] Docs/mm/damon/design: document for intervals auto-tuning Date: Mon, 3 Mar 2025 14:17:24 -0800 Message-Id: <20250303221726.484227-7-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Document the design of DAMON sampling and aggregation intervals auto-tuning. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 46 +++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index 5af991551a86..cb388d791ff7 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -313,6 +313,10 @@ sufficient for the given purpose, it shouldn't be unne= cessarily further lowered. It is recommended to be set proportional to ``aggregation interv= al``. By default, the ratio is set as ``1/20``, and it is still recommended. =20 +Based on the manual tuning guide, DAMON provides more intuitive knob-based +intervals auto tuning mechanism. Please refer to :ref:`the design documen= t of +the feature ` for detail. + Refer to below documents for an example tuning based on the above guide. =20 .. toctree:: @@ -321,6 +325,48 @@ Refer to below documents for an example tuning based o= n the above guide. monitoring_intervals_tuning_example =20 =20 +.. _damon_design_monitoring_intervals_autotuning: + +Monitoring Intervals Auto-tuning +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +DAMON provides automatic tuning of the ``sampling interval`` and ``aggrega= tion +interval`` based on the :ref:`the tuning guide idea +`. The tuning mechanism allo= ws +users to set the aimed amount of access events to observe via DAMON within +given time interval. The target can be specified by the user as a ratio of +DAMON-observed access events to the theoretical maximum amount of the even= ts +(``access_bp``) that measured within a given number of aggregations +(``aggrs``). + +The DAMON-observed access events are calculated in byte granularity based = on +DAMON :ref:`region assumption `. For +example, if a region of size ``X`` bytes of ``Y`` ``nr_accesses`` is found= , it +means ``X * Y`` access events are observed by DAMON. Theoretical maximum +access events for the region is calculated in same way, but replacing ``Y`` +with theoretical maximum ``nr_accesses``, which can be calculated as +``aggregation interval / sampling interval``. + +The mechanism calculates the ratio of access events for ``aggrs`` aggregat= ions, +and increases or decrease the ``sampleing interval`` and ``aggregation +interval`` in same ratio, if the observed access ratio is lower or higher = than +the target, respectively. The ratio of the intervals change is decided in +proportion to the distance between current samples ratio and the target ra= tio. + +The user can further set the minimum and maximum ``sampling interval`` tha= t can +be set by the tuning mechanism using two parameters (``min_sample_us`` and +``max_sample_us``). Because the tuning mechanism changes ``sampling inter= val`` +and ``aggregation interval`` in same ratio always, the minimum and maximum +``aggregation interval`` after each of the tuning changes can automaticall= y set +together. + +The tuning is turned off by default, and need to be set explicitly by the = user. +As a rule of thumbs and the Parreto principle, 4% access samples ratio tar= get +is recommended. Note that Parreto principle (80/20 rule) has applied twic= e. +That is, assumes 4% (20% of 20%) DAMON-observed access events ratio (sourc= e) +to capture 64% (80% multipled by 80%) real access events (outcomes). + + .. _damon_design_damos: =20 Operation Schemes --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 77ED723DE85; Mon, 3 Mar 2025 22:17:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040260; cv=none; b=VOqO7doJsMhT+o02jp2zYj+1FM9qDzwF/z57syDQLwhaaXqjj0o01UJwWPl7xlxF+IWXcmOINCMejR3qb1SKfxexgEwTmRKmhEREXD6ogyUCraKYuGWP9AUlzVToMAPztk0FhrNMvoifT7hy6hUGPcnCqoIQRyYau1b6YDVVuu8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040260; c=relaxed/simple; bh=XpcVMfDACd++qb3Pq98x+XaZ3PfwwLWSEoYntOcOzFw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=ePI1/118g9vAxcb2f9G7svb27f2dPRjdMY8t7Eo5wtP3zWUW41/AdAYMrKJxsrUA4w6gUgEwLXHZwckBSxF7UMeSlYFcFUYKFjVMzvajyCvV3QNWeeUiPe1P18mTXS74lMLPaGpdPsFE2JoAuK8xunFq801oi7nYuhW+MmTglC8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=XfdZWy97; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="XfdZWy97" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 092DCC4CEF3; Mon, 3 Mar 2025 22:17:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040260; bh=XpcVMfDACd++qb3Pq98x+XaZ3PfwwLWSEoYntOcOzFw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=XfdZWy97nH/eiYY8CQK2C3uoDHTugsPUgNxPosNITPG8ev16imKFJzsHQJ+RnLrm3 uhctjWkLWWpklHpE42SSz1cs1QJhNssM7NnzRx2i7MElFJ3dvRHC7PMSAfJj7ji08X DUOQ6RJnH7/JBEqrmpk2eOqQF9fRck0Jt11ZuVxAs7Eo4d7IVuhn5h+m/qJcKEmEC3 x91GNxG8Rw7F38NSca/3dIR2jfU6Sr8vMxXc0p4WAFuMpIxhVNJOma4+7kTsTmtZX8 TfQ3nt5nW+pmx5q2+TSNfjadw5XsHXvaSBd1NcYZ/K5oxiFYjuEIpDHJOAv5VLqBK8 AvLHkF0doBvHw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 7/8] Docs/ABI/damon: document intervals auto-tuning ABI Date: Mon, 3 Mar 2025 14:17:25 -0800 Message-Id: <20250303221726.484227-8-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Document the DAMON user-space ABI for DAMON sampling and aggregation intervals auto-tuning. Signed-off-by: SeongJae Park --- .../ABI/testing/sysfs-kernel-mm-damon | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-kernel-mm-damon b/Documentatio= n/ABI/testing/sysfs-kernel-mm-damon index ccd13ca668c8..76da77d7f7b6 100644 --- a/Documentation/ABI/testing/sysfs-kernel-mm-damon +++ b/Documentation/ABI/testing/sysfs-kernel-mm-damon @@ -91,6 +91,36 @@ Description: Writing a value to this file sets the updat= e interval of the DAMON context in microseconds as the value. Reading this file returns the value. =20 +What: /sys/kernel/mm/damon/admin/kdamonds//contexts//monitoring_att= rs/intervals/intrvals_goal/access_bp +Date: Feb 2025 +Contact: SeongJae Park +Description: Writing a value to this file sets the monitoring intervals + auto-tuning target DAMON-observed access events ratio within + the given time interval (aggrs in same directory), in bp + (1/10,000). Reading this file returns the value. + +What: /sys/kernel/mm/damon/admin/kdamonds//contexts//monitoring_att= rs/intervals/intrvals_goal/aggrs +Date: Feb 2025 +Contact: SeongJae Park +Description: Writing a value to this file sets the time interval to achieve + the monitoring intervals auto-tuning target DAMON-observed + access events ratio (access_bp in same directory) within. + Reading this file returns the value. + +What: /sys/kernel/mm/damon/admin/kdamonds//contexts//monitoring_att= rs/intervals/intrvals_goal/min_sample_us +Date: Feb 2025 +Contact: SeongJae Park +Description: Writing a value to this file sets the minimum value of + auto-tuned sampling interval in microseconds. Reading this + file returns the value. + +What: /sys/kernel/mm/damon/admin/kdamonds//contexts//monitoring_att= rs/intervals/intrvals_goal/max_sample_us +Date: Feb 2025 +Contact: SeongJae Park +Description: Writing a value to this file sets the maximum value of + auto-tuned sampling interval in microseconds. Reading this + file returns the value. + What: /sys/kernel/mm/damon/admin/kdamonds//contexts//monitoring_att= rs/nr_regions/min =20 WDate: Mar 2022 --=20 2.39.5 From nobody Fri Dec 19 06:17:54 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B9A2C23E333; Mon, 3 Mar 2025 22:17:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040261; cv=none; b=tIqhL5hY/ZWcNd+kQd9ekoO2xwUnEyuD9X85xDhYgy60K7/74MLxYm11N6EDIAryKu7OzeWqt+bsUAsA4inhW2IwMUJ6lqPlkmoC+wPI3PwJaBH+NBCj+4z2w0qL/y/QGiLmoeuNJTjyEbJoxhX0/25GXh3oM8Mj1Y83zqfpmwg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741040261; c=relaxed/simple; bh=ki10B3zR5mixA9j/A7CWQx5SObRymhGEPj5DgsDuWCo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=GqBYZcrzvszUsrovCJWOnvPX5V5wEAu3eWwW6O3l8WXsVhjnnkbgiFUXPef4wQQ3Xp+SW7L6JStyaW/PbE7EhXT0v5+Y0tksgT+C2v04LLWd8y6mDC15rYMYoI+zlM1JpszSCdux+7EfCIhMzX6FHSISJScVA2s1PCgDxzbqRaw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bSqjdJHA; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="bSqjdJHA" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4CD32C4CED6; Mon, 3 Mar 2025 22:17:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1741040261; bh=ki10B3zR5mixA9j/A7CWQx5SObRymhGEPj5DgsDuWCo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bSqjdJHAWbCdKV26S5QgEbhmE/6LeicMKJ+wZON2b3jtP32CDTJN8OUy8U8OY7syH u64jhcgK91le676PO9VA6Vmk32Jv73Zy0spDofUVWFUwh2KV8KoZboLwh4F6Y6sG/X QwDCblpotBaH8hZrUKCgm2GFZ44sTsxbteMzd0GqOgDDRQ/oGMOA3PQIqpNybb8FBs ByTkVeW2FI03SCLnn4RHpRyQWXT0Gb0iJVGQgzf83PjqR72I2Xenb45FltOLWcHJ72 E8/IRa4wDv4/hKWWK4PC9qEBkIo41NxYaGiEmj/Os9LLrGNPdmIMzh8+RXyjPPnf8e jpAtHzLHxn7Rg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , Jonathan Corbet , damon@lists.linux.dev, kernel-team@meta.com, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 8/8] Docs/admin-guide/mm/damon/usage: add intervals_goal directory on the hierarchy Date: Mon, 3 Mar 2025 14:17:26 -0800 Message-Id: <20250303221726.484227-9-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250303221726.484227-1-sj@kernel.org> References: <20250303221726.484227-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Document DAMON sysfs interface usage for DAMON sampling and aggregation intervals auto-tuning. Signed-off-by: SeongJae Park --- Documentation/admin-guide/mm/damon/usage.rst | 25 ++++++++++++++++++++ Documentation/mm/damon/design.rst | 4 ++++ 2 files changed, 29 insertions(+) diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/a= dmin-guide/mm/damon/usage.rst index dc37bba96273..de549dd18107 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -64,6 +64,7 @@ comma (","). =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`0 `/avail= _operations,operations =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`monitoring_att= rs `/ =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 intervals/= sample_us,aggr_us,update_us + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = intervals_goal/access_bp,aggrs,min_sample_us,max_sample_us =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 nr_regions= /min,max =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`targets `/nr_targets =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`0 `/pid_target @@ -132,6 +133,11 @@ Users can write below commands for the kdamond to the = ``state`` file. - ``off``: Stop running. - ``commit``: Read the user inputs in the sysfs files except ``state`` file again. +- ``update_tuned_intervals``: Update the contents of ``sample_us`` and + ``aggr_us`` files of the kdamond with the auto-tuning applied ``sampling + interval`` and ``aggregation interval`` for the files. Please refer to + :ref:`intervals_goal section ` + for more details. - ``commit_schemes_quota_goals``: Read the DAMON-based operation schemes' :ref:`quota goals `. - ``update_schemes_stats``: Update the contents of stats files for each @@ -213,6 +219,25 @@ writing to and rading from the files. For more details about the intervals and monitoring regions range, please = refer to the Design document (:doc:`/mm/damon/design`). =20 +.. _damon_usage_sysfs_monitoring_intervals_goal: + +contexts//monitoring_attrs/intervals/intervals_goal/ +------------------------------------------------------- + +Under the ``intervals`` directory, one directory for automated tuning of +``sample_us`` and ``aggr_us``, namely ``intervals_goal`` directory also ex= ists. +Under the directory, four files for the auto-tuning control, namely +``access_bp``, ``aggrs``, ``min_sample_us`` and ``max_sample_us`` exist. +Please refer to the :ref:`design document of the feature +` for the internal of the tu= ning +mechanism. Reading and writing the four files under ``intervals_goal`` +directory shows and updates the tuning parameters that described in the +:ref:design doc ` with the s= ame +names. The tuning starts with the user-set ``sample_us`` and ``aggr_us``.= The +tuning-applied current values of the two intervals can be read from the +``sample_us`` and ``aggr_us`` files after writing ``update_tuned_intervals= `` to +the ``state`` file. + .. _sysfs_targets: =20 contexts//targets/ diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index cb388d791ff7..26c9ab10daf7 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -366,6 +366,10 @@ is recommended. Note that Parreto principle (80/20 ru= le) has applied twice. That is, assumes 4% (20% of 20%) DAMON-observed access events ratio (sourc= e) to capture 64% (80% multipled by 80%) real access events (outcomes). =20 +To know how user-space can use this feature via :ref:`DAMON sysfs interface +`, refer to :ref:`intervals_goal ` part of +the documentation. + =20 .. _damon_design_damos: =20 --=20 2.39.5