From: SeongJae Park <[email protected]>
Currently, DAMON[1] supports only virtual memory address spaces because it
utilizes PTE Accessed bits as its low-level access check primitive and ``struct
vma`` as a way to address the monitoring target regions. However, the core
idea of DAMON, which makes it able to provide the accurate, efficient, and
scalable monitoring, is in a separate higher layer. Therefore, DAMON can be
extended for other various address spaces by changing the two low primitives to
others for the address spaces.
This patchset makes the DAMON's low level primitives configurable and provide
reference implementation of the primitives for the virtual memory address
spaces and the physical memory address space. Therefore, users can monitor
both of the two address spaces by simply configuring the provided low level
primitives. Note that only the user memory is supported, as same to the idle
page access tracking feature.
After this patchset, the programming interface users can implement the
primitives by themselves for their special use cases. Clean/dirty/entire page
cache, NUMA nodes, specific files, or block devices would be examples of such
special use cases.
[1] https://lore.kernel.org/linux-mm/[email protected]/
Baseline and Complete Git Trees
===============================
The patches are based on the v5.7 plus DAMON v15 patchset[1] and DAMOS RFC v11
patchset[2]. You can also clone the complete git tree:
$ git clone git://github.com/sjp38/linux -b cdamon/rfc/v3
The web is also available:
https://github.com/sjp38/linux/releases/tag/cdamon/rfc/v3
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://lore.kernel.org/linux-mm/[email protected]/
Sequence of Patches
===================
The sequence of patches is as follow. The 1st patch defines the monitoring
region again based on pure address range abstraction so that no assumption of
virtual memory is in there.
The 2nd patch allows users to configure the low level pritimives for
initialization and dynamic update of the target address regions, which were
previously coupled with the virtual memory. Then, the 3rd and 4th patches
allow user space to also be able to set the monitoring target regions via the
debugfs and the user space tool. The 5th patch documents this feature.
The 6th patch makes the access check primitives, which were coupled with the
virtual memory address, freely configurable. Now any address space can be
supported. The 7th patch provides the reference implementations of the
configurable primitives for the physical memory monitoring. The 8th and 9th
patch makes the user space to be able to use the physical memory monitoring via
debugfs and the user space tool, respectively. Finally, the 10th patch
documents the physical memory monitoring support.
Patch History
=============
Changes from RFC v2
(https://lore.kernel.org/linux-mm/[email protected]/)
- Support the physical memory monitoring with the user space tool
- Use 'pfn_to_online_page()' (David Hildenbrand)
- Document more detail on random 'pfn' and its safeness (David Hildenbrand)
Changes from RFC v1
(https://lore.kernel.org/linux-mm/[email protected]/)
- Provide the reference primitive implementations for the physical memory
- Connect the extensions with the debugfs interface
SeongJae Park (8):
mm/damon/debugfs: Allow users to set initial monitoring target regions
tools/damon: Implement init target regions feature
Docs/damon: Document 'initial_regions' feature
mm/rmap: Export essential functions for rmap_run
mm/damon: Implement callbacks for physical memory monitoring
mm/damon/debugfs: Support physical memory monitoring
tools/damon/record: Support physical memory address spce
Docs/damon: Document physical memory monitoring support
Documentation/admin-guide/mm/damon/faq.rst | 7 +-
Documentation/admin-guide/mm/damon/index.rst | 1 -
Documentation/admin-guide/mm/damon/plans.rst | 7 -
Documentation/admin-guide/mm/damon/usage.rst | 73 +++-
include/linux/damon.h | 5 +
mm/damon.c | 374 ++++++++++++++++++-
mm/rmap.c | 2 +
mm/util.c | 1 +
tools/damon/_damon.py | 41 ++
tools/damon/heats.py | 2 +-
tools/damon/record.py | 41 +-
tools/damon/schemes.py | 12 +-
12 files changed, 532 insertions(+), 34 deletions(-)
delete mode 100644 Documentation/admin-guide/mm/damon/plans.rst
--
2.17.1
From: SeongJae Park <[email protected]>
This commit exports the three essential functions for ramp walk,
'page_lock_anon_vma_read()', 'rmap_walk()', and 'page_rmapping()', to
GPL modules. Those will be used by DAMON for the physical memory
address based access monitoring in the following commit.
Signed-off-by: SeongJae Park <[email protected]>
---
mm/rmap.c | 2 ++
mm/util.c | 1 +
2 files changed, 3 insertions(+)
diff --git a/mm/rmap.c b/mm/rmap.c
index f79a206b271a..20ac37b27a7d 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -579,6 +579,7 @@ struct anon_vma *page_lock_anon_vma_read(struct page *page)
rcu_read_unlock();
return anon_vma;
}
+EXPORT_SYMBOL_GPL(page_lock_anon_vma_read);
void page_unlock_anon_vma_read(struct anon_vma *anon_vma)
{
@@ -1934,6 +1935,7 @@ void rmap_walk(struct page *page, struct rmap_walk_control *rwc)
else
rmap_walk_file(page, rwc, false);
}
+EXPORT_SYMBOL_GPL(rmap_walk);
/* Like rmap_walk, but caller holds relevant rmap lock */
void rmap_walk_locked(struct page *page, struct rmap_walk_control *rwc)
diff --git a/mm/util.c b/mm/util.c
index 988d11e6c17c..1df32546fe28 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -620,6 +620,7 @@ void *page_rmapping(struct page *page)
page = compound_head(page);
return __page_rmapping(page);
}
+EXPORT_SYMBOL_GPL(page_rmapping);
/*
* Return true if this page is mapped into pagetables.
--
2.17.1
From: SeongJae Park <[email protected]>
This commit makes the debugfs interface to support the physical memory
monitoring, in addition to the virtual memory monitoring.
Users can do the physical memory monitoring by writing a special
keyword, 'paddr\n' to the 'pids' debugfs file. Then, DAMON will check
the special keyword and configure the callbacks of the monitoring
context for the debugfs user for physical memory. This will internally
add one fake monitoring target process, which has pid as -1.
Unlike the virtual memory monitoring, DAMON debugfs will not
automatically set the monitoring target region. Therefore, users should
also set the monitoring target address region using the 'init_regions'
debugfs file. While doing this, the 'pid' in the input should be '-1'.
Finally, the physical memory monitoring will not automatically
terminated because it has fake monitoring target process. The user
should explicitly turn off the monitoring by writing 'off' to the
'monitor_on' debugfs file.
Signed-off-by: SeongJae Park <[email protected]>
---
mm/damon.c | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/mm/damon.c b/mm/damon.c
index fdf3425befb2..efd6428bd85e 100644
--- a/mm/damon.c
+++ b/mm/damon.c
@@ -1918,6 +1918,23 @@ static ssize_t debugfs_pids_write(struct file *file,
if (IS_ERR(kbuf))
return PTR_ERR(kbuf);
+ if (!strncmp(kbuf, "paddr\n", count)) {
+ /* Configure the context for physical memory monitoring */
+ ctx->init_target_regions = kdamond_init_phys_regions;
+ ctx->update_target_regions = kdamond_update_phys_regions;
+ ctx->prepare_access_checks = kdamond_prepare_phys_access_checks;
+ ctx->check_accesses = kdamond_check_phys_accesses;
+
+ /* Set the fake target task pid as -1 */
+ snprintf(kbuf, count, "-1 ");
+ } else {
+ /* Configure the context for virtual memory monitoring */
+ ctx->init_target_regions = kdamond_init_vm_regions;
+ ctx->update_target_regions = kdamond_update_vm_regions;
+ ctx->prepare_access_checks = kdamond_prepare_vm_access_checks;
+ ctx->check_accesses = kdamond_check_vm_accesses;
+ }
+
targets = str_to_pids(kbuf, ret, &nr_targets);
if (!targets) {
ret = -ENOMEM;
--
2.17.1
From: SeongJae Park <[email protected]>
This commit allows users to record the data accesses on physical memory
address space by passing 'paddr' as target to 'damo-record'. If the
init regions are given, the regions will be monitored. Else, it will
monitor biggest conitguous 'System RAM' region in '/proc/iomem' and
monitor the region.
Signed-off-by: SeongJae Park <[email protected]>
---
tools/damon/_damon.py | 2 ++
tools/damon/heats.py | 2 +-
tools/damon/record.py | 29 ++++++++++++++++++++++++++++-
3 files changed, 31 insertions(+), 2 deletions(-)
diff --git a/tools/damon/_damon.py b/tools/damon/_damon.py
index ad476cc61421..95d23c2ab6ee 100644
--- a/tools/damon/_damon.py
+++ b/tools/damon/_damon.py
@@ -27,6 +27,8 @@ def set_target(pid, init_regions=[]):
if not os.path.exists(debugfs_init_regions):
return 0
+ if pid == 'paddr':
+ pid = -1
string = ' '.join(['%s %d %d' % (pid, r[0], r[1]) for r in init_regions])
return subprocess.call('echo "%s" > %s' % (string, debugfs_init_regions),
shell=True, executable='/bin/bash')
diff --git a/tools/damon/heats.py b/tools/damon/heats.py
index 99837083874e..34dbcf1a839d 100644
--- a/tools/damon/heats.py
+++ b/tools/damon/heats.py
@@ -307,7 +307,7 @@ def plot_heatmap(data_file, output_file):
set xrange [0:];
set yrange [0:];
set xlabel 'Time (ns)';
- set ylabel 'Virtual Address (bytes)';
+ set ylabel 'Address (bytes)';
plot '%s' using 1:2:3 with image;""" % (terminal, output_file, data_file)
subprocess.call(['gnuplot', '-e', gnuplot_cmd])
os.remove(data_file)
diff --git a/tools/damon/record.py b/tools/damon/record.py
index 6ce8721d782a..416dca940c1d 100644
--- a/tools/damon/record.py
+++ b/tools/damon/record.py
@@ -73,6 +73,29 @@ def set_argparser(parser):
parser.add_argument('-o', '--out', metavar='<file path>', type=str,
default='damon.data', help='output file path')
+def default_paddr_region():
+ "Largest System RAM region becomes the default"
+ ret = []
+ with open('/proc/iomem', 'r') as f:
+ # example of the line: '100000000-42b201fff : System RAM'
+ for line in f:
+ fields = line.split(':')
+ if len(fields) != 2:
+ continue
+ name = fields[1].strip()
+ if name != 'System RAM':
+ continue
+ addrs = fields[0].split('-')
+ if len(addrs) != 2:
+ continue
+ start = int(addrs[0], 16)
+ end = int(addrs[1], 16)
+
+ sz_region = end - start
+ if not ret or sz_region > (ret[1] - ret[0]):
+ ret = [start, end]
+ return ret
+
def main(args=None):
global orig_attrs
if not args:
@@ -93,7 +116,11 @@ def main(args=None):
target = args.target
target_fields = target.split()
- if not subprocess.call('which %s > /dev/null' % target_fields[0],
+ if target == 'paddr': # physical memory address space
+ if not init_regions:
+ init_regions = [default_paddr_region()]
+ do_record(target, False, init_regions, new_attrs, orig_attrs)
+ elif not subprocess.call('which %s > /dev/null' % target_fields[0],
shell=True, executable='/bin/bash'):
do_record(target, True, init_regions, new_attrs, orig_attrs)
else:
--
2.17.1
From: SeongJae Park <[email protected]>
This commit implements the four callbacks (->init_target_regions,
->update_target_regions, ->prepare_access_check, and ->check_accesses)
for the basic access monitoring of the physical memory address space.
By setting the callback pointers to point those, users can easily
monitor the accesses to the physical memory.
Internally, it uses the PTE Accessed bit, as similar to that of the
virtual memory support. Also, it supports only user memory pages, as
idle page tracking also does, for the same reason. If the monitoring
target physical memory address range contains non-user memory pages,
access check of the pages will do nothing but simply treat the pages as
not accessed.
Users who want to use other access check primitives and/or monitor the
non-user memory regions could implement and use their own callbacks.
Signed-off-by: SeongJae Park <[email protected]>
---
include/linux/damon.h | 5 ++
mm/damon.c | 201 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 206 insertions(+)
diff --git a/include/linux/damon.h b/include/linux/damon.h
index 076852bab7aa..6c0e9bb35a1f 100644
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -227,6 +227,11 @@ void kdamond_update_vm_regions(struct damon_ctx *ctx);
void kdamond_prepare_vm_access_checks(struct damon_ctx *ctx);
unsigned int kdamond_check_vm_accesses(struct damon_ctx *ctx);
+void kdamond_init_phys_regions(struct damon_ctx *ctx);
+void kdamond_update_phys_regions(struct damon_ctx *ctx);
+void kdamond_prepare_phys_access_checks(struct damon_ctx *ctx);
+unsigned int kdamond_check_phys_accesses(struct damon_ctx *ctx);
+
int damon_set_pids(struct damon_ctx *ctx, int *pids, ssize_t nr_pids);
int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int,
unsigned long aggr_int, unsigned long regions_update_int,
diff --git a/mm/damon.c b/mm/damon.c
index ab115db1f20c..fdf3425befb2 100644
--- a/mm/damon.c
+++ b/mm/damon.c
@@ -27,10 +27,13 @@
#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/kthread.h>
+#include <linux/memory_hotplug.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/page_idle.h>
+#include <linux/pagemap.h>
#include <linux/random.h>
+#include <linux/rmap.h>
#include <linux/sched/mm.h>
#include <linux/sched/task.h>
#include <linux/slab.h>
@@ -534,6 +537,18 @@ void kdamond_init_vm_regions(struct damon_ctx *ctx)
}
}
+/*
+ * The initial regions construction function for the physical address space.
+ *
+ * This default version does nothing in actual. Users should set the initial
+ * regions by themselves before passing their damon_ctx to 'start_damon()', or
+ * implement their version of this and set '->init_target_regions' of their
+ * damon_ctx to point it.
+ */
+void kdamond_init_phys_regions(struct damon_ctx *ctx)
+{
+}
+
/*
* Functions for the dynamic monitoring target regions update
*/
@@ -617,6 +632,19 @@ void kdamond_update_vm_regions(struct damon_ctx *ctx)
}
}
+/*
+ * The dynamic monitoring target regions update function for the physical
+ * address space.
+ *
+ * This default version does nothing in actual. Users should update the
+ * regions in other callbacks such as '->aggregate_cb', or implement their
+ * version of this and set the '->init_target_regions' of their damon_ctx to
+ * point it.
+ */
+void kdamond_update_phys_regions(struct damon_ctx *ctx)
+{
+}
+
/*
* Functions for the access checking of the regions
*/
@@ -752,6 +780,179 @@ unsigned int kdamond_check_vm_accesses(struct damon_ctx *ctx)
return max_nr_accesses;
}
+/* access check functions for physical address based regions */
+
+/*
+ * Get a page by pfn if it is in the LRU list. Otherwise, returns NULL.
+ *
+ * The body of this function is stollen from the 'page_idle_get_page()'. We
+ * steal rather than reuse it because the code is quite simple .
+ */
+static struct page *damon_phys_get_page(unsigned long pfn)
+{
+ struct page *page = pfn_to_online_page(pfn);
+ pg_data_t *pgdat;
+
+ if (!page || !PageLRU(page) ||
+ !get_page_unless_zero(page))
+ return NULL;
+
+ pgdat = page_pgdat(page);
+ spin_lock_irq(&pgdat->lru_lock);
+ if (unlikely(!PageLRU(page))) {
+ put_page(page);
+ page = NULL;
+ }
+ spin_unlock_irq(&pgdat->lru_lock);
+ return page;
+}
+
+static bool damon_page_mkold(struct page *page, struct vm_area_struct *vma,
+ unsigned long addr, void *arg)
+{
+ damon_mkold(vma->vm_mm, addr);
+ return true;
+}
+
+static void damon_phys_mkold(unsigned long paddr)
+{
+ struct page *page = damon_phys_get_page(PHYS_PFN(paddr));
+ struct rmap_walk_control rwc = {
+ .rmap_one = damon_page_mkold,
+ .anon_lock = page_lock_anon_vma_read,
+ };
+ bool need_lock;
+
+ if (!page)
+ return;
+
+ if (!page_mapped(page) || !page_rmapping(page))
+ return;
+
+ need_lock = !PageAnon(page) || PageKsm(page);
+ if (need_lock && !trylock_page(page))
+ return;
+
+ rmap_walk(page, &rwc);
+
+ if (need_lock)
+ unlock_page(page);
+ put_page(page);
+}
+
+static void damon_prepare_phys_access_check(struct damon_ctx *ctx,
+ struct damon_region *r)
+{
+ r->sampling_addr = damon_rand(r->ar.start, r->ar.end);
+
+ damon_phys_mkold(r->sampling_addr);
+}
+
+void kdamond_prepare_phys_access_checks(struct damon_ctx *ctx)
+{
+ struct damon_task *t;
+ struct damon_region *r;
+
+ damon_for_each_task(t, ctx) {
+ damon_for_each_region(r, t)
+ damon_prepare_phys_access_check(ctx, r);
+ }
+}
+
+struct damon_phys_access_chk_result {
+ unsigned long page_sz;
+ bool accessed;
+};
+
+static bool damon_page_accessed(struct page *page, struct vm_area_struct *vma,
+ unsigned long addr, void *arg)
+{
+ struct damon_phys_access_chk_result *result = arg;
+
+ result->accessed = damon_young(vma->vm_mm, addr, &result->page_sz);
+
+ /* If accessed, stop walking */
+ return !result->accessed;
+}
+
+static bool damon_phys_young(unsigned long paddr, unsigned long *page_sz)
+{
+ struct page *page = damon_phys_get_page(PHYS_PFN(paddr));
+ struct damon_phys_access_chk_result result = {
+ .page_sz = PAGE_SIZE,
+ .accessed = false,
+ };
+ struct rmap_walk_control rwc = {
+ .arg = &result,
+ .rmap_one = damon_page_accessed,
+ .anon_lock = page_lock_anon_vma_read,
+ };
+ bool need_lock;
+
+ if (!page)
+ return false;
+
+ if (!page_mapped(page) || !page_rmapping(page))
+ return false;
+
+ need_lock = !PageAnon(page) || PageKsm(page);
+ if (need_lock && !trylock_page(page))
+ return false;
+
+ rmap_walk(page, &rwc);
+
+ if (need_lock)
+ unlock_page(page);
+ put_page(page);
+
+ *page_sz = result.page_sz;
+ return result.accessed;
+}
+
+/*
+ * Check whether the region was accessed after the last preparation
+ *
+ * mm 'mm_struct' for the given virtual address space
+ * r the region of physical address space that needs to be checked
+ */
+static void damon_check_phys_access(struct damon_ctx *ctx,
+ struct damon_region *r)
+{
+ static unsigned long last_addr;
+ static unsigned long last_page_sz = PAGE_SIZE;
+ static bool last_accessed;
+
+ /* If the region is in the last checked page, reuse the result */
+ if (ALIGN_DOWN(last_addr, last_page_sz) ==
+ ALIGN_DOWN(r->sampling_addr, last_page_sz)) {
+ if (last_accessed)
+ r->nr_accesses++;
+ return;
+ }
+
+ last_accessed = damon_phys_young(r->sampling_addr, &last_page_sz);
+ if (last_accessed)
+ r->nr_accesses++;
+
+ last_addr = r->sampling_addr;
+}
+
+unsigned int kdamond_check_phys_accesses(struct damon_ctx *ctx)
+{
+ struct damon_task *t;
+ struct damon_region *r;
+ unsigned int max_nr_accesses = 0;
+
+ damon_for_each_task(t, ctx) {
+ damon_for_each_region(r, t) {
+ damon_check_phys_access(ctx, r);
+ max_nr_accesses = max(r->nr_accesses, max_nr_accesses);
+ }
+ }
+
+ return max_nr_accesses;
+}
+
/*
* Functions for DAMON core logics and features
*/
--
2.17.1
From: SeongJae Park <[email protected]>
This commit adds description for the physical memory monitoring usage in
the DAMON document.
Signed-off-by: SeongJae Park <[email protected]>
---
Documentation/admin-guide/mm/damon/faq.rst | 7 +--
Documentation/admin-guide/mm/damon/index.rst | 1 -
Documentation/admin-guide/mm/damon/plans.rst | 7 ---
Documentation/admin-guide/mm/damon/usage.rst | 59 ++++++++++++++------
4 files changed, 46 insertions(+), 28 deletions(-)
delete mode 100644 Documentation/admin-guide/mm/damon/plans.rst
diff --git a/Documentation/admin-guide/mm/damon/faq.rst b/Documentation/admin-guide/mm/damon/faq.rst
index b1f108009115..d72d6182d7ea 100644
--- a/Documentation/admin-guide/mm/damon/faq.rst
+++ b/Documentation/admin-guide/mm/damon/faq.rst
@@ -45,10 +45,9 @@ constructions and actual access checks can be implemented and configured on the
DAMON core by the users. In this way, DAMON users can monitor any address
space with any access check technique.
-Nonetheless, DAMON provides a vma tracking and PTE Accessed bit check based
-implementation of the address space dependent functions for the virtual memory
-by default, for a reference and convenient use. In near future, we will also
-provide that for physical memory address space.
+Nonetheless, DAMON provides vma/rmap tracking and PTE Accessed bit check based
+implementations of the address space dependent functions for the virtual memory
+and the physical memory by default, for a reference and convenient use.
Can I simply monitor page granularity?
diff --git a/Documentation/admin-guide/mm/damon/index.rst b/Documentation/admin-guide/mm/damon/index.rst
index 4d128e4fd9c8..7b2939d50408 100644
--- a/Documentation/admin-guide/mm/damon/index.rst
+++ b/Documentation/admin-guide/mm/damon/index.rst
@@ -33,4 +33,3 @@ optimizations of their systems.
faq
mechanisms
eval
- plans
diff --git a/Documentation/admin-guide/mm/damon/plans.rst b/Documentation/admin-guide/mm/damon/plans.rst
deleted file mode 100644
index 765344f02eb3..000000000000
--- a/Documentation/admin-guide/mm/damon/plans.rst
+++ /dev/null
@@ -1,7 +0,0 @@
-.. SPDX-License-Identifier: GPL-2.0
-
-============
-Future Plans
-============
-
-TBD.
diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/admin-guide/mm/damon/usage.rst
index 24f1b05a859a..b2bcbd6ebe9d 100644
--- a/Documentation/admin-guide/mm/damon/usage.rst
+++ b/Documentation/admin-guide/mm/damon/usage.rst
@@ -61,9 +61,11 @@ Recording Data Access Pattern
-----------------------------
The ``record`` subcommand records the data access pattern of target processes
-in a file (``./damon.data`` by default). You can specify the target as either
-pid of running target or a command for execution of the process. Below example
-shows a command target usage::
+in a file (``./damon.data`` by default). You can specify the target with 1)
+the command for execution of the monitoring target process, 2) pid of running
+target process, or 3) the special keyword, 'paddr', if you want to monitor the
+system's physical memory address space. Below example shows a command target
+usage::
# cd <kernel>/tools/damon/
# damo record "sleep 5"
@@ -74,6 +76,15 @@ of the process. Below example shows a pid target usage::
# sleep 5 &
# damo record `pidof sleep`
+Finally, below example shows the use of the special keyword, 'paddr'::
+
+ # damo record paddr
+
+In this case, the monitoring target regions defaults to the largetst 'System
+RAM' region specified in '/proc/iomem' file. Note that the initial monitoring
+target region is maintained rather than dynamically updated like the virtual
+memory address spaces monitoring mode.
+
You can tune this by setting the monitoring attributes and path to the record
file using optional arguments to the subcommand. To know about the monitoring
attributes in detail, please refer to :doc:`mechanisms`.
@@ -317,27 +328,42 @@ check it again::
Target PIDs
-----------
-Users can get and set the pids of monitoring target processes by reading from
-and writing to the ``pids`` file. For example, below commands set processes
-having pids 42 and 4242 as the processes to be monitored and check it again::
+To monitor the virtual memory address spaces of specific processes, users can
+get and set the pids of monitoring target processes by reading from and writing
+to the ``pids`` file. For example, below commands set processes having pids 42
+and 4242 as the processes to be monitored and check it again::
# cd <debugfs>/damon
# echo 42 4242 > pids
# cat pids
42 4242
+Users can also monitor the physical memory address space of the system by
+writing a special keyword, "``paddr\n``" to the file. In this case, reading the
+file will show ``-1``, as below::
+
+ # cd <debugfs>/damon
+ # echo paddr > pids
+ # cat pids
+ -1
+
Note that setting the pids doesn't start the monitoring.
Initial Monitoring Target Regions
---------------------------------
-DAMON automatically sets and updates the monitoring target regions so that
-entire memory mappings of target processes can be covered. However, users
-might want to limit the monitoring region to specific address ranges, such as
-the heap, the stack, or specific file-mapped area. Or, some users might know
-the initial access pattern of their workloads and therefore want to set optimal
-initial regions for the 'adaptive regions adjustment'.
+In case of the virtual memory monitoring, DAMON automatically sets and updates
+the monitoring target regions so that entire memory mappings of target
+processes can be covered. However, users might want to limit the monitoring
+region to specific address ranges, such as the heap, the stack, or specific
+file-mapped area. Or, some users might know the initial access pattern of
+their workloads and therefore want to set optimal initial regions for the
+'adaptive regions adjustment'.
+
+In contrast, DAMON do not automatically sets and updates the monitoring target
+regions in case of physical memory monitoring. Therefore, users should set the
+monitoring target regions by themselves.
In such cases, users can explicitly set the initial monitoring target regions
as they want, by writing proper values to the ``init_regions`` file. Each line
@@ -357,10 +383,11 @@ region of process 42, and another couple of address ranges, ``20-40`` and
4242 20 40
4242 50 100" > init_regions
-Note that this sets the initial monitoring target regions only. DAMON will
-automatically updates the boundary of the regions after one ``regions update
-interval``. Therefore, users should set the ``regions update interval`` large
-enough.
+Note that this sets the initial monitoring target regions only. In case of
+virtual memory monitoring, DAMON will automatically updates the boundary of the
+regions after one ``regions update interval``. Therefore, users should set the
+``regions update interval`` large enough in this case, if they don't want the
+update.
Record
--
2.17.1
Sorry, the cover letter for previous version of the patchset was mistakenly
sent. Below is the proper coverletter for this version.
================================ >8 ===========================================
Subject: [RFC v4 0/8] DAMON: Support Physical Memory Address Space Monitoring
DAMON[1] programming interface users can extend DAMON for any address space by
implementing and using their own address-space specific low level primitives.
However, the user space users who rely on the debugfs interface and user space
tool, can monitor the virtual address space only. This is mainly due to DAMON
is providing the reference implementation of the low level primitives for the
virtual address space only.
This patchset implements another reference implementation of the low level
primitives for the physical memory address space. Therefore, users can monitor
both of the virtual and the physical address spaces by simply configuring the
provided low level primitives. Further, this patchset links the
implementation to the debugfs interface and the user space tool, so that user
space users can also use the features.
Note that the implementation supports only the user memory, as same to the idle
page access tracking feature.
[1] https://lore.kernel.org/linux-mm/[email protected]/
Baseline and Complete Git Trees
===============================
The patches are based on the v5.7 plus DAMON v16 patchset[1] and DAMOS RFC v12
patchset[2]. You can also clone the complete git tree:
$ git clone git://github.com/sjp38/linux -b cdamon/rfc/v4
The web is also available:
https://github.com/sjp38/linux/releases/tag/cdamon/rfc/v4
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://lore.kernel.org/linux-mm/[email protected]/
Sequence of Patches
===================
The sequence of patches is as follow.
The 1st and 2nd patches allow the debugfs interface and the user space tool to
be able to set the monitoring target regions as they want, respectively. The
3rd patch documents the feature.
The 4th patch exports rmap essential functions to GPL modules as those are
required from the DAMON's reference implementation of the low level primitives
for the physical memory address space. The 5th patch provides the reference
implementations of the configurable primitives for the physical memory
monitoring. The 6th and 7th patches make the user space to be able to use the
physical memory monitoring via debugfs and the user space tool, respectively.
Finally, the 8th patch documents the physical memory monitoring support.
Patch History
=============
Changes from RFC v3
(https://lore.kernel.org/linux-mm/[email protected]/)
- Export rmap functions
- Reorganize for physical memory monitoring support only
- Clean up debugfs code
Changes from RFC v2
(https://lore.kernel.org/linux-mm/[email protected]/)
- Support the physical memory monitoring with the user space tool
- Use 'pfn_to_online_page()' (David Hildenbrand)
- Document more detail on random 'pfn' and its safeness (David Hildenbrand)
Changes from RFC v1
(https://lore.kernel.org/linux-mm/[email protected]/)
- Provide the reference primitive implementations for the physical memory
- Connect the extensions with the debugfs interface
SeongJae Park (8):
mm/damon/debugfs: Allow users to set initial monitoring target regions
tools/damon: Implement init target regions feature
Docs/damon: Document 'initial_regions' feature
mm/rmap: Export essential functions for rmap_run
mm/damon: Implement callbacks for physical memory monitoring
mm/damon/debugfs: Support physical memory monitoring
tools/damon/record: Support physical memory address spce
Docs/damon: Document physical memory monitoring support
Documentation/admin-guide/mm/damon/faq.rst | 7 +-
Documentation/admin-guide/mm/damon/index.rst | 1 -
Documentation/admin-guide/mm/damon/plans.rst | 7 -
Documentation/admin-guide/mm/damon/usage.rst | 73 +++-
include/linux/damon.h | 5 +
mm/damon.c | 374 ++++++++++++++++++-
mm/rmap.c | 2 +
mm/util.c | 1 +
tools/damon/_damon.py | 41 ++
tools/damon/heats.py | 2 +-
tools/damon/record.py | 41 +-
tools/damon/schemes.py | 12 +-
12 files changed, 532 insertions(+), 34 deletions(-)
delete mode 100644 Documentation/admin-guide/mm/damon/plans.rst
--
2.17.1