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 C1195CDB46E for ; Thu, 12 Oct 2023 19:23:05 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 0B0068000B; Thu, 12 Oct 2023 15:23:05 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 05D158D0002; Thu, 12 Oct 2023 15:23:04 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id E3FE08000B; Thu, 12 Oct 2023 15:23:04 -0400 (EDT) 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 CF7088D0002 for ; Thu, 12 Oct 2023 15:23:04 -0400 (EDT) Received: from smtpin02.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay09.hostedemail.com (Postfix) with ESMTP id A020680803 for ; Thu, 12 Oct 2023 19:23:04 +0000 (UTC) X-FDA: 81337782288.02.C054CF6 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf22.hostedemail.com (Postfix) with ESMTP id D7852C002F for ; Thu, 12 Oct 2023 19:23:02 +0000 (UTC) Authentication-Results: imf22.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=aIdWdAmT; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf22.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=1697138582; 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=kVignUki5JZnCPqJilSs5i8raEK8eQaEo1c0T2dA0wQ=; b=rtjZKVcncyK4lEHz7Mr3QfbCZKH0LEs+dyTKzSFN4L/gIAFxJX89JRWmEYFBNvlyMGmoCB IKD12Yq+ZQSdWQbj9M3gD0hwS29Tnb5XYSD86oIcwIggX1cNw+wYoidl2i1c54Sxx6VwyC pmbbKO6DqL61z3YIapSxFxhq/Pca1NY= ARC-Authentication-Results: i=1; imf22.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=aIdWdAmT; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf22.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=1697138582; a=rsa-sha256; cv=none; b=F2ShssBNXcg8fJjsoJjdckkbYA4xUwUpQ0z4BDznm/weNY4UVYq8204SHhMrSfW/b5ldpR DuiJmzmEjBaFdqs2NazbcyExB2D/kErLgOo/B4Xv7lIdmm9zPG+K1Bj3LFTMG8u0vqeTIa tQOrNBW2TAXIK1DdZmUDGXikKgvMNWg= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 0271D61F2F; Thu, 12 Oct 2023 19:23:02 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3C18EC433C8; Thu, 12 Oct 2023 19:23:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1697138581; bh=tkpBuPAHcXxVtnYMQEIhabnoxptCyM9g6IJhkHy1SMg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=aIdWdAmThfiNczrCHF64qTVKfLSk01CfLnL5UFWaPXwntIdXJ6UfNINVkYsd5Vhll VVHbCRYub75Tby4lEez/3PttT7S0GwlkcTAFbBhKcSoeurdPxSSPsiYnyNPm68gJy2 lkmgFs5kJoCNolAeQaQLyYoILXreILMp0vXynsFEeMBB/9dOl51qDZyqTIG2QTuvvY OI9OkcU7V/BpMZaqRYxKhr0FNpsPQ4u33+Xjdk2k51ot7FKasLhZpXylstmVaKF9QR ZhNo/fspViHzQnQathBncfXwWLgNlMK4jYKn5CnJ3DAZDhmOEkJX474+95IZYuU7Ia gatFrhmNm3ccw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 1/3] mm/damon/sysfs-schemes: do not update tried regions more than one DAMON snapshot Date: Thu, 12 Oct 2023 19:22:53 +0000 Message-Id: <20231012192256.33556-2-sj@kernel.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231012192256.33556-1-sj@kernel.org> References: <20231012192256.33556-1-sj@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Rspamd-Queue-Id: D7852C002F X-Rspam-User: X-Rspamd-Server: rspam05 X-Stat-Signature: nxq5o84pz83k89joca9eeei193pizk9b X-HE-Tag: 1697138582-697101 X-HE-Meta: U2FsdGVkX19mBazmUXISQQ3FWaizW2s5d4hVyGbx3wptQ/jktlDsjeZg6yMb7Dc0FgHYEIhfZ3efdROctR2Z6fFvluhwv6rkktd7YkhgW2HFrnTU7EGZ+lBVcqdcAuvb8cvHMHWIz7zBeAGNgKbWdvnH7PWjStx3FQkXMEefCezOXfEI+oUYXAne9/Lr/mTXbRhdXAwoMZX0ah5V+Y45NQ4pwshGiI86lrurrbXsE3BjlKxOvxlDNDN3s2wlDpJClWifE66OAfUbQJMNhrO2clE4X05Mys2CZR7YAIBarJp5pEHGlEruqJzC08ImaobmE7hDQYn94F5XucYUKwUAEAjVvibgIKmT5c8NbJLulrDQqyZDnyv8UIr7KoGxPHEi92ibKJ3FFR5fbo4pyvlkNNtArIQPt3P+stk+aX7WT3dl2wywtjnDSGTkAKsTp+uO5Kvc13CKzuqRPl5ZkwvDnWbaRY8mAzldYoyEtFqfVxYVbWCdTFyATcBwUHOoNdxIhmREWtFgKxWYLxyHKfMkYyGaXMHw3nMeDgQY3jEZ3U4HUgWHF/5w++wy0u9WsgI2c8eUHlyrqKlD4nTo43PYu9n7UeaOFYBDbxBXmgBe/8TQNGomVzMvyORKxCggBOaBjXX9evtma20iC9pq3/JLIlzmkt11qcc49hyAFtJLcvVuBPi/mh277RMpjuDs9qevQwjlTg4bKA2G9cw8PyJ7TldYGxSVdAX5oi/d251EFycZFed9aXmuxYlnXk1Z5/jgF0Ff8TKNKkzMcGjyqzKVibMrfyOJi6ksGv1Ys2ZdhZelr1uU6wkqt84odixg/2u0q6WyFLb/zLsT5i4Bsx1C0u8ot7+5h3xOFQ4Er00zq+8AHQ5ISfMLdZ7sFuEgdWYQf3mtdsDVx1Afvlo7CV5jGV2QzqFy2vibeRza9KG7J5oVpZpLe5aHQs6+jipjsEjXK7SvV81ga8gSFVjl4NM lICp6JXn Hqx5dKg5Iwy2d68vZ4aCyeHUfgOOZmyXQJnRBuu8h4vFj9dUP3dHHG+46d5viiXfNBZtSOrBRYfiAAn7d2YQIRmeYi/uMMsCZjO4ZkiOQO8354NK/LUtRKRFen2HaAeA+7EDKbjcTFVBzSOOIEqx9mtvumiuOav44XNE8qr4Qng5yD//VYEy8pYGDiLoXTK9nvCkJc8SXozrl2HjG1wpkxgdi2VsuzGFOYiRp/saFI5EOlXTZJGoHehApTQ== 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: DAMON_SYSFS exposes every DAMON-found region that eligible for applying the scheme action for one aggregation interval. However, each DAMON-based operation scheme has its own apply interval. Hence, for a scheme that having its apply interval much smaller than the aggregation interval, DAMON_SYSFS will expose the scheme regions that applied to more than one DAMON monitoring results snapshots. Since the purpose of DAMON tried regions is exposing single snapshot, this makes no much sense. Track progress of each scheme's tried regions update and avoid the case. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 77 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index a7d70b95c4dd..b07a5c544b34 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -113,11 +113,47 @@ static const struct kobj_type damon_sysfs_scheme_region_ktype = { * scheme regions directory */ +/* + * enum damos_sysfs_regions_upd_status - Represent DAMOS tried regions update + * status + * @DAMOS_TRIED_REGIONS_UPD_IDLE: Waiting for next request. + * @DAMOS_TRIED_REGIONS_UPD_STARTED: Update started. + * @DAMOS_TRIED_REGIONS_UPD_FINISHED: Update finished. + * + * Each DAMON-based operation scheme (&struct damos) has its own apply + * interval, and we need to expose the scheme tried regions based on only + * single snapshot. For this, we keep the tried regions update status for each + * scheme. The status becomes 'idle' at the beginning. + * + * Once the tried regions update request is received, the request handling + * start function (damon_sysfs_scheme_update_regions_start()) sets the status + * of all schemes as 'idle' again, and register ->before_damos_apply() and + * ->after_sampling() callbacks. + * + * Then, the first followup ->before_damos_apply() callback + * (damon_sysfs_before_damos_apply()) sets the status 'started'. The first + * ->after_sampling() callback (damon_sysfs_after_sampling()) after the call + * is called only after the scheme is completely applied + * to the given snapshot. Hence the callback knows the situation by showing + * 'started' status, and sets the status as 'finished'. Then, + * damon_sysfs_before_damos_apply() understands the situation by showing the + * 'finished' status and do nothing. + * + * Finally, the tried regions request handling finisher function + * (damon_sysfs_schemes_update_regions_stop()) unregisters the callbacks. + */ +enum damos_sysfs_regions_upd_status { + DAMOS_TRIED_REGIONS_UPD_IDLE, + DAMOS_TRIED_REGIONS_UPD_STARTED, + DAMOS_TRIED_REGIONS_UPD_FINISHED, +}; + struct damon_sysfs_scheme_regions { struct kobject kobj; struct list_head regions_list; int nr_regions; unsigned long total_bytes; + enum damos_sysfs_regions_upd_status upd_status; }; static struct damon_sysfs_scheme_regions * @@ -130,6 +166,7 @@ damon_sysfs_scheme_regions_alloc(void) INIT_LIST_HEAD(®ions->regions_list); regions->nr_regions = 0; regions->total_bytes = 0; + regions->upd_status = DAMOS_TRIED_REGIONS_UPD_IDLE; return regions; } @@ -1777,6 +1814,10 @@ static int damon_sysfs_before_damos_apply(struct damon_ctx *ctx, return 0; sysfs_regions = sysfs_schemes->schemes_arr[schemes_idx]->tried_regions; + if (sysfs_regions->upd_status == DAMOS_TRIED_REGIONS_UPD_FINISHED) + return 0; + if (sysfs_regions->upd_status == DAMOS_TRIED_REGIONS_UPD_IDLE) + sysfs_regions->upd_status = DAMOS_TRIED_REGIONS_UPD_STARTED; sysfs_regions->total_bytes += r->ar.end - r->ar.start; if (damos_regions_upd_total_bytes_only) return 0; @@ -1793,6 +1834,29 @@ static int damon_sysfs_before_damos_apply(struct damon_ctx *ctx, return 0; } +/* + * DAMON callback that called after each accesses sampling. While this + * callback is registered, damon_sysfs_lock should be held to ensure the + * regions directories exist. + */ +static int damon_sysfs_after_sampling(struct damon_ctx *ctx) +{ + struct damon_sysfs_schemes *sysfs_schemes = + damon_sysfs_schemes_for_damos_callback; + struct damon_sysfs_scheme_regions *sysfs_regions; + int i; + + for (i = 0; i < sysfs_schemes->nr; i++) { + sysfs_regions = sysfs_schemes->schemes_arr[i]->tried_regions; + if (sysfs_regions->upd_status == + DAMOS_TRIED_REGIONS_UPD_STARTED) + sysfs_regions->upd_status = + DAMOS_TRIED_REGIONS_UPD_FINISHED; + } + + return 0; +} + /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */ int damon_sysfs_schemes_clear_regions( struct damon_sysfs_schemes *sysfs_schemes, @@ -1816,6 +1880,16 @@ int damon_sysfs_schemes_clear_regions( return 0; } +static void damos_tried_regions_init_upd_status( + struct damon_sysfs_schemes *sysfs_schemes) +{ + int i; + + for (i = 0; i < sysfs_schemes->nr; i++) + sysfs_schemes->schemes_arr[i]->tried_regions->upd_status = + DAMOS_TRIED_REGIONS_UPD_IDLE; +} + /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */ int damon_sysfs_schemes_update_regions_start( struct damon_sysfs_schemes *sysfs_schemes, @@ -1823,8 +1897,10 @@ int damon_sysfs_schemes_update_regions_start( { damon_sysfs_schemes_clear_regions(sysfs_schemes, ctx); damon_sysfs_schemes_for_damos_callback = sysfs_schemes; + damos_tried_regions_init_upd_status(sysfs_schemes); damos_regions_upd_total_bytes_only = total_bytes_only; ctx->callback.before_damos_apply = damon_sysfs_before_damos_apply; + ctx->callback.after_sampling = damon_sysfs_after_sampling; return 0; } @@ -1837,6 +1913,7 @@ int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx) { damon_sysfs_schemes_for_damos_callback = NULL; ctx->callback.before_damos_apply = NULL; + ctx->callback.after_sampling = NULL; damon_sysfs_schemes_region_idx = 0; return 0; } -- 2.34.1