From patchwork Wed Aug 2 21:43:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13338862 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 DA8B4C04FDF for ; Wed, 2 Aug 2023 21:43:20 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 5163B2801EF; Wed, 2 Aug 2023 17:43:20 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 425DD2801EB; Wed, 2 Aug 2023 17:43:20 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 2785D2801EF; Wed, 2 Aug 2023 17:43:20 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id 140A82801EB for ; Wed, 2 Aug 2023 17:43:20 -0400 (EDT) Received: from smtpin08.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay05.hostedemail.com (Postfix) with ESMTP id CF13241022 for ; Wed, 2 Aug 2023 21:43:19 +0000 (UTC) X-FDA: 81080490918.08.EA58670 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf24.hostedemail.com (Postfix) with ESMTP id 1C631180011 for ; Wed, 2 Aug 2023 21:43:17 +0000 (UTC) Authentication-Results: imf24.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=XTxyZN9w; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf24.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=1691012598; 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=m2EB/ZNIq7o1p24186AiZxZCg7n63aXOu1SRfHcwmTQ=; b=7BLnf2L/DekizPV+VywD/ouUUzfLY5TbZiLZE9seNvCIOaRBvjlHhVMnviyXurBvv7PNgu T1/RT/rJzf1XSX3jj7aunqDsR2TU7S6T+Y2T6iNdQmeFTugZPuDz3PlfznKQXXdp2gFduK 4fQmeAJtYlTNd4n3nZxeOeNQqrGpuCI= ARC-Authentication-Results: i=1; imf24.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=XTxyZN9w; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf24.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=1691012598; a=rsa-sha256; cv=none; b=Uc2KtYbSbHd9k9ckzdeU4ybPRk1kQ3EmTMczGYB9Yv+a/ID0zvCeveN2sk6L6Wzh3mj3p9 jO37KdYq22fD5v8Ni/k2rgr8DJDSkCyBDK/4yjxZG29QeU/Zr2S4vE+3g64v9Uk766AM/7 2fUx2FcUknJMDb6DfI2397Dn/5HHBHk= Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 3F82F61B3B; Wed, 2 Aug 2023 21:43:17 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 411BEC433C7; Wed, 2 Aug 2023 21:43:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1691012596; bh=kMVc66oZXCOktM4R7/awXD6J4keYYzNjFUaNutsI2bU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=XTxyZN9wgm81uYCBD8tsYa8GiyQrknkGGCqGP+Zp6Wc+lvHBHfpOQUmIBlKSTGYmh 1UKD17lJBeOavBqNqJh3fOpnflBOMfvY+Bx0jYBVEh9fZDHTjC1jP/dOaSqYFRl+jQ veY9IxAu4ARncosqjFWMds8VXLP9r2WxtyD1BaEJhw27OGS7l0Q+iUKN5psDk0se7K fo0JmD6X43tdBI8eG86p92nY0vo9ypmrouOlHNvXMWIrOP1qktU2tIGPQ6yqqpzsfG st/A6Dt42kSWmistvHhdf0bjHrvd2e8qx+VIySEG2VKdtpNHM1uHAeQMlcVifJDMHs fhvvpLexHQ2Hw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 01/13] mm/damon/core: introduce address range type damos filter Date: Wed, 2 Aug 2023 21:43:00 +0000 Message-Id: <20230802214312.110532-2-sj@kernel.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230802214312.110532-1-sj@kernel.org> References: <20230802214312.110532-1-sj@kernel.org> MIME-Version: 1.0 X-Rspam-User: X-Stat-Signature: 7fpp1zkuhgj8t177qubz8ga3puyfc6wj X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 1C631180011 X-HE-Tag: 1691012597-789948 X-HE-Meta: U2FsdGVkX198tc3AqapgQoMdxt+i1oKU9Ytx9io19X8Vnu3SDPpDqB1gpjMVly27OpOyPZXn9r6O/CRLd9KJSq7s8GMFreou8MZ74eJVdQq6WCsT9pe+G8eg6oyDx8k2UxnLZtl/3H6B5iyllkiKp7etuTbc0kKH5DTKAD5b6F3G3tle6RmkGLL1lopNRlELMWWJ4FacPYMdxfJRkp1BeIMbHOe7sfrCGX4z6G1vgB197I6a3q2MiXVdZc3DGcNDVGtvQSaLHP5FkbAow8RxP+HftzXfyW+mqv/GWYpld8j4ID9+vcDjmtTN2zsgemDlcfQhmZOkKBdVsuuwakkCHIgIwtEhBg/dBsI7p09VKd5WlYZYHljSvSUlrBdQDY8u9Sxo5u5V1kKrscEqjJHSRO51BPYbThiSiJxWl0IpSqmn1QFqFEUEf9a/RqCshOHnQdgfdS6knJr9Z4w/lLW3nkqPtLD7rX/KWtxxiLpVcoSTQaIxqFSZsOmmmj0LNiENDIwKMs5hnTGkPXwxzMZg36TI1YIHwl03qWFDpWfvDweeZCPyJ6f4GnH8M8DvZcKtFx6LvfLHKBYBRwwpr6cRYwtp5w2tGTsFNsZlbMgI9nK6RP65Tb24lcB/BuiDNTv4KObeoMRv8eIxZlIJXNK51nsc/h6udCwA0JkLmFmPGESWFG+kYWloKEQzstO1ZztkK9L+5jsrCrDmI/yO3STziKh4nKKE9T3je3heIzvKqUs1GY9NGM3UXP5B+kUOJnvHfa6YSO7pRZwALYexISeSaGGEEOxvOZ0iBEOIA6PJHZBtIoiOAdGNn/zm/mBgl6qC2C1RBOCeIQ7x3eJ7yVwyytQHKEfK/ZWP2v8lwUFcM7LnkeE6DYZDHz9YsUTh5jU2et+yfwFrE1ksVWFl33uFyRWxnC/bBfn/tR0h1iu2npMmaHv/l/9bm2S42LwFNh/UR7qLerW0XlD8QK/3+nb MgZrlY18 GEXKBvdRwktYYS/r6GmR8dnhPBmAL3e1MdLmEy+hsS1Wm0LkTJIx75nHzpuw8gR0SFJ45/1dRIndUUjWl5abi7UIvZuEQfF/0+ZFpe+/VzrDf4vj7tRO7HqCcAxgAjRWlgxvMgaKGKGao9oBZiMcrHsti5T3+BfA3vZsuUxY5qNW88Un0s32euEnlaizJFu0I6aCavX5Z0TuIX816RaBffzmssUXMgQQ2z5ANmsadxbR9ou00ynD9wu9J8czBWep8e1u5swrmw7nHnPcyvUSFJHmIASgl2bBSdE9ZI+9BdOTQ5S71A6YrjnjzeZAJW08Kt1nVtLi/Pd6V/ZcIMWUoazmpiA== 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: Users can know special characteristic of specific address ranges. NUMA nodes or special objects or buffers in virtual address space could be such examples. For such cases, DAMOS schemes could required to be applied to only specific address ranges. Implement yet another type of DAMOS filter for the purpose. Note that the existing filter types, namely anon pages and memcg DAMOS filters needed page level type check. Because such check can be done efficiently in the opertions set layer, those filters are handled in operations set layer. Specifically, only paddr operations set implementation supports these filters. Also, because statistics counting is done in the DAMON core layer, the regions that filtered out by these filters are counted as tried but failed to the statistics. Unlike those, address range based filters can efficiently handled in the core layer. Hence, do the handling in the layer, and count the regions that filtered out by those as the scheme has not tried for the region. This difference should clearly documented. Signed-off-by: SeongJae Park --- include/linux/damon.h | 22 +++++++++++++----- mm/damon/core.c | 52 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+), 6 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index d5d4d19928e0..476f37a883a4 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -226,16 +226,24 @@ struct damos_stat { * enum damos_filter_type - Type of memory for &struct damos_filter * @DAMOS_FILTER_TYPE_ANON: Anonymous pages. * @DAMOS_FILTER_TYPE_MEMCG: Specific memcg's pages. + * @DAMOS_FILTER_TYPE_ADDR: Address range. * @NR_DAMOS_FILTER_TYPES: Number of filter types. * - * The support of each filter type is up to running &struct damon_operations. - * &enum DAMON_OPS_PADDR is supporting all filter types, while - * &enum DAMON_OPS_VADDR and &enum DAMON_OPS_FVADDR are not supporting any - * filter types. + * The anon pages type and memcg type filters are handled by underlying + * &struct damon_operations as a part of scheme action trying, and therefore + * accounted as 'tried'. In contrast, other types are handled by core layer + * before trying of the action and therefore not accounted as 'tried'. + * + * The support of the filters that handled by &struct damon_operations depend + * on the running &struct damon_operations. + * &enum DAMON_OPS_PADDR supports both anon pages type and memcg type filters, + * while &enum DAMON_OPS_VADDR and &enum DAMON_OPS_FVADDR don't support any of + * the two types. */ enum damos_filter_type { DAMOS_FILTER_TYPE_ANON, DAMOS_FILTER_TYPE_MEMCG, + DAMOS_FILTER_TYPE_ADDR, NR_DAMOS_FILTER_TYPES, }; @@ -244,18 +252,20 @@ enum damos_filter_type { * @type: Type of the page. * @matching: If the matching page should filtered out or in. * @memcg_id: Memcg id of the question if @type is DAMOS_FILTER_MEMCG. + * @addr_range: Address range if @type is DAMOS_FILTER_TYPE_ADDR. * @list: List head for siblings. * * Before applying the &damos->action to a memory region, DAMOS checks if each * page of the region matches to this and avoid applying the action if so. - * Note that the check support is up to &struct damon_operations - * implementation. + * Support of each filter type depends on the running &struct damon_operations + * and the type. Refer to &enum damos_filter_type for more detai. */ struct damos_filter { enum damos_filter_type type; bool matching; union { unsigned short memcg_id; + struct damon_addr_range addr_range; }; struct list_head list; }; diff --git a/mm/damon/core.c b/mm/damon/core.c index eb9580942a5c..f3a821215230 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -878,6 +878,56 @@ static void damos_update_stat(struct damos *s, s->stat.sz_applied += sz_applied; } +static bool __damos_filter_out(struct damon_target *t, struct damon_region *r, + struct damos_filter *filter) +{ + bool matched = false; + unsigned long start, end; + + switch (filter->type) { + case DAMOS_FILTER_TYPE_ADDR: + start = ALIGN_DOWN(filter->addr_range.start, DAMON_MIN_REGION); + end = ALIGN_DOWN(filter->addr_range.end, DAMON_MIN_REGION); + + /* inside the range */ + if (start <= r->ar.start && r->ar.end <= end) { + matched = true; + break; + } + /* outside of the range */ + if (r->ar.end <= start || end <= r->ar.start) { + matched = false; + break; + } + /* start before the range and overlap */ + if (r->ar.start < start) { + damon_split_region_at(t, r, start - r->ar.start); + matched = false; + break; + } + /* start inside the range */ + damon_split_region_at(t, r, end - r->ar.start); + matched = true; + break; + default: + break; + } + + return matched == filter->matching; +} + +static bool damos_filter_out(struct damon_target *t, struct damon_region *r, + struct damos *s) +{ + struct damos_filter *filter; + + damos_for_each_filter(filter, s) { + if (__damos_filter_out(t, r, filter)) + return true; + } + return false; +} + static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t, struct damon_region *r, struct damos *s) { @@ -895,6 +945,8 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t, goto update_stat; damon_split_region_at(t, r, sz); } + if (damos_filter_out(t, r, s)) + return; ktime_get_coarse_ts64(&begin); if (c->callback.before_damos_apply) err = c->callback.before_damos_apply(c, t, r, s);