From patchwork Fri Feb 28 22:03:21 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997206 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 52600C282C6 for ; Fri, 28 Feb 2025 22:03:36 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id D3E7F280003; Fri, 28 Feb 2025 17:03:35 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id CEEC2280001; Fri, 28 Feb 2025 17:03:35 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id B19F7280003; Fri, 28 Feb 2025 17:03:35 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id 86D12280001 for ; Fri, 28 Feb 2025 17:03:35 -0500 (EST) Received: from smtpin15.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id 10B9F121366 for ; Fri, 28 Feb 2025 22:03:35 +0000 (UTC) X-FDA: 83170730790.15.1098B06 Received: from tor.source.kernel.org (tor.source.kernel.org [172.105.4.254]) by imf12.hostedemail.com (Postfix) with ESMTP id 8220640006 for ; Fri, 28 Feb 2025 22:03:33 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=Qolasen7; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf12.hostedemail.com: domain of sj@kernel.org designates 172.105.4.254 as permitted sender) smtp.mailfrom=sj@kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780213; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=1YzCRybioufq7zplolrw6tSUnX2tLxgOwfIBlndR6SA=; b=a+ZIRv+Yg6j54FLFpLtsxbME9E3pcVgpOSRXB3UvsG9CJV/Xbsfkaj/fVFEJVCMYxbY0mH xh0ROr3wm7lm0bgB45MAf8/dx1cNcT7Pc04Li9vIzKAT4/twFAigEelWKsVDIvWvv5SLhh DEd+liOu/SePEtbJWBf2XQFyPsLqQzw= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=Qolasen7; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf12.hostedemail.com: domain of sj@kernel.org designates 172.105.4.254 as permitted sender) smtp.mailfrom=sj@kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780213; a=rsa-sha256; cv=none; b=8ppmo9QCYt4mTq1GsYgrAqSTBza3lnWD33kTMFhBh8+jtVFPW61XxhVWt6Wl1LZQhG7XfJ 64huwFVj9STtlAqb9SBiGw5mZBG2UQDfvzQc1r0Cnc2o4FCkOTIFUSjksqyZqMR+WPwhg+ OBroMAeqR56ovGvsWyDdCaWQe3aUWZk= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 3B8596116A; Fri, 28 Feb 2025 22:03:24 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 45DD2C4CEE2; Fri, 28 Feb 2025 22:03:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780212; bh=WFfBywqImxG6v/56XXskkWPj4/LAxcRbv+8nhLsSUtU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Qolasen77R4AKPul7302i/J/jc8m4WE1xtdK4RjnK3EFxeh9+4t71+pj9Z2eSeEdT woOrrZeEfGUNT2vNx7Gb4lkglQ8b4ISsvdsp/GEW/mG6ru7MgqV4z8JcaKmY2ElFgl 6MwBJQ6yxN+kyFlfctzeiQk0632wQ+iiBriNfSTVX/vy3042/Zg5KS/5v7hGCGS+1r uTRbplH9kcsuqWh5CC2AxegMw8s2Bs3ZrrfnVrWGyDIk1JnP7tVOMoFBP7/FmsNlNF l+4A8q1lKR6HjvEaxmwVujZkk/bHiReBrHC5gUsX37bU6D1LztW1c4Go5Ro/05v2HW RdIpeOQy5BPwQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v2 1/8] mm/damon: add data structure for monitoring intervals auto-tuning Date: Fri, 28 Feb 2025 14:03:21 -0800 Message-Id: <20250228220328.49438-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Rspamd-Server: rspam04 X-Rspamd-Queue-Id: 8220640006 X-Rspam-User: X-Stat-Signature: dxhwu1bozf4ybr519xkp4cwo85uf6kbb X-HE-Tag: 1740780213-553339 X-HE-Meta: U2FsdGVkX19Nk0mYXYw6WB6w/onoPjtMJ+PHKTkNzA5wjFz/xKqfp139aGTsO1nQRXg+rweCaEyMXx+UfPzUkeHr04BGPerpQEZNa6nSw4bsWmHh95p8jEIzBZA6yBh5fuDmPpB2eKFS6vkSROF88MhVcE2VUmy8qNbmGMJDGuvnp/wGrDkNv/Ny8GTWyo3rcOqTSQ2kKjmNtLMThpdqIKxPHSJujBLLyfJ0cre7q2PlgRK8+KY5hMWNaRYGtps5o0/dO7u6p1RZUT0FHW1oYhwq5HGl1tFz7IHmWq8pMFMxso9OVzM0Pqv8LAZFxykBPndfI7Vr532MRdi8QKalo15UgKIujk5mZ+0/5k1Zy3cE+1LceBfrY56cvegOUqE/pCGqums0Z4MBvh5iataUSg185KW3dQHY0bRtVKTeW7mT4mHF5LMekYcEMSQ4vWK9uqbjK99QOJX6q1Nhd28+XebE0X7PN8Cw/pEvDNQfyESc8l0XYm8hzBYoRx+lXvEzhwStBf+f2aha5iI94/eoiUEBq7/o/HHaeEOZcrEo+KXLFLfRenfywrsCoV3nf5QNpwunsajsf7wG+vkrLxcyJfbildzAn7k43INr9jKvIQA8alfLhWrlj3ZY1IrPPsxi8jT4lyLDHwJ+N4N5wAw5844ClHYUNXG7ldlFqew5hqRy6gfH8TjvREgZ/kzUtrT1hC25WGLm/fGc8dCwJ9G0s6lPSP5axFw3WI+7p+aDXN8uqkgbL2mjTXTsQsa44ypLpvB4TUM3MxCIHeQ5ocv9BL1ueEbJ5RFn5kC0fhTP1uOBBRE/DvhdeJGGHeYAdE/+Eu0BCvtohBv4xyIp+3N3qTaP0CELKDF06xRbhvUZykbBPbEqdlas4pPiiXNDSKgYEWFziFG8VmrAOEsbY8VOvw3eW4tHattjQndOO4W+41YPpTdFOTG4Sw1cwPR5ItRhp6hS7u2YvCwpVzSFucw azg2yZ/K AxHGkBz5PfyWIficDnub5x3d6RNtX4gJJIVxosuLZrui78IkBVNH3i9rKffnJw5NQEZr9pbtXhVKnb+KNT0wDNzKt75WC2htPFltFQB6NFda7jejOMIr8lHg7zUSuBRew6mb1Q9SMgPjYk/kVqSIVtgP2etLKreUp75wafq1CITIwODifIr4upuQG8mdJfbm7i8NaSN6QtuEWWXMnkMyo9A/3RkKGY+Twz4qfz6mArK53wYk= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000653, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: 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 8264e9f1db7e..130c3e01089c 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -664,12 +664,38 @@ struct damon_call_control { bool canceled; }; +/** + * 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 ignored. + */ +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 control. * * @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 @@ -689,6 +715,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 4bf8fb4e7ab2..b11595c01c37 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -638,6 +638,25 @@ static void damon_update_monitoring_results(struct damon_ctx *ctx, r, old_attrs, new_attrs); } +/* + * 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 = &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 @@ -658,6 +677,9 @@ int damon_set_attrs(struct damon_ctx *ctx, struct damon_attrs *attrs) attrs->sample_interval : 1; struct damos *s; + 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) From patchwork Fri Feb 28 22:03:22 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997207 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 7C7E9C282D0 for ; Fri, 28 Feb 2025 22:03:38 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id DDAEC280004; Fri, 28 Feb 2025 17:03:36 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id D3BF5280001; Fri, 28 Feb 2025 17:03:36 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id B8F1E280004; Fri, 28 Feb 2025 17:03:36 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id 9DF5E280001 for ; Fri, 28 Feb 2025 17:03:36 -0500 (EST) Received: from smtpin20.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 45EC514135A for ; Fri, 28 Feb 2025 22:03:36 +0000 (UTC) X-FDA: 83170730832.20.AE559D5 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf02.hostedemail.com (Postfix) with ESMTP id 9078080011 for ; Fri, 28 Feb 2025 22:03:34 +0000 (UTC) Authentication-Results: imf02.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=vGfRkR+Y; spf=pass (imf02.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780214; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=zmGs8Er9RYV4HDgxFiKDVP+pssCzJiVA9KZtO+ha3js=; b=5DNH0azDOYAyVsA43yw8NJyUPMZtB2TRznAvLok5KZR2JI8BFrK+6DZiSJl6byHkUo5oD+ vzEaUW2gn38iizQwVo1Gd74reLZGbjBNs1ZyVjrkrQ/hhbP1Ko4N9UHTfmREiFR3EYIPWP dRg4vuzFThmIElIAIeUb0yAwM7i8pF8= ARC-Authentication-Results: i=1; imf02.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=vGfRkR+Y; spf=pass (imf02.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780214; a=rsa-sha256; cv=none; b=NZOAEn1gz+mMLUhOdnewXBCsSR4760gYytd412lfXOA8zPkqysYTU8qfWksmiANtFYoy8D l4nGHSOPIVXq2DaocrrA4/KVa48Ql+nOuWiyCiUEVXtZXvFjQ8MF0H7SHYwUS97mtPgoju CaX3OVNfU2jNMAvxzXiEIKAeCw/GcK8= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id F2A0C5C6A40; Fri, 28 Feb 2025 22:01:16 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 781B7C4CEE2; Fri, 28 Feb 2025 22:03:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780213; bh=w21tstzzb4FfHupcVwHDLvqkq/QXU7C/Es38OxUzGJE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=vGfRkR+YJIBl3Vea7jC1iBcMljBOVbkTePmmNC8lkKlsV7rX0LY8snKXVd+qbhs/0 uMu5P8J3qPX6bnBq+lua2Djqx6g/S5QxO6G2/wGhW9ze/UmZOUqmW27vQbSnQPyp8v AxZUiJSIOp5uGFJDYsRcTrIi4aSBY9Se+BZeT9HplmzY02OL3VR512RWaaQgVeWCZ4 G+r3xT2IcgOR1AAilvNuSDoEb1zLS5rW6Vop0tRrfA6lauWKbkTwho6XF5uqmjcP3u BH2nWDJZD6DegKZqBfPB2ulMTD1R+0JGgNmUT/ks4s9JK36V76ceRgGMbp5BWR1ujv sv1J4TYVU+Y+g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v2 2/8] mm/damon/core: implement intervals auto-tuning Date: Fri, 28 Feb 2025 14:03:22 -0800 Message-Id: <20250228220328.49438-3-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 9078080011 X-Rspamd-Server: rspam09 X-Stat-Signature: 9t1dad4f7edgemb9rg6kmwbj9uohng1w X-HE-Tag: 1740780214-636716 X-HE-Meta: U2FsdGVkX19fYqqauTURnvFRDPKtqxoj5rEi3RFA8PfqBJ6jAcIBrCRfhqg8/e6SPORYrzje55IUcdUwScM8MHPNt+AeX2MtxpPQN8yqS7CZt8yYyapHhxOmrfsJ+gmNxuHeTbBy3nZvper1riV3Mo00DhR1+m66yniqgmKWBDfgXD0UvrAw2HgXjAmI4RH2gMOpiocK4PLjBfswxzgD9V0FLyeO5MwTEbCSdxMQry6BVmqdKVzGyLwCbVmasIuVv8QbPlqO1heweNls3XGmEExAk9cekNoXem+JsXYM8PIuT02sX7I/Rq+e+dTXLLFhS3UP/Wiuoth98ugt4APw9JJ4eoiUji2DRrKHtYDLHbMfUP+8qcO4eOGumkHwt/vM7tnXFlCMcm+vc8hvKrLaY4ft3kRu26vqI/E9tK6dG+6HQBuupqpztUN5ASk+RMeD0HFFTeXNYkfgy9baKLywtcklp1kALUulEs70qoeWs06sOZoMXB/pBFPj5JG8WJjCrXpcs01wFUKSe/YOWk1t6FJ8mbksQbNG0imGT90vgpUoZnd/8OXheY5shTdg01Z7AJaFs+4HTNcopNw9ev/gPDuGYMmTjJb08w4RM63cZa5DqFZRms7uVRN17Sh7tgEvtmmiB6+QRS0+DBT4kYVKuHhRgQOayDpK0+HsWGblxS7zTV+AdYxE4IvoD/mVKLQo7uxfRItxH61MUNT0ghY3Gy1JDbqKfB9Z4ihPUBXdH3lJoI2KI24G9azt4QQQSAh4g57LAznZuKc1SdLK5lcDNPq0KtDI3kC9aRa2o4K/IqvHj80g5N9+jjb+wRU4tzV1uokk1M5ZmbIp6lGQkYV4ED8637drSFt6Mj3002cgIul3i1c8Am3FyeAusuEBURyOLKT438yGM91bolmTml4wMkqKJVDu2LScXYhiDZG5K3L6b4iNBLzrUrc+Piibk1ThLcP7UiiKb0SNpcglae9 ech6+wW6 kafsY4+xfJ6VF9UMTiMwHXBgq9cYylxrFsWMpur/hG6YIICNcoZ0NiWKaXqzZpfY9iiN06Zeu86LApTwRwaPtLRC8rCiwYvEhisdsAf/H91FOco1oq/xsvBt+olHsPIGhguZQKH4Ou/L0W+Hx9SYcORO2Uk6jnfzaSW7IFfW2ItKHnB/ju9nbFP/s8CmOVoNfOkBadkzy/Nme6rLWPePV81MiqoQ9JRaCOk8dwegKyV9gaPw= 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: List-Subscribe: List-Unsubscribe: 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 130c3e01089c..eed008b64a23 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -718,6 +718,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; }; /** @@ -766,6 +777,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 b11595c01c37..d4fc2c907cfc 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -687,6 +687,10 @@ int damon_set_attrs(struct damon_ctx *ctx, struct damon_attrs *attrs) if (attrs->sample_interval > attrs->aggr_interval) return -EINVAL; + /* calls from core-external doesn't set this. */ + if (!attrs->aggr_samples) + attrs->aggr_samples = attrs->aggr_interval / sample_interval; + ctx->next_aggregation_sis = ctx->passed_sample_intervals + attrs->aggr_interval / sample_interval; ctx->next_ops_update_sis = ctx->passed_sample_intervals + @@ -1392,6 +1396,65 @@ static void kdamond_reset_aggregated(struct damon_ctx *c) } } +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 = 0, access_events = 0; + unsigned long target_access_events; + unsigned long goal_bp = c->attrs.intervals_goal.access_bp; + + damon_for_each_target(t, c) { + damon_for_each_region(r, t) { + sz_region = damon_sz_region(r); + max_access_events += sz_region * c->attrs.aggr_samples; + access_events += sz_region * r->nr_accesses; + } + } + target_access_events = 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 = damon_get_intervals_score(c); + adaptation_bp = 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 <= 10000) + adaptation_bp = 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 = damon_get_intervals_adaptation_bp(c); + if (adaptation_bp == 10000) + return; + + new_attrs = c->attrs; + goal = &c->attrs.intervals_goal; + new_attrs.sample_interval = min(goal->max_sample_us, + c->attrs.sample_interval * adaptation_bp / 10000); + new_attrs.sample_interval = max(goal->min_sample_us, + new_attrs.sample_interval); + new_attrs.aggr_interval = 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); @@ -2300,6 +2363,8 @@ static void kdamond_init_intervals_sis(struct damon_ctx *ctx) ctx->next_aggregation_sis = ctx->attrs.aggr_interval / sample_interval; ctx->next_ops_update_sis = ctx->attrs.ops_update_interval / sample_interval; + ctx->next_intervals_tune_sis = ctx->next_aggregation_sis * + ctx->attrs.intervals_goal.aggrs; damon_for_each_scheme(scheme, ctx) { apply_interval = scheme->apply_interval_us ? @@ -2384,6 +2449,17 @@ static int kdamond_fn(void *data) sample_interval = ctx->attrs.sample_interval ? ctx->attrs.sample_interval : 1; if (ctx->passed_sample_intervals >= next_aggregation_sis) { + if (ctx->attrs.intervals_goal.aggrs && + ctx->passed_sample_intervals >= + ctx->next_intervals_tune_sis) { + ctx->next_intervals_tune_sis += + ctx->attrs.aggr_samples * + ctx->attrs.intervals_goal.aggrs; + kdamond_tune_intervals(ctx); + sample_interval = ctx->attrs.sample_interval ? + ctx->attrs.sample_interval : 1; + + } ctx->next_aggregation_sis = next_aggregation_sis + ctx->attrs.aggr_interval / sample_interval; From patchwork Fri Feb 28 22:03:23 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997208 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 ACAC1C282C5 for ; Fri, 28 Feb 2025 22:03:40 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id C555A280005; Fri, 28 Feb 2025 17:03:37 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id BE145280001; Fri, 28 Feb 2025 17:03:37 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id A0838280005; Fri, 28 Feb 2025 17:03:37 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0010.hostedemail.com [216.40.44.10]) by kanga.kvack.org (Postfix) with ESMTP id 847D4280001 for ; Fri, 28 Feb 2025 17:03:37 -0500 (EST) Received: from smtpin30.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay01.hostedemail.com (Postfix) with ESMTP id 410241C98B0 for ; Fri, 28 Feb 2025 22:03:37 +0000 (UTC) X-FDA: 83170730874.30.F8E992A Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf22.hostedemail.com (Postfix) with ESMTP id A7055C0002 for ; Fri, 28 Feb 2025 22:03:35 +0000 (UTC) Authentication-Results: imf22.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="e/FphRjd"; spf=pass (imf22.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780215; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=QzvYG+cEAjM9AbEQ23ogKHWCItSVRW1Cs0pAW4+BkAY=; b=8SjR0Pna1i5G/CIR12d8Xisxnk19WDDTEvnOoMpWqUbvzSm4m/rrxtqFmMWDCFV2dK+yCA /nNtTHf8WCNsVUVfjtnO6hYamAZ0zYyonqF1VLE2Q0jLMAPLz9EkCsJbBqVm5u8H3VCkKQ wmQUBaay5tLD+yCEbqzbPcAQOdRPWso= ARC-Authentication-Results: i=1; imf22.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="e/FphRjd"; spf=pass (imf22.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780215; a=rsa-sha256; cv=none; b=pvaZhPUEbFC+zyEvqoKQ3oNHuJjTOmbUP2Ba/ksOfLHLAQlZH9kgOdXmeKcDbfCiieuDiX 2FToAwvJQ8bDBJonwOkB7vmHNH9Ywo5IjF0TZVaVd2J9akAiv5c8EmwNndNCOxbeWJ1PD9 f7dR3keRuVvnSAmX2wwwH6y/ewM5KFg= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 29B155C5D3F; Fri, 28 Feb 2025 22:01:18 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 96286C4AF09; Fri, 28 Feb 2025 22:03:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780214; bh=oYTrlxmiR5BNoFrioFop/hpnftvDsKcm3PmL/H0/UqA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=e/FphRjdGqDtr0R0HIkMrG187LEe7z469tMGPI07zZ54hj1kb7AgXUVnoFoTGPK7I tgnafQKOapIxO1YQszMqW1Y0QlZtSphOc/TYJdCb6hut5LvcL2v1DC/gASdD+9KVhv 9GWkNI9qH12ebwRByk2InerJEWBorZDbo0vHUnAO8X2kGYozCZZSPzyOMAiWHOfzCl AMwVQEXD7G2+ui63OTvUeghCyhujwrf7KtfkPX5J3EDroNetug/pRduK9yNplTXyn6 gFAJRK3rsetI3uZ+h7WGbC/XtbLbIzmCcnrSbtSZFQodT+Xrc/zICc3Zuk5OdYlAmk 5Rd2++9FJieEA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v2 3/8] mm/damon/sysfs: implement intervals tuning goal directory Date: Fri, 28 Feb 2025 14:03:23 -0800 Message-Id: <20250228220328.49438-4-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Stat-Signature: bmoyt11t4mi7od9smdjkhyd8aqe5ct8e X-Rspamd-Queue-Id: A7055C0002 X-Rspamd-Server: rspam06 X-Rspam-User: X-HE-Tag: 1740780215-612207 X-HE-Meta: U2FsdGVkX19FgOOP53FDdHByHYcUQNmQrA5Pn9FfzqraMelkTvqUqIlJp59azjLjMM2+pJeUqLxOstb9d/QdKEq6ifovBM8HBkqyFRjVi4YVxaQawN2Z4K5wkGwGive3akJU64JX2vNLo1CCFKNN7WElmCcGzq0BpZDCyHxBiF0kHnWEg5/O3DLqUwSV/38OGtOsgbhiY2bXiB0WCvCoYGhEioL+Bz6+SvYHnNE8fyfZWb6RBokTn3nPzTjfFZP4heLb5KQXyB+XRDAflq8UTVeG5elRi2i3gu6X1SBdsGCnWpQBjg4aWrAZn/+otvthdC1R5ersXMJv0cYPYgtiusBO8PAoXg4yDcBTQOPyzKw2B4bKDS0kgDJQXAfciQ5gjl9afCaQpAJVROyXWhk3XbkVephXTLx5TK6W98thA2gjeEmyi03DdjkQYih92IP5/PZi0eu6N3mQCeaFo4bSFryDPXZ5yCKzJMMP56/AOjLniinpbNJz6vfbwPnmCjssVt1hCSv7JdxlHTOum4UBl9vyZDKJvl1i6k3GZthjj5ZBDl/4J15aJOiwxu0+hafM85hQbtmeFkiWS25DeP2klIgI7zBLqmqMhEhsxHfX52S4KbI+Tiv90QQpDGlZ1VaT30FYrrLpnT114RKFtTAHzECDuDsXi4Zr6UqCoXzU0Qdldyu1LqB8jyU7qBt0epw6wYX2hvwNF5DwagX9LcetkNM3C3wusWLDYKkBEg3Uk2Rt0h3pQIr+a9P7OXRXUTOeaoV3jbKDDf/MzU1Cx6hnuKyf0eJwMmyJQusMGMzUP1hcJhX0cLp4zmMGb0XPjGekLxzDQBdi4AP36d6uiYRlCzoCnVkXjiCXovIMADcAK96hKH/rybExt5toowXVlpMGP3tp8CsnpI6wa1R03PtKl1wPMbhEYX7KUsJAolPFISkA98pkcgVR7JiLb0aYEDSAyEZ6T4l1aPy0wnS0qSU 8gb/FQpx tMzSUcWrj2SXu/+72N5LA82F51fmQg3d0DuS9/Qzh7fY7Pa97LfWrvuwekK3JcCQTFRZPLwz0K02qTlJeX3TjrGPoyJ2U2fFhfk9Zi5iQ0D+9ZLiG9vzvTpQrl7Sn/1sdZCYAO9VMfsJLeHwiJ+aNq7vHINSr+igmMeO/tjwkLIbtFeGY4VSYFnjP2KWwnbK1PSMg8XoVIBBpusOhuSXrT7SY28/NzYMyPPMLS108E+QffCI= 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: List-Subscribe: List-Unsubscribe: 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_ktype = { .default_groups = damon_sysfs_targets_groups, }; +/* + * 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 = kmalloc(sizeof(*goal), + GFP_KERNEL); + + if (!goal) + return NULL; + + goal->kobj = (struct kobject){}; + goal->access_bp = access_bp; + goal->aggrs = aggrs; + goal->min_sample_us = min_sample_us; + goal->max_sample_us = 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 = 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 = container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err = kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->access_bp = nr; + return count; +} + +static ssize_t aggrs_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_intervals_goal *goal = 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 = container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err = kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->aggrs = 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 = 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 = container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err = kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->min_sample_us = 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 = 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 = container_of(kobj, + struct damon_sysfs_intervals_goal, kobj); + unsigned long nr; + int err = kstrtoul(buf, 0, &nr); + + if (err) + return err; + + goal->max_sample_us = 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 = + __ATTR_RW_MODE(access_bp, 0600); + +static struct kobj_attribute damon_sysfs_intervals_goal_aggrs_attr = + __ATTR_RW_MODE(aggrs, 0600); + +static struct kobj_attribute damon_sysfs_intervals_goal_min_sample_us_attr = + __ATTR_RW_MODE(min_sample_us, 0600); + +static struct kobj_attribute damon_sysfs_intervals_goal_max_sample_us_attr = + __ATTR_RW_MODE(max_sample_us, 0600); + +static struct attribute *damon_sysfs_intervals_goal_attrs[] = { + &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 = { + .release = damon_sysfs_intervals_goal_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = 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; }; static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc( @@ -436,6 +595,32 @@ static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc( return intervals; } +static int damon_sysfs_intervals_add_dirs(struct damon_sysfs_intervals *intervals) +{ + struct damon_sysfs_intervals_goal *goal; + int err; + + goal = damon_sysfs_intervals_goal_alloc(0, 0, 0, 0); + if (!goal) + return -ENOMEM; + + err = kobject_init_and_add(&goal->kobj, + &damon_sysfs_intervals_goal_ktype, &intervals->kobj, + "intervals_goal"); + if (err) { + kobject_put(&goal->kobj); + intervals->intervals_goal = NULL; + return err; + } + intervals->intervals_goal = goal; + return 0; +} + +static void damon_sysfs_intervals_rm_dirs(struct damon_sysfs_intervals *intervals) +{ + 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_sysfs_attrs *attrs) err = kobject_init_and_add(&intervals->kobj, &damon_sysfs_intervals_ktype, &attrs->kobj, "intervals"); + if (err) + goto put_intervals_out; + err = damon_sysfs_intervals_add_dirs(intervals); if (err) goto put_intervals_out; attrs->intervals = intervals; @@ -599,6 +787,7 @@ static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_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); } From patchwork Fri Feb 28 22:03:24 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997209 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 A708EC282C5 for ; Fri, 28 Feb 2025 22:03:43 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 52786280006; Fri, 28 Feb 2025 17:03:39 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 4D821280001; Fri, 28 Feb 2025 17:03:39 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 37A7F280006; Fri, 28 Feb 2025 17:03:39 -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 17154280001 for ; Fri, 28 Feb 2025 17:03:39 -0500 (EST) Received: from smtpin08.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay07.hostedemail.com (Postfix) with ESMTP id 96595161021 for ; Fri, 28 Feb 2025 22:03:38 +0000 (UTC) X-FDA: 83170730916.08.C5B622B Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf01.hostedemail.com (Postfix) with ESMTP id 07FB24000C for ; Fri, 28 Feb 2025 22:03:36 +0000 (UTC) Authentication-Results: imf01.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=RcCtkQaE; spf=pass (imf01.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780217; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=8i/oEMB3GKvldq7PSmxuz4yWzXxV5X+RjRs5ixg/ZME=; b=W0Zgt6mpFCLigDpe27L0jcxPFymvdVBO2DeeiLBaUWBkdUpfG9ack6c8vUu7TPK47ade9H vplB4Lu81OW5Sbh0vnZpGbeK9SJ47R3HOSr3KIfebRv5zC4ziOILkqSNenyeHgQu5CuJMj y5rvDiFAxHCQm6z1M5tz4t/sUk/6iTY= ARC-Authentication-Results: i=1; imf01.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=RcCtkQaE; spf=pass (imf01.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780217; a=rsa-sha256; cv=none; b=1sDxWpijxQLyNC7CFtEB2lIq6FpHltsxmoYRWXtBCHy+E55Ibs1d781R0EKJ8fjyfEgMJi SFCyCZLEcyAxX8ek7BshoSZuvdcs0+cirmV1RzjyzhcBPoMXOHQr1Ur+mhGOgT0NP7GCA4 kpTbGjdrc3XzYJzN084/QfBZSJWGi+s= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 6CCF75C6904; Fri, 28 Feb 2025 22:01:19 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E878BC4CED6; Fri, 28 Feb 2025 22:03:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780216; bh=0K6yd3M1vKE/q1zzJCXy7CoQ3azMzfYHIkHl3bOjRxs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=RcCtkQaESFf5y1g5mOXKOhQCuzU0QktIpwpSJaWldsKbKMwcF+S0oFoQ6Y8G1knlH fTjzAAZ/DpjUf7jjF5IbgcGZLXhnqPkEu2hUf/UCy4LCTaqE2kfxirOuWKGe/J59gw oFnaoWl8vZcTfvZJH/4/vI2aCZ+s5hPB6Qbxj8YdKtleklCm6dJ4P55adsA1VAbjY5 iKzsa02CZc3r3vjfLJt9Hzx8UHr+2B/E5yhqqxLLCeBdCMLeZGri51wLi6Q5u+wDuj uV4EA/ERkJx4Fzrp4TkmlwFogk98r6AVOtmBb2hxSGVpEllwkEnuGgXKfk36s+95nr ZhvKbvfDpl5WA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v2 4/8] mm/damon/sysfs: commit intervals tuning goal Date: Fri, 28 Feb 2025 14:03:24 -0800 Message-Id: <20250228220328.49438-5-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 07FB24000C X-Rspamd-Server: rspam09 X-Stat-Signature: zm7f4j65tn4kmfzhipw7j6baq4s6r9tc X-HE-Tag: 1740780216-742972 X-HE-Meta: U2FsdGVkX181xPuuDPa7zlnWAg/C65NovfEAaaGxndF9ZBPIOmcjl2K3bi8F7OaQqzar6BHIjEm5fMGcs4mhCY+H/aH56bldXBKjFBVBQqQfj2YnzoLVjFU7AjnRL4knr83oDW4TJY0eyhZc3JalsgOTNmJTTiKW2knvU9XiMQ/AXtlR3uvR13NYwXYB1ccR4LGS6xVX+hPuAckyvL+yhP5g0MKuy3brpnDJQmM0TBzVpY+CjRWI3BDdezxu57UbU6SBDseT8hKVMCYVc8QmAiLk0grUceQn/thWLixrqWfV0WXKOuHjlspV6g18stlxPOYTUjs+2hzaxgr2bylsVQ59aPLCGHdoBzJpJLnqljwKErR99p9K4wm0uoVFVyU7aaBQAs4a3sBhbX5UogvR7NvtSauigqZHgDSCJ+qMGgyCDCVaqvJeU4yhVNS0dNvvrCd1rLsjE8ybCpL0g7G66P05GSEuX5XLM2l3Q0ioRWVqRzhwiN5d2m+quD9PPCeD5rlDeMglQjQeI95PlUDWRZkluektF/qjBez1YjJ0hqHQoA0d8iRua+eBOZrIpyn2MBEzOf/4EET8JTSaGcG+JF2dKKv/CSleQ8ZRC64sG475d8Y5B9pF1kBMbo2IWyQBW1w1Os6AOicj2j8vvuQYXQ4ysq0vdN8jvEb5BVnFJ3Mz6BTJFWQu0OTrZ9hArD2SZLzlZT+V1GNEeWhFWpWhEbxUR2pAJTV56i4Gpk10wJpAejWLPJqJ1CKJG0h7CzQbZl42otsestXdWq71XSaF8IMriagSDPM3c6WStfzI5nmtsXja2rGosRpqf06KoR9X/9jkifHoMoZLaCpJq7RxiefqIO2OvTf9jcqMmL8oeaL4rFgji9cRlyPjhoYQQnP+NZy72iPF43ExtAbbiWujquKYzHj1iQ9+fkRmKqc0t2d66vW4xiqsy57A3FVIvp90DOOOHi1LupzCa572KOj 9FfeO4mr QL3o4w4i07RyHeTVk0BhLCVEKTHZglCTsvxXSXv2NkMNcJyk+60JAUfsCCWAqvRDI90UHW3sfT6jSUpESvpsiDjvQI84e1AvjwwE8fo3EkuAlbYPYboyx/HBV3c3Dx85N92Wxq9s+C5J7vQaN39ZTmEz0gBrHKoGo8FRpwDtAtOkxtfcXWEOfdpq068YRgzHyPIYMN8g325RzvsMezUv7zKNsKHLn+8jKSpanh215wlEZBPE= 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: List-Subscribe: List-Unsubscribe: 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 = sys_attrs->intervals; + struct damon_sysfs_intervals_goal *sys_goal = + sys_intervals->intervals_goal; struct damon_sysfs_ul_range *sys_nr_regions = sys_attrs->nr_regions_range; struct damon_attrs attrs = { .sample_interval = sys_intervals->sample_us, .aggr_interval = sys_intervals->aggr_us, + .intervals_goal = { + .access_bp = sys_goal->access_bp, + .aggrs = sys_goal->aggrs, + .min_sample_us = sys_goal->min_sample_us, + .max_sample_us = sys_goal->max_sample_us}, .ops_update_interval = sys_intervals->update_us, .min_nr_regions = sys_nr_regions->min, .max_nr_regions = sys_nr_regions->max, From patchwork Fri Feb 28 22:03:25 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997210 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 DFD65C282C5 for ; Fri, 28 Feb 2025 22:03:46 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id F1344280007; Fri, 28 Feb 2025 17:03:39 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id E9DCE280001; Fri, 28 Feb 2025 17:03:39 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id CC86D280007; Fri, 28 Feb 2025 17:03:39 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id B16B4280001 for ; Fri, 28 Feb 2025 17:03:39 -0500 (EST) Received: from smtpin09.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 5987F141361 for ; Fri, 28 Feb 2025 22:03:39 +0000 (UTC) X-FDA: 83170730958.09.44BFD45 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf22.hostedemail.com (Postfix) with ESMTP id B6663C0005 for ; Fri, 28 Feb 2025 22:03:37 +0000 (UTC) Authentication-Results: imf22.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=ZyUvQ5RC; spf=pass (imf22.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780217; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=wecWayJya7F4S/L3tq2SIKHIfTBd/Rti4Uu+Pf2IOVE=; b=KctJrR6TRjFA9AwhY3uFHyt6vE9+A4ztJpPHy4IFuGEzbY9+7Xj1Hm5fCQf/iFa4Wuhv2c R7XD/2InMiN3APixSPwbQvKGjHALqX56mN7xFkTAa3kaPfBVV0VfThtUESg9tv3Pw8o/Rs n4zDtfuEGT5k7E+0Fwr7omB+5Im6ymU= ARC-Authentication-Results: i=1; imf22.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=ZyUvQ5RC; spf=pass (imf22.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780217; a=rsa-sha256; cv=none; b=LPZt1C5FEEij66MzcLqPxd7id7HO5JW3oltBrZfMT+kkXzIMZVyaXp9/YrUPGuH9CF+hpw Qukcv9blnT/bjdfI76sH4k7Jz5jLzXT5jH9wxwfbZFQJU8Mj9VqJ66w2e2Oz48WRZyAZyY hP30ORC4lajwf6GBEHqmV14idIN5TzE= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id A24065C69FE; Fri, 28 Feb 2025 22:01:20 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 26C68C4CEE5; Fri, 28 Feb 2025 22:03:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780217; bh=LSjpeMzXWVkQm84u7Pg3DRD/aAE+XvDLQxgeGEMx2JU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ZyUvQ5RCMFQwflA+TMO8dM7S8jYiryk86Led7r9AWzRFl7xTVycCaRQSn1iJo6WYv jztKcAwB8eAZ0Mkw/Tp1l2SfKnkW5IgmEZjQsG+pC3+R0t2eFqcLFn+SkJW2s+YPgT Fq8ncuwkI7PWynynSVOXwUSMbMxEipKUZXQRZI8ClmQP3EewaVcrxLoybZrBGiWNHa W6EPURqnOVVydku6UCehBFEThJRRLqGY0/9ZDtcGz2xiVRznycPdk/dAcUNjQjaDIb ryk+5js4ai70mv6qkGpCl6Fa1PEi/gHMcPPqChg0z3KCjS8gloBVy2iDJXgealPOjR 0cOIV0q2sQX0Q== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v2 5/8] mm/damon/sysfs: implement a command to update auto-tuned monitoring intervals Date: Fri, 28 Feb 2025 14:03:25 -0800 Message-Id: <20250228220328.49438-6-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Stat-Signature: qgda31t5bb38bwr88uxegqj3objxeggx X-Rspamd-Queue-Id: B6663C0005 X-Rspamd-Server: rspam06 X-Rspam-User: X-HE-Tag: 1740780217-54638 X-HE-Meta: U2FsdGVkX19HeM5egVVyWC1K/MIghuRWsqj3pPdv9zSJ7pINVZno6l5XkUX6RRR23V9wsWpmNppeecMeAdla3UEOVZqTeWKDMIC6BmEFU8DrNfBKpzti+C77FrITvWuCWdzzIuLGF8RGlrmBt4fXQtO/Hr0EYRHyx2OXqCHzJdSmzaQ2TiBFRSxDarCBtUqfQaUSHKXyvo3T/YtTmklLXbibrgJ1h1YU/IVEmP0YnqvtSAIyovcqszc0QoF/HdgeS5F/L81Y4GkAojBI9jyvYkMp54puUHdetN7zOyDSmog/sjfq7nubuKmjgz2tTV8kKnmqKVTyfCTRb6+OCYSOUkRDTqAQaFoSbFIY9rLEO31p4U8ZQ3wgSu41vOuvhOGQ/zQXujZHDizM83i5hok2fOS3fYgTQME5rpvKnXmHwEaj/028fBdkCgcxTk249uEvCNs9yPDI4E2IBrU8cX1zEkXtdjtrgaXEgBoaT4orIC6E1+xLphpMlkIK6ssAMaTGNwDLkSae9xZHQHgrmBKOHCoVUtLjDLYMdbbRQI2Ni6t7MCXePaxbmPpy47ZBLiGxVDv0gvxG7Io7l4pv7JYw2f6x4lwVVDwmWBgCHEVwPCi8tytPlKqmz9lgIfG3ZXj7IbaCuA/hYj0tUPyqF1yyd9cMwspsOvqXBF9i3i73ZxBESYJnA1KEm9JF2uLnEsaTaAGOLH+TGBr+MAvQdIbuT+wmRUT1A2vgkc89keMC1cJjbI/+hG35OUcs9sst3xm/OiH3WF9wDaqiSwuxw1z6YduGTgt/09oSnrGUazJHQcPDcV3RTvUq+veIdsr/0pBcEuEZC3QFMYHMjgx8O1EBphc2SjdPZ+hm27N8WG/h8vzkg5sDxux0lfqQsQUzNdUyr1VYf2nOIpsNXg3W5yaPeabRC3OitOGpc/9zUz7zdKP4Y6PascMTU8sG0D1da4gSPgOR4lm2/pkoZ6LXGo/ WIGtMjFl Im2WUdfMNnnx9fLCRMFrSqnl7od4YmMHvvdKQjb30gMHkHZFwekYm3Q+4GDRftQmblvbMTB63S6mf0L6L4cYWmaDA87zYvr+l+CL9gLSfp4x7TUSx/ACJHbea4xlllT0vcY+j4r0OroqfXeSAvs7xBX+Z4WVlV5qI9yPZTMtFD/ZhVAntoSLn35ekpkJ+mAb1tw/YgvulX3SQSBYtDez4vfjq3vEP8lfyclUyUQxmsew17oA= 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: List-Subscribe: List-Unsubscribe: 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[] = { "update_schemes_tried_regions", "clear_schemes_tried_regions", "update_schemes_effective_quotas", + "update_tuned_intervals", }; /* @@ -1502,6 +1508,17 @@ static int damon_sysfs_upd_schemes_effective_quotas(void *data) return 0; } +static int damon_sysfs_upd_tuned_intervals(void *data) +{ + struct damon_sysfs_kdamond *kdamond = data; + struct damon_ctx *ctx = kdamond->damon_ctx; + + kdamond->contexts->contexts_arr[0]->attrs->intervals->sample_us = + ctx->attrs.sample_interval; + kdamond->contexts->contexts_arr[0]->attrs->intervals->aggr_us = + ctx->attrs.aggr_interval; + return 0; +} /* * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests. @@ -1723,6 +1740,9 @@ static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd 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; } From patchwork Fri Feb 28 22:03:26 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997211 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 BD873C282C5 for ; Fri, 28 Feb 2025 22:03:49 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 8DFBF280008; Fri, 28 Feb 2025 17:03:41 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 88251280001; Fri, 28 Feb 2025 17:03:41 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 6FB61280008; Fri, 28 Feb 2025 17:03:41 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id 490AE280001 for ; Fri, 28 Feb 2025 17:03:41 -0500 (EST) Received: from smtpin05.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id C8BCDC1398 for ; Fri, 28 Feb 2025 22:03:40 +0000 (UTC) X-FDA: 83170731000.05.067FD59 Received: from tor.source.kernel.org (tor.source.kernel.org [172.105.4.254]) by imf29.hostedemail.com (Postfix) with ESMTP id 3BCAA120007 for ; Fri, 28 Feb 2025 22:03:39 +0000 (UTC) Authentication-Results: imf29.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=ajQa2jtK; spf=pass (imf29.hostedemail.com: domain of sj@kernel.org designates 172.105.4.254 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780219; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=SaLnG8F9so66bZwrCQn2mXwK3Qz8oyckNSgefMuW9WE=; b=TXyq+kYpVPCS3RIrMuzt6ppH/0tFl2Da1ZLbw3EYe4/HpidFhCvR1/1q2m2SiN4EML9gzH szmSkMO0DWlCZMgOObHZKaj3di3i3L4l1gVGxIhTA2w2La1RxY+v/mHHjN9JCjQhy2ixz0 jLTrZKX+uLyVUseT2CedZVQJSggR6zs= ARC-Authentication-Results: i=1; imf29.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=ajQa2jtK; spf=pass (imf29.hostedemail.com: domain of sj@kernel.org designates 172.105.4.254 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780219; a=rsa-sha256; cv=none; b=iSjihXj+zkK6KlkJwI7Hh5+E38ZX5hIrhIvXLQ7h9DY/qvQppicU6FxCoQy3M1usfbtDE2 6dxpo1TOvEGifHDnGu4miXSVBA/Mxw3QRVnkACviHrzVTNBLtTfO8KpoKaKPltfW6SMaUp 9yyKSaPNedm4CXL79lePrIlCQi3Cfrk= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 243AA61160; Fri, 28 Feb 2025 22:03:30 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5B641C4CEE9; Fri, 28 Feb 2025 22:03:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780218; bh=lz38ZfaiLRvrAxvubSW+sgoHg1CnZkQRWxBUnqzdWlw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ajQa2jtKMbyi6nxzW5Lc6EVqDsUDtcxOIO2hfWYywHFkfkP4rbp5RZAMPZNmG715S UCM+wPFTFQPTDm/5EebwAntpeZuspJtiJg3R0GIstymjrCq/0YiyKgkqa8t5mtloPf yWMUNq/SIWdWFIeunONR3vARkdI03fGWwnyBf3PftIGIvaH5ZDm6iHeH62oJQc3MPe k41CHY3GqcGlVpqcMzvu34bAin6xmou7DwaWGJSOlvagKbejFCNrVGb3UKuH8gHjJU RsgiZzZm7vJg6aVneFZD4mAccNKMnXuSN1VaocW4xg6nl48Vcp38nBo6oZA8cpED5i g6VUMB9GkbSfA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , 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: [RFC PATCH v2 6/8] Docs/mm/damon/design: document for intervals auto-tuning Date: Fri, 28 Feb 2025 14:03:26 -0800 Message-Id: <20250228220328.49438-7-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 3BCAA120007 X-Rspamd-Server: rspam09 X-Stat-Signature: heyzujruaczz5fh19if8u5wpkwfs6yh3 X-HE-Tag: 1740780219-755137 X-HE-Meta: U2FsdGVkX1/Gb8y1rQyZvrOMhQ2FRFeGg6jIYhKD0VFZgtK/gFsrcgdWhcgh6mVUnLaS13Elvbg9j4RRFskPfT98FOjgPN82u53gJyxY0SOIHNhk/bazr5hje4cWNKpvSW+B7KX+fobl3t8+/Kae/70GcXJpaEPYqcch+g//O9KFDlnUshrAQWgbsv22do07SfbM3bjXYe+Nku4IH4mHAmPWA5hQZNy+M+ZARRMmQXiKPoX0ByC/obToe53GnfyLkN/JL2LTpYMHlKQtu/dyeYs0tEPBoThMRqZeDUJhL+R4VyVgHwo3kvWorDKeED52U6E+VFCy8aodGz4hMvnV4F0zVHBh434Ltxv0j7xiYU7ifQNZ1YAvnEN94MdSbRj5CpZKAhMUHWI68Wre6OYkwm0wDcmNYA7GB1FraxLDCFfZFKdMuFOYejCra+Mp6vfcUebF3TEn8eUeaaDu0sIg2/oq91qNeBmoMssZhxSmXQwOw0oR94xd0qSjNWZ5muvb4ArYPxBwWJW58nGrkapUizVOk8vtqsfklojN3+c2ieniOquvq3iFNYfX7bmhZuSl6/QCL2qvo/ZVLXh0sJcMo59vBTl3UMYJjWn0L1Qz0vnqdh74+Scfm/7VtTtWCDRcq8Xc92H5HjdncBq32LvOia4aOJClWZaGUbzqqCr9cAELwJ7Q8EzO3oVm3cvW8y6QSGKqhKLCxW3Boj00bd+e08Gfwn83ibOdNm+z/d8WaK4DQY2BFF+UjBo4DhXvDDomHrEX87BBQaQVZpyWbAWnCZHs8nSdwfxLseFmx/Dok/mu9jn4+gXE5w1hm9qb7njmJEtx4CwXDiPUOqGAu/ZdDNLfjwJkissREPTakng60a3F+6iMJ3J6HOzaoL6wKyEpzLtEy3MtlnJlhxuuwSUAM8TGJRKgTK56ZZaD3BCanLWm1u099KVzUdgzGSAko0UmBUZ9rfiz27OC7yy5I2B Tm1GCm0W NRRYLNGma+lh4tygnVwH+Gy4/VauzgPYsfQYx9emal81V40ytbue/eLXtOnkRqqD6rDT7kh6cZtpaTPzx1aMLoqM16Js/7HwbpYIyynPWPrYnCZMPFixSWXWdRG/ryAIbQtjk9hhZG7VjSP8GKJT5CRpqG7MATgLvEZ+EFY46z77MCy0Em6IX92+aPu9cw/MjdpFfnEt7iJApagWzM3UrsaCA5Hayo0vbZDTc99bfOriYZgXl4WXIJ5xlpgNoDZ0LSpv73QGQQRoRmlQ= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000206, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: 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/design.rst index ffea744e4889..0cc9f6441354 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 unnecessarily further lowered. It is recommended to be set proportional to ``aggregation interval``. By default, the ratio is set as ``1/20``, and it is still recommended. +Based on the manual tuning guide, DAMON provides more intuitive knob-based +intervals auto tuning mechanism. Please refer to :ref:`the design document of +the feature ` for detail. + Refer to below documents for an example tuning based on the above guide. .. toctree:: @@ -321,6 +325,48 @@ Refer to below documents for an example tuning based on the above guide. monitoring_intervals_tuning_example +.. _damon_design_monitoring_intervals_autotuning: + +Monitoring Intervals Auto-tuning +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +DAMON provides automatic tuning of the ``sampling interval`` and ``aggregation +interval`` based on the :ref:`the tuning guide idea +`. The tuning mechanism allows +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 events +(``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`` aggregations, +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 ratio. + +The user can further set the minimum and maximum ``sampling interval`` that can +be set by the tuning mechanism using two parameters (``min_sample_us`` and +``max_sample_us``). Because the tuning mechanism changes ``sampling interval`` +and ``aggregation interval`` in same ratio always, the minimum and maximum +``aggregation interval`` after each of the tuning changes can automatically 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 target +is recommended. Note that Parreto principle (80/20 rule) has applied twice. +That is, assumes 4% (20% of 20%) DAMON-observed access events ratio (source) +to capture 64% (80% multipled by 80%) real access events (outcomes). + + .. _damon_design_damos: Operation Schemes From patchwork Fri Feb 28 22:03:27 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997212 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 9A8BBC282C5 for ; Fri, 28 Feb 2025 22:03:52 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id ACF15280009; Fri, 28 Feb 2025 17:03:45 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id A583D280001; Fri, 28 Feb 2025 17:03:45 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 8D01A280009; Fri, 28 Feb 2025 17:03:45 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 71590280001 for ; Fri, 28 Feb 2025 17:03:45 -0500 (EST) Received: from smtpin24.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay01.hostedemail.com (Postfix) with ESMTP id 316721C98A1 for ; Fri, 28 Feb 2025 22:03:45 +0000 (UTC) X-FDA: 83170731210.24.EFC3D3F Received: from tor.source.kernel.org (tor.source.kernel.org [172.105.4.254]) by imf11.hostedemail.com (Postfix) with ESMTP id 9581F40012 for ; Fri, 28 Feb 2025 22:03:43 +0000 (UTC) Authentication-Results: imf11.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=IwbR1DRq; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf11.hostedemail.com: domain of sj@kernel.org designates 172.105.4.254 as permitted sender) smtp.mailfrom=sj@kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780223; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=25rXZSMHd1vhUYjPK1LrUL0DL4Aip6M91aIUDVF0Jj0=; b=Y97TWMFuxrkdB+Xk4AcFcBmycW2IxA53NlNASrNRKpWAjiAvDbEJ3yHMGd7jFrieqGNQW8 5ifXwTxpvgTOHHwbDqQg/8vA61/0EnU0j4Dweg8IXiUrxq0H44vlVvGiJ6r/wxZfbkYiHw TnOxu9sGbKfZlJSUo01jJn8MGJUoQHc= ARC-Authentication-Results: i=1; imf11.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=IwbR1DRq; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf11.hostedemail.com: domain of sj@kernel.org designates 172.105.4.254 as permitted sender) smtp.mailfrom=sj@kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780223; a=rsa-sha256; cv=none; b=SJp71DIM+UGqbZ9Rw14cevwA+2TCDV2DAQZwrQdEu3hxEuxzUphstcXJr50LrY2BsQtws9 eBwlJUhrGs+S+zAbMJZ7OYRR7s68zSkBBAmVitbYfuzoSQ7n3Xjz+mvkByBj9bZO8ZIhv9 tC82YftkcNC5p9jnbjzT07fRJ9Kgpdg= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 42DC66115C; Fri, 28 Feb 2025 22:03:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id AA81AC4CEE2; Fri, 28 Feb 2025 22:03:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780222; bh=B70HmhIJO7Eh/CP1TQGw5euMpvWBGHv7eOKxBRU5Z5w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=IwbR1DRqnyn+hhaN7l8cEj7lEPg+iYG8BDSQFmBJ0uc5SgEbwpsfOS+vQ3X/N1P1R FKmdUpSI67JyQy+A6WTma7/nvUtqicF4UABpFa5V2aeuOVDBdxHivm37a2hKwqw4nt tKW2Qh5r9agqTfUF/0H0Setjo1SPsIUDp17vQTZC22SXxEP/XAtHHcShJhgcJhmkSd bgKtbzzJEiOgwK4tdCnrNEXwkLnOfK8IGDTi4B0YG3Ayqn/eOwxQWp3rTXmT47E9yj KsSbhVijI3bcFHkr6kiWd0oGvVZ+s1K/E+5J/WO78bPVdZxxbSFxfmGqL6HC0aU82H 7/ZFu9VMp1Tvg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v2 7/8] Docs/ABI/damon: document intervals auto-tuning ABI Date: Fri, 28 Feb 2025 14:03:27 -0800 Message-Id: <20250228220328.49438-8-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Rspamd-Server: rspam04 X-Rspamd-Queue-Id: 9581F40012 X-Rspam-User: X-Stat-Signature: 5sdeeq7xs53xocaafe7uwdi6gr1j35x9 X-HE-Tag: 1740780223-552232 X-HE-Meta: U2FsdGVkX1/NHvbJ/Lk2nfIgch3KnVBe+gpDfLDCmKRHAswFMPVXA16+Sj7Ec2lj2om8zRfaAAxS06YcJl0IdE9EGKPdzMSrGVY/xTeR2cGT0aD3scmct7FwjP/V9NnnXQFwNPWo5KfkyfnXLatZ39kUdRlaH0wycOI/ZYo8mJmulIJbVnrdQf1oSQQZh4cBBlP09SAIVLwefq31M4LY4kabGn7wGsiotfgNCNPZZwN7DJ2qC7COmqq78oLcXE3bUi6LHNjuttqpvRbwxturCn+76l/k2teUUB7Fdr0qqAD9eHIMGzFsZZ5njpulpNEmvFV3XwhKdGTIeGUsFn7DbRDMevlaIRZEhxiofn1NgracK+SD06a/L8G23ukB67CTDTjsPcR5FWl10M3Ux5SVqrLzcjDdmKNpz7RlSYbkV83X1Ma/lN8dJG9bajEOy8bOw8M8yBgWnrw8/m1IWrMnyVwmUlYAQC55XdmVA2JJijQBj3xKxF7lZ3m9FEVG8ALl0CA9a5Ua+jw6L2HzWYNWhNgeZBbTlrEBZXY8xAH/rZbm8AVq6mpsmoCUjpMK1JUDQQQvJtOHT/bWBbyaYNJAVPOOKhUWDSZDB+uUM2Z6j5gP75F2xdyCHOVyosgGS+R7AVhibeOvU0biSmDN+H7Vn1rPER2+qvnlxszvO8+hUt9A7T+6sbUU8kBFzSOAWXRKGw6vCkeF8TjpVcSTY5xhRHOvx9mGfu6TzflzyIwNpgpaIBUI5bH9QFoyirXzBvC7rHrtYc6HLVIaiKq/9/9B57I1Xa3EOe2+EcAQYWkA2hBapQ2qIvGDbu4cx6R7MgJdSCUJVo3UPTfOOaVahJ5xoHyAn2jGPF33AN/yVgMTkozuPG/HssVlncbRlkDJf6HkjbJ6WFpbO9ra9uVsp/8H+PG1GqjYW9ZBgXYkSL7pJpHdH4H7NtbWAg17iFF1y2d0hT+gjBXqOUjUaccGbHV 0FB4Bylh bz3pkADEbrwFR/b2Uq4cJ9dpoRwArnsEqE+3jQYODGts5WynVWIGFsuoceVrlROhQlsnoe/Ojjs+2YdzScj3LE6KSzPxOtWCeeDk9+WddOZHrDc+KdaGi/9OdccQ+wUGbLXqLkOhYP0uKVbDZ8DzwInBiH1Iumn71fiaK1zUZRPzS4ePS75i9ORhLGxXZ/cpxw47DCxPWscKkbyJj+AQ5rGSiO3hBdalV488F5gfYW17FTmG+ScB8xcsqyF+9bqEA0s7Tv0WK4uvkeAI= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000010, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: 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/Documentation/ABI/testing/sysfs-kernel-mm-damon index 9666074f06f3..293197f180ad 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 update interval of the DAMON context in microseconds as the value. Reading this file returns the value. +What: /sys/kernel/mm/damon/admin/kdamonds//contexts//monitoring_attrs/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_attrs/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_attrs/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_attrs/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_attrs/nr_regions/min WDate: Mar 2022 From patchwork Fri Feb 28 22:03:28 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13997213 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 9DA00C282C5 for ; Fri, 28 Feb 2025 22:03:55 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id E01E928000A; Fri, 28 Feb 2025 17:03:46 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id D8ECC280001; Fri, 28 Feb 2025 17:03:46 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id C2A8228000A; Fri, 28 Feb 2025 17:03:46 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id A25AF280001 for ; Fri, 28 Feb 2025 17:03:46 -0500 (EST) Received: from smtpin29.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay05.hostedemail.com (Postfix) with ESMTP id 5F10F51049 for ; Fri, 28 Feb 2025 22:03:46 +0000 (UTC) X-FDA: 83170731252.29.E07966C Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf12.hostedemail.com (Postfix) with ESMTP id 9B9CE4001E for ; Fri, 28 Feb 2025 22:03:44 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=Nq2iiPk2; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf12.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1740780224; a=rsa-sha256; cv=none; b=f8rU0/l+WSRIxQt5EsxhhXOFQoTI+No6bTqbcjgnPpipcvisobA0pBIgSpSWsiboXBa5I5 CJVAwQTWcN/iqQSGIaEhUOrnpPos87TWyadVYCsGHg//WDj2eCQg8yIlE3gQAAGzlVBScL LMzZfVTvTRcWI5s05JB/H7zkm0Aui0M= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=Nq2iiPk2; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf12.hostedemail.com: domain of sj@kernel.org designates 139.178.84.217 as permitted sender) smtp.mailfrom=sj@kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1740780224; h=from:from:sender: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:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=bVg1UWRq+jplojKVJsv8iNMp7YxxSUDLbXksMkp4XAA=; b=oMarS0hozQB5IT9vrfhvd5ofpnZz64BkL0vTYq5xNdLiq8LNEO93S1NDqTR/GFx8mvC+cV zW6cdKVlZQJkRCMzVLUQ8CXSnLoQNUN/niEDtTKnrzSAwxXcraLXTS7vGEzzkqUhpMFIpz 4J5g3l1Mld8KfQmcyZP/knu5l9EeFxY= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 0B25D5C6542; Fri, 28 Feb 2025 22:01:27 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8453CC4CED6; Fri, 28 Feb 2025 22:03:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740780223; bh=/MYVJ3rlbtoAJvOWV+07+WHhI+Q9ZMyJiRshemc3Pdc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Nq2iiPk2X5wTDN1rEOhOJnEv7NUqTZJOvlOPuG4MMW8vwgYUrCmBJZr0xIR1yo67p d62wq7xVOamZeT/26kiOHlRTUgVUh+AKnoUpbQvikp9/ocZxHLXyjbkLd3hq84CNsr itckDfPhKA/XUHOR/oCEIecXteOvOtfPEAVZ+dJlAW9cT0J9Otlla234ZkzQuJFEyR ICpB0TrNmaOreR88REGBcrAGzRMAo5KqlM4PuuNKBWE2GJES9v5cdNsU8Op9pvsHTT xy80Iro2FNyawVskSDN6LLFepAILtO1ZerHnL5MBoetcI+LH4E19VwtbKEPXLQDT/s FgfKKuVTQLcTQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , 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: [RFC PATCH v2 8/8] Docs/admin-guide/mm/damon/usage: add intervals_goal directory on the hierarchy Date: Fri, 28 Feb 2025 14:03:28 -0800 Message-Id: <20250228220328.49438-9-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250228220328.49438-1-sj@kernel.org> References: <20250228220328.49438-1-sj@kernel.org> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: 9B9CE4001E X-Stat-Signature: ttin64b8bs6uzgrffro6qq173dc1ozfn X-HE-Tag: 1740780224-467700 X-HE-Meta: U2FsdGVkX1+vedoJAqnTAOsWjCn6vlXJ55uEZ9Bw7iRVNUWHyjUk6DW28KRScNfNZiC2onyAgy7lMN2LChdWhcyAQ2OVaKd0rpr+T27To9kWR4Hbp33o1WpwA9O2uiiP5ywe6k+TUfZdUpLsiALOPC5cWRcQ8YjPzTPTuLmqCrpNOWYixr1dMT0hobnJQl7HKW3yXCd1gSOZhEGBEghYA2ZJjnTAeXOaHTlDfnIwCYz9JsOFg8nKIiyLsN+eatcmGLaqPE2mknMM31JrQvlQ7dvI3IciSD9S1YixRD2aaOKcoIXq0GHAVt52v4LyLJNDtyzYURxFkmFHQ0qevTrfoWPnR/EaSvsfRBJCwU33Ebs5UdCV0h9YKyV6tIQXeJV87qknhptjp7/X6gh0BjjApYuV/2jCLALzRG8LM8QCt/2c2UiLUZandJPB+qwSjrLHuaHpi1OhLibkzX4jtf4/7ZUDYndMsUXCmxmY9/cLm+GGOD9NY1y+K3R+/KzhX/B7kYCTlnJzvdsQIHaq8KJjAFiJudbSzaZMbDQFc9UNCxSTdBwW6jawmh4x83PJhmOYYilWvir1zt9aLmBetNmArRcIfipr2FkmSmIV4N8xLXyh+UStI9/NcjlcFTVV8acKFKMlc6KnW3IWxLVkxLFWRHHWxxUUuEtG0biF4l9NtmcSz82KVWvVSyKbof2YTlkaCKzK7Mb2/GAY7zzsrh3zDFVvc4hK0jEMRgKYVJW6jTFKj1UlgK8Yd6mQgl6OaL2PCnh4TsHpjaYoBQmyt1ewtKVlCT2HRG+62NP8k9aT7U+Q7c6gRtPwtnazyP3PPv3966FC35SfXi3mRegj5v2wlJso6BxAeHpQf+w0RfQoutD5nDhIBwrsFWct8LoILSqYucgmbLsgXPTpe0O3S6Jjf93qX5dMHlo7q33V2i3DkBFEEUqw4nPn31tqByBV+4ZbXa5D32py9ZDvXzgFZAr KYncRgGh fYrduuCS/ooeIctDzeJH3rIcVBI9a1YYspdE7RAsF+N3GOXtaZPXTWYJPGCvX+gcQOGJpwjr6o5bQXKdMubcLwZ9Ybx/Wci5KlU/IjXeisXAMlr/n2eC4WC4J+wRDiyR53tBst/crlnGX3MgaLJ1y5wRFuOTbrppLUzIx2LS9ejV6luHMQMaY08go29wXnIDL+TFnc9EdeawcAX5SlMf9ja/M1MxqdoJUo1kAJrPpxPrS2039zNrCyCBZeOk8zbmfEpdYzioVHm/ioP8sNTJZICHQ0jL5haNjjAmHWsCx0Oudns9QVQeYbNWlvA== 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: List-Subscribe: List-Unsubscribe: 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/admin-guide/mm/damon/usage.rst index 4b25c25d4f4f..8f01ad8792e7 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -64,6 +64,7 @@ comma (","). │ │ │ │ :ref:`0 `/avail_operations,operations │ │ │ │ │ :ref:`monitoring_attrs `/ │ │ │ │ │ │ intervals/sample_us,aggr_us,update_us + │ │ │ │ │ │ │ intervals_goal/access_bp,aggrs,min_sample_us,max_sample_us │ │ │ │ │ │ nr_regions/min,max │ │ │ │ │ :ref:`targets `/nr_targets │ │ │ │ │ │ :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`). +.. _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 exists. +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 tuning +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 same +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: contexts//targets/ diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/design.rst index 0cc9f6441354..0cf678d98b1b 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 rule) has applied twice. That is, assumes 4% (20% of 20%) DAMON-observed access events ratio (source) to capture 64% (80% multipled by 80%) real access events (outcomes). +To know how user-space can use this feature via :ref:`DAMON sysfs interface +`, refer to :ref:`intervals_goal ` part of +the documentation. + .. _damon_design_damos: