On Wed, 29 Jul 2020 08:31:29 -0700 Shakeel Butt <shakeelb@xxxxxxxxxx> wrote:
> On Sat, Jul 18, 2020 at 6:31 AM SeongJae Park <sjpark@xxxxxxxxxx> wrote:
> >
> > On Fri, 17 Jul 2020 19:47:50 -0700 Shakeel Butt <shakeelb@xxxxxxxxxx> wrote:
> >
> > > On Mon, Jul 13, 2020 at 1:43 AM SeongJae Park <sjpark@xxxxxxxxxx> wrote:
> > > >
> > > > From: SeongJae Park <sjpark@xxxxxxxxx>
> > > >
> > > > DAMON is a data access monitoring framework subsystem for the Linux
> > > > kernel. The core mechanisms of DAMON 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.
> > > >
> > > > This commit is implementing only the stub for the module load/unload,
> > > > basic data structures, and simple manipulation functions of the
> > > > structures to keep the size of commit small. The core mechanisms of
> > > > DAMON will be implemented one by one by following commits.
> > > >
> > > > Signed-off-by: SeongJae Park <sjpark@xxxxxxxxx>
> > > > Reviewed-by: Leonard Foerster <foersleo@xxxxxxxxx>
> > > > Reviewed-by: Varad Gautam <vrd@xxxxxxxxx>
> > > > ---
> > > > include/linux/damon.h | 63 ++++++++++++++
> > > > mm/Kconfig | 12 +++
> > > > mm/Makefile | 1 +
> > > > mm/damon.c | 188 ++++++++++++++++++++++++++++++++++++++++++
> > > > 4 files changed, 264 insertions(+)
> > > > create mode 100644 include/linux/damon.h
> > > > create mode 100644 mm/damon.c
> > > >
> > > > diff --git a/include/linux/damon.h b/include/linux/damon.h
> > > > new file mode 100644
> > > > index 000000000000..c8f8c1c41a45
> > > > --- /dev/null
> > > > +++ b/include/linux/damon.h
> > > > @@ -0,0 +1,63 @@
> > > > +/* SPDX-License-Identifier: GPL-2.0 */
> > > > +/*
> > > > + * DAMON api
> > > > + *
> > > > + * Copyright 2019-2020 Amazon.com, Inc. or its affiliates.
> > > > + *
> > > > + * Author: SeongJae Park <sjpark@xxxxxxxxx>
> > > > + */
> > > > +
> > [...]
> > > > +
> > > > +/**
> > > > + * struct damon_task - Represents a monitoring target task.
> > > > + * @pid: Process id of the task.
> > > > + * @regions_list: Head of the monitoring target regions of this task.
> > > > + * @list: List head for siblings.
> > > > + *
> > > > + * If the monitoring target address space is task independent (e.g., physical
> > > > + * memory address space monitoring), @pid should be '-1'.
> > > > + */
> > > > +struct damon_task {
> > > > + int pid;
> > >
> > > Storing and accessing pid like this is racy. Why not save the "struct
> > > pid" after getting the reference? I am still going over the usage,
> > > maybe storing mm_struct would be an even better choice.
> > >
> > > > + struct list_head regions_list;
> > > > + struct list_head list;
> > > > +};
> > > > +
> > [...]
> > > > +
> > > > +#define damon_get_task_struct(t) \
> > > > + (get_pid_task(find_vpid(t->pid), PIDTYPE_PID))
> > >
> > > You need at least rcu lock around find_vpid(). Also you need to be
> > > careful about the context. If you accept my previous suggestion then
> > > you just need to do this in the process context which is registering
> > > the pid (no need to worry about the pid namespace).
> > >
> > > I am wondering if there should be an interface to register processes
> > > with DAMON using pidfd instead of integer pid.
> >
> > Good points! I will use pidfd for this purpose, instead.
> >
> > BTW, 'struct damon_task' was introduced while DAMON supports only virtual
> > address spaces and recently extended to support physical memory address
> > monitoring case by defining an exceptional pid (-1) for such case. I think it
> > doesn't smoothly fit with the design.
> >
> > Therefore, I would like to change it with more general named struct, e.g.,
> >
> > struct damon_target {
> > void *id;
> > struct list_head regions_list;
> > struct list_head list;
> > };
> >
> > The 'id' field will be able to store or point pid_t, struct mm_struct, struct
> > pid, or anything relevant, depending on the target address space.
> >
> > Only one part of the address space independent logics of DAMON, namely
> > 'kdamon_need_stop()', uses '->pid' of the 'struct damon_task'. It will be
> > introduced by the next patch ("mm/damon: Implement region based sampling").
> > Therefore, the conversion will be easy. For the part, I could add another
> > callback, e.g.,
> >
> > struct damon_ctx {
> > [...]
> > bool (*is_target_valid)(struct damon_target *t);
> > };
> >
> > And let the address space specific primitives to implement this.
> >
> > Then, damon_get_task_struct() and damon_get_mm() will be introduced by the
> > sixth patch ("mm/damon: Implement callbacks for the virtual memory address
> > spaces") as a part of the virtual address space specific primitives
> > implementation.
> >
> > I gonna make the change in the next spin. If you have some opinions on this,
> > please let me know.
> >
> >
>
> Sorry for the late response. I think the general direction you are
> taking is fine but there are still some open questions. I am trying to
> reason if 'address space' is general enough abstraction for different
> types of monitoring targets. It fits well for the 'processes' targets.
Agreed, and that's why I'm planning to make the target as a simple
identifier[1] that independent of the real types of the targets. It will be
interpreted by only the low level primitive implementation. From the core
logic's perspective, it will not be interpreted at all but only required to be
unique among the targets of the monitoring context (damon_ctx). The changed
version will be posted in the next spin.
[1] https://damonitor.github.io/doc/html/next/vm/damon/api.html#c.damon_target
> For the physical memory, the monitoring part of the abstraction (i.e.
> damon_ctx) seems fine but I am not sure about the optimization part
> (i.e. [merge|split]_regions) which raises the question that should the
> merge/split functionality be part of the abstraction.
I would like to argue that the optimization is the core part of DAMON that
makes its difference: It provides _controllable_ tradeoff between the accuracy
and the overhead while doing the best effort for the accuracy. Even on
physical memory space, the logic works well if the memory is not highly
segmented. Even under the significant segmentation, it could provide a sign of
compaction necessity. I also believe compaction and DAMON can complement each
other. Nonetheless, the optimization could be turned off by manipulating the
DAMON's attributes if needed.
>
> I am also very interested in the 'cgroups' as the target and I am not
> sure if 'address space' is the right abstraction for the cgroups as
> well. Well we can think of cgroups as a combination of tasks but
> cgroup also contains unmapped pages. So, maybe it is a combination of
> virtual and physical address space targets damon can monitor but I am
> still not clear how to specify that in the abstractions provided by
> damon.
In this case, because DAMON provides the low level primitives for the virtual
address space and the physical address space itself, the user could simply make
two DAMON contexts, one for the virtual address parts of the processes in the
cgroup and one for physical address part of the cgroup and run those in
parallel.
Or, you could implement another low level primitives for cgroups usecase. If
your usecase is somewhat complex and need some level of optimization, I think
this is the right way. The low level primitive implementation should provide
methods[1] for 1) identifying the target, 2) constructing the monitoring target
address ranges, and 3) checking access of small address ranges in the target
ranges. The implementation for cgroups could 1) use cgroup ids as the target
ids, 2) construct the target address ranges by integrating the address spaces
of the processes in the cgroup and the related physical memory regions (maybe
you could convert every address ranges to physical address), and 3) use page
table walk/rmap and PTE/PMD Accessed bit for the access checking.
[1] https://damonitor.github.io/doc/html/next/vm/damon/design.html#configurable-layers
> Anyways these are the questions for later and we can start
> simple with just processes but I would like to not expose these
> abstractions/interfaces to userspace otherwise it would be really hard
> to change later.
Agreed. For now, DAMON provides three interfaces for the user space. First
and the main one is the debugfs interface[1]. I chose debugfs because it's
relatively easy to change the interface. Second one is tracepoint[2]. It only
provides monitoring time, the target id, and the monitored access frequency of
each region. I believe this is sufficiently abstracted format. Final one is
user space tool[3] written in python. It is only a wrapper of the debugfs
interface. I believe keeping the higher level interface will not be hard.
[1] 9th patch of this series: https://lore.kernel.org/linux-mm/20200713084144.4430-10-sjpark@xxxxxxxxxx/
[2] 8th patch of this series: https://lore.kernel.org/linux-mm/20200713084144.4430-9-sjpark@xxxxxxxxxx/
[3] 10th patch of this series: https://lore.kernel.org/linux-mm/20200713084144.4430-11-sjpark@xxxxxxxxxx/
>
> Another topic I want to discuss is managing/charging the resource
> (cpu) usage of monitoring. Yes, damon with optimization has low cpu
> cost but as the number of targets increase the cpu cost will increase
> which will be in a range which can not be ignored as system overhead.
> At the moment, it seems like there is one kthread doing all the
> monitoring, since we can control the cpu usage of kthreads, it might
> make sense to allow different kthreads for different sets of targets
> (processes in a cgroup).
Each DAMON context is proccessed by one kthread. Therefore, running each of or
a group of targets in dedicated kthread is naturally supported.
Thanks again for the questions. If I misunderstood your points or my answers
are insufficient to understand, please don't hesitate letting me know :)
Thanks,
SeongJae Park
