From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1C241C3ABDD for ; Mon, 19 May 2025 16:44:25 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id C660B6B00BD; Mon, 19 May 2025 12:44:21 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id BEB5C6B00D5; Mon, 19 May 2025 12:44:21 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id A66906B00D6; Mon, 19 May 2025 12:44:21 -0400 (EDT) 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 7F1D26B00BD for ; Mon, 19 May 2025 12:44:21 -0400 (EDT) Received: from smtpin14.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id E4447C0A71 for ; Mon, 19 May 2025 16:44:23 +0000 (UTC) X-FDA: 83460230406.14.FF65296 Received: from tor.source.kernel.org (tor.source.kernel.org [172.105.4.254]) by imf18.hostedemail.com (Postfix) with ESMTP id 56B2E1C0007 for ; Mon, 19 May 2025 16:44:22 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="A4096UE/"; spf=pass (imf18.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=1747673062; 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=z/2xfgp57v/g9Nn/heur6qdTUmKvpCc97G3BCGIYlp8=; b=elOnMk89F5Ph6kSniiUcGB8icQFtaY7B9bEfgCB4VStUwY0f/JvojG/nPENmHHSxBfpEFU ObwZS0PtiHD+TX2ko/UzTREABhtZHZvNNVWvd5dmNp3F6yMD/7FLX65kVF1eXf1xjUKe/c jMmKTz/EgFDfuU4ghPvJ464x6U4+xBY= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="A4096UE/"; spf=pass (imf18.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=1747673062; a=rsa-sha256; cv=none; b=FaCBbtR/CSki6dT2TYnpX4dU3ZjN6eKbL9Hkf7hRF1qSc/NQeVtgNUpMQGksjEEeZq93ap PTRWEKK7Yn8xqdVVu81pJMyP4rAQRwzK31An1avw/NBvpZ4Ux7SUAxUxuHiE2VVKx1brDO PJ7JSlOtz7Ea540CVRIF/Z+XTWdp4Ic= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 87E74629CF; Mon, 19 May 2025 16:44:21 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E78CAC4CEE4; Mon, 19 May 2025 16:44:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1747673061; bh=z0JjO0m2glY+dWvePC6PxEeqvFGxsuXbQo7p4xrgJ7o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=A4096UE/qe57WsG567bTv86VBECxPRLhGkVvxhfmJYwVtD6749du/aRo8RlV6MNUj ZUdwzVY6+7NqUFkcDXCHDH4bsJQq1p1EeBqV1/6j+g3q0eknIgPtm5X5muz7Su3C5t c+ULcSB+XACMT//o4AhxXYxgfXf9jaEzdRqrLljVATMS1KUaGJXo+8jF0m9NvXPpAP 8wMZfUROpkQSU0/hsJmBStb3sAetXd5fqXWD9V4E+UQh1lSsGBncboCUmA/2SZrFQf aVKqpcy6iJQI0q8/jonwMli41sWtQgI2E3DtFruY2X1h4DP7bfw2SY5gCFzwktw8/3 dv8loBkXhB2QQ== 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 1/3] mm/damon: introduce DAMON_STAT module Date: Mon, 19 May 2025 09:44:13 -0700 Message-Id: <20250519164415.43935-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250519164415.43935-1-sj@kernel.org> References: <20250519164415.43935-1-sj@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Rspam-User: X-Rspamd-Queue-Id: 56B2E1C0007 X-Rspamd-Server: rspam09 X-Stat-Signature: 3ct37agi1guef8kkhsoszk4imqeorhii X-HE-Tag: 1747673062-818427 X-HE-Meta: U2FsdGVkX18JNrzrpJxP/WygvnJx7UCSC7sl9m8jflz3SOoiCN68kkekzpYovlQEC7NXEar7Mk22fLvk6dzyradVfC2P/lRRwCEVgvsuEyra1MeIjmT87zxZ8+zBr+mO7JLmA8zrTyN+v8IXkBVRA9ZNMW9YhVAdu09oEWGlHBPplc4I5uqTp1V4/vAoN8kbBOyFD70R7yNd3jdYo8y2orGIcK16RzO6UiAveNBR6KgEhRaebSMbfyMPTQ8vpgeDkK32HhMkVNKRB03UtdIMJtOegliG6gQiNH/kFps9epYUdP0VfevON+Ph83Fpi3UJF/JmmvS9ioxSkVWLV+8u535SbmOe+Xrt8+pPTeKdyxixNGMJ4usXtmrpz1jb0MaEob6oua0H7EkkUja6/A/NXJfGJTECsNX7t48CZBc+i5z1+BnpjOacHQexLyKwdnBPaYcVYSGAgvoahypAdJPnVLmmKFOT++lDqK9K9JX6QrsHr1n1wr6J+h7GrjhlQEn5cI81sJc/Z3jjWJrEp2SurNEm2ztU5FkeFJt96sm7BJts2iJlpuhJ1Tlrq/bN8jT+QQ2nHohN/SixzbX96nsirE9bjqGhrJ1ame0Q04tp1tMzsfJFyFjUzPSL0jsl0uskG4zWjANafFg2wZudoqvJTjo+3GtYLlhIJlXecH0zZbHDrZPPh3AaADPFetzhMbV57lMzXyPXLbnVh/d+1Nv0y/Oo2JFvuoMZ8eRqdPBbN/v1awi8wbey73RVKlCNtEPeYaT0LyB2tCOmjztk9zMRsnPphz+RvknEQDmKW1PKG+Npg0EkdIlmQ3b3p4MsCA4RFIsU644S/NCxeUddr7XfdjCyQWeNm2R5Ojbj6OxPoSewvxOXFREi42yavK1Z3Jnpe08qWV+4zup4XAXYPb6nPo7wAUOA1+TTiFRcVzCO7WeCxcCCqUAUQhXR5OfN614UND0O/JXh6zkYUd25+Zk 81oQv4dy 6651iPYdTxqCCdBfkTKSMuQvTNpsF+mtV+aMI/gCtNKhXLk8DpVfJ/ieo7gFoTaTECmkmYX1oI1K9LseqkdZTxgr2/O8zKa1T+ttKYmhGuDjS9QslxSDeh5qpz9sQzTQ9ykJ7DcnbwiNJicbUxtT3JNMhLJpDCfbQyyLyT1FwYA8C6aXMp8xp0+3jYnuH1eIa0XtYnGD9fe7bQEKHVRmk4v2RfidMLsTzheAT70d+wzTAB2SzILg5yqsPHUKty2tTNloSmxxjQw/5UAUwmzIBGI9d3q98+vmwEP5+T7hOFMeFaAD96VCJ/X7YRQ== 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: To use DAMON for monitoring access pattern of the system, users should manually start DAMON via DAMON sysfs ABI with a number of parameters for specifying the monitoring target address space, address ranges, and monitoring intervals. After that, users should also wait until desired amount of time data is captured into DAMON's monitoring results. It is bothersome and take a long time to be practical for access monitoring on large fleet level production environments. For access-aware system operations use cases like proactive cold memory reclamation, similar problem existed and we solved those by introducing dedicated static kernel modules such as DAMON_RECLAIM. Implement such static kernel module for access monitoring, namely DAMON_STAT. It monitors the entire physical address space with auto-tuned monitoring intervals. The auto-tuning is set to capture 4 % of observable access events in each snapshot while keeping the sampling intervals in a range of 5 milliseconds and 10 seconds. From production environemnts, we confirmed this setup provides high quality monitoring results with minimum overheads. The module therefore receives only one user input, whether to enable or disable it. It can be set on build or boot time via build configuration or kernel boot command line. It can also be overridden at runtime. Note that this commit only implements the DAMON control part of the module. Users could to get the monitoring results via damon:damon_aggregated tracepoints, but that's of course not the recommended way. Following commits will implement convenient and optimized ways for serving the monitoring results to users. Signed-off-by: SeongJae Park --- mm/damon/Kconfig | 16 ++++++ mm/damon/Makefile | 1 + mm/damon/stat.c | 138 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 155 insertions(+) create mode 100644 mm/damon/stat.c diff --git a/mm/damon/Kconfig b/mm/damon/Kconfig index 551745df011b..9f482e3adc67 100644 --- a/mm/damon/Kconfig +++ b/mm/damon/Kconfig @@ -95,4 +95,20 @@ config DAMON_LRU_SORT protect frequently accessed (hot) pages while rarely accessed (cold) pages reclaimed first under memory pressure. +config DAMON_STAT + bool "Build data access monitoring stat (DAMON_STAT)" + depends on DAMON_PADDR + help + This builds the DAMON-based access monitoring statistics subsystem. + It runs DAMON and expose access monitoring results in simple stat + metrics. + +config DAMON_STAT_ENABLED_DEFAULT + bool "Enable DAMON_STAT by default" + depends on DAMON_PADDR + default DAMON_STAT + help + Whether to enable DAMON_STAT by default. Users can disable it in + boot or runtime using its 'enabled' parameter. + endmenu diff --git a/mm/damon/Makefile b/mm/damon/Makefile index 8b49012ba8c3..d8d6bf5f8bff 100644 --- a/mm/damon/Makefile +++ b/mm/damon/Makefile @@ -6,3 +6,4 @@ obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs-schemes.o sysfs.o obj-$(CONFIG_DAMON_RECLAIM) += modules-common.o reclaim.o obj-$(CONFIG_DAMON_LRU_SORT) += modules-common.o lru_sort.o +obj-$(CONFIG_DAMON_STAT) += modules-common.o stat.o diff --git a/mm/damon/stat.c b/mm/damon/stat.c new file mode 100644 index 000000000000..852848ce844e --- /dev/null +++ b/mm/damon/stat.c @@ -0,0 +1,138 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Shows data access monitoring resutls in simple metrics. + */ + +#define pr_fmt(fmt) "damon-stat: " fmt + +#include +#include +#include +#include +#include + +#ifdef MODULE_PARAM_PREFIX +#undef MODULE_PARAM_PREFIX +#endif +#define MODULE_PARAM_PREFIX "damon_stat." + +static int damon_stat_enabled_store( + const char *val, const struct kernel_param *kp); + +static const struct kernel_param_ops enabled_param_ops = { + .set = damon_stat_enabled_store, + .get = param_get_bool, +}; + +static bool enabled __read_mostly = CONFIG_DAMON_STAT_ENABLED_DEFAULT; +module_param_cb(enabled, &enabled_param_ops, &enabled, 0600); +MODULE_PARM_DESC(enabled, "Enable of disable DAMON_STAT"); + +static struct damon_ctx *damon_stat_context; + +static struct damon_ctx *damon_stat_build_ctx(void) +{ + struct damon_ctx *ctx; + struct damon_attrs attrs; + struct damon_target *target; + unsigned long start = 0, end = 0; + + ctx = damon_new_ctx(); + if (!ctx) + return NULL; + attrs = (struct damon_attrs) { + .sample_interval = 5 * USEC_PER_MSEC, + .aggr_interval = 100 * USEC_PER_MSEC, + .ops_update_interval = 60 * USEC_PER_MSEC * MSEC_PER_SEC, + .min_nr_regions = 10, + .max_nr_regions = 1000, + }; + /* + * auto-tune sampling and aggregation interval aiming 4% DAMON-observed + * accesses ratio, keeping sampling interval in [5ms, 10s] range. + */ + attrs.intervals_goal = (struct damon_intervals_goal) { + .access_bp = 400, .aggrs = 3, + .min_sample_us = 5000, .max_sample_us = 10000000, + }; + if (damon_set_attrs(ctx, &attrs)) + goto free_out; + + /* + * auto-tune sampling and aggregation interval aiming 4% DAMON-observed + * accesses ratio, keeping sampling interval in [5ms, 10s] range. + */ + ctx->attrs.intervals_goal = (struct damon_intervals_goal) { + .access_bp = 400, .aggrs = 3, + .min_sample_us = 5000, .max_sample_us = 10000000, + }; + if (damon_select_ops(ctx, DAMON_OPS_PADDR)) + goto free_out; + + target = damon_new_target(); + if (!target) + goto free_out; + damon_add_target(ctx, target); + if (damon_set_region_biggest_system_ram_default(target, &start, &end)) + goto free_out; + return ctx; +free_out: + damon_destroy_ctx(ctx); + return NULL; +} + +static int damon_stat_start(void) +{ + damon_stat_context = damon_stat_build_ctx(); + if (!damon_stat_context) + return -ENOMEM; + return damon_start(&damon_stat_context, 1, true); +} + +static void damon_stat_stop(void) +{ + damon_stop(&damon_stat_context, 1); + damon_destroy_ctx(damon_stat_context); +} + +static bool damon_stat_init_called; + +static int damon_stat_enabled_store( + const char *val, const struct kernel_param *kp) +{ + bool is_enabled = enabled; + int err; + + err = kstrtobool(val, &enabled); + if (err) + return err; + + if (is_enabled == enabled) + return 0; + + if (!damon_stat_init_called) + /* + * probably called from command line parsing (parse_args()). + * Cannot call damon_new_ctx(). Let damon_stat_init() handle. + */ + return 0; + + if (enabled) + return damon_stat_start(); + damon_stat_stop(); + return 0; +} + +static int __init damon_stat_init(void) +{ + int err = 0; + + damon_stat_init_called = true; + + /* probably set via command line */ + if (enabled) + err = damon_stat_start(); + return err; +} + +module_init(damon_stat_init); -- 2.39.5