From patchwork Tue Jan 28 08:57:34 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 11353781 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 42172112B for ; Tue, 28 Jan 2020 08:58:30 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id E05C12468E for ; Tue, 28 Jan 2020 08:58:29 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=amazon.com header.i=@amazon.com header.b="ClIk8JG2" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E05C12468E Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=amazon.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 0D2DB6B0007; Tue, 28 Jan 2020 03:58:29 -0500 (EST) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 0850C6B0008; Tue, 28 Jan 2020 03:58:29 -0500 (EST) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id EB60B6B000A; Tue, 28 Jan 2020 03:58:28 -0500 (EST) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0156.hostedemail.com [216.40.44.156]) by kanga.kvack.org (Postfix) with ESMTP id D582D6B0007 for ; Tue, 28 Jan 2020 03:58:28 -0500 (EST) Received: from smtpin08.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay02.hostedemail.com (Postfix) with SMTP id A1B7B584D for ; Tue, 28 Jan 2020 08:58:28 +0000 (UTC) X-FDA: 76426441896.08.soda20_8427edff37612 X-Spam-Summary: 1,0,0,,d41d8cd98f00b204,prvs=289b61846=sjpark@amazon.com,:akpm@linux-foundation.org:sjpark@amazon.de:sj38.park@gmail.com:acme@kernel.org:amit@kernel.org:brendan.d.gregg@gmail.com:corbet@lwn.net:dwmw@amazon.com:mgorman@suse.de:rostedt@goodmis.org:kirill@shutemov.name:brendanhiggins@google.com:colin.king@canonical.com:minchan@kernel.org:vdavydov.dev@gmail.com:vdavydov@parallels.com::linux-doc@vger.kernel.org:linux-kernel@vger.kernel.org,RULES_HIT:2539:30003:30005:30016:30034:30051:30054:30064:30067,0,RBL:52.95.49.90:@amazon.com:.lbl8.mailshell.net-62.18.0.100 64.10.201.10,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fp,MSBL:0,DNSBL:none,Custom_rules:0:2:0,LFtime:24,LUA_SUMMARY:none X-HE-Tag: soda20_8427edff37612 X-Filterd-Recvd-Size: 12872 Received: from smtp-fw-6002.amazon.com (smtp-fw-6002.amazon.com [52.95.49.90]) by imf31.hostedemail.com (Postfix) with ESMTP for ; Tue, 28 Jan 2020 08:58:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amazon.com; i=@amazon.com; q=dns/txt; s=amazon201209; t=1580201909; x=1611737909; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version; bh=qMeUe5LpnN2gPMSP7kFnV1uiYWrGhDzwORwq2eHzInY=; b=ClIk8JG2t63K1q6ngv2s0Cj9mBMALrRYIxiX28kbL7tLgxeaF7Cpd8QX g7wOgIqv8aZBo5OMGSnZ17lzqiOngD7kAjlE3Jk17Y58UtsLv+T7cAQF/ pWCODza01+0+ewvGoP1L6pLInk8f7siCUGPolxyw+EwFcco1az/WtJKSZ s=; IronPort-SDR: 1VkpQGpH0DJrRNwImXaJF6y4sVT17tLPGjNmEu8/22gwxuLXiDk2FZ+N1eE8WcyIi99Gh18ARm zAVlnSQMriZw== X-IronPort-AV: E=Sophos;i="5.70,373,1574121600"; d="scan'208";a="13618728" Received: from iad12-co-svc-p1-lb1-vlan3.amazon.com (HELO email-inbound-relay-2b-81e76b79.us-west-2.amazon.com) ([10.43.8.6]) by smtp-border-fw-out-6002.iad6.amazon.com with ESMTP; 28 Jan 2020 08:58:26 +0000 Received: from EX13MTAUEA002.ant.amazon.com (pdx4-ws-svc-p6-lb7-vlan3.pdx.amazon.com [10.170.41.166]) by email-inbound-relay-2b-81e76b79.us-west-2.amazon.com (Postfix) with ESMTPS id 2C4D8A2576; Tue, 28 Jan 2020 08:58:24 +0000 (UTC) Received: from EX13D31EUA001.ant.amazon.com (10.43.165.15) by EX13MTAUEA002.ant.amazon.com (10.43.61.77) with Microsoft SMTP Server (TLS) id 15.0.1236.3; Tue, 28 Jan 2020 08:58:23 +0000 Received: from u886c93fd17d25d.ant.amazon.com (10.43.160.29) by EX13D31EUA001.ant.amazon.com (10.43.165.15) with Microsoft SMTP Server (TLS) id 15.0.1367.3; Tue, 28 Jan 2020 08:58:16 +0000 From: To: CC: SeongJae Park , , , , , , , , , , , , , , , , , Subject: [PATCH v2 1/9] mm: Introduce Data Access MONitor (DAMON) Date: Tue, 28 Jan 2020 09:57:34 +0100 Message-ID: <20200128085742.14566-2-sjpark@amazon.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200128085742.14566-1-sjpark@amazon.com> References: <20200128085742.14566-1-sjpark@amazon.com> MIME-Version: 1.0 X-Originating-IP: [10.43.160.29] X-ClientProxiedBy: EX13D21UWA001.ant.amazon.com (10.43.160.154) To EX13D31EUA001.ant.amazon.com (10.43.165.15) 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: From: SeongJae Park This commit introduces a new kernel module named DAMON. Note that this commit is implementing only the stub for the module load/unload, basic data structures, and simple manipulation functions of the structures to keep the size of commit small. The core mechanisms of DAMON will be implemented one by one by following commits. Brief Introduction ================== DAMON is a kernel module that would allow users to monitor the actual memory access pattern of specific user-space processes. It aims to be 1) accurate enough to be useful for performance-centric domains, and 2) sufficiently light-weight so that it can be applied online. For the goals, DAMON will utilize its two core mechanisms, called region-based sampling and adaptive regions adjustment. The region-based sampling allows users to make their own trade-off between the quality and the overhead of the monitoring and set the upperbound of the monitoring overhead. Further, the adaptive regions adjustment mechanism makes DAMON to maximize the quality and minimize the overhead with its best efforts while preserving the users configured trade-off. Please note that the term 'memory' in this context means 'main memory'. It also assumes that it would usually utilizes the middle level speed memory devices such as DRAMs or NVRAMs. CPU caches or storage devices are not DAMON's concern, as those are too fast or too slow to be in DAMON's scope. Expected Use-cases ================== A straightforward usecase of DAMON would be the program behavior analysis. With the DAMON output, users can confirm whether the program is running as intended or not. This will be useful for debuggings and tests of design points. The monitored results can also be useful for counting the dynamic working set size of workloads. For the administration of memory overcommitted systems or selection of the environments (e.g., containers providing different amount of memory) for your workloads, this will be useful. If you are a programmer, you can optimize your program by managing the memory based on the actual data access pattern. For example, you can identify the dynamic hotness of your data using DAMON and call ``mlock()`` to keep your hot data in DRAM, or call ``madvise()`` with ``MADV_PAGEOUT`` to proactively reclaim cold data. Even though your program is guaranteed to not encounter memory pressure, you can still improve the performance by applying the DAMON outputs for call of ``MADV_HUGEPAGE`` and ``MADV_NOHUGEPAGE``. More creative optimizations would be possible. Our evaluations of DAMON includes a straightforward optimization using the ``mlock()``. Please refer to the below Evaluation section for more detail. As DAMON incurs very low overhead, such optimizations can be applied not only offline, but also online. Also, there is no reason to limit such optimizations to the user space. Several parts of the kernel's memory management mechanisms could be also optimized using DAMON. The reclamation, the THP (de)promotion decisions, and the compaction would be such a candidates. Nevertheless, current version of DAMON is not highly optimized for the online/in-kernel uses. Signed-off-by: SeongJae Park --- MAINTAINERS | 6 ++ mm/Kconfig | 12 +++ mm/Makefile | 1 + mm/damon.c | 223 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 242 insertions(+) create mode 100644 mm/damon.c diff --git a/MAINTAINERS b/MAINTAINERS index 56765f542244..5a4db07cad33 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4611,6 +4611,12 @@ F: net/ax25/ax25_out.c F: net/ax25/ax25_timer.c F: net/ax25/sysctl_net_ax25.c +DATA ACCESS MONITOR +M: SeongJae Park +L: linux-mm@kvack.org +S: Maintained +F: mm/damon.c + DAVICOM FAST ETHERNET (DMFE) NETWORK DRIVER L: netdev@vger.kernel.org S: Orphan diff --git a/mm/Kconfig b/mm/Kconfig index ab80933be65f..144fb916aa8b 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -739,4 +739,16 @@ config ARCH_HAS_HUGEPD config MAPPING_DIRTY_HELPERS bool +config DAMON + tristate "Data Access Monitor" + depends on MMU + default y + help + Provides data access monitoring. + + DAMON is a kernel module that allows users to monitor the actual + memory access pattern of specific user-space processes. It aims to + be 1) accurate enough to be useful for performance-centric domains, + and 2) sufficiently light-weight so that it can be applied online. + endmenu diff --git a/mm/Makefile b/mm/Makefile index 1937cc251883..2911b3832c90 100644 --- a/mm/Makefile +++ b/mm/Makefile @@ -108,3 +108,4 @@ obj-$(CONFIG_ZONE_DEVICE) += memremap.o obj-$(CONFIG_HMM_MIRROR) += hmm.o obj-$(CONFIG_MEMFD_CREATE) += memfd.o obj-$(CONFIG_MAPPING_DIRTY_HELPERS) += mapping_dirty_helpers.o +obj-$(CONFIG_DAMON) += damon.o diff --git a/mm/damon.c b/mm/damon.c new file mode 100644 index 000000000000..064ec1f6ded9 --- /dev/null +++ b/mm/damon.c @@ -0,0 +1,223 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Data Access Monitor + * + * Copyright 2019 Amazon.com, Inc. or its affiliates. All rights reserved. + * + * Author: SeongJae Park + */ + +#define pr_fmt(fmt) "damon: " fmt + +#include +#include +#include +#include + +#define damon_get_task_struct(t) \ + (get_pid_task(find_vpid(t->pid), PIDTYPE_PID)) + +#define damon_next_region(r) \ + (container_of(r->list.next, struct damon_region, list)) + +#define damon_prev_region(r) \ + (container_of(r->list.prev, struct damon_region, list)) + +#define damon_for_each_region(r, t) \ + list_for_each_entry(r, &t->regions_list, list) + +#define damon_for_each_region_safe(r, next, t) \ + list_for_each_entry_safe(r, next, &t->regions_list, list) + +#define damon_for_each_task(t) \ + list_for_each_entry(t, &damon_tasks_list, list) + +#define damon_for_each_task_safe(t, next) \ + list_for_each_entry_safe(t, next, &damon_tasks_list, list) + +/* Represents a monitoring target region on the virtual address space */ +struct damon_region { + unsigned long vm_start; + unsigned long vm_end; + unsigned long sampling_addr; + unsigned int nr_accesses; + struct list_head list; +}; + +/* Represents a monitoring target task */ +struct damon_task { + unsigned long pid; + struct list_head regions_list; + struct list_head list; +}; + +/* List of damon_task objects */ +static LIST_HEAD(damon_tasks_list); + +static struct rnd_state rndseed; +/* Get a random number in [l, r) */ +#define damon_rand(l, r) (l + prandom_u32_state(&rndseed) % (r - l)) + +/* + * Construct a damon_region struct + * + * Returns the pointer to the new struct if success, or NULL otherwise + */ +static struct damon_region *damon_new_region(unsigned long vm_start, + unsigned long vm_end) +{ + struct damon_region *ret; + + ret = kmalloc(sizeof(struct damon_region), GFP_KERNEL); + if (!ret) + return NULL; + ret->vm_start = vm_start; + ret->vm_end = vm_end; + ret->nr_accesses = 0; + ret->sampling_addr = damon_rand(vm_start, vm_end); + INIT_LIST_HEAD(&ret->list); + + return ret; +} + +/* + * Add a region between two other regions + */ +static inline void damon_add_region(struct damon_region *r, + struct damon_region *prev, struct damon_region *next) +{ + __list_add(&r->list, &prev->list, &next->list); +} + +/* + * Append a region to a task's list of regions + */ +static void damon_add_region_tail(struct damon_region *r, struct damon_task *t) +{ + list_add_tail(&r->list, &t->regions_list); +} + +/* + * Delete a region from its list + */ +static void damon_del_region(struct damon_region *r) +{ + list_del(&r->list); +} + +/* + * De-allocate a region + */ +static void damon_free_region(struct damon_region *r) +{ + kfree(r); +} + +static void damon_destroy_region(struct damon_region *r) +{ + damon_del_region(r); + damon_free_region(r); +} + +/* + * Construct a damon_task struct + * + * Returns the pointer to the new struct if success, or NULL otherwise + */ +static struct damon_task *damon_new_task(unsigned long pid) +{ + struct damon_task *t; + + t = kmalloc(sizeof(struct damon_task), GFP_KERNEL); + if (!t) + return NULL; + t->pid = pid; + INIT_LIST_HEAD(&t->regions_list); + + return t; +} + +/* Returns n-th damon_region of the given task */ +struct damon_region *damon_nth_region_of(struct damon_task *t, unsigned int n) +{ + struct damon_region *r; + unsigned int i; + + i = 0; + damon_for_each_region(r, t) { + if (i++ == n) + return r; + } + return NULL; +} + +static void damon_add_task_tail(struct damon_task *t) +{ + list_add_tail(&t->list, &damon_tasks_list); +} + +static void damon_del_task(struct damon_task *t) +{ + list_del(&t->list); +} + +static void damon_free_task(struct damon_task *t) +{ + struct damon_region *r, *next; + + damon_for_each_region_safe(r, next, t) + damon_free_region(r); + kfree(t); +} + +static void damon_destroy_task(struct damon_task *t) +{ + damon_del_task(t); + damon_free_task(t); +} + +/* + * Returns number of monitoring target tasks + */ +static unsigned int nr_damon_tasks(void) +{ + struct damon_task *t; + unsigned int ret = 0; + + damon_for_each_task(t) + ret++; + return ret; +} + +/* + * Returns the number of target regions for a given target task + */ +static unsigned int nr_damon_regions(struct damon_task *t) +{ + struct damon_region *r; + unsigned int ret = 0; + + damon_for_each_region(r, t) + ret++; + return ret; +} + +static int __init damon_init(void) +{ + pr_info("init\n"); + + prandom_seed_state(&rndseed, 42); + return 0; +} + +static void __exit damon_exit(void) +{ + pr_info("exit\n"); +} + +module_init(damon_init); +module_exit(damon_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("SeongJae Park "); +MODULE_DESCRIPTION("DAMON: Data Access MONitor"); From patchwork Tue Jan 28 08:57:35 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 11353785 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id B82A4112B for ; Tue, 28 Jan 2020 08:58:37 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 6BB3224688 for ; Tue, 28 Jan 2020 08:58:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=amazon.com header.i=@amazon.com header.b="VQ7BdG7B" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6BB3224688 Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=amazon.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 5B5946B000A; Tue, 28 Jan 2020 03:58:36 -0500 (EST) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 566B36B000C; Tue, 28 Jan 2020 03:58:36 -0500 (EST) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 4544A6B000D; Tue, 28 Jan 2020 03:58:36 -0500 (EST) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0040.hostedemail.com [216.40.44.40]) by kanga.kvack.org (Postfix) with ESMTP id 2E9886B000A for ; Tue, 28 Jan 2020 03:58:36 -0500 (EST) Received: from smtpin12.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay01.hostedemail.com (Postfix) with SMTP id E2D83180AD802 for ; Tue, 28 Jan 2020 08:58:35 +0000 (UTC) X-FDA: 76426442190.12.beam74_85382afdbb735 X-Spam-Summary: 1,0,0,,d41d8cd98f00b204,prvs=289b61846=sjpark@amazon.com,:akpm@linux-foundation.org:sjpark@amazon.de:sj38.park@gmail.com:acme@kernel.org:amit@kernel.org:brendan.d.gregg@gmail.com:corbet@lwn.net:dwmw@amazon.com:mgorman@suse.de:rostedt@goodmis.org:kirill@shutemov.name:brendanhiggins@google.com:colin.king@canonical.com:minchan@kernel.org:vdavydov.dev@gmail.com:vdavydov@parallels.com::linux-doc@vger.kernel.org:linux-kernel@vger.kernel.org,RULES_HIT:30003:30012:30034:30051:30054:30056:30064:30070:30075,0,RBL:72.21.196.25:@amazon.com:.lbl8.mailshell.net-62.18.0.100 66.10.201.10,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fp,MSBL:0,DNSBL:neutral,Custom_rules:0:0:0,LFtime:25,LUA_SUMMARY:none X-HE-Tag: beam74_85382afdbb735 X-Filterd-Recvd-Size: 21684 Received: from smtp-fw-2101.amazon.com (smtp-fw-2101.amazon.com [72.21.196.25]) by imf30.hostedemail.com (Postfix) with ESMTP for ; Tue, 28 Jan 2020 08:58:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amazon.com; i=@amazon.com; q=dns/txt; s=amazon201209; t=1580201915; x=1611737915; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version; bh=wJ/KbDn9ODQ8bIxPN5eYNxHEbIpfqs2V11SCqxFPMk8=; b=VQ7BdG7BrTx5J+1gVuCnQdSLQGleekz2IhsyyqTT5sUpUJb0trqVX4ZT gwoaqrWVKnNEbOUsZFO73oK7KgKXJdhdYI72oxG7V1Q1uU/uaa2QqJIgp 96U8QyqiK5R55nAaJ2f19jthcXJmCMR54IcHeuM77TQUrudZIS0Z9IoYQ w=; IronPort-SDR: IM+5GR21Bij2yRlk2CnL1aotoYfk0HwSF95XQieiS3hfDlWstjDngjfmO26eHum30Yz6faK+wC YJ9InxiiP96Q== X-IronPort-AV: E=Sophos;i="5.70,373,1574121600"; d="scan'208";a="14531605" Received: from iad12-co-svc-p1-lb1-vlan2.amazon.com (HELO email-inbound-relay-2a-6e2fc477.us-west-2.amazon.com) ([10.43.8.2]) by smtp-border-fw-out-2101.iad2.amazon.com with ESMTP; 28 Jan 2020 08:58:33 +0000 Received: from EX13MTAUEA002.ant.amazon.com (pdx4-ws-svc-p6-lb7-vlan2.pdx.amazon.com [10.170.41.162]) by email-inbound-relay-2a-6e2fc477.us-west-2.amazon.com (Postfix) with ESMTPS id 9BB8CA23D5; Tue, 28 Jan 2020 08:58:31 +0000 (UTC) Received: from EX13D31EUA001.ant.amazon.com (10.43.165.15) by EX13MTAUEA002.ant.amazon.com (10.43.61.77) with Microsoft SMTP Server (TLS) id 15.0.1236.3; Tue, 28 Jan 2020 08:58:31 +0000 Received: from u886c93fd17d25d.ant.amazon.com (10.43.160.29) by EX13D31EUA001.ant.amazon.com (10.43.165.15) with Microsoft SMTP Server (TLS) id 15.0.1367.3; Tue, 28 Jan 2020 08:58:23 +0000 From: To: CC: SeongJae Park , , , , , , , , , , , , , , , , , Subject: [PATCH v2 2/9] mm/damon: Implement region based sampling Date: Tue, 28 Jan 2020 09:57:35 +0100 Message-ID: <20200128085742.14566-3-sjpark@amazon.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200128085742.14566-1-sjpark@amazon.com> References: <20200128085742.14566-1-sjpark@amazon.com> MIME-Version: 1.0 X-Originating-IP: [10.43.160.29] X-ClientProxiedBy: EX13D21UWA001.ant.amazon.com (10.43.160.154) To EX13D31EUA001.ant.amazon.com (10.43.165.15) 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: From: SeongJae Park This commit implements DAMON's basic access check and region based sampling mechanisms. Basic Access Check ------------------ DAMON basically reports what pages are how frequently accessed. Note that the frequency is not an absolute number of accesses, but a relative frequency among the pages of the target workloads. Users can control the resolution of the reports by setting two time intervals, ``sampling interval`` and ``aggregation interval``. In detail, DAMON checks access to each page per ``sampling interval``, aggregates the results (counts the number of the accesses to each page), and reports the aggregated results per ``aggregation interval``. For the access check of each page, DAMON uses the Accessed bits of PTEs. This is thus similar to common periodic access checks based access tracking mechanisms, which overhead is increasing as the size of the target process grows. Region Based Sampling --------------------- To avoid the unbounded increase of the overhead, DAMON groups a number of adjacent pages that assumed to have same access frequencies into a region. As long as the assumption (pages in a region have same access frequencies) is kept, only one page in the region is required to be checked. Thus, for each ``sampling interval``, DAMON randomly picks one page in each region and clears its Accessed bit. After one more ``sampling interval``, DAMON reads the Accessed bit of the page and increases the access frequency of the region if the bit has set meanwhile. Therefore, the monitoring overhead is controllable by setting the number of regions. Nonetheless, this scheme cannot preserve the quality of the output if the assumption is not kept. Signed-off-by: SeongJae Park --- mm/damon.c | 608 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 608 insertions(+) diff --git a/mm/damon.c b/mm/damon.c index 064ec1f6ded9..4144e9da9282 100644 --- a/mm/damon.c +++ b/mm/damon.c @@ -9,9 +9,14 @@ #define pr_fmt(fmt) "damon: " fmt +#include +#include #include #include +#include #include +#include +#include #include #define damon_get_task_struct(t) \ @@ -54,6 +59,36 @@ struct damon_task { /* List of damon_task objects */ static LIST_HEAD(damon_tasks_list); +/* + * For each 'sample_interval', DAMON checks whether each region is accessed or + * not. It aggregates and keeps the access information (number of accesses to + * each region) for 'aggr_interval' and then flushes it to the result buffer if + * an 'aggr_interval' surpassed. + * + * All time intervals are in micro-seconds. + */ +static unsigned long sample_interval = 5 * 1000; +static unsigned long aggr_interval = 100 * 1000; + +static struct timespec64 last_aggregate_time; + +static unsigned long min_nr_regions = 10; + +/* result buffer */ +#define DAMON_LEN_RBUF (1024 * 1024 * 4) +static char damon_rbuf[DAMON_LEN_RBUF]; +static unsigned int damon_rbuf_offset; + +/* result file */ +#define LEN_RES_FILE_PATH 256 +static char rfile_path[LEN_RES_FILE_PATH] = "/damon.data"; + +static struct task_struct *kdamond; +static bool kdamond_stop; + +/* Protects read/write of kdamond and kdamond_stop */ +static DEFINE_SPINLOCK(kdamond_lock); + static struct rnd_state rndseed; /* Get a random number in [l, r) */ #define damon_rand(l, r) (l + prandom_u32_state(&rndseed) % (r - l)) @@ -202,16 +237,589 @@ static unsigned int nr_damon_regions(struct damon_task *t) return ret; } +/* + * Get the mm_struct of the given task + * + * Callser should put the mm_struct after use, unless it is NULL. + * + * Returns the mm_struct of the task on success, NULL on failure + */ +static struct mm_struct *damon_get_mm(struct damon_task *t) +{ + struct task_struct *task; + struct mm_struct *mm; + + task = damon_get_task_struct(t); + if (!task) + return NULL; + + mm = get_task_mm(task); + put_task_struct(task); + return mm; +} + +/* + * Size-evenly split a region into 'nr_pieces' small regions + * + * Returns 0 on success, or negative error code otherwise. + */ +static int damon_split_region_evenly(struct damon_region *r, + unsigned int nr_pieces) +{ + unsigned long sz_orig, sz_piece, orig_end; + struct damon_region *piece = NULL, *next; + unsigned long start; + + if (!r || !nr_pieces) + return -EINVAL; + + orig_end = r->vm_end; + sz_orig = r->vm_end - r->vm_start; + sz_piece = sz_orig / nr_pieces; + + if (!sz_piece) + return -EINVAL; + + r->vm_end = r->vm_start + sz_piece; + next = damon_next_region(r); + for (start = r->vm_end; start + sz_piece <= orig_end; + start += sz_piece) { + piece = damon_new_region(start, start + sz_piece); + damon_add_region(piece, r, next); + r = piece; + } + if (piece) + piece->vm_end = orig_end; + return 0; +} + +struct region { + unsigned long start; + unsigned long end; +}; + +static unsigned long sz_region(struct region *r) +{ + return r->end - r->start; +} + +static void swap_regions(struct region *r1, struct region *r2) +{ + struct region tmp; + + tmp = *r1; + *r1 = *r2; + *r2 = tmp; +} + +/* + * Find the three regions in an address space + * + * vma the head vma of the target address space + * regions an array of three 'struct region's that results will be saved + * + * This function receives an address space and finds three regions in it which + * separated by the two biggest unmapped regions in the space. + * + * Returns 0 if success, or negative error code otherwise. + */ +static int damon_three_regions_in_vmas(struct vm_area_struct *vma, + struct region regions[3]) +{ + struct region gap = {0,}, first_gap = {0,}, second_gap = {0,}; + struct vm_area_struct *last_vma = NULL; + unsigned long start = 0; + + /* Find two biggest gaps so that first_gap > second_gap > others */ + for (; vma; vma = vma->vm_next) { + if (!last_vma) { + start = vma->vm_start; + last_vma = vma; + continue; + } + gap.start = last_vma->vm_end; + gap.end = vma->vm_start; + if (sz_region(&gap) > sz_region(&second_gap)) { + swap_regions(&gap, &second_gap); + if (sz_region(&second_gap) > sz_region(&first_gap)) + swap_regions(&second_gap, &first_gap); + } + last_vma = vma; + } + + if (!sz_region(&second_gap) || !sz_region(&first_gap)) + return -EINVAL; + + /* Sort the two biggest gaps by address */ + if (first_gap.start > second_gap.start) + swap_regions(&first_gap, &second_gap); + + /* Store the result */ + regions[0].start = start; + regions[0].end = first_gap.start; + regions[1].start = first_gap.end; + regions[1].end = second_gap.start; + regions[2].start = second_gap.end; + regions[2].end = last_vma->vm_end; + + return 0; +} + +/* + * Get the three regions in the given task + * + * Returns 0 on success, negative error code otherwise. + */ +static int damon_three_regions_of(struct damon_task *t, + struct region regions[3]) +{ + struct mm_struct *mm; + int ret; + + mm = damon_get_mm(t); + if (!mm) + return -EINVAL; + + down_read(&mm->mmap_sem); + ret = damon_three_regions_in_vmas(mm->mmap, regions); + up_read(&mm->mmap_sem); + + mmput(mm); + return ret; +} + +/* + * Initialize the monitoring target regions for the given task + * + * t the given target task + * + * Because only a number of small portions of the entire address space + * is acutally mapped to the memory and accessed, monitoring the unmapped + * regions is wasteful. That said, because we can deal with small noises, + * tracking every mapping is not strictly required but could even incur a high + * overhead if the mapping frequently changes or the number of mappings is + * high. + * + * For the reason, we convert the complex mappings to three distinct regions + * that cover every mapped areas of the address space. Also the two gaps + * between the three regions are the two biggest unmapped areas in the given + * address space. In detail, this function first identifies the start and the + * end of the mappings and the two biggest unmapped areas of the address space. + * Then, it constructs the three regions as below: + * + * [mappings[0]->start, big_two_unmapped_areas[0]->start) + * [big_two_unmapped_areas[0]->end, big_two_unmapped_areas[1]->start) + * [big_two_unmapped_areas[1]->end, mappings[nr_mappings - 1]->end) + * + * As usual memory map of processes is as below, the gap between the heap and + * the uppermost mmap()-ed region, and the gap between the lowermost mmap()-ed + * region and the stack will be two biggest unmapped regions. Because these + * gaps are exceptionally huge areas in usual address space, excluding these + * two biggest unmapped regions will be sufficient to make a trade-off. + * + * + * + * + * (other mmap()-ed regions and small unmapped regions) + * + * + * + */ +static void damon_init_regions_of(struct damon_task *t) +{ + struct damon_region *r; + struct region regions[3]; + int i; + + if (damon_three_regions_of(t, regions)) { + pr_err("Failed to get three regions of task %lu\n", t->pid); + return; + } + + /* Set the initial three regions of the task */ + for (i = 0; i < 3; i++) { + r = damon_new_region(regions[i].start, regions[i].end); + damon_add_region_tail(r, t); + } + + /* Split the middle region into 'min_nr_regions - 2' regions */ + r = damon_nth_region_of(t, 1); + if (damon_split_region_evenly(r, min_nr_regions - 2)) + pr_warn("Init middle region failed to be split\n"); +} + +/* Initialize '->regions_list' of every task */ +static void kdamond_init_regions(void) +{ + struct damon_task *t; + + damon_for_each_task(t) + damon_init_regions_of(t); +} + +/* + * Check whether the given region has accessed since the last check + * + * mm 'mm_struct' for the given virtual address space + * r the region to be checked + */ +static void kdamond_check_access(struct mm_struct *mm, struct damon_region *r) +{ + pte_t *pte = NULL; + pmd_t *pmd = NULL; + spinlock_t *ptl; + + if (follow_pte_pmd(mm, r->sampling_addr, NULL, &pte, &pmd, &ptl)) + goto mkold; + + /* Read the page table access bit of the page */ + if (pte && pte_young(*pte)) + r->nr_accesses++; +#ifdef CONFIG_TRANSPARENT_HUGEPAGE + else if (pmd && pmd_young(*pmd)) + r->nr_accesses++; +#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ + + spin_unlock(ptl); + +mkold: + /* mkold next target */ + r->sampling_addr = damon_rand(r->vm_start, r->vm_end); + + if (follow_pte_pmd(mm, r->sampling_addr, NULL, &pte, &pmd, &ptl)) + return; + + if (pte) { + if (pte_young(*pte)) { + clear_page_idle(pte_page(*pte)); + set_page_young(pte_page(*pte)); + } + *pte = pte_mkold(*pte); + } +#ifdef CONFIG_TRANSPARENT_HUGEPAGE + else if (pmd) { + if (pmd_young(*pmd)) { + clear_page_idle(pmd_page(*pmd)); + set_page_young(pte_page(*pte)); + } + *pmd = pmd_mkold(*pmd); + } +#endif + + spin_unlock(ptl); +} + +/* + * Check whether a time interval is elapsed + * + * baseline the time to check whether the interval has elapsed since + * interval the time interval (microseconds) + * + * See whether the given time interval has passed since the given baseline + * time. If so, it also updates the baseline to current time for next check. + * + * Returns true if the time interval has passed, or false otherwise. + */ +static bool damon_check_reset_time_interval(struct timespec64 *baseline, + unsigned long interval) +{ + struct timespec64 now; + + ktime_get_coarse_ts64(&now); + if ((timespec64_to_ns(&now) - timespec64_to_ns(baseline)) / 1000 < + interval) + return false; + *baseline = now; + return true; +} + +/* + * Check whether it is time to flush the aggregated information + */ +static bool kdamond_aggregate_interval_passed(void) +{ + return damon_check_reset_time_interval(&last_aggregate_time, + aggr_interval); +} + +/* + * Flush the content in the result buffer to the result file + */ +static void damon_flush_rbuffer(void) +{ + ssize_t sz; + loff_t pos; + struct file *rfile; + + while (damon_rbuf_offset) { + pos = 0; + rfile = filp_open(rfile_path, O_CREAT | O_RDWR | O_APPEND, + 0644); + if (IS_ERR(rfile)) { + pr_err("Cannot open the result file %s\n", rfile_path); + return; + } + + sz = kernel_write(rfile, damon_rbuf, damon_rbuf_offset, &pos); + filp_close(rfile, NULL); + + damon_rbuf_offset -= sz; + } +} + +/* + * Write a data into the result buffer + */ +static void damon_write_rbuf(void *data, ssize_t size) +{ + if (damon_rbuf_offset + size > DAMON_LEN_RBUF) + damon_flush_rbuffer(); + + memcpy(&damon_rbuf[damon_rbuf_offset], data, size); + damon_rbuf_offset += size; +} + +/* + * Flush the aggregated monitoring results to the result buffer + * + * Stores current tracking results to the result buffer and reset 'nr_accesses' + * of each regions. The format for the result buffer is as below: + * + *