Introduce Data Access MONitor (DAMON)
Subsystems (8)
v34 cover Introduce Data Access MONitor (DAMON)
From: SeongJae Park <[email protected]>
Changes from Previous Version (v33)
===================================
Compared to the v33
(https://lore.kernel.org/linux-mm/[email protected]/),
this version contains below minor changes.
- Rebase on latest -mm tree (v5.14-rc1-mmots-2021-07-15-18-47)
- Remove unnecessary asterisks from the MAINTAINERS file update (Joe Perches)
Now all patches of this patchset has at least one 'Reviewed-by:' or 'Acked-by:' tags. Andrew, could you please consider merging this into the -mm tree?
Introduction
============
DAMON is a data access monitoring framework for the Linux kernel. The core mechanisms of DAMON called 'region based sampling' and 'adaptive regions adjustment' (refer to 'mechanisms.rst' in the 11th patch of this patchset for the detail) make it
- accurate (The monitored information is useful for DRAM level memory management. It might not appropriate for Cache-level accuracy, though.),
- light-weight (The monitoring overhead is low enough to be applied online while making no impact on the performance of the target workloads.), and
- scalable (the upper-bound of the instrumentation overhead is controllable regardless of the size of target workloads.).
Using this framework, therefore, several memory management mechanisms such as reclamation and THP can be optimized to aware real data access patterns. Experimental access pattern aware memory management optimization works that incurring high instrumentation overhead will be able to have another try.
Though DAMON is for kernel subsystems, it can be easily exposed to the user space by writing a DAMON-wrapper kernel subsystem. Then, user space users who have some special workloads will be able to write personalized tools or applications for deeper understanding and specialized optimizations of their systems.
DAMON is also merged in two public Amazon Linux kernel trees that based on v5.4.y[1] and v5.10.y[2].
[1] https://github.com/amazonlinux/linux/tree/amazon-5.4.y/master/mm/damon
[2] https://github.com/amazonlinux/linux/tree/amazon-5.10.y/master/mm/damon
Long-term Plan
--------------
DAMON is a part of a project called Data Access-aware Operating System (DAOS). As the name implies, I want to improve the performance and efficiency of systems using fine-grained data access patterns. The optimizations are for both kernel and user spaces. I will therefore modify or create kernel subsystems, export some of those to user space and implement user space library / tools. Below shows the layers and components for the project.
---------------------------------------------------------------------------
Primitives: PTE Accessed bit, PG_idle, rmap, (Intel CMT), ...
Framework: DAMON
Features: DAMOS, virtual addr, physical addr, ...
Applications: DAMON-debugfs, (DARC), ...
^^^^^^^^^^^^^^^^^^^^^^^ KERNEL SPACE ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Raw Interface: debugfs, (sysfs), (damonfs), tracepoints, (sys_damon), ...
vvvvvvvvvvvvvvvvvvvvvvv USER SPACE vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
Library: (libdamon), ...
Tools: DAMO, (perf), ...
---------------------------------------------------------------------------
The components in parentheses or marked as '...' are not implemented yet but in the future plan. IOW, those are the TODO tasks of DAOS project. For more detail, please refer to the plans:
https://lore.kernel.org/linux-mm/[email protected]/
Evaluations
===========
We evaluated DAMON's overhead, monitoring quality and usefulness using 24 realistic workloads on my QEMU/KVM based virtual machine running a kernel that v24 DAMON patchset is applied.
DAMON is lightweight. It increases system memory usage by 0.39% and slows target workloads down by 1.16%.
DAMON is accurate and useful for memory management optimizations. An experimental DAMON-based operation scheme for THP, namely 'ethp', removes 76.15% of THP memory overheads while preserving 51.25% of THP speedup. Another experimental DAMON-based 'proactive reclamation' implementation, 'prcl', reduces 93.38% of residential sets and 23.63% of system memory footprint while incurring only 1.22% runtime overhead in the best case (parsec3/freqmine).
NOTE that the experimental THP optimization and proactive reclamation are not for production but only for proof of concepts.
Please refer to the official document[1] or "Documentation/admin-guide/mm: Add a document for DAMON" patch in this patchset for detailed evaluation setup and results.
[1] https://damonitor.github.io/doc/html/latest-damon/admin-guide/mm/damon/eval.html
Real-world User Story
=====================
In summary, DAMON has used on production systems and proved its usefulness.
DAMON as a profiler
-------------------
We analyzed characteristics of a large scale production systems of our customers using DAMON. The systems utilize 70GB DRAM and 36 CPUs. From this, we were able to find interesting things below.
There were obviously different access pattern under idle workload and active workload. Under the idle workload, it accessed large memory regions with low frequency, while the active workload accessed small memory regions with high freuqnecy.
DAMON found a 7GB memory region that showing obviously high access frequency under the active workload. We believe this is the performance-effective working set and need to be protected.
There was a 4KB memory region that showing highest access frequency under not only active but also idle workloads. We think this must be a hottest code section like thing that should never be paged out.
For this analysis, DAMON used only 0.3-1% of single CPU time. Because we used recording-based analysis, it consumed about 3-12 MB of disk space per 20 minutes. This is only small amount of disk space, but we can further reduce the disk usage by using non-recording-based DAMON features. I'd like to argue that only DAMON can do such detailed analysis (finding 4KB highest region in 70GB memory) with the light overhead.
DAMON as a system optimization tool
-----------------------------------
We also found below potential performance problems on the systems and made DAMON-based solutions.
The system doesn't want to make the workload suffer from the page reclamation and thus it utilizes enough DRAM but no swap device. However, we found the system is actively reclaiming file-backed pages, because the system has intensive file IO. The file IO turned out to be not performance critical for the workload, but the customer wanted to ensure performance critical file-backed pages like code section to not mistakenly be evicted.
Using direct IO should or mlock() would be a straightforward solution, but modifying the user space code is not easy for the customer. Alternatively, we could use DAMON-based operation scheme[1]. By using it, we can ask DAMON to track access frequency of each region and make 'process_madvise(MADV_WILLNEED)[2]' call for regions having specific size and access frequency for a time interval.
We also found the system is having high number of TLB misses. We tried 'always' THP enabled policy and it greatly reduced TLB misses, but the page reclamation also been more frequent due to the THP internal fragmentation caused memory bloat. We could try another DAMON-based operation scheme that applies 'MADV_HUGEPAGE' to memory regions having >=2MB size and high access frequency, while applying 'MADV_NOHUGEPAGE' to regions having <2MB size and low access frequency.
We do not own the systems so we only reported the analysis results and possible optimization solutions to the customers. The customers satisfied about the analysis results and promised to try the optimization guides.
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://lore.kernel.org/linux-api/[email protected]/
Comparison with Idle Page Tracking
==================================
Idle Page Tracking allows users to set and read idleness of pages using a bitmap file which represents each page with each bit of the file. One recommended usage of it is working set size detection. Users can do that by
1. find PFN of each page for workloads in interest,
2. set all the pages as idle by doing writes to the bitmap file,
3. wait until the workload accesses its working set, and
4. read the idleness of the pages again and count pages became not idle.
NOTE: While Idle Page Tracking is for user space users, DAMON is primarily designed for kernel subsystems though it can easily exposed to the user space. Hence, this section only assumes such user space use of DAMON.
For what use cases Idle Page Tracking would be better?
------------------------------------------------------
1. Flexible usecases other than hotness monitoring.
Because Idle Page Tracking allows users to control the primitive (Page idleness) by themselves, Idle Page Tracking users can do anything they want. Meanwhile, DAMON is primarily designed to monitor the hotness of each memory region. For this, DAMON asks users to provide sampling interval and aggregation interval. For the reason, there could be some use case that using Idle Page Tracking is simpler.
2. Physical memory monitoring.
Idle Page Tracking receives PFN range as input, so natively supports physical memory monitoring.
DAMON is designed to be extensible for multiple address spaces and use cases by implementing and using primitives for the given use case. Therefore, by theory, DAMON has no limitation in the type of target address space as long as primitives for the given address space exists. However, the default primitives introduced by this patchset supports only virtual address spaces.
Therefore, for physical memory monitoring, you should implement your own primitives and use it, or simply use Idle Page Tracking.
Nonetheless, RFC patchsets[1] for the physical memory address space primitives is already available. It also supports user memory same to Idle Page Tracking.
[1] https://lore.kernel.org/linux-mm/[email protected]/
For what use cases DAMON is better?
-----------------------------------
1. Hotness Monitoring.
Idle Page Tracking let users know only if a page frame is accessed or not. For hotness check, the user should write more code and use more memory. DAMON do that by itself.
2. Low Monitoring Overhead
DAMON receives user's monitoring request with one step and then provide the results. So, roughly speaking, DAMON require only O(1) user/kernel context switches.
In case of Idle Page Tracking, however, because the interface receives contiguous page frames, the number of user/kernel context switches increases as the monitoring target becomes complex and huge. As a result, the context switch overhead could be not negligible.
Moreover, DAMON is born to handle with the monitoring overhead. Because the core mechanism is pure logical, Idle Page Tracking users might be able to implement the mechanism on thier own, but it would be time consuming and the user/kernel context switching will still more frequent than that of DAMON. Also, the kernel subsystems cannot use the logic in this case.
3. Page granularity working set size detection.
Until v22 of this patchset, this was categorized as the thing Idle Page Tracking could do better, because DAMON basically maintains additional metadata for each of the monitoring target regions. So, in the page granularity working set size detection use case, DAMON would incur (number of monitoring target pages * size of metadata) memory overhead. Size of the single metadata item is about 54 bytes, so assuming 4KB pages, about 1.3% of monitoring target pages will be additionally used.
All essential metadata for Idle Page Tracking are embedded in 'struct page' and page table entries. Therefore, in this use case, only one counter variable for working set size accounting is required if Idle Page Tracking is used.
There are more details to consider, but roughly speaking, this is true in most cases.
However, the situation changed from v23. Now DAMON supports arbitrary types of monitoring targets, which don't use the metadata. Using that, DAMON can do the working set size detection with no additional space overhead but less user-kernel context switch. A first draft for the implementation of monitoring primitives for this usage is available in a DAMON development tree[1]. An RFC patchset for it based on this patchset will also be available soon.
From v24, the arbitrary type support is dropped from this patchset because this patchset doesn't introduce real use of the type. You can still get it from the DAMON development tree[2], though.
[1] https://github.com/sjp38/linux/tree/damon/pgidle_hack
[2] https://github.com/sjp38/linux/tree/damon/master
4. More future usecases
While Idle Page Tracking has tight coupling with base primitives (PG_Idle and page table Accessed bits), DAMON is designed to be extensible for many use cases and address spaces. If you need some special address type or want to use special h/w access check primitives, you can write your own primitives for that and configure DAMON to use those. Therefore, if your use case could be changed a lot in future, using DAMON could be better.
Can I use both Idle Page Tracking and DAMON?
--------------------------------------------
Yes, though using them concurrently for overlapping memory regions could result in interference to each other. Nevertheless, such use case would be rare or makes no sense at all. Even in the case, the noise would bot be really significant. So, you can choose whatever you want depending on the characteristics of your use cases.
More Information
================
We prepared a showcase web site[1] that you can get more information. There are
- the official documentations[2],
- the heatmap format dynamic access pattern of various realistic workloads for heap area[3], mmap()-ed area[4], and stack[5] area,
- the dynamic working set size distribution[6] and chronological working set size changes[7], and
- the latest performance test results[8].
[1] https://damonitor.github.io/_index
[2] https://damonitor.github.io/doc/html/latest-damon
[3] https://damonitor.github.io/test/result/visual/latest/rec.heatmap.0.png.html
[4] https://damonitor.github.io/test/result/visual/latest/rec.heatmap.1.png.html
[5] https://damonitor.github.io/test/result/visual/latest/rec.heatmap.2.png.html
[6] https://damonitor.github.io/test/result/visual/latest/rec.wss_sz.png.html
[7] https://damonitor.github.io/test/result/visual/latest/rec.wss_time.png.html
[8] https://damonitor.github.io/test/result/perf/latest/html/index.html
Baseline and Complete Git Trees
===============================
The patches are based on the latest -mm tree, specifically v5.14-rc1-mmots-2021-07-15-18-47 of https://github.com/hnaz/linux-mm. You can also clone the complete git tree:
$ git clone git://github.com/sjp38/linux -b damon/patches/v34
The web is also available:
https://github.com/sjp38/linux/releases/tag/damon/patches/v34
Development Trees
-----------------
There are a couple of trees for entire DAMON patchset series and features for future release.
- For latest release: https://github.com/sjp38/linux/tree/damon/master
- For next release: https://github.com/sjp38/linux/tree/damon/next
Long-term Support Trees
-----------------------
For people who want to test DAMON but using LTS kernels, there are another couple of trees based on two latest LTS kernels respectively and containing the 'damon/master' backports.
- For v5.4.y: https://github.com/sjp38/linux/tree/damon/for-v5.4.y
- For v5.10.y: https://github.com/sjp38/linux/tree/damon/for-v5.10.y
Amazon Linux Kernel Trees
-------------------------
DAMON is also merged in two public Amazon Linux kernel trees that based on v5.4.y[1] and v5.10.y[2].
[1] https://github.com/amazonlinux/linux/tree/amazon-5.4.y/master/mm/damon
[2] https://github.com/amazonlinux/linux/tree/amazon-5.10.y/master/mm/damon
Git Tree for Diff of Patches
============================
For easy review of diff between different versions of each patch, I prepared a git tree containing all versions of the DAMON patchset series:
https://github.com/sjp38/damon-patches
You can clone it and use 'diff' for easy review of changes between different versions of the patchset. For example:
$ git clone https://github.com/sjp38/damon-patches && cd damon-patches $ diff -u damon/v33 damon/v34
Sequence Of Patches
===================
First three patches implement the core logics of DAMON. The 1st patch introduces basic sampling based hotness monitoring for arbitrary types of targets. Following two patches implement the core mechanisms for control of overhead and accuracy, namely regions based sampling (patch 2) and adaptive regions adjustment (patch 3).
Now the essential parts of DAMON is complete, but it cannot work unless someone provides monitoring primitives for a specific use case. The following two patches make it just work for virtual address spaces monitoring. The 4th patch makes 'PG_idle' can be used by DAMON and the 5th patch implements the virtual memory address space specific monitoring primitives using page table Accessed bits and the 'PG_idle' page flag.
Now DAMON just works for virtual address space monitoring via the kernel space api. To let the user space users can use DAMON, following four patches add interfaces for them. The 6th patch adds a tracepoint for monitoring results. The 7th patch implements a DAMON application kernel module, namely damon-dbgfs, that simply wraps DAMON and exposes DAMON interface to the user space via the debugfs interface. The 8th patch further exports pid of monitoring thread (kdamond) to user space for easier cpu usage accounting, and the 9th patch makes the debugfs interface to support multiple contexts.
Three patches for maintainability follows. The 10th patch adds documentations for both the user space and the kernel space. The 11th patch provides unit tests (based on the kunit) while the 12th patch adds user space tests (based on the kselftest).
Finally, the last patch (13th) updates the MAINTAINERS file.
Patch History
=============
Changes from v33
(https://lore.kernel.org/linux-mm/[email protected]/),
- Rebase on latest -mm tree (v5.14-rc1-mmots-2021-07-15-18-47)
- Remove unnecessary asterisks from the MAINTAINERS file update (Joe Perches)
Changes from v32
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on latest mainline (7d0fc5c62385)
- Collect 'Acked-by:' tags from Shakeel Butt
Chages from v31
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on latest -mm tree (v5.13-rc7-mmots-2021-06-24-20-54)
- Add 'Acked-by:' tags from Shakeel Butt
- Use 'kthread_run()' (Shakeel Butt)
- Change default 'update_interval' to 60 seconds (Shakeel Butt)
- Utilize 'nr_regions' field in each 'damon_target' object (Shakeel Butt)
- Remove unused parameters in some functions (Shakeel Butt)
- Use variable name 'ctx' for 'damon_ctx' (Shakeel Butt)
- Make 'dbgfs' to completely manage pid reference counting (Shakeel Butt)
- Remove '.owner' of debugfs files (Shakeel Butt)
Changes from v30
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on latest -mm tree (v5.13-rc6-mmots-2021-06-16-22-17)
- selftest: Fix wrong file content comparison (Markus Boehme)
- Collect 'Reviewed-by:' tags from Markus
Changes from v29
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on latest -mm tree (v5.13-rc6-mmots-2021-06-15-20-28)
- Remove unnecessary documents
- Wordsmith commit message for PAGE_IDLE separation (Amit Shah)
- selftests: Fix shellcheck warnings and cleanup (Maximilian Heyne)
- Wordsmith the document (Markus Boehme)
- Fix a typo in comments (Fernand Sieber)
- Collect 'Reviewed-by:' tags from "Fernand Sieber <[email protected]>"
Please refer to the v29 patchset to get older history.
SeongJae Park (13):
mm: Introduce Data Access MONitor (DAMON)
mm/damon/core: Implement region-based sampling
mm/damon: Adaptively adjust regions mm/idle_page_tracking: Make PG_idle reusable
mm/damon: Implement primitives for the virtual memory address spaces mm/damon: Add a tracepoint
mm/damon: Implement a debugfs-based user space interface mm/damon/dbgfs: Export kdamond pid to the user space mm/damon/dbgfs: Support multiple contexts
Documentation: Add documents for DAMON
mm/damon: Add kunit tests
mm/damon: Add user space selftests
MAINTAINERS: Update for DAMON
Documentation/admin-guide/mm/damon/index.rst | 15 + Documentation/admin-guide/mm/damon/start.rst | 114 +++ Documentation/admin-guide/mm/damon/usage.rst | 112 +++ Documentation/admin-guide/mm/index.rst | 1 + Documentation/vm/damon/api.rst | 20 + Documentation/vm/damon/design.rst | 166 ++++ Documentation/vm/damon/faq.rst | 51 ++ Documentation/vm/damon/index.rst | 30 + Documentation/vm/index.rst | 1 + MAINTAINERS | 11 + include/linux/damon.h | 268 +++++++ include/linux/page-flags.h | 4 +- include/linux/page_ext.h | 2 +- include/linux/page_idle.h | 6 +- include/trace/events/damon.h | 43 ++ include/trace/events/mmflags.h | 2 +- mm/Kconfig | 10 + mm/Makefile | 1 + mm/damon/Kconfig | 69 ++ mm/damon/Makefile | 5 + mm/damon/core-test.h | 253 ++++++ mm/damon/core.c | 720 ++++++++++++++++++ mm/damon/dbgfs-test.h | 126 +++ mm/damon/dbgfs.c | 624 +++++++++++++++ mm/damon/vaddr-test.h | 329 ++++++++ mm/damon/vaddr.c | 613 +++++++++++++++ mm/page_ext.c | 12 +- mm/page_idle.c | 10 - tools/testing/selftests/damon/Makefile | 7 + .../selftests/damon/_chk_dependency.sh | 28 + .../testing/selftests/damon/debugfs_attrs.sh | 75 ++ 31 files changed, 3710 insertions(+), 18 deletions(-) create mode 100644 Documentation/admin-guide/mm/damon/index.rst create mode 100644 Documentation/admin-guide/mm/damon/start.rst create mode 100644 Documentation/admin-guide/mm/damon/usage.rst create mode 100644 Documentation/vm/damon/api.rst create mode 100644 Documentation/vm/damon/design.rst create mode 100644 Documentation/vm/damon/faq.rst create mode 100644 Documentation/vm/damon/index.rst create mode 100644 include/linux/damon.h create mode 100644 include/trace/events/damon.h create mode 100644 mm/damon/Kconfig create mode 100644 mm/damon/Makefile create mode 100644 mm/damon/core-test.h create mode 100644 mm/damon/core.c create mode 100644 mm/damon/dbgfs-test.h create mode 100644 mm/damon/dbgfs.c create mode 100644 mm/damon/vaddr-test.h create mode 100644 mm/damon/vaddr.c create mode 100644 tools/testing/selftests/damon/Makefile create mode 100644 tools/testing/selftests/damon/_chk_dependency.sh create mode 100755 tools/testing/selftests/damon/debugfs_attrs.sh
Signature · 1 line
2.17.1
PATCH v34 1/13 mm: Introduce Data Access MONitor (DAMON)
From: SeongJae Park <[email protected]>
DAMON is a data access monitoring framework for the Linux kernel. The core mechanisms of DAMON make it
- accurate (the monitoring output is useful enough for DRAM level performance-centric memory management; It might be inappropriate for CPU cache levels, though),
- light-weight (the monitoring overhead is normally low enough to be applied online), and
- scalable (the upper-bound of the overhead is in constant range regardless of the size of target workloads).
Using this framework, hence, we can easily write efficient kernel space data access monitoring applications. For example, the kernel's memory management mechanisms can make advanced decisions using this. Experimental data access aware optimization works that incurring high access monitoring overhead could again be implemented on top of this.
Due to its simple and flexible interface, providing user space interface would be also easy. Then, user space users who have some special workloads can write personalized applications for better understanding and optimizations of their workloads and systems.
===
Nevertheless, this commit is defining and implementing only basic access check part without the overhead-accuracy handling core logic. The basic access check is as below.
The output of DAMON says what memory regions are how frequently accessed for a given duration. The resolution of the access frequency is controlled by setting ``sampling interval`` and ``aggregation interval``. In detail, DAMON checks access to each page per ``sampling interval`` and aggregates the results. In other words, counts the number of the accesses to each region. After each ``aggregation interval`` passes, DAMON calls callback functions that previously registered by users so that users can read the aggregated results and then clears the results. This can be described in below simple pseudo-code::
init()
while monitoring_on:
for page in monitoring_target:
if accessed(page):
nr_accesses[page] += 1
if time() % aggregation_interval == 0:
for callback in user_registered_callbacks:
callback(monitoring_target, nr_accesses)
for page in monitoring_target:
nr_accesses[page] = 0
if time() % update_interval == 0:
update()
sleep(sampling interval)
The target regions constructed at the beginning of the monitoring and updated after each ``regions_update_interval``, because the target regions could be dynamically changed (e.g., mmap() or memory hotplug). The monitoring overhead of this mechanism will arbitrarily increase as the size of the target workload grows.
The basic monitoring primitives for actual access check and dynamic target regions construction aren't in the core part of DAMON. Instead, it allows users to implement their own primitives that are optimized for their use case and configure DAMON to use those. In other words, users cannot use current version of DAMON without some additional works.
Following commits will implement the core mechanisms for the overhead-accuracy control and default primitives implementations.
--- include/linux/damon.h | 167 ++++++++++++++++++++++ mm/Kconfig | 2 + mm/Makefile | 1 + mm/damon/Kconfig | 15 ++ mm/damon/Makefile | 3 + mm/damon/core.c | 320 ++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 508 insertions(+) create mode 100644 include/linux/damon.h create mode 100644 mm/damon/Kconfig create mode 100644 mm/damon/Makefile create mode 100644 mm/damon/core.c
include/linux/damon.h new file +167 -0
@@ -0,0 +1,167 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* DAMON api +* +* Author: SeongJae Park <[email protected]> +*/ + +#ifndef _DAMON_H_ +#define _DAMON_H_ + +#include <linux/mutex.h> +#include <linux/time64.h> +#include <linux/types.h> + +struct damon_ctx ; + +/** +* struct damon_primitive Monitoring primitives for given use cases. +* +* @init: Initialize primitive-internal data structures. +* @update: Update primitive-internal data structures. +* @prepare_access_checks: Prepare next access check of target regions. +* @check_accesses: Check the accesses to target regions. +* @reset_aggregated: Reset aggregated accesses monitoring results. +* @target_valid: Determine if the target is valid. +* @cleanup: Clean up the context. +* +* DAMON can be extended for various address spaces and usages. For this, +* users should register the low level primitives for their target address +* space and usecase via the &damon_ctx.primitive. Then, the monitoring thread +* (&damon_ctx.kdamond) calls @init and @prepare_access_checks before starting +* the monitoring, @update after each &damon_ctx.primitive_update_interval, and +* @check_accesses, @target_valid and @prepare_access_checks after each +* &damon_ctx.sample_interval. Finally, @reset_aggregated is called after each +* &damon_ctx.aggr_interval. +* +* @init should initialize primitive-internal data structures. For example, +* this could be used to construct proper monitoring target regions and link +* those to @damon_ctx.target. +* @update should update the primitive-internal data structures. For example, +* this could be used to update monitoring target regions for current status. +* @prepare_access_checks should manipulate the monitoring regions to be +* prepared for the next access check. +* @check_accesses should check the accesses to each region that made after the +* last preparation and update the number of observed accesses of each region. +* @reset_aggregated should reset the access monitoring results that aggregated +* by @check_accesses. +* @target_valid should check whether the target is still valid for the +* monitoring. +* @cleanup is called from @kdamond just before its termination. +*/ +struct damon_primitive { +void (*init)(struct damon_ctx *context); +void (*update)(struct damon_ctx *context); +void (*prepare_access_checks)(struct damon_ctx *context); +void (*check_accesses)(struct damon_ctx *context); +void (*reset_aggregated)(struct damon_ctx *context); +bool (*target_valid)(void *target); +void (*cleanup)(struct damon_ctx *context); +}; + +/* +* struct damon_callback Monitoring events notification callbacks. +* +* @before_start: Called before starting the monitoring. +* @after_sampling: Called after each sampling. +* @after_aggregation: Called after each aggregation. +* @before_terminate: Called before terminating the monitoring. +* @private: User private data. +* +* The monitoring thread (&damon_ctx.kdamond) calls @before_start and +* @before_terminate just before starting and finishing the monitoring, +* respectively. Therefore, those are good places for installing and cleaning +* @private. +* +* The monitoring thread calls @after_sampling and @after_aggregation for each +* of the sampling intervals and aggregation intervals, respectively. +* Therefore, users can safely access the monitoring results without additional +* protection. For the reason, users are recommended to use these callback for +* the accesses to the results. +* +* If any callback returns non-zero, monitoring stops. +*/ +struct damon_callback { +void *private; + +int (*before_start)(struct damon_ctx *context); +int (*after_sampling)(struct damon_ctx *context); +int (*after_aggregation)(struct damon_ctx *context); +int (*before_terminate)(struct damon_ctx *context); +}; + +/** +* struct damon_ctx - Represents a context for each monitoring. This is the +* main interface that allows users to set the attributes and get the results +* of the monitoring. +* +* @sample_interval: The time between access samplings. +* @aggr_interval: The time between monitor results aggregations. +* @primitive_update_interval: The time between monitoring primitive updates. +* +* 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 time. DAMON also checks whether the target +* memory regions need update (e.g., by ``mmap()`` calls from the application, +* in case of virtual memory monitoring) and applies the changes for each +* @primitive_update_interval. All time intervals are in micro-seconds. +* Please refer to &struct damon_primitive and &struct damon_callback for more +* detail. +* +* @kdamond: Kernel thread who does the monitoring. +* @kdamond_stop: Notifies whether kdamond should stop. +* @kdamond_lock: Mutex for the synchronizations with @kdamond. +* +* For each monitoring context, one kernel thread for the monitoring is +* created. The pointer to the thread is stored in @kdamond. +* +* Once started, the monitoring thread runs until explicitly required to be +* terminated or every monitoring target is invalid. The validity of the +* targets is checked via the &damon_primitive.target_valid of @primitive. The +* termination can also be explicitly requested by writing non-zero to +* @kdamond_stop. The thread sets @kdamond to NULL when it terminates. +* Therefore, users can know whether the monitoring is ongoing or terminated by +* reading @kdamond. Reads and writes to @kdamond and @kdamond_stop from +* outside of the monitoring thread must be protected by @kdamond_lock. +* +* Note that the monitoring thread protects only @kdamond and @kdamond_stop via +* @kdamond_lock. Accesses to other fields must be protected by themselves. +* +* @primitive: Set of monitoring primitives for given use cases. +* @callback: Set of callbacks for monitoring events notifications. +* +* @target: Pointer to the user-defined monitoring target. +*/ +struct damon_ctx { +unsigned long sample_interval; +unsigned long aggr_interval; +unsigned long primitive_update_interval; + +/* private: internal use only */ +struct timespec64 last_aggregation; +struct timespec64 last_primitive_update; + +/* public: */ +struct task_struct *kdamond; +bool kdamond_stop; +struct mutex kdamond_lock; + +struct damon_primitive primitive; +struct damon_callback callback; + +void *target; +}; + +#ifdef CONFIG_DAMON + +struct damon_ctx *damon_new_ctx (void ); +void damon_destroy_ctx (struct damon_ctx *ctx); +int damon_set_attrs (struct damon_ctx *ctx,unsigned long sample_int, +unsigned long aggr_int,unsigned long primitive_upd_int); + +int damon_start (struct damon_ctx **ctxs,int nr_ctxs); +int damon_stop (struct damon_ctx **ctxs,int nr_ctxs); + +#endif /* CONFIG_DAMON */ + +#endif /* _DAMON_H */
mm/Kconfig +2 -0
@@ -886,4 +886,6 @@ config IO_MAPPING config SECRETMEM def_bool ARCH_HAS_SET_DIRECT_MAP && !EMBEDDED +source "mm/damon/Kconfig" + endmenu
mm/Makefile +1 -0
@@ -128,3 +128,4 @@ obj-$(CONFIG_PTDUMP_CORE) += ptdump.o obj-$(CONFIG_PAGE_REPORTING) += page_reporting.o obj-$(CONFIG_IO_MAPPING) += io-mapping.o obj-$(CONFIG_HAVE_BOOTMEM_INFO_NODE) += bootmem_info.o +obj-$(CONFIG_DAMON) += damon/
mm/damon/Kconfig new file +15 -0
@@ -0,0 +1,15 @@ +# SPDX-License-Identifier: GPL-2.0-only + +menu "Data Access Monitoring" + +config DAMON + bool "DAMON: Data Access Monitoring Framework" + help + This builds a framework that allows kernel subsystems to monitor + access frequency of each memory region. The information can be useful + for performance-centric DRAM level memory management. + + See https://damonitor.github.io/doc/html/latest-damon/index.html for + more information. + +endmenu
mm/damon/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_DAMON) := core.o
mm/damon/core.c new file +320 -0
320 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v34 2/13 mm/damon/core: Implement region-based sampling
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
To avoid the unbounded increase of the overhead, DAMON groups adjacent pages that are assumed to have the same access frequencies into a region. As long as the assumption (pages in a region have the same access frequencies) is kept, only one page in the region is required to be checked. Thus, for each ``sampling interval``,
1. the 'prepare_access_checks' primitive picks one page in each region,
2. waits for one ``sampling interval``,
3. checks whether the page is accessed meanwhile, and
4. increases the access count of the region if so.
Therefore, the monitoring overhead is controllable by adjusting the number of regions. DAMON allows both the underlying primitives and user callbacks to adjust regions for the trade-off. In other words, this commit makes DAMON to use not only time-based sampling but also space-based sampling.
This scheme, however, cannot preserve the quality of the output if the assumption is not guaranteed. Next commit will address this problem.
--- include/linux/damon.h | 77 ++++++++++++++++++++++- mm/damon/core.c | 143 ++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 213 insertions(+), 7 deletions(-)
include/linux/damon.h +74 -3
@@ -12,6 +12,48 @@#include <linux/time64.h> #include <linux/types.h> +/** +* struct damon_addr_range - Represents an address region of [@start, @end). +* @start: Start address of the region (inclusive). +* @end: End address of the region (exclusive). +*/ +struct damon_addr_range { +unsigned long start; +unsigned long end; +}; + +/** +* struct damon_region - Represents a monitoring target region. +* @ar: The address range of the region. +* @sampling_addr: Address of the sample for the next access check. +* @nr_accesses: Access frequency of this region. +* @list: List head for siblings. +*/ +struct damon_region { +struct damon_addr_range ar; +unsigned long sampling_addr; +unsigned int nr_accesses; +struct list_head list; +}; + +/** +* struct damon_target - Represents a monitoring target. +* @id: Unique identifier for this target. +* @regions_list: Head of the monitoring target regions of this target. +* @list: List head for siblings. +* +* Each monitoring context could have multiple targets. For example, a context +* for virtual memory address spaces could have multiple target processes. The +* @id of each target should be unique among the targets of the context. For +* example, in the virtual address monitoring context, it could be a pidfd or +* an address of an mm_struct. +*/ +struct damon_target { +unsigned long id; +struct list_head regions_list; +struct list_head list; +}; +struct damon_ctx ;/**
@@ -36,7 +78,7 @@ struct damon_ctx;* * @init should initialize primitive-internal data structures. For example, * this could be used to construct proper monitoring target regions and link -* those to @damon_ctx.target. +* those to @damon_ctx.adaptive_targets. * @update should update the primitive-internal data structures. For example, * this could be used to update monitoring target regions for current status. * @prepare_access_checks should manipulate the monitoring regions to be
@@ -130,7 +172,7 @@ struct damon_callback {* @primitive: Set of monitoring primitives for given use cases. * @callback: Set of callbacks for monitoring events notifications. * -* @target: Pointer to the user-defined monitoring target. +* @region_targets: Head of monitoring targets (&damon_target) list. */ struct damon_ctx {unsigned long sample_interval;
@@ -149,11 +191,40 @@ struct damon_ctx {struct damon_primitive primitive;struct damon_callback callback; -void *target; +struct list_head region_targets; }; +#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_target (t, ctx) \ + list_for_each_entry(t, &(ctx)->region_targets, list) + +#define damon_for_each_target_safe (t, next, ctx) \ + list_for_each_entry_safe(t, next, &(ctx)->region_targets, list) +#ifdef CONFIG_DAMON +struct damon_region *damon_new_region (unsigned long start,unsigned long end); +inline void damon_insert_region (struct damon_region *r, +struct damon_region *prev,struct damon_region *next); +void damon_add_region (struct damon_region *r,struct damon_target *t); +void damon_destroy_region (struct damon_region *r); + +struct damon_target *damon_new_target (unsigned long id); +void damon_add_target (struct damon_ctx *ctx,struct damon_target *t); +void damon_free_target (struct damon_target *t); +void damon_destroy_target (struct damon_target *t); +struct damon_ctx *damon_new_ctx (void );void damon_destroy_ctx (struct damon_ctx *ctx); int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int,
mm/damon/core.c +139 -4
197 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v34 3/13 mm/damon: Adaptively adjust regions
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
Even somehow the initial monitoring target regions are well constructed to fulfill the assumption (pages in same region have similar access frequencies), the data access pattern can be dynamically changed. This will result in low monitoring quality. To keep the assumption as much as possible, DAMON adaptively merges and splits each region based on their access frequency.
For each ``aggregation interval``, it compares the access frequencies of adjacent regions and merges those if the frequency difference is small. Then, after it reports and clears the aggregated access frequency of each region, it splits each region into two or three regions if the total number of regions will not exceed the user-specified maximum number of regions after the split.
In this way, DAMON provides its best-effort quality and minimal overhead while keeping the upper-bound overhead that users set.
--- include/linux/damon.h | 30 ++++-- mm/damon/core.c | 224 ++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 237 insertions(+), 17 deletions(-)
include/linux/damon.h +22 -8
@@ -12,6 +12,9 @@#include <linux/time64.h> #include <linux/types.h> +/* Minimal region size. Every damon_region is aligned by this. */ +#define DAMON_MIN_REGION PAGE_SIZE +/** * struct damon_addr_range - Represents an address region of [@start, @end). * @start: Start address of the region (inclusive).
@@ -39,6 +42,7 @@ struct damon_region {/** * struct damon_target - Represents a monitoring target. * @id: Unique identifier for this target. +* @nr_regions: Number of monitoring target regions of this target. * @regions_list: Head of the monitoring target regions of this target. * @list: List head for siblings. *
@@ -50,6 +54,7 @@ struct damon_region {*/ struct damon_target {unsigned long id; +unsigned int nr_regions;struct list_head regions_list;struct list_head list; };
@@ -85,6 +90,8 @@ struct damon_ctx;* prepared for the next access check. * @check_accesses should check the accesses to each region that made after the * last preparation and update the number of observed accesses of each region. +* It should also return max number of observed accesses that made as a result +* of its update. The value will be used for regions adjustment threshold. * @reset_aggregated should reset the access monitoring results that aggregated * by @check_accesses. * @target_valid should check whether the target is still valid for the
@@ -95,7 +102,7 @@ struct damon_primitive {void (*init)(struct damon_ctx *context);void (*update)(struct damon_ctx *context);void (*prepare_access_checks)(struct damon_ctx *context); -void (*check_accesses)(struct damon_ctx *context); +unsigned int (*check_accesses)(struct damon_ctx *context);void (*reset_aggregated)(struct damon_ctx *context);bool (*target_valid)(void *target);void (*cleanup)(struct damon_ctx *context);
@@ -172,7 +179,9 @@ struct damon_callback {* @primitive: Set of monitoring primitives for given use cases. * @callback: Set of callbacks for monitoring events notifications. * -* @region_targets: Head of monitoring targets (&damon_target) list. +* @min_nr_regions: The minimum number of adaptive monitoring regions. +* @max_nr_regions: The maximum number of adaptive monitoring regions. +* @adaptive_targets: Head of monitoring targets (&damon_target) list. */ struct damon_ctx {unsigned long sample_interval;
@@ -191,7 +200,9 @@ struct damon_ctx {struct damon_primitive primitive;struct damon_callback callback; -struct list_head region_targets; +unsigned long min_nr_regions; +unsigned long max_nr_regions; +struct list_head adaptive_targets; };#define damon_next_region (r) \
@@ -207,28 +218,31 @@ struct damon_ctx { list_for_each_entry_safe(r, next, &t->regions_list, list)#define damon_for_each_target (t, ctx) \ - list_for_each_entry(t, &(ctx)->region_targets, list) + list_for_each_entry(t, &(ctx)->adaptive_targets, list)#define damon_for_each_target_safe (t, next, ctx) \ - list_for_each_entry_safe(t, next, &(ctx)->region_targets, list) + list_for_each_entry_safe(t, next, &(ctx)->adaptive_targets, list)#ifdef CONFIG_DAMON struct damon_region *damon_new_region (unsigned long start,unsigned long end);inline void damon_insert_region (struct damon_region *r, -struct damon_region *prev,struct damon_region *next); +struct damon_region *prev,struct damon_region *next, +struct damon_target *t);void damon_add_region (struct damon_region *r,struct damon_target *t); -void damon_destroy_region (struct damon_region *r); +void damon_destroy_region (struct damon_region *r,struct damon_target *t);struct damon_target *damon_new_target (unsigned long id);void damon_add_target (struct damon_ctx *ctx,struct damon_target *t);void damon_free_target (struct damon_target *t);void damon_destroy_target (struct damon_target *t); +unsigned int damon_nr_regions (struct damon_target *t);struct damon_ctx *damon_new_ctx (void );void damon_destroy_ctx (struct damon_ctx *ctx);int damon_set_attrs (struct damon_ctx *ctx,unsigned long sample_int, -unsigned long aggr_int,unsigned long primitive_upd_int); +unsigned long aggr_int,unsigned long primitive_upd_int, +unsigned long min_nr_reg,unsigned long max_nr_reg);int damon_start (struct damon_ctx **ctxs,int nr_ctxs);int damon_stop (struct damon_ctx **ctxs,int nr_ctxs);
mm/damon/core.c +215 -9
340 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v34 4/13 mm/idle_page_tracking: Make PG_idle reusable
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
PG_idle and PG_young allow the two PTE Accessed bit users, Idle Page Tracking and the reclaim logic concurrently work while not interfering with each other. That is, when they need to clear the Accessed bit, they set PG_young to represent the previous state of the bit, respectively. And when they need to read the bit, if the bit is cleared, they further read the PG_young to know whether the other has cleared the bit meanwhile or not.
For yet another user of the PTE Accessed bit, we could add another page flag, or extend the mechanism to use the flags. For the DAMON usecase, however, we don't need to do that just yet. IDLE_PAGE_TRACKING and DAMON are mutually exclusive, so there's only ever going to be one user of the current set of flags.
In this commit, we split out the CONFIG options to allow for the use of PG_young and PG_idle outside of idle page tracking.
In the next commit, DAMON's reference implementation of the virtual memory address space monitoring primitives will use it.
--- include/linux/page-flags.h | 4 ++-- include/linux/page_ext.h | 2 +- include/linux/page_idle.h | 6 +++--- include/trace/events/mmflags.h | 2 +- mm/Kconfig | 8 ++++++++ mm/page_ext.c | 12 +++++++++++- mm/page_idle.c | 10 ---------- 7 files changed, 26 insertions(+), 18 deletions(-)
include/linux/page-flags.h +2 -2
@@ -131,7 +131,7 @@ enum pageflags {#ifdef CONFIG_MEMORY_FAILURE PG_hwpoison, /* hardware poisoned page. Don't touch */#endif -#if defined(CONFIG_IDLE_PAGE_TRACKING ) && defined(CONFIG_64BIT ) +#if defined(CONFIG_PAGE_IDLE_FLAG ) && defined(CONFIG_64BIT ) PG_young, PG_idle,#endif
@@ -439,7 +439,7 @@ PAGEFLAG_FALSE(HWPoison)#define __PG_HWPOISON 0#endif -#if defined(CONFIG_IDLE_PAGE_TRACKING ) && defined(CONFIG_64BIT ) +#if defined(CONFIG_PAGE_IDLE_FLAG ) && defined(CONFIG_64BIT ) TESTPAGEFLAG(Young, young, PF_ANY) SETPAGEFLAG(Young, young, PF_ANY)TESTCLEARFLAG (Young, young,PF_ANY )
include/linux/page_ext.h +1 -1
@@ -19,7 +19,7 @@ struct page_ext_operations {enum page_ext_flags {PAGE_EXT_OWNER ,PAGE_EXT_OWNER_ALLOCATED , -#if defined(CONFIG_IDLE_PAGE_TRACKING ) && !defined(CONFIG_64BIT ) +#if defined(CONFIG_PAGE_IDLE_FLAG ) && !defined(CONFIG_64BIT )PAGE_EXT_YOUNG ,PAGE_EXT_IDLE ,#endif
include/linux/page_idle.h +3 -3
@@ -6,7 +6,7 @@#include <linux/page-flags.h> #include <linux/page_ext.h> -#ifdef CONFIG_IDLE_PAGE_TRACKING +#ifdef CONFIG_PAGE_IDLE_FLAG #ifdef CONFIG_64BIT static inline bool page_is_young (struct page *page)
@@ -106,7 +106,7 @@ static inline void clear_page_idle(struct page *page) }#endif /* CONFIG_64BIT */ -#else /* !CONFIG_IDLE_PAGE_TRACKING */ +#else /* !CONFIG_PAGE_IDLE_FLAG */ static inline bool page_is_young (struct page *page) {
@@ -135,6 +135,6 @@ static inline void clear_page_idle(struct page *page) { } -#endif /* CONFIG_IDLE_PAGE_TRACKING */ +#endif /* CONFIG_PAGE_IDLE_FLAG */ #endif /* _LINUX_MM_PAGE_IDLE_H */
include/trace/events/mmflags.h +1 -1
@@ -73,7 +73,7 @@#define IF_HAVE_PG_HWPOISON (flag,string)#endif -#if defined(CONFIG_IDLE_PAGE_TRACKING ) && defined(CONFIG_64BIT ) +#if defined(CONFIG_PAGE_IDLE_FLAG ) && defined(CONFIG_64BIT )#define IF_HAVE_PG_IDLE (flag,string) ,{1UL << flag, string}#else #define IF_HAVE_PG_IDLE (flag,string)
mm/Kconfig +8 -0
@@ -739,10 +739,18 @@ config DEFERRED_STRUCT_PAGE_INIT lifetime of the system until these kthreads finish the initialisation. +config PAGE_IDLE_FLAG + bool "Add PG_idle and PG_young flags" + help + This feature adds PG_idle and PG_young flags in 'struct page'. PTE + Accessed bit writers can set the state of the bit in the flags to let + other PTE Accessed bit readers don't disturbed. + config IDLE_PAGE_TRACKING bool "Enable idle page tracking" depends on SYSFS && MMU && BROKEN select PAGE_EXTENSION if !64BIT + select PAGE_IDLE_FLAG help This feature allows to estimate the amount of user pages that have not been touched during a given period of time. This information can
mm/page_ext.c +11 -1
@@ -58,11 +58,21 @@* can utilize this callback to initialize the state of it correctly. */ +#if defined(CONFIG_PAGE_IDLE_FLAG ) && !defined(CONFIG_64BIT ) +static bool need_page_idle (void ) +{ +return true; +} +struct page_ext_operations page_idle_ops = { + .need = need_page_idle, +}; +#endif +static struct page_ext_operations *page_ext_ops[] = { #ifdef CONFIG_PAGE_OWNER &page_owner_ops, #endif -#if defined(CONFIG_IDLE_PAGE_TRACKING) && !defined(CONFIG_64BIT) +#if defined(CONFIG_PAGE_IDLE_FLAG) && !defined(CONFIG_64BIT) &page_idle_ops, #endif };
mm/page_idle.c +0 -10
@@ -207,16 +207,6 @@ static const struct attribute_group page_idle_attr_group = { .name = "page_idle", }; -#ifndef CONFIG_64BIT -static bool need_page_idle (void ) -{ -return true; -} -struct page_ext_operations page_idle_ops = { - .need = need_page_idle, -}; -#endif -static int __init page_idle_init (void ) {int err;
Signature · 1 line
2.17.1
PATCH v34 5/13 mm/damon: Implement primitives for the virtual memory address spaces
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit introduces a reference implementation of the address space specific low level primitives for the virtual address space, so that users of DAMON can easily monitor the data accesses on virtual address spaces of specific processes by simply configuring the implementation to be used by DAMON.
The low level primitives for the fundamental access monitoring are defined in two parts:
1. Identification of the monitoring target address range for the address space.
2. Access check of specific address range in the target space.
The reference implementation for the virtual address space does the works as below.
PTE Accessed-bit Based Access Check
-----------------------------------
The implementation uses PTE Accessed-bit for basic access checks. That is, it clears the bit for the next sampling target page and checks whether it is set again after one sampling period. This could disturb the reclaim logic. DAMON uses ``PG_idle`` and ``PG_young`` page flags to solve the conflict, as Idle page tracking does.
VMA-based Target Address Range Construction
-------------------------------------------
Only small parts in the super-huge virtual address space of the processes are mapped to physical memory and accessed. Thus, tracking the unmapped address regions is just wasteful. However, because DAMON can deal with some level of noise using the adaptive regions adjustment mechanism, tracking every mapping is not strictly required but could even incur a high overhead in some cases. That said, too huge unmapped areas inside the monitoring target should be removed to not take the time for the adaptive mechanism.
For the reason, this implementation converts the complex mappings to three distinct regions that cover every mapped area of the address space. Also, the two gaps between the three regions are the two biggest unmapped areas in the given address space. The two biggest unmapped areas would be the gap between the heap and the uppermost mmap()-ed region, and the gap between the lowermost mmap()-ed region and the stack in most of the cases. Because these gaps are exceptionally huge in usual address spaces, excluding these will be sufficient to make a reasonable trade-off. Below shows this in detail::
<heap>
<BIG UNMAPPED REGION 1>
<uppermost mmap()-ed region>
(small mmap()-ed regions and munmap()-ed regions) <lowermost mmap()-ed region>
<BIG UNMAPPED REGION 2>
<stack>
--- include/linux/damon.h | 13 + mm/damon/Kconfig | 9 + mm/damon/Makefile | 1 + mm/damon/vaddr.c | 606 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 629 insertions(+) create mode 100644 mm/damon/vaddr.c
include/linux/damon.h +13 -0
@@ -249,4 +249,17 @@ int damon_stop(struct damon_ctx **ctxs, int nr_ctxs);#endif /* CONFIG_DAMON */ +#ifdef CONFIG_DAMON_VADDR + +/* Monitoring primitives for virtual memory address spaces */ +void damon_va_init (struct damon_ctx *ctx); +void damon_va_update (struct damon_ctx *ctx); +void damon_va_prepare_access_checks (struct damon_ctx *ctx); +unsigned int damon_va_check_accesses (struct damon_ctx *ctx); +bool damon_va_target_valid (void *t); +void damon_va_cleanup (struct damon_ctx *ctx); +void damon_va_set_primitives (struct damon_ctx *ctx); + +#endif /* CONFIG_DAMON_VADDR */ +#endif /* _DAMON_H */
mm/damon/Kconfig +9 -0
@@ -12,4 +12,13 @@ config DAMON See https://damonitor.github.io/doc/html/latest-damon/index.html for more information. +config DAMON_VADDR + bool "Data access monitoring primitives for virtual address spaces" + depends on DAMON && MMU + select PAGE_EXTENSION if !64BIT + select PAGE_IDLE_FLAG + help + This builds the default data access monitoring primitives for DAMON + that works for virtual address spaces. + endmenu
mm/damon/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_DAMON) := core.o +obj-$(CONFIG_DAMON_VADDR) += vaddr.o
mm/damon/vaddr.c new file +606 -0
606 lines not on this page · raw message
Signature · 1 line
2.17.1
Re: [PATCH v34 05/13] mm/damon: Implement primitives for the virtual memory address spaces
mm/damon/vaddr.c line 448
Quoted 6 lines
mm/damon/vaddr.c new file +6
-0+static void damon_va_mkold (struct mm_struct *mm,unsigned long addr) +{ +pte_t *pte =NULL ; +pmd_t *pmd =NULL ; +spinlock_t *ptl; +
I just stumbled over this, sorry for the dumb questions:
a) What do we know about that region we are messing with?
AFAIU, just like follow_pte() and follow_pfn(), follow_invalidate_pte() should only be called on VM_IO and raw VM_PFNMAP mappings in general (see the doc of follow_pte()). Do you even know that it's within a single VMA and that there are no concurrent modifications?
b) Which locks are we holding?
I hope we're holding the mmap lock in read mode at least. Or how are you making sure there are no concurrent modifications to page tables / VMA layout ... ?
Quoted 1 line
(quoted diff) +1
-0+ if (follow_invalidate_pte(mm, addr, NULL, &pte, &pmd, &ptl))
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v34 05/13] mm/damon: Implement primitives for the virtual memory address spaces
From: SeongJae Park <[email protected]>
Hello David,
Quoted 8 lines · On Thu, 26 Aug 2021 16:09:23 +0200 David Hildenbrand <[email protected]> wrote:
mm/damon/vaddr.c line 448
Quoted 6 lines
mm/damon/vaddr.c new file +6
-0+static void damon_va_mkold (struct mm_struct *mm,unsigned long addr) +{ +pte_t *pte =NULL ; +pmd_t *pmd =NULL ; +spinlock_t *ptl; +I just stumbled over this, sorry for the dumb questions:
Appreciate for the great questions!
Quoted 8 lines
a) What do we know about that region we are messing with?
AFAIU, just like
follow_pte()andfollow_pfn(),follow_invalidate_pte()should only be called onVM_IOand rawVM_PFNMAPmappings in general (see the doc offollow_pte()). Do you even know that it's within a single VMA and that there are no concurrent modifications?
We have no idea about the region at this moment. However, if we successfully get the pte or pmd under the protection of the page table lock, we ensure the page for the pte or pmd is a online LRU-page with damon_get_page(), before updating the pte or pmd's PAGE_ACCESSED bit. We release the page table lock only after the update.
And concurrent VMA change doesn't matter here because we read and write only the page table. If the address is not mapped or not backed by LRU pages, we simply treat it as not accessed.
Quoted 8 lines
b) Which locks are we holding?
I hope we're holding the mmap lock in read mode at least. Or how are you making sure there are no concurrent modifications to page tables / VMA layout ... ?
Review
Quoted 1 line
(quoted diff) +1
-0+ if (follow_invalidate_pte(mm, addr, NULL, &pte, &pmd, &ptl))
All the operations are protected by the page table lock of the pte or pmd, so no concurrent page table modification would happen. As previously mentioned, because we read and update only page table, we don't care about VMAs and therefore we don't need to hold mmap lock here.
Outside of this function, DAMON reads the VMAs to know which address ranges are not mapped, and avoid inefficiently checking access to the area with the information. Nevertheless, it happens only occasionally (once per 60 seconds by default), and it holds the mmap read lock in the case.
Nonetheless, I agree the usage of follow_invalidate_pte() here could make readers very confusing. It would be better to implement and use DAMON's own page table walk logic. Of course, I might missing something important. If you think so, please don't hesitate at yelling to me.
Thanks,
SJ
Quoted 7 lines
Signature · 4 lines
-- Thanks, David / dhildenb
Re: [PATCH v34 05/13] mm/damon: Implement primitives for the virtual memory address spaces
Quoted 33 lines · SeongJae Park
From: SeongJae Park <[email protected]>
Hello David,
Quoted 8 lines · On Thu, 26 Aug 2021 16:09:23 +0200 David Hildenbrand <[email protected]> wrote:
mm/damon/vaddr.c line 448
Quoted 6 lines
mm/damon/vaddr.c new file +6
-0+static void damon_va_mkold (struct mm_struct *mm,unsigned long addr) +{ +pte_t *pte =NULL ; +pmd_t *pmd =NULL ; +spinlock_t *ptl; +I just stumbled over this, sorry for the dumb questions:
Appreciate for the great questions!
Quoted 8 lines
a) What do we know about that region we are messing with?
AFAIU, just like
follow_pte()andfollow_pfn(),follow_invalidate_pte()should only be called onVM_IOand rawVM_PFNMAPmappings in general (see the doc offollow_pte()). Do you even know that it's within a single VMA and that there are no concurrent modifications?We have no idea about the region at this moment. However, if we successfully get the pte or pmd under the protection of the page table lock, we ensure the page for the pte or pmd is a online LRU-page with
damon_get_page(), before updating the pte or pmd'sPAGE_ACCESSEDbit. We release the page table lock only after the update.
Quoted 3 lines
And concurrent VMA change doesn't matter here because we read and write only the page table. If the address is not mapped or not backed by LRU pages, we simply treat it as not accessed.
reading/writing page tables is the real problem.
Quoted 8 lines
Quoted 8 lines
b) Which locks are we holding?
I hope we're holding the mmap lock in read mode at least. Or how are you making sure there are no concurrent modifications to page tables / VMA layout ... ?
Quoted 6 lines
Quoted 1 line
Review
Quoted 1 line
(quoted diff) +1
-0+ if (follow_invalidate_pte(mm, addr, NULL, &pte, &pmd, &ptl))All the operations are protected by the page table lock of the pte or pmd, so no concurrent page table modification would happen. As previously mentioned, because we read and update only page table, we don't care about VMAs and therefore we don't need to hold mmap lock here.
See below, that's unfortunately not sufficient.
Quoted 10 lines
Outside of this function, DAMON reads the VMAs to know which address ranges are not mapped, and avoid inefficiently checking access to the area with the information. Nevertheless, it happens only occasionally (once per 60 seconds by default), and it holds the mmap read lock in the case.
Nonetheless, I agree the usage of
follow_invalidate_pte()here could make readers very confusing. It would be better to implement and use DAMON's own page table walk logic. Of course, I might missing something important. If you think so, please don't hesitate at yelling to me.
I'm certainly not going to yell :) But unfortunately I'll have to tell you that what you are doing is in my understanding fundamentally broken.
See, page tables might get removed any time
a) By munmap() code even while holding the mmap semaphore in read (!)
b) By khugepaged holding the mmap lock in write mode
The rules are (ignoring the rmap side of things)
a) You can walk page tables inside a known VMA with the mmap semaphore held in read mode. If you drop the mmap sem, you have to re-validate the VMA! Anything could have changed in the meantime. This is essentially what mm/pagewalk.c does.
b) You can walk page tables ignoring VMAs with the mmap semaphore held in write mode.
c) You can walk page tables lockless if the architecture supports it and you have interrupts disabled the hole time. But you are not allowed to write.
With what you're doing, you might end up reading random garbage as page table pointers, or writing random garbage to pages that are no longer used as page tables.
Take a look at mm/gup.c:lockless_pages_from_mm() to see how difficult it is to walk page tables lockless. And it only works because page table freeing code synchronizes either via IPI or fake-rcu before actually freeing a page table.
follow_invalidate_pte() is, in general, the wrong thing to use. It's specialized to VM_IO and VM_PFNMAP. take a look at the difference in complexity between follow_invalidate_pte() and mm/pagewalk.c!
I'm really sorry, but as far as I can tell, this is locking-wise broken and follow_invalidate_pte() is the wrong interface to use here.
Someone can most certainly correct me if I'm wrong, or if I'm missing something regarding your implementation, but if you take a look around, you won't find any code walking page tables without at least holding the mmap sem in read mode -- for a good reason.
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v34 05/13] mm/damon: Implement primitives for the virtual memory address spaces
From: SeongJae Park <[email protected]>
Quoted 103 lines · On Thu, 26 Aug 2021 23:42:19 +0200 David Hildenbrand <[email protected]> wrote:
Quoted 33 lines · SeongJae Park
From: SeongJae Park <[email protected]>
Hello David,
Quoted 8 lines · On Thu, 26 Aug 2021 16:09:23 +0200 David Hildenbrand <[email protected]> wrote:
mm/damon/vaddr.c line 448
Quoted 6 lines
mm/damon/vaddr.c new file +6
-0+static void damon_va_mkold (struct mm_struct *mm,unsigned long addr) +{ +pte_t *pte =NULL ; +pmd_t *pmd =NULL ; +spinlock_t *ptl; +I just stumbled over this, sorry for the dumb questions:
Appreciate for the great questions!
Quoted 8 lines
a) What do we know about that region we are messing with?
AFAIU, just like
follow_pte()andfollow_pfn(),follow_invalidate_pte()should only be called onVM_IOand rawVM_PFNMAPmappings in general (see the doc offollow_pte()). Do you even know that it's within a single VMA and that there are no concurrent modifications?We have no idea about the region at this moment. However, if we successfully get the pte or pmd under the protection of the page table lock, we ensure the page for the pte or pmd is a online LRU-page with
damon_get_page(), before updating the pte or pmd'sPAGE_ACCESSEDbit. We release the page table lock only after the update.Quoted 3 lines
And concurrent VMA change doesn't matter here because we read and write only the page table. If the address is not mapped or not backed by LRU pages, we simply treat it as not accessed.
reading/writing page tables is the real problem.
Quoted 8 lines
Quoted 8 lines
b) Which locks are we holding?
I hope we're holding the mmap lock in read mode at least. Or how are you making sure there are no concurrent modifications to page tables / VMA layout ... ?
Quoted 6 lines
Quoted 1 line
Review
Quoted 1 line
(quoted diff) +1
-0+ if (follow_invalidate_pte(mm, addr, NULL, &pte, &pmd, &ptl))All the operations are protected by the page table lock of the pte or pmd, so no concurrent page table modification would happen. As previously mentioned, because we read and update only page table, we don't care about VMAs and therefore we don't need to hold mmap lock here.
See below, that's unfortunately not sufficient.
Quoted 10 lines
Outside of this function, DAMON reads the VMAs to know which address ranges are not mapped, and avoid inefficiently checking access to the area with the information. Nevertheless, it happens only occasionally (once per 60 seconds by default), and it holds the mmap read lock in the case.
Nonetheless, I agree the usage of
follow_invalidate_pte()here could make readers very confusing. It would be better to implement and use DAMON's own page table walk logic. Of course, I might missing something important. If you think so, please don't hesitate at yelling to me.I'm certainly not going to yell :) But unfortunately I'll have to tell you that what you are doing is in my understanding fundamentally broken.
See, page tables might get removed any time
a) Bymunmap()code even while holding the mmap semaphore in read (!)
b) By khugepaged holding the mmap lock in write modeThe rules are (ignoring the rmap side of things)
a) You can walk page tables inside a known VMA with the mmap semaphore held in read mode. If you drop the mmap sem, you have to re-validate the VMA! Anything could have changed in the meantime. This is essentially what
mm/pagewalk.cdoes.b) You can walk page tables ignoring VMAs with the mmap semaphore held in write mode.
c) You can walk page tables lockless if the architecture supports it and you have interrupts disabled the hole time. But you are not allowed to write.
With what you're doing, you might end up reading random garbage as page table pointers, or writing random garbage to pages that are no longer used as page tables.
Take a look at mm/gup.c:lockless_pages_from_mm() to see how difficult it is to walk page tables lockless. And it only works because page table freeing code synchronizes either via IPI or fake-rcu before actually freeing a page table.
follow_invalidate_pte()is, in general, the wrong thing to use. It's specialized toVM_IOandVM_PFNMAP. take a look at the difference in complexity betweenfollow_invalidate_pte()andmm/pagewalk.c!
Quoted 7 lines
I'm really sorry, but as far as I can tell, this is locking-wise broken and
follow_invalidate_pte()is the wrong interface to use here.Someone can most certainly correct me if I'm wrong, or if I'm missing something regarding your implementation, but if you take a look around, you won't find any code walking page tables without at least holding the mmap sem in read mode -- for a good reason.
Thank you very much for this kind explanation, David! I will send a patch for this soon.
Thanks,
SJ
Quoted 6 lines
Signature · 4 lines
-- Thanks, David / dhildenb
PATCH v34 6/13 mm/damon: Add a tracepoint
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit adds a tracepoint for DAMON. It traces the monitoring results of each region for each aggregation interval. Using this, DAMON can easily integrated with tracepoints supporting tools such as perf.
--- include/trace/events/damon.h | 43 ++++++++++++++++++++++++++++++++++++ mm/damon/core.c | 7 +++++- 2 files changed, 49 insertions(+), 1 deletion(-) create mode 100644 include/trace/events/damon.h
include/trace/events/damon.h new file +43 -0
@@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM damon + +#if !defined(_TRACE_DAMON_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_DAMON_H + +#include <linux/damon.h> +#include <linux/types.h> +#include <linux/tracepoint.h> + +TRACE_EVENT (damon_aggregated, + + TP_PROTO(struct damon_target *t, struct damon_region *r, + unsigned int nr_regions), + +TP_ARGS (t, r, nr_regions), + +TP_STRUCT__entry ( + __field(unsigned long, target_id) + __field(unsigned int, nr_regions) + __field(unsigned long, start) + __field(unsigned long, end) + __field(unsigned int, nr_accesses) + ), + +TP_fast_assign ( + __entry->target_id = t->id; + __entry->nr_regions = nr_regions; + __entry->start = r->ar.start; + __entry->end = r->ar.end; + __entry->nr_accesses = r->nr_accesses; + ), + +TP_printk ("target_id=%lu nr_regions=%u %lu-%lu: %u" , + __entry->target_id, __entry->nr_regions, + __entry->start, __entry->end, __entry->nr_accesses) +); + +#endif /* _TRACE_DAMON_H */ + +/* This part must be outside protection */ +#include <trace/define_trace.h>
mm/damon/core.c +6 -1
@@ -13,6 +13,9 @@#include <linux/random.h> #include <linux/slab.h> +#define CREATE_TRACE_POINTS +#include <trace/events/damon.h> +/* Get a random number in [l, r) */ #define damon_rand (l, r) (l + prandom_u32_max(r - l))
@@ -387,8 +390,10 @@ static void kdamond_reset_aggregated(struct damon_ctx *c)damon_for_each_target (t, c) {struct damon_region *r; -damon_for_each_region (r, t) +damon_for_each_region (r, t) { +trace_damon_aggregated (t, r,damon_nr_regions (t)); r->nr_accesses =0 ; + } } }
Signature · 1 line
2.17.1
PATCH v34 7/13 mm/damon: Implement a debugfs-based user space interface
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
DAMON is designed to be used by kernel space code such as the memory management subsystems, and therefore it provides only kernel space API. That said, letting the user space control DAMON could provide some benefits to them. For example, it will allow user space to analyze their specific workloads and make their own special optimizations.
For such cases, this commit implements a simple DAMON application kernel module, namely 'damon-dbgfs', which merely wraps the DAMON api and exports those to the user space via the debugfs.
'damon-dbgfs' exports three files, ``attrs``, ``target_ids``, and ``monitor_on`` under its debugfs directory, ``<debugfs>/damon/``.
Attributes
----------
Users can read and write the ``sampling interval``, ``aggregation interval``, ``regions update interval``, and min/max number of monitoring target regions by reading from and writing to the ``attrs`` file. For example, below commands set those values to 5 ms, 100 ms, 1,000 ms, 10, 1000 and check it again::
# cd <debugfs>/damon
# echo 5000 100000 1000000 10 1000 > attrs
# cat attrs
5000 100000 1000000 10 1000Target IDs
----------
Some types of address spaces supports multiple monitoring target. For example, the virtual memory address spaces monitoring can have multiple processes as the monitoring targets. Users can set the targets by writing relevant id values of the targets to, and get the ids of the current targets by reading from the ``target_ids`` file. In case of the virtual address spaces monitoring, the values should be pids of the monitoring target processes. For example, below commands set processes having pids 42 and 4242 as the monitoring targets and check it again::
# cd <debugfs>/damon
# echo 42 4242 > target_ids
# cat target_ids
42 4242Note that setting the target ids doesn't start the monitoring.
Turning On/Off
--------------
Setting the files as described above doesn't incur effect unless you explicitly start the monitoring. You can start, stop, and check the current status of the monitoring by writing to and reading from the ``monitor_on`` file. Writing ``on`` to the file starts the monitoring of the targets with the attributes. Writing ``off`` to the file stops those. DAMON also stops if every targets are invalidated (in case of the virtual memory monitoring, target processes are invalidated when terminated). Below example commands turn on, off, and check the status of DAMON::
# cd <debugfs>/damon
# echo on > monitor_on
# echo off > monitor_on
# cat monitor_on
offPlease note that you cannot write to the above-mentioned debugfs files while the monitoring is turned on. If you write to the files while DAMON is running, an error code such as ``-EBUSY`` will be returned.
--- include/linux/damon.h | 3 + mm/damon/Kconfig | 9 + mm/damon/Makefile | 1 + mm/damon/core.c | 47 +++++ mm/damon/dbgfs.c | 398 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 458 insertions(+) create mode 100644 mm/damon/dbgfs.c
include/linux/damon.h +3 -0
@@ -240,9 +240,12 @@ unsigned int damon_nr_regions(struct damon_target *t);struct damon_ctx *damon_new_ctx (void );void damon_destroy_ctx (struct damon_ctx *ctx); +int damon_set_targets (struct damon_ctx *ctx, +unsigned long *ids,ssize_t nr_ids);int damon_set_attrs (struct damon_ctx *ctx,unsigned long sample_int,unsigned long aggr_int,unsigned long primitive_upd_int,unsigned long min_nr_reg,unsigned long max_nr_reg); +int damon_nr_running_ctxs (void );int damon_start (struct damon_ctx **ctxs,int nr_ctxs);int damon_stop (struct damon_ctx **ctxs,int nr_ctxs);
mm/damon/Kconfig +9 -0
@@ -21,4 +21,13 @@ config DAMON_VADDR This builds the default data access monitoring primitives for DAMON that works for virtual address spaces. +config DAMON_DBGFS + bool "DAMON debugfs interface" + depends on DAMON_VADDR && DEBUG_FS + help + This builds the debugfs interface for DAMON. The user space admins + can use the interface for arbitrary data access monitoring. + + If unsure, say N. + endmenu
mm/damon/Makefile +1 -0
@@ -2,3 +2,4 @@ obj-$(CONFIG_DAMON) := core.o obj-$(CONFIG_DAMON_VADDR) += vaddr.o +obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o
mm/damon/core.c +47 -0
59 lines not on this page · raw message
mm/damon/dbgfs.c new file +398 -0
398 lines not on this page · raw message
Signature · 1 line
2.17.1
Andrew Morton
maintainerRe: [PATCH v34 07/13] mm/damon: Implement a debugfs-based user space interface
Quoted 19 lines · On Fri, 16 Jul 2021 08:14:43 +0000 SeongJae Park <[email protected]> wrote:
From: SeongJae Park <[email protected]>
DAMON is designed to be used by kernel space code such as the memory management subsystems, and therefore it provides only kernel space API. That said, letting the user space control DAMON could provide some benefits to them. For example, it will allow user space to analyze their specific workloads and make their own special optimizations.
For such cases, this commit implements a simple DAMON application kernel module, namely 'damon-dbgfs', which merely wraps the DAMON api and exports those to the user space via the debugfs.
...
(quoted diff) +5
-0+static int __init damon_dbgfs_init(void) +{ + int rc; + + dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL);
Review
Quoted 10 lines
(quoted diff) +10
-0+ if (!dbgfs_ctxs) { + pr_err("%s: dbgfs ctxs alloc failed\n", __func__); + return -ENOMEM; + } + dbgfs_ctxs[0] = dbgfs_new_ctx(); + if (!dbgfs_ctxs[0]) { + kfree(dbgfs_ctxs); + pr_err("%s: dbgfs ctx alloc failed\n", __func__); + return -ENOMEM; + }
checkpatch points out that the "alloc failed" messages are unneeded - kmalloc(GFP_KERNEL) will have already emitted a stack trace. Is this fixup OK?
mm/damon/dbgfs.c renamed from mm/damon/dbgfs.c~mm-damon-implement-a-debugfs-based-user-space-interface-fix +1 -4
@@ -373,14 +373,11 @@ static int __init damon_dbgfs_init(void)int rc; dbgfs_ctxs =kmalloc (sizeof (*dbgfs_ctxs),GFP_KERNEL ); -if (!dbgfs_ctxs) { -pr_err ("%s: dbgfs ctxs alloc failed\n" , __func__); +if (!dbgfs_ctxs)return -ENOMEM ; - } dbgfs_ctxs[0 ] =dbgfs_new_ctx ();if (!dbgfs_ctxs[0 ]) {kfree (dbgfs_ctxs); -pr_err ("%s: dbgfs ctx alloc failed\n" , __func__);return -ENOMEM ; } dbgfs_nr_ctxs =1 ;
_
Re: [PATCH v34 07/13] mm/damon: Implement a debugfs-based user space interface
From: SeongJae Park <[email protected]>
Quoted 27 lines · On Thu, 5 Aug 2021 17:43:04 -0700 Andrew Morton <[email protected]>…
Quoted 25 lines · On Fri, 16 Jul 2021 08:14:43 +0000 SeongJae Park <[email protected]> wrote:
From: SeongJae Park <[email protected]>
DAMON is designed to be used by kernel space code such as the memory management subsystems, and therefore it provides only kernel space API. That said, letting the user space control DAMON could provide some benefits to them. For example, it will allow user space to analyze their specific workloads and make their own special optimizations.
For such cases, this commit implements a simple DAMON application kernel module, namely 'damon-dbgfs', which merely wraps the DAMON api and exports those to the user space via the debugfs.
...
(quoted diff) +11
-0+static int __init damon_dbgfs_init(void) +{ + int rc; + + dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL); + if (!dbgfs_ctxs) { + pr_err("%s: dbgfs ctxs alloc failed\n", __func__); + return -ENOMEM; + } + dbgfs_ctxs[0] = dbgfs_new_ctx(); + if (!dbgfs_ctxs[0]) {
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ kfree(dbgfs_ctxs); + pr_err("%s: dbgfs ctx alloc failed\n", __func__); + return -ENOMEM; + }checkpatch points out that the "alloc failed" messages are unneeded -
kmalloc(GFP_KERNEL)will have already emitted a stack trace. Is this fixup OK?
Yes, of course. I also see you already kindly applied this in the -mm tree[1], appreciate!
Thanks,
SeongJae Park
[...]
Andrew Morton
maintainerRe: [PATCH v34 07/13] mm/damon: Implement a debugfs-based user space interface
In reply to SeongJae ParkReview
Quoted 3 lines · On Fri, 16 Jul 2021 08:14:43 +0000 SeongJae Park <[email protected]> wrote:
(quoted diff) +3
-0+#define targetid_is_pid(ctx) \ + (ctx->primitive.target_valid == damon_va_target_valid) +
I think this can be implemented as a static inline C function?
mm/damon/dbgfs.c renamed from mm/damon/dbgfs.c~mm-damon-implement-a-debugfs-based-user-space-interface-fix-fix +4 -2
@@ -97,8 +97,10 @@ out:return ret; } -#define targetid_is_pid (ctx) \ - (ctx->primitive.target_valid == damon_va_target_valid) +static inline bool targetid_is_pid (const struct damon_ctx *ctx) +{ +return ctx->primitive.target_valid == damon_va_target_valid; +}static ssize_t sprint_target_ids (struct damon_ctx *ctx,char *buf,ssize_t len) {
We prefer this because it looks better, provides typechecking and can in some situations suppress unused variable warnings.
Re: [PATCH v34 07/13] mm/damon: Implement a debugfs-based user space interface
From: SeongJae Park <[email protected]>
Quoted 24 lines · On Thu, 5 Aug 2021 17:43:16 -0700 Andrew Morton <[email protected]>…
Review
Quoted 3 lines · On Fri, 16 Jul 2021 08:14:43 +0000 SeongJae Park <[email protected]> wrote:
(quoted diff) +3
-0+#define targetid_is_pid(ctx) \ + (ctx->primitive.target_valid == damon_va_target_valid) +I think this can be implemented as a static inline C function?
mm/damon/dbgfs.c renamed from mm/damon/dbgfs.c~mm-damon-implement-a-debugfs-based-user-space-interface-fix-fix +4
-2@@ -97,8 +97,10 @@ out:return ret; } -#define targetid_is_pid (ctx) \ - (ctx->primitive.target_valid == damon_va_target_valid) +static inline bool targetid_is_pid (const struct damon_ctx *ctx) +{ +return ctx->primitive.target_valid == damon_va_target_valid; +}static ssize_t sprint_target_ids (struct damon_ctx *ctx,char *buf,ssize_t len) {
Quoted 2 lines
We prefer this because it looks better, provides typechecking and can in some situations suppress unused variable warnings.
Agreed, I will keep that preference in my mind. I also found that you already nicely made the change in the the -mm tree[1], appreciate!
Thanks,
SeongJae Park
PATCH v34 8/13 mm/damon/dbgfs: Export kdamond pid to the user space
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
For CPU usage accounting, knowing pid of the monitoring thread could be helpful. For example, users could use cpuaccount cgroups with the pid.
This commit therefore exports the pid of currently running monitoring thread to the user space via 'kdamond_pid' file in the debugfs directory.
--- mm/damon/dbgfs.c | 37 +++++++++++++++++++++++++++++++++++-- 1 file changed, 35 insertions(+), 2 deletions(-)
mm/damon/dbgfs.c +35 -2
@@ -237,6 +237,32 @@ static ssize_t dbgfs_target_ids_write(struct file *file,return ret; } +static ssize_t dbgfs_kdamond_pid_read (struct file *file, +char __user *buf,size_t count,loff_t *ppos) +{ +struct damon_ctx *ctx = file->private_data; +char *kbuf; +ssize_t len; + + kbuf =kmalloc (count,GFP_KERNEL ); +if (!kbuf) +return -ENOMEM ; + +mutex_lock (&ctx->kdamond_lock); +if (ctx->kdamond) + len =scnprintf (kbuf, count,"%d\n" , ctx->kdamond->pid); +else + len =scnprintf (kbuf, count,"none\n" ); +mutex_unlock (&ctx->kdamond_lock); +if (!len) + goto out; + len =simple_read_from_buffer (buf, count, ppos, kbuf, len); + +out: +kfree (kbuf); +return len; +} +static int damon_dbgfs_open (struct inode *inode,struct file *file) { file->private_data = inode->i_private;
@@ -256,10 +282,17 @@ static const struct file_operations target_ids_fops = { .write = dbgfs_target_ids_write, }; +static const struct file_operations kdamond_pid_fops = { + .open = damon_dbgfs_open, + .read = dbgfs_kdamond_pid_read, +}; +static void dbgfs_fill_ctx_dir (struct dentry *dir,struct damon_ctx *ctx) { -const char *const file_names[] = {"attrs" ,"target_ids" }; -const struct file_operations *fops[] = {&attrs_fops, &target_ids_fops}; +const char *const file_names[] = {"attrs" ,"target_ids" , +"kdamond_pid" }; +const struct file_operations *fops[] = {&attrs_fops, &target_ids_fops, + &kdamond_pid_fops};int i;for (i =0 ; i <ARRAY_SIZE (file_names); i++)
Signature · 1 line
2.17.1
PATCH v34 9/13 mm/damon/dbgfs: Support multiple contexts
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
In some use cases, users would want to run multiple monitoring context. For example, if a user wants a high precision monitoring and dedicating multiple CPUs for the job is ok, because DAMON creates one monitoring thread per one context, the user can split the monitoring target regions into multiple small regions and create one context for each region. Or, someone might want to simultaneously monitor different address spaces, e.g., both virtual address space and physical address space.
The DAMON's API allows such usage, but 'damon-dbgfs' does not. Therefore, only kernel space DAMON users can do multiple contexts monitoring.
This commit allows the user space DAMON users to use multiple contexts monitoring by introducing two new 'damon-dbgfs' debugfs files, 'mk_context' and 'rm_context'. Users can create a new monitoring context by writing the desired name of the new context to 'mk_context'. Then, a new directory with the name and having the files for setting of the context ('attrs', 'target_ids' and 'record') will be created under the debugfs directory. Writing the name of the context to remove to 'rm_context' will remove the related context and directory.
--- mm/damon/dbgfs.c | 195 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 193 insertions(+), 2 deletions(-)
mm/damon/dbgfs.c +193 -2
@@ -18,6 +18,7 @@static struct damon_ctx **dbgfs_ctxs;static int dbgfs_nr_ctxs;static struct dentry **dbgfs_dirs; +static DEFINE_MUTEX (damon_dbgfs_lock);/* * Returns non-empty string on success, negative error code otherwise.
@@ -326,6 +327,186 @@ static struct damon_ctx *dbgfs_new_ctx(void)return ctx; } +static void dbgfs_destroy_ctx (struct damon_ctx *ctx) +{ +damon_destroy_ctx (ctx); +} + +/* +* Make a context of @name and create a debugfs directory for it. +* +* This function should be called while holding damon_dbgfs_lock. +* +* Returns 0 on success, negative error code otherwise. +*/ +static int dbgfs_mk_context (char *name) +{ +struct dentry *root, **new_dirs, *new_dir; +struct damon_ctx **new_ctxs, *new_ctx; + +if (damon_nr_running_ctxs ()) +return -EBUSY ; + + new_ctxs =krealloc (dbgfs_ctxs,sizeof (*dbgfs_ctxs) * + (dbgfs_nr_ctxs +1 ),GFP_KERNEL ); +if (!new_ctxs) +return -ENOMEM ; + dbgfs_ctxs = new_ctxs; + + new_dirs =krealloc (dbgfs_dirs,sizeof (*dbgfs_dirs) * + (dbgfs_nr_ctxs +1 ),GFP_KERNEL ); +if (!new_dirs) +return -ENOMEM ; + dbgfs_dirs = new_dirs; + + root = dbgfs_dirs[0 ]; +if (!root) +return -ENOENT ; + + new_dir =debugfs_create_dir (name, root); + dbgfs_dirs[dbgfs_nr_ctxs] = new_dir; + + new_ctx =dbgfs_new_ctx (); +if (!new_ctx) { +debugfs_remove (new_dir); + dbgfs_dirs[dbgfs_nr_ctxs] =NULL ; +return -ENOMEM ; + } + + dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx; +dbgfs_fill_ctx_dir (dbgfs_dirs[dbgfs_nr_ctxs], + dbgfs_ctxs[dbgfs_nr_ctxs]); + dbgfs_nr_ctxs++; + +return 0 ; +} + +static ssize_t dbgfs_mk_context_write (struct file *file, +const char __user *buf,size_t count,loff_t *ppos) +{ +char *kbuf; +char *ctx_name; +ssize_t ret = count; +int err; + + kbuf =user_input_str (buf, count, ppos); +if (IS_ERR (kbuf)) +return PTR_ERR (kbuf); + ctx_name =kmalloc (count +1 ,GFP_KERNEL ); +if (!ctx_name) { +kfree (kbuf); +return -ENOMEM ; + } + +/* Trim white space */ +if (sscanf (kbuf,"%s" , ctx_name) !=1 ) { + ret = -EINVAL ; + goto out; + } + +mutex_lock (&damon_dbgfs_lock); + err =dbgfs_mk_context (ctx_name); +if (err) + ret = err; +mutex_unlock (&damon_dbgfs_lock); + +out: +kfree (kbuf); +kfree (ctx_name); +return ret; +} + +/* +* Remove a context of @name and its debugfs directory. +* +* This function should be called while holding damon_dbgfs_lock. +* +* Return 0 on success, negative error code otherwise. +*/ +static int dbgfs_rm_context (char *name) +{ +struct dentry *root, *dir, **new_dirs; +struct damon_ctx **new_ctxs; +int i, j; + +if (damon_nr_running_ctxs ()) +return -EBUSY ; + + root = dbgfs_dirs[0 ]; +if (!root) +return -ENOENT ; + + dir =debugfs_lookup (name, root); +if (!dir) +return -ENOENT ; + + new_dirs =kmalloc_array (dbgfs_nr_ctxs -1 ,sizeof (*dbgfs_dirs), +GFP_KERNEL ); +if (!new_dirs) +return -ENOMEM ; + + new_ctxs =kmalloc_array (dbgfs_nr_ctxs -1 ,sizeof (*dbgfs_ctxs), +GFP_KERNEL ); +if (!new_ctxs) { +kfree (new_dirs); +return -ENOMEM ; + } + +for (i =0 , j =0 ; i < dbgfs_nr_ctxs; i++) { +if (dbgfs_dirs[i] == dir) { +debugfs_remove (dbgfs_dirs[i]); +dbgfs_destroy_ctx (dbgfs_ctxs[i]); +continue ; + } + new_dirs[j] = dbgfs_dirs[i]; + new_ctxs[j++] = dbgfs_ctxs[i]; + } + +kfree (dbgfs_dirs); +kfree (dbgfs_ctxs); + + dbgfs_dirs = new_dirs; + dbgfs_ctxs = new_ctxs; + dbgfs_nr_ctxs--; + +return 0 ; +} + +static ssize_t dbgfs_rm_context_write (struct file *file, +const char __user *buf,size_t count,loff_t *ppos) +{ +char *kbuf; +ssize_t ret = count; +int err; +char *ctx_name; + + kbuf =user_input_str (buf, count, ppos); +if (IS_ERR (kbuf)) +return PTR_ERR (kbuf); + ctx_name =kmalloc (count +1 ,GFP_KERNEL ); +if (!ctx_name) { +kfree (kbuf); +return -ENOMEM ; + } + +/* Trim white space */ +if (sscanf (kbuf,"%s" , ctx_name) !=1 ) { + ret = -EINVAL ; + goto out; + } + +mutex_lock (&damon_dbgfs_lock); + err =dbgfs_rm_context (ctx_name); +if (err) + ret = err; +mutex_unlock (&damon_dbgfs_lock); + +out: +kfree (kbuf); +kfree (ctx_name); +return ret; +} +static ssize_t dbgfs_monitor_on_read (struct file *file,char __user *buf,size_t count,loff_t *ppos) {
@@ -368,6 +549,14 @@ static ssize_t dbgfs_monitor_on_write(struct file *file,return ret; } +static const struct file_operations mk_contexts_fops = { + .write = dbgfs_mk_context_write, +}; + +static const struct file_operations rm_contexts_fops = { + .write = dbgfs_rm_context_write, +}; +static const struct file_operations monitor_on_fops = { .read = dbgfs_monitor_on_read, .write = dbgfs_monitor_on_write,
@@ -376,8 +565,10 @@ static const struct file_operations monitor_on_fops = {static int __init __damon_dbgfs_init (void ) {struct dentry *dbgfs_root; -const char *const file_names[] = {"monitor_on" }; -const struct file_operations *fops[] = {&monitor_on_fops}; +const char *const file_names[] = {"mk_contexts" ,"rm_contexts" , +"monitor_on" }; +const struct file_operations *fops[] = {&mk_contexts_fops, + &rm_contexts_fops, &monitor_on_fops};int i; dbgfs_root =debugfs_create_dir ("damon" ,NULL );
Signature · 1 line
2.17.1
PATCH v34 10/13 Documentation: Add documents for DAMON
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit adds documents for DAMON under Documentation/admin-guide/mm/damon/ and Documentation/vm/damon/.
--- Documentation/admin-guide/mm/damon/index.rst | 15 ++ Documentation/admin-guide/mm/damon/start.rst | 114 +++++++++++++ Documentation/admin-guide/mm/damon/usage.rst | 112 +++++++++++++ Documentation/admin-guide/mm/index.rst | 1 + Documentation/vm/damon/api.rst | 20 +++ Documentation/vm/damon/design.rst | 166 +++++++++++++++++++ Documentation/vm/damon/faq.rst | 51 ++++++ Documentation/vm/damon/index.rst | 30 ++++ Documentation/vm/index.rst | 1 + 9 files changed, 510 insertions(+) create mode 100644 Documentation/admin-guide/mm/damon/index.rst create mode 100644 Documentation/admin-guide/mm/damon/start.rst create mode 100644 Documentation/admin-guide/mm/damon/usage.rst create mode 100644 Documentation/vm/damon/api.rst create mode 100644 Documentation/vm/damon/design.rst create mode 100644 Documentation/vm/damon/faq.rst create mode 100644 Documentation/vm/damon/index.rst
Documentation/admin-guide/mm/damon/index.rst new file +15 -0
@@ -0,0 +1,15 @@ +.. SPDX-License-Identifier: GPL-2.0 + +======================== +Monitoring Data Accesses +======================== + +:doc:`DAMON </vm/damon/index>` allows light-weight data access monitoring. +Using DAMON, users can analyze the memory access patterns of their systems and +optimize those. + +.. toctree:: + :maxdepth: 2 + + start + usage
Documentation/admin-guide/mm/damon/start.rst new file +114 -0
114 lines not on this page · raw message
Documentation/admin-guide/mm/damon/usage.rst new file +112 -0
112 lines not on this page · raw message
Documentation/admin-guide/mm/index.rst +1 -0
@@ -27,6 +27,7 @@ the Linux memory management. concepts cma_debugfs + damon/index hugetlbpage idle_page_tracking ksm
Documentation/vm/damon/api.rst new file +20 -0
@@ -0,0 +1,20 @@ +.. SPDX-License-Identifier: GPL-2.0 + +============= +API Reference +============= + +Kernel space programs can use every feature of DAMON using below APIs. All you +need to do is including ``damon.h``, which is located in ``include/linux/`` of +the source tree. + +Structures +========== + +.. kernel-doc:: include/linux/damon.h + + +Functions +========= + +.. kernel-doc:: mm/damon/core.c
Documentation/vm/damon/design.rst new file +166 -0
166 lines not on this page · raw message
Documentation/vm/damon/faq.rst new file +51 -0
51 lines not on this page · raw message
Documentation/vm/damon/index.rst new file +30 -0
@@ -0,0 +1,30 @@ +.. SPDX-License-Identifier: GPL-2.0 + +========================== +DAMON: Data Access MONitor +========================== + +DAMON is a data access monitoring framework subsystem for the Linux kernel. +The core mechanisms of DAMON (refer to :doc:`design` for the detail) make it + + - *accurate* (the monitoring output is useful enough for DRAM level memory + management; It might not appropriate for CPU Cache levels, though), + - *light-weight* (the monitoring overhead is low enough to be applied online), + and + - *scalable* (the upper-bound of the overhead is in constant range regardless + of the size of target workloads). + +Using this framework, therefore, the kernel's memory management mechanisms can +make advanced decisions. Experimental memory management optimization works +that incurring high data accesses monitoring overhead could implemented again. +In user space, meanwhile, users who have some special workloads can write +personalized applications for better understanding and optimizations of their +workloads and systems. + +.. toctree:: + :maxdepth: 2 + + faq + design + api + plans
Documentation/vm/index.rst +1 -0
@@ -32,6 +32,7 @@ descriptions of data structures and algorithms. arch_pgtable_helpers balance cleancache + damon/index free_page_reporting frontswap highmem
Signature · 1 line
2.17.1
PATCH v34 11/13 mm/damon: Add kunit tests
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit adds kunit based unit tests for the core and the virtual address spaces monitoring primitives of DAMON.
--- mm/damon/Kconfig | 36 +++++ mm/damon/core-test.h | 253 ++++++++++++++++++++++++++++++++ mm/damon/core.c | 7 + mm/damon/dbgfs-test.h | 126 ++++++++++++++++ mm/damon/dbgfs.c | 2 + mm/damon/vaddr-test.h | 329 ++++++++++++++++++++++++++++++++++++++++++ mm/damon/vaddr.c | 7 + 7 files changed, 760 insertions(+) create mode 100644 mm/damon/core-test.h create mode 100644 mm/damon/dbgfs-test.h create mode 100644 mm/damon/vaddr-test.h
mm/damon/Kconfig +36 -0
@@ -12,6 +12,18 @@ config DAMON See https://damonitor.github.io/doc/html/latest-damon/index.html for more information. +config DAMON_KUNIT_TEST + bool "Test for damon" if !KUNIT_ALL_TESTS + depends on DAMON && KUNIT=y + default KUNIT_ALL_TESTS + help + This builds the DAMON Kunit test suite. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation. + + If unsure, say N. + config DAMON_VADDR bool "Data access monitoring primitives for virtual address spaces" depends on DAMON && MMU
@@ -21,6 +33,18 @@ config DAMON_VADDR This builds the default data access monitoring primitives for DAMON that works for virtual address spaces. +config DAMON_VADDR_KUNIT_TEST + bool "Test for DAMON primitives" if !KUNIT_ALL_TESTS + depends on DAMON_VADDR && KUNIT=y + default KUNIT_ALL_TESTS + help + This builds the DAMON virtual addresses primitives Kunit test suite. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation. + + If unsure, say N. + config DAMON_DBGFS bool "DAMON debugfs interface" depends on DAMON_VADDR && DEBUG_FS
@@ -30,4 +54,16 @@ config DAMON_DBGFS If unsure, say N. +config DAMON_DBGFS_KUNIT_TEST + bool "Test for damon debugfs interface" if !KUNIT_ALL_TESTS + depends on DAMON_DBGFS && KUNIT=y + default KUNIT_ALL_TESTS + help + This builds the DAMON debugfs interface Kunit test suite. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation. + + If unsure, say N. + endmenu
mm/damon/core-test.h new file +253 -0
253 lines not on this page · raw message
mm/damon/core.c +7 -0
@@ -16,6 +16,11 @@#define CREATE_TRACE_POINTS #include <trace/events/damon.h> +#ifdef CONFIG_DAMON_KUNIT_TEST +#undef DAMON_MIN_REGION +#define DAMON_MIN_REGION 1 +#endif +/* Get a random number in [l, r) */ #define damon_rand (l, r) (l + prandom_u32_max(r - l))
@@ -711,3 +716,5 @@ static int kdamond_fn(void *data)do_exit (0 ); } + +#include "core-test.h"
mm/damon/dbgfs-test.h new file +126 -0
126 lines not on this page · raw message
mm/damon/dbgfs.c +2 -0
@@ -620,3 +620,5 @@ static int __init damon_dbgfs_init(void) }module_init (damon_dbgfs_init); + +#include "dbgfs-test.h"
mm/damon/vaddr-test.h new file +329 -0
329 lines not on this page · raw message
mm/damon/vaddr.c +7 -0
@@ -15,6 +15,11 @@#include <linux/sched/mm.h> #include <linux/slab.h> +#ifdef CONFIG_DAMON_VADDR_KUNIT_TEST +#undef DAMON_MIN_REGION +#define DAMON_MIN_REGION 1 +#endif +/* Get a random number in [l, r) */ #define damon_rand (l, r) (l + prandom_u32_max(r - l))
@@ -604,3 +609,5 @@ void damon_va_set_primitives(struct damon_ctx *ctx) ctx->primitive.target_valid = damon_va_target_valid; ctx->primitive.cleanup =NULL ; } + +#include "vaddr-test.h"
Signature · 1 line
2.17.1
PATCH v34 12/13 mm/damon: Add user space selftests
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit adds a simple user space tests for DAMON. The tests are using kselftest framework.
--- tools/testing/selftests/damon/Makefile | 7 ++ .../selftests/damon/_chk_dependency.sh | 28 +++++++ .../testing/selftests/damon/debugfs_attrs.sh | 75 +++++++++++++++++++ 3 files changed, 110 insertions(+) create mode 100644 tools/testing/selftests/damon/Makefile create mode 100644 tools/testing/selftests/damon/_chk_dependency.sh create mode 100755 tools/testing/selftests/damon/debugfs_attrs.sh
tools/testing/selftests/damon/Makefile new file +7 -0
@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0 +# Makefile for damon selftests + +TEST_FILES = _chk_dependency.sh +TEST_PROGS = debugfs_attrs.sh + +include ../lib.mk
tools/testing/selftests/damon/_chk_dependency.sh new file +28 -0
@@ -0,0 +1,28 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 + +# Kselftest framework requirement - SKIP code is 4. +ksft_skip=4 + +DBGFS=/sys/kernel/debug/damon + +if [ $EUID -ne 0 ]; +then + echo "Run as root" + exit $ksft_skip +fi + +if [ ! -d "$DBGFS" ] +then + echo "$DBGFS not found" + exit $ksft_skip +fi + +for f in attrs target_ids monitor_on +do + if [ ! -f "$DBGFS/$f" ] + then + echo "$f not found" + exit 1 + fi +done
tools/testing/selftests/damon/debugfs_attrs.sh new file +75 -0
75 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v34 13/13 MAINTAINERS: Update for DAMON
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit updates MAINTAINERS file for DAMON related files.
--- MAINTAINERS | 11 +++++++++++ 1 file changed, 11 insertions(+)
MAINTAINERS +11 -0
@@ -5128,6 +5128,17 @@ 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 <[email protected]> +L: [email protected] +S: Maintained +F: Documentation/admin-guide/mm/damon/ +F: Documentation/vm/damon/ +F: include/linux/damon.h +F: include/trace/events/damon.h +F: mm/damon/ +F: tools/testing/selftests/damon/ + DAVICOM FAST ETHERNET (DMFE) NETWORK DRIVER L: [email protected] S: Orphan
Signature · 1 line
2.17.1
(reduced CC list)
Hi all,
I have been asked to comment if Google is interested in using this feature, its general usefulness and if it is sufficiently general and non-duplicative. I will try to answer these but first I will explain the use-cases we are particularly interested in and for which we want a general access monitoring mechanism.
At the moment Google is particularly interested in four use-cases:
1) Working set estimation: This is used for cluster level scheduling and controlling the knobs of memory overcommit.
2) Proactive reclaim
3) Balancing between memory tiers: Moving hot pages to fast tiers and cold pages to slow tiers
4) Hugepage optimization: Hot memory backed by hugepages
In addition, these uses are not happening in isolation. We want a combination of these running concurrently on a system. So, it is clear that the first version or step of DAMON which only targets virtual address space monitoring is not sufficient for these use-cases.
I think the more important question is if DAMON can be extended to system level monitoring to fulfill these use-cases. Address space monitoring is a core concept in DAMON and it has implemented address space based optimizations (i.e. dividing address space into regions, assuming locality within regions, random sampling within regions instead of looking at each page and dynamically adjusting regions). There is a followup proposal on monitoring physical address space in DAMON. However for systems running multiple workloads, the address space optimizations core to DAMON would be ineffective.
There are discussions/brainstorming on supporting abstract address space based on LRUs which is somewhat similar to Multigen LRU [1] proposal but not well articulated yet. BTW Multigen LRU [1] is another similar proposal but targets one specific use-case i.e. memory reclaim (proactive reclaim). Anyways I think we need more brainstorming for a generalized solution of system level access monitoring.
Regarding merging DAMON, I personally think there are users who might be interested in only their virtual address space and DAMON is providing a solution for such users. SeongJae can provide more details or knowledge if any big user other than Amazon is interested in the feature. DAMON does not expose stable APIs at the moment, so these can be changed later if needed. I think it is ok to merge DAMON for some exposure. However I do want to make this clear that the solution space is not complete. The solution of system level monitoring is still needed which can be a future extension to DAMON or more generalized Multigen LRU.
thanks,
Shakeel
From: SeongJae Park <[email protected]>
Hello,
Quoted 9 lines · On Tue, 27 Jul 2021 14:30:38 -0700 Shakeel Butt <[email protected]> wrote:
(reduced CC list)
Hi all,
I have been asked to comment if Google is interested in using this feature, its general usefulness and if it is sufficiently general and non-duplicative. I will try to answer these but first I will explain the use-cases we are particularly interested in and for which we want a general access monitoring mechanism.
Thank you for your great opinion below, Shakeel.
Quoted 13 lines
At the moment Google is particularly interested in four use-cases:
1) Working set estimation: This is used for cluster level scheduling and controlling the knobs of memory overcommit.
2) Proactive reclaim
3) Balancing between memory tiers: Moving hot pages to fast tiers and cold pages to slow tiers
4) Hugepage optimization: Hot memory backed by hugepages
Quoted 7 lines
In addition, these uses are not happening in isolation. We want a combination of these running concurrently on a system. So, it is clear that the first version or step of DAMON which only targets virtual address space monitoring is not sufficient for these use-cases.
I think the more important question is if DAMON can be extended to system level monitoring to fulfill these use-cases.
I also think this is the important point. The main purpose of DAMON patchset is providing a flexible monitoring framework which can easily extended for many use cases. Once we have the framework, I believe people will be able to extend it for their usages, and others will be able to reuse those (a snowball can start rolling).
Quoted 7 lines
Address space monitoring is a core concept in DAMON and it has implemented address space based optimizations (i.e. dividing address space into regions, assuming locality within regions, random sampling within regions instead of looking at each page and dynamically adjusting regions). There is a followup proposal on monitoring physical address space in DAMON. However for systems running multiple workloads, the address space optimizations core to DAMON would be ineffective.
Right. If the system is running a huge number of different workloads (e.g., systems running a huge number of virtual machines or kubernetes-managed containers), DAMON's region-based monitoring's accuracy could be lowered.
However, I'd like to note that there are many people running only a small number of major workloads on their systems. Even in the above case of systems running a huge number of virtual machines, each virtual machine would have only a small number of major workloads. People can use DAMON inside the guests. We also confirmed the region-based physical address space monitoring on such production systems achieves high accuracy (we found 4KB hottest memory region in 70GB memory).
Also, the region-based monitoring is not mandatory. The followup proposal which extends DAMON for physical address space monitoring[1] allows people opt out it if they want. In addition to that, it implements a page-granularity monitoring. I unsure if the implementation fits for Google's usage, but I sure you can at least implement your own on the framework without the limitation of the regions abstraction.
Quoted 7 lines
There are discussions/brainstorming on supporting abstract address space based on LRUs which is somewhat similar to Multigen LRU [1] proposal but not well articulated yet. BTW Multigen LRU [1] is another similar proposal but targets one specific use-case i.e. memory reclaim (proactive reclaim). Anyways I think we need more brainstorming for a generalized solution of system level access monitoring.
The idea is using the positional index of each page in its LRU list as its address. For example, a page at the head of a LRU list will have address 0. On the address space, we can safely assume the pages adjacent in the address scheme will have similar access frequency, and therefore DAMON's region-based monitoring would work. Further, we can proactively move the pages in the LRU list so that pages near the head of the list have higher frequencies, based on the monitoring results.
For example, if we see below monitoring results from the address space:
<HEAD of a LRU list> HHHHHHHMMMMMMMCCCCHHCCCCC <TAIL of a LRU list> (H: Hot page, M: Mid-temperature page, C: Cold page)
We can move the hot pages near the tail to the head, as below:
<HEAD of a LRU list> HHHHHHHHHMMMMMMMCCCCCCCCC <TAIL of a LRU list> (H: Hot page, M: Mid-temperature page, C: Cold page)
This will improve not only monitoring accuracy but also other mechanisms such as reclamation, which are based on the assumption of LRU list.
As Shakeel also told, this is only in a brainstorming stage, though.
Quoted 6 lines
Regarding merging DAMON, I personally think there are users who might be interested in only their virtual address space and DAMON is providing a solution for such users. SeongJae can provide more details or knowledge if any big user other than Amazon is interested in the feature.
AFAIR, Huawei, Intel, and Alibaba shown some level of their interests publicly and/or personally, so far. They did code review and/or tests and bug reports. Also a number of researchers and individuals have reached out to me.
Quoted 6 lines
DAMON does not expose stable APIs at the moment, so these can be changed later if needed. I think it is ok to merge DAMON for some exposure. However I do want to make this clear that the solution space is not complete. The solution of system level monitoring is still needed which can be a future extension to DAMON or more generalized Multigen LRU.
Agreed. We have lots more works to do. Some of those are already posted as RFC patchsets[1,2,3,4]. I promise I will happily do the works. But, how dare could only I get all the fun? I'd like to do that together with others in this great community. One major purpose of this patchset is thus providing a flexible framework for such collaboration. The virtual address space monitoring, which this patchset provides in addition to the framework, is also for real-world usages, though.
Now all the patches have at least one 'Reviewed-by:' or 'Acked-by:' tags. We didn't find serious problems since v26[5], which was posted about four months ago. so I'm thinking this patchset has passed the minimum qualification. If you think there are more things to be done before this patchset is merged in the -mm tree or mainline, please let me know. If not, Andrew, I'd like you to consider merging this patchset into '-mm' tree.
Thanks,
SeongJae Park
Quoted 5 lines
thanks,
Shakeel
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://lore.kernel.org/linux-mm/[email protected]/
[3] https://lore.kernel.org/linux-mm/[email protected]/
[4] https://lore.kernel.org/linux-mm/[email protected]/
[5] https://lore.kernel.org/linux-mm/[email protected]/
From: SeongJae Park <[email protected]>
Hello Andrew,
On Wed, 28 Jul 2021 08:36:43 +0000 SeongJae Park <[email protected]> wrote:
[...]
Quoted 6 lines
Now all the patches have at least one 'Reviewed-by:' or 'Acked-by:' tags. We didn't find serious problems since v26[5], which was posted about four months ago. so I'm thinking this patchset has passed the minimum qualification. If you think there are more things to be done before this patchset is merged in the -mm tree or mainline, please let me know. If not, Andrew, I'd like you to consider merging this patchset into '-mm' tree.
I'm wondering if you had a chance to consider that. If you had the chance but this patchset didn't convince you, could you please let me know your concerns so that I can make some progress?
Thanks,
SeongJae Park
[...]
From: SeongJae Park <[email protected]>
Hello Andrew,
Quoted 14 lines · On Mon, 2 Aug 2021 08:24:24 +0000 SeongJae Park <[email protected]> wrote:
From: SeongJae Park <[email protected]>
Hello Andrew,
On Wed, 28 Jul 2021 08:36:43 +0000 SeongJae Park <[email protected]> wrote:
[...]
Quoted 6 lines
Now all the patches have at least one 'Reviewed-by:' or 'Acked-by:' tags. We didn't find serious problems since v26[5], which was posted about four months ago. so I'm thinking this patchset has passed the minimum qualification. If you think there are more things to be done before this patchset is merged in the -mm tree or mainline, please let me know. If not, Andrew, I'd like you to consider merging this patchset into '-mm' tree.
Quoted 3 lines
I'm wondering if you had a chance to consider that. If you had the chance but this patchset didn't convince you, could you please let me know your concerns so that I can make some progress?
Because nearly three weeks passed since this patchset is posted, I considered rebasing it on the latest -mm tree and posting it as v35. But, apparently it makes no much sense because we found nothing to fix or improve. And, this version can still cleanly be applied on top of the latest -mm tree. So, instead of merely increasing the version number, I'd like to describe why I believe this need to be merged into the -mm tree and eventually the mainline.
1. Merging this patchset will not bother other developers
Most changes in this patchset are for DAMON-dedicated new source files. There is a change[1] for existing files, which makes PG_Idle independent of Idle Page Tracking, but it is only small. Therefore, merging this patchset will not increase the complexity of the other parts or introduce a regression.
2. Merging this patchset will not bother other users
DAMON utilizes a mechanism that designed to minimize and limit the monitoring overhead. That said, DAMON can be opt out in the compile time for users who don't want it. Even though it is compiled, it does nothing at all unless a user explicitly asks it to do some works. Therefore, merging this patchset will not silently introduce any additional overhead to users.
3. This patchset is deployed to real users
We are currently using DAMON patchset for profiling production workloads, as described in 'Real-world User Story' section of the cover letter. It is also deployed to real users other than us via Amazon Linux[2,3]. A few companies and several researchers outside Amazon have publicly and/or privately shown their interests in DAMON.
4. The downstream-only maintenance overhead is significant
Following development works based on DAMON[4,5,6] are also ongoing. Because all the works are currently in downstream only, the maintenance overhead is not small for us. Once DAMON is upstreamed, the overhead will significantly be reduced.
5. This patchset is reviewed and apparently is stabilized
Since the first version of DAMON patchset is posted (2020-01-20), it has evolved a lot. All patches of this patchset got at least one 'Reviewed-by:' or 'Acked-by:' tag by v31[7], which have posted about seven weeks ago (2021-06-21). After that, we found and fixed only minor issues. We also got a few more 'Acked-by:' tags. Since v34, which has posted about three weeks ago, we found no more issues. We are also continuously running extensive DAMON-dedicated tests. The tests include unit tests, self tests, functional tests, performance tests, and static code analysis. Some of those are also publicly available[8].
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://github.com/amazonlinux/linux/tree/amazon-5.4.y/master/mm/damon
[3] https://github.com/amazonlinux/linux/tree/amazon-5.10.y/master/mm/damon
[4] https://lore.kernel.org/linux-mm/[email protected]/
[5] https://lore.kernel.org/linux-mm/[email protected]/
[6] https://lore.kernel.org/linux-mm/[email protected]/
[7] https://lore.kernel.org/linux-mm/[email protected]/
[8] https://github.com/awslabs/damon-tests
If you think above explanation makes sense, please consider merging this into the -mm tree. Else, if this doesn't convince you, please let me know your concerns or what I'm missing, so that I can make some progress.
Thanks,
SeongJae Park
[...]
Andrew Morton
maintainerQuoted 15 lines · On Wed, 28 Jul 2021 08:36:43 +0000 SeongJae Park <[email protected]> wrote:
Quoted 6 lines
DAMON does not expose stable APIs at the moment, so these can be changed later if needed. I think it is ok to merge DAMON for some exposure. However I do want to make this clear that the solution space is not complete. The solution of system level monitoring is still needed which can be a future extension to DAMON or more generalized Multigen LRU.
Agreed. We have lots more works to do. Some of those are already posted as RFC patchsets[1,2,3,4]. I promise I will happily do the works. But, how dare could only I get all the fun? I'd like to do that together with others in this great community. One major purpose of this patchset is thus providing a flexible framework for such collaboration. The virtual address space monitoring, which this patchset provides in addition to the framework, is also for real-world usages, though.
Quoted 6 lines
Now all the patches have at least one 'Reviewed-by:' or 'Acked-by:' tags. We didn't find serious problems since v26[5], which was posted about four months ago. so I'm thinking this patchset has passed the minimum qualification. If you think there are more things to be done before this patchset is merged in the -mm tree or mainline, please let me know. If not, Andrew, I'd like you to consider merging this patchset into '-mm' tree.
Shall take a look. With some trepidation.
1-2 years from now someone will pop up with a massive patchset implementing some monitoring scheme and we'll say "why didn't you use DAMON" and they'll say "it's unsuitable for <reasons>".
I would like to see more thought/design go into how DAMON could be modified to address Shakeel's other three requirements. At least to the point where we can confidently say "yes, we will be able to do this". Are you able to drive this discussion along please?
From: SeongJae Park <[email protected]>
Quoted 24 lines · On Thu, 5 Aug 2021 17:03:44 -0700 Andrew Morton <[email protected]>…
Quoted 15 lines · On Wed, 28 Jul 2021 08:36:43 +0000 SeongJae Park <[email protected]> wrote:
Quoted 6 lines
DAMON does not expose stable APIs at the moment, so these can be changed later if needed. I think it is ok to merge DAMON for some exposure. However I do want to make this clear that the solution space is not complete. The solution of system level monitoring is still needed which can be a future extension to DAMON or more generalized Multigen LRU.
Agreed. We have lots more works to do. Some of those are already posted as RFC patchsets[1,2,3,4]. I promise I will happily do the works. But, how dare could only I get all the fun? I'd like to do that together with others in this great community. One major purpose of this patchset is thus providing a flexible framework for such collaboration. The virtual address space monitoring, which this patchset provides in addition to the framework, is also for real-world usages, though.
Quoted 6 lines
Now all the patches have at least one 'Reviewed-by:' or 'Acked-by:' tags. We didn't find serious problems since v26[5], which was posted about four months ago. so I'm thinking this patchset has passed the minimum qualification. If you think there are more things to be done before this patchset is merged in the -mm tree or mainline, please let me know. If not, Andrew, I'd like you to consider merging this patchset into '-mm' tree.
Quoted 5 lines
Shall take a look. With some trepidation.
1-2 years from now someone will pop up with a massive patchset implementing some monitoring scheme and we'll say "why didn't you use DAMON" and they'll say "it's unsuitable for <reasons>".
Agreed. And I personally believe merging this in will help avoiding such situation, because the someone will be able to easily find the developer who is responsible to convince the person. I will happily and definitely do my best for that.
Quoted 5 lines
I would like to see more thought/design go into how DAMON could be modified to address Shakeel's other three requirements. At least to the point where we can confidently say "yes, we will be able to do this". Are you able to drive this discussion along please?
Sure. I will describe my plan for convincing Shakeel's usages in detail as a reply to this mail.
Thanks,
SeongJae Park
From: SeongJae Park <[email protected]>
Quoted 4 lines · On Fri, 6 Aug 2021 11:48:01 +0000 SeongJae Park <[email protected]> wrote:
From: SeongJae Park <[email protected]>
On Thu, 5 Aug 2021 17:03:44 -0700 Andrew Morton <[email protected]> wrote:
[...]
Quoted 8 lines
Quoted 5 lines
I would like to see more thought/design go into how DAMON could be modified to address Shakeel's other three requirements. At least to the point where we can confidently say "yes, we will be able to do this". Are you able to drive this discussion along please?
Sure. I will describe my plan for convincing Shakeel's usages in detail as a reply to this mail.
Shakeel, I am explaining how DAMON will be extended and how it can be used for your usages below. If there is any doubt or question, please feel free to let me know.
What information DAMON (will) provides: contiguity, frequency, and recency
--------------------------------------------------------------------------
DAMON of this patchset informs users which memory region is how frequently accessed. The memory region is a set of contiguous pages which having similar access frequency. In addition to this, a following patch[1] will make DAMON to track how long time the region maintained its size and access frequency. We call this as 'age' of each region. That is, DAMON will be extended to provide three attributes of data access patterns: contiguity (size of each region), frequency, and recency.
Physical Address Space support
------------------------------
This version of DAMON is supporting only virtual address spaces of processes, but will be extended to the physical address space[2]. The extension will be quite simple because DAMON's monitoring primitives layer is separated from its core logic.
How DAMON can be used for Shakeel's usages
------------------------------------------
The usages described in Shakeel's prior mail[1] are:
1) Working set estimation: This is used for cluster level scheduling and controlling the knobs of memory overcommit.
2) Proactive reclaim
3) Balancing between memory tiers: Moving hot pages to fast tiers and cold pages to slow tiers
4) Hugepage optimization: Hot memory backed by hugepages
In addition, these uses are not happening in isolation. We want a combination of these running concurrently on a system. So, it is clear that the first version or step of DAMON which only targets virtual address space monitoring is not sufficient for these use-cases.
DAMON can satisfy all the usages as below.
- working set estimation: This can be done by iterating each region and checking if the access frequency of it is higher than a threshold. Our user space tool provides an implementation[3] for this. Below is a pseudo-code for this:
workingsets = []
working_set_size = 0
for region in regions:
if region.access_frequncy > threshold:
workingsets.append(region)
working_set_size += region.end_address - region.start_address
return workingsets, working_set_size
- proactive reclaim: This can be done by iterating each region while checking if it has zero access frequency and if its age is higher than a time threshold, and reclaim those. We implemented this as a kernel module with only 354 lines of code[4]. Below is a pseudo-code for this:
for region in regions:
if region.access_frquency == 0 and region.age > threshold:
reclaim(region)
- Balancing between memory tiers: Because DAMON provides access frequency, we can know not only idle memory region but cold/cool/warm/hot memory region. Once the functions for migrating pages from a tier to different tier is matured, applying DAMON for this usage will be quite straightforward. That is, for each region, if its access frequency and age is higher than thresholds, migrate pages in the region to faster tier. If its access frequency is lower than a threshold and its age is higher than a threshold, migrate pages in the region to slower tier. Below is a pseudo-code for this:
for region in regions:
if region.age > age_threshod:
if region.access_frequency > hot_threshold:
migrate_to_fast_tier(region)
if region.access_frequency < cold_threshold:
migrate_to_slow_tier(region)
- Hugepage optimization: This will be quite similar to tiers balancing, but we can use the size of regions. That is, we do monitoring of virtual address spaces first. Then, for each region, if its access frequency, age, and size are higher than thresholds (size threshold would be 2MB), makes the region to be backed by huge pages. If the age and size are higher than thresholds but the access frequency is lower than a threshold, makes the huge pages of the region to be backed by regular pages. We evaluated this idea with a prototype[5]. It removed 76.15% of THP memory overheads while preserving 51.25% of THP speedup. Below is a pseudo-code for this:
for region in regions:
if region.age > age_threshod and region.size >= 2 * MB:
if region.access_frequency > hot_threshold:
use_thps_for(region)
if region.access_frequency < cold_threshold:
use_regular_pages_for(region)
- Combination of these running concurrently: DAMON will be extended to be able to monitor both the physical address space and virtual address spaces simultaneously, like below.
struct damon_ctx *ctx_for_virt = damon_new_ctx();
struct damon_ctx *ctx_for_phys = damon_new_ctx();
struct damon_context *ctxs[] = {ctx_for_virt, ctx_for_phys};
[...]
/* first context for physical address space monitoring */
damon_pa_set_primitives(ctx_for_virt);
/* second context for virtual address spaces monitoring */
damon_va_set_primitives(ctx_for_phys);
damon_start(ctxs, 2);Extending for page-granularity monitoring
-----------------------------------------
To my understanding, Shakeel wants to do above with page-granularity monitoring. It will incur inevitable high overhead, but for someone who can afford the cost, I will make DAMON to support it, as below.
Even with DAMON of this patchset, users can do the page-granularity monitoring by simply setting the 'min_nr_regions' and 'max_nr_regions' of DAMON to the number of pages in the target address space (nr_pages). Nevertheless, it will result in creation of 'nr_pages' region structs. Assuming 4K pages, this will result in about 1% memory waste, as each region struct consumes about 44 bytes of memory. Our plan for removal of such overhead is as below.
In a future, the regions abstraction will be able to be entirely opted out[6]. In the case, no region structs will be allocated, so the memory overhead will be zero. Nonetheless, the user will be required to configure DAMON to use a special monitoring primitive which saves the monitoring results such as access frequency and age in somewhere such as their own data structure or page flags, like multi-gen LRU patchset does. If such data structure is commonly usable, we can extend DAMON core to support it. To show how this will work, we implemented a page-granularity idleness monitoring primitive with only 69 lines of code[6].
Also, if someone has ideas for reducing the page granularity monitoring overhead, we can put the optimization in the monitoring primitives layer, which is separated from the core logic.
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://lore.kernel.org/linux-mm/[email protected]/
[3] https://github.com/awslabs/damo/blob/master/wss.py
[4] https://lore.kernel.org/linux-mm/[email protected]/
[5] https://damonitor.github.io/doc/html/latest/vm/damon/eval.html#efficient-thp
[6] https://github.com/sjp38/linux/commit/9e0cb168d30e
[7] https://lore.kernel.org/linux-mm/[email protected]/
Thanks,
SeongJae Park
Quoted 1 line · On Fri, 16 Jul 2021 08:14:36 +0000 SeongJae Park <[email protected]> wrote:
DAMON is a data access monitoring framework for the Linux kernel.
Merged, thanks.
Presumably there are companion userspace tools for DAMON. Are they available? Is there a plan to release and maintain these?
Quoted 5 lines · On Thu, 5 Aug 2021 17:43:24 -0700 Andrew Morton <[email protected]>…
Quoted 1 line · On Fri, 16 Jul 2021 08:14:36 +0000 SeongJae Park <[email protected]> wrote:
DAMON is a data access monitoring framework for the Linux kernel.
Merged, thanks.
Thank you!
Quoted 3 lines
Presumably there are companion userspace tools for DAMON. Are they available? Is there a plan to release and maintain these?
Yes, the userspace tool[1] is available, released under GPLv2, and actively being maintained. I am also planning to implement another basic user interface in perf[2]. Also, the basic test suite for DAMON is available under GPLv2[3].
[1] https://github.com/awslabs/damo
[2] https://lore.kernel.org/linux-mm/[email protected]/
[3] https://github.com/awslabs/damon-tests
Thanks,
SeongJae Park
Andrew Morton
maintainerQuoted 11 lines · On Fri, 6 Aug 2021 11:48:30 +0000 SeongJae Park <[email protected]> wrote:
Quoted 3 lines
Presumably there are companion userspace tools for DAMON. Are they available? Is there a plan to release and maintain these?
Yes, the userspace tool[1] is available, released under GPLv2, and actively being maintained. I am also planning to implement another basic user interface in perf[2]. Also, the basic test suite for DAMON is available under GPLv2[3].
[1] https://github.com/awslabs/damo
[2] https://lore.kernel.org/linux-mm/[email protected]/
[3] https://github.com/awslabs/damon-tests
Ah. Useful info to have in the changelogs! I added the above words to the [0/n] introduction in mm-introduce-data-access-monitor-damon.patch