From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-dl1-f52.google.com (mail-dl1-f52.google.com [74.125.82.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1A1BB3BCD27 for ; Thu, 18 Jun 2026 09:49:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.52 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781776146; cv=none; b=ZtxpxviiILpbo80UwsWJIbmZN8xTOGoWPBRGXKhrygfgrpYMtBAGLWC1B7nQvB7V5ZWaFtJ/tmVBn1QCcd2va8Iq2yV5W4qAy6Mr+3e5LxDGLCzaNgLQ1zpzykaIMhkhz06+eWOv5JLVZta72tnhO3uBFUk6VOZQvbq9nXV2fSU= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781776146; c=relaxed/simple; bh=rCzJfvoVZBu8pxVQb0et4Fw/Gz7l9e/Vrc+Fy3aapI0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ee/2lQOuSnugWNBJRTZ08DnhI7TDjofSG476fKB4Hor8M+JzsSvf9k5P/0Anaje+t8NZeLqexDtlN83botqs3GkieouHQL5M+3bs2H0CJW1v2awRz5N1osQfmCbXCziYB1vIjFpUtrhBzF8xYtwvQCKNwvN2q7334+dN9NDCRSc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=CUlz7ECG; arc=none smtp.client-ip=74.125.82.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="CUlz7ECG" Received: by mail-dl1-f52.google.com with SMTP id a92af1059eb24-13986d61b4eso561590c88.0 for ; Thu, 18 Jun 2026 02:49:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1781776142; x=1782380942; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=JfvukYAwbFp2g5Admau+TmMD4cVWEsG3RqzVu1bH8I8=; b=CUlz7ECG1QDjGYX5jWSIw+3JMrttcs4O1VL/kAivtFmyv/XKVOLDVW075k4tK0M5aX jKbyRoOeYbMbDMO+ravcYo0RaUjnO+TsgT7jDsh/VxrA9D7v/pgfnPvYh0Gg6FI8vjt0 UtsL2z/GQlIYLJXbFU8b1Z71lHoeOusx8bzxpzJ31wEh66sQX8X8KL/xcjmIYUBI4vys 5x0E1tIi7dmUx0uR7fqbci9HBlh8hxGdPFLdeKV+RdSEMztroy5dcBdAQcjtASaYlLOM gElEmeUhEyztiWqmXUpjQt++cHT6YpcJ3hUtfQvIWPznH/0V04lWlkEhQ3Hinmq9xOWB ya4w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1781776142; x=1782380942; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=JfvukYAwbFp2g5Admau+TmMD4cVWEsG3RqzVu1bH8I8=; b=KhS+WS3Mzy9mxKwbITutP3ni749fS1FSZAb9XiQUjutDWknnV6+EsVBfuxMcJDuGku +1aMckMH3LO1Pl8VAqVXMZyR8cYGTgkvGssHtDE/huT3GzJYEjmZMcDfxFBkhS0l0oKx cN7NE+QGWVdyu8hBoiXw5K3GHq6sH6PpWLjV7zL6b2x/GSxmaQSbHinIDWpXotfizeKW iuNek3U1CYBQ3QFl4xIOtK6wOi7y0fJPAiVuzp7JV4yAHmEXcARZAKj9uH+l2fpckfH/ ZJvXaEkKl3v5qL0Q+mYjRlh35lrMLIKv7KOh3h5gqkxpdPAJ+8oAHNGHCI/7/CcIpixm Eu2A== X-Forwarded-Encrypted: i=1; AFNElJ9UoIJNs5L1jQZFHnP4k25jjVnSLoZNGu/NubjtlNtuQbJKrECWHdRcZGg45Fjr0RYELHML8oR/5BgP7bg=@vger.kernel.org X-Gm-Message-State: AOJu0Yx0D9As19aGBr30gWSS/vwIR4F2YgiYPOlqczu3RPRRqrRuDfVK BPNohMRVump7yKu1wp4CJwjqUpJkkiRUlWoZ7E7zptYRNRolpmseZ5PX X-Gm-Gg: Acq92OFExXOUcwO4zdmn/wtODUe0KkAzsoGxU15pDgvzJIAB9/ZjZ9J85R+EY+Z0RWn koVif2hXsZ+fYhuc1prSppotFs4J4DjZXTnF9ewoqfNXHsNax0RZeiedhVwa8VERuJi3Db5ocCl utnJ/zOg2+crcSXzQk39IIB1SMorYzHenv0iYzzyUuh1KrphHGb+792G1VMpYNpIZZ9zzd+riDB FwRig5q6WQYLOZSqbgbWjmydSRQkeN1TlB+Pydiy3hDCACaM6xcTxU/+wpKedlikG7nBk8FEiPF ORJtzG5Tkh6wEGsR33i6rdhAoD93EwKHCyelc8kQ9OkRdcAIKtkzxEYYZCxoYRCu1hXRojxRHZP AmMRHxB208mdfiIpl8ND1jdzl4EpHMytTismgKU9b8SufasUacYdCGu6uusrEoqqmdJSaI02FDt Zhl98PyvHM2IQh9ZsdAfLIBUtn X-Received: by 2002:a05:7022:6093:b0:136:c565:e862 with SMTP id a92af1059eb24-13999b4d769mr1166356c88.26.1781776141957; Thu, 18 Jun 2026 02:49:01 -0700 (PDT) Received: from localhost.localdomain ([104.28.158.224]) by smtp.gmail.com with ESMTPSA id a92af1059eb24-1384b91a4c7sm18069971c88.8.2026.06.18.02.48.58 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Thu, 18 Jun 2026 02:49:01 -0700 (PDT) From: Wang Lian To: sj@kernel.org, akpm@linux-foundation.org Cc: npache@redhat.com, gutierrez.asier@huawei-partners.com, daichaobing@sangfor.com.cn, linux-mm@kvack.org, linux-kernel@vger.kernel.org, lianux.mm@gmail.com, kunwu.chan@gmail.com Subject: [RFC PATCH 4/6] mm/damon: introduce DAMOS_MTHP_SPLIT action and hot_threshold Date: Thu, 18 Jun 2026 17:48:36 +0800 Message-ID: <20260618094838.32805-5-lianux.mm@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260618094838.32805-1-lianux.mm@gmail.com> References: <20260618094838.32805-1-lianux.mm@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Add a new DAMOS_MTHP_SPLIT action to split a large folio to the specified target_order, and a hot_threshold parameter to control split decisions based on sub-page access heatmap. target_order: For MTHP_SPLIT, valid range is 2..HPAGE_PMD_ORDER-1, allowing splits to e.g. order-2 (16KB) or order-3 (32KB) mTHP. An invalid value (0 or >= PMD_ORDER) defaults to order-2; 0 would mean "split to base page" which defeats the purpose of mTHP split. hot_threshold: Minimum percentage (0-100) of hot subpages required to preserve a THP. THPs with hot_fraction >= hot_threshold are kept intact; below it, the THP is split to target_order. Default is 30%, based on ARM SPE profiling on Kunpeng 920 which showed: - 97% of THPs have <10% hot subpages (clearly cold, split) - 1-2% have 10-30% (borderline, tunable) - <1% have >30% (genuinely hot, preserve) The 30% default catches genuinely hot THPs while splitting the vast majority of cold THPs. Exposed as sysfs attribute for per-scheme tuning (e.g. lower for memory-pressure scenarios, higher for latency-sensitive workloads). sysfs interface: /sys/kernel/mm/damon/admin/kdamonds/.../schemes/0/hot_threshold The actual split implementation follows in subsequent patches. Co-developed-by: Kunwu Chan Signed-off-by: Kunwu Chan Signed-off-by: Wang Lian --- include/linux/damon.h | 17 ++++++++++++-- mm/damon/sysfs-schemes.c | 51 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 2 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 5a0587556573..982057bbce3b 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -121,6 +121,7 @@ struct damon_target { * @DAMOS_HUGEPAGE: Call ``madvise()`` for the region with MADV_HUGEPAGE. * @DAMOS_NOHUGEPAGE: Call ``madvise()`` for the region with MADV_NOHUGEPAGE. * @DAMOS_COLLAPSE: Call ``madvise()`` for the region with MADV_COLLAPSE. + * @DAMOS_MTHP_SPLIT: Split large folios to the target mTHP order. * @DAMOS_LRU_PRIO: Prioritize the region on its LRU lists. * @DAMOS_LRU_DEPRIO: Deprioritize the region on its LRU lists. * @DAMOS_MIGRATE_HOT: Migrate the regions prioritizing warmer regions. @@ -141,6 +142,7 @@ enum damos_action { DAMOS_HUGEPAGE, DAMOS_NOHUGEPAGE, DAMOS_COLLAPSE, + DAMOS_MTHP_SPLIT, DAMOS_LRU_PRIO, DAMOS_LRU_DEPRIO, DAMOS_MIGRATE_HOT, @@ -573,10 +575,21 @@ struct damos { struct damos_access_pattern pattern; enum damos_action action; /* - * @target_order: target order for mTHP actions (DAMOS_COLLAPSE). - * 0 means system default (PMD order). Valid: 0, 2..HPAGE_PMD_ORDER. + * @target_order: target mTHP order for DAMOS_COLLAPSE and + * DAMOS_MTHP_SPLIT. For COLLAPSE, 0 means PMD order default, + * valid values: 0, 2..HPAGE_PMD_ORDER. For MTHP_SPLIT, + * valid values: 2..HPAGE_PMD_ORDER-1; 0 and HPAGE_PMD_ORDER + * are rejected at scheme creation time (defaulting to 2). */ unsigned int target_order; + /* + * @hot_threshold: minimum hot subpage percentage (0-100) to + * preserve a THP during DAMOS_MTHP_SPLIT. A THP with + * hot_fraction >= hot_threshold is kept intact; below it, the + * THP is split to @target_order. Default 30 based on SPE + * profiling showing 97% of THPs have <10% hot subpages. + */ + unsigned int hot_threshold; unsigned long apply_interval_us; /* private: internal use only */ /* diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 735970717048..823f1ca9bd90 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -2260,6 +2260,7 @@ struct damon_sysfs_scheme { struct damon_sysfs_scheme_regions *tried_regions; int target_nid; unsigned int target_order; + unsigned int hot_threshold; struct damos_sysfs_dests *dests; }; @@ -2293,6 +2294,10 @@ static struct damos_sysfs_action_name damos_sysfs_action_names[] = { .action = DAMOS_COLLAPSE, .name = "collapse", }, + { + .action = DAMOS_MTHP_SPLIT, + .name = "mthp_split", + }, { .action = DAMOS_LRU_PRIO, .name = "lru_prio", @@ -2673,6 +2678,34 @@ static ssize_t target_order_store(struct kobject *kobj, return count; } +static ssize_t hot_threshold_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_scheme *scheme = container_of(kobj, + struct damon_sysfs_scheme, kobj); + + return sysfs_emit(buf, "%u\n", scheme->hot_threshold); +} + +static ssize_t hot_threshold_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_scheme *scheme = container_of(kobj, + struct damon_sysfs_scheme, kobj); + unsigned int val; + int err; + + err = kstrtouint(buf, 0, &val); + if (err) + return err; + + if (val > 100) + return -EINVAL; + + scheme->hot_threshold = val; + return count; +} + static void damon_sysfs_scheme_release(struct kobject *kobj) { kfree(container_of(kobj, struct damon_sysfs_scheme, kobj)); @@ -2690,11 +2723,15 @@ static struct kobj_attribute damon_sysfs_scheme_target_nid_attr = static struct kobj_attribute damon_sysfs_scheme_target_order_attr = __ATTR_RW_MODE(target_order, 0600); +static struct kobj_attribute damon_sysfs_scheme_hot_threshold_attr = + __ATTR_RW_MODE(hot_threshold, 0600); + static struct attribute *damon_sysfs_scheme_attrs[] = { &damon_sysfs_scheme_action_attr.attr, &damon_sysfs_scheme_apply_interval_us_attr.attr, &damon_sysfs_scheme_target_nid_attr.attr, &damon_sysfs_scheme_target_order_attr.attr, + &damon_sysfs_scheme_hot_threshold_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_scheme); @@ -3048,8 +3085,22 @@ static struct damos *damon_sysfs_mk_scheme( HPAGE_PMD_ORDER, HPAGE_PMD_ORDER); sysfs_scheme->target_order = 0; } + if (sysfs_scheme->action == DAMOS_MTHP_SPLIT && + (sysfs_scheme->target_order == 0 || + sysfs_scheme->target_order >= HPAGE_PMD_ORDER)) { + pr_warn("DAMON mthp_split: target_order %u invalid, need 2..%u. Defaulting to 2.\n", + sysfs_scheme->target_order, + HPAGE_PMD_ORDER - 1); + sysfs_scheme->target_order = 2; + } scheme->target_order = sysfs_scheme->target_order; + if (sysfs_scheme->action == DAMOS_MTHP_SPLIT) { + if (sysfs_scheme->hot_threshold == 0) + sysfs_scheme->hot_threshold = 30; + scheme->hot_threshold = sysfs_scheme->hot_threshold; + } + err = damos_sysfs_add_quota_score(sysfs_quotas->goals, &scheme->quota); if (err) { damon_destroy_scheme(scheme); -- 2.50.1 (Apple Git-155)