Commit 2aca2546 authored by SeongJae Park's avatar SeongJae Park Committed by Andrew Morton
Browse files

samples/damon: introduce a skeleton of a smaple DAMON module for proactive reclamation 

DAMON is not only for monitoring of access patterns, but also for
access-aware system operations.  For the system operations, DAMON provides
a feature called DAMOS (Data Access Monitoring-based Operation Schemes). 
There is no sample API usage of DAMOS, though.  Copy the working set size
estimation sample modules with changed names of the module and symbols, to
use it as a skeleton for a sample module showing the DAMOS API usage.  The
following commit will make it proactively reclaim cold memory of the given
process, using DAMOS.

Link: https://lkml.kernel.org/r/20241210215030.85675-5-sj@kernel.org


Signed-off-by: default avatarSeongJae Park <sj@kernel.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 65cc56d0

samples/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -40,3 +40,4 @@ obj-$(CONFIG_SAMPLE_CORESIGHT_SYSCFG) += coresight/ 
obj-$(CONFIG_SAMPLE_FPROBE)		+= fprobe/

obj-$(CONFIG_SAMPLES_RUST)		+= rust/

obj-$(CONFIG_SAMPLE_DAMON_WSSE)		+= damon/

obj-$(CONFIG_SAMPLE_DAMON_PRCL)		+= damon/

samples/damon/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -14,4 +14,17 @@ config SAMPLE_DAMON_WSSE 


	  If unsure, say N.



config SAMPLE_DAMON_PRCL

	bool "DAMON sameple module for access-aware proactive reclamation"

	depends on DAMON && DAMON_VADDR

	help

	  This builds DAMON sample module for access-aware proactive

	  reclamation.



	  The module receives a pid, monitor access to the virtual address

	  space of the process, find memory regions that not accessed, and

	  proactively reclaim the regions.



	  If unsure, say N.



endmenu

samples/damon/Makefile

+1 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0



obj-$(CONFIG_SAMPLE_DAMON_WSSE) += wsse.o

obj-$(CONFIG_SAMPLE_DAMON_PRCL) += prcl.o

samples/damon/prcl.c

0 → 100644
+116 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * proactive reclamation: monitor access pattern of a given process, find

 * regiosn that seems not accessed, and proactively page out the regions.

 */



#define pr_fmt(fmt) "damon_sample_prcl: " fmt



#include <linux/damon.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/module.h>



static int target_pid __read_mostly;

module_param(target_pid, int, 0600);



static int damon_sample_prcl_enable_store(

		const char *val, const struct kernel_param *kp);



static const struct kernel_param_ops enable_param_ops = {

	.set = damon_sample_prcl_enable_store,

	.get = param_get_bool,

};



static bool enable __read_mostly;

module_param_cb(enable, &enable_param_ops, &enable, 0600);

MODULE_PARM_DESC(enable, "Enable of disable DAMON_SAMPLE_WSSE");



static struct damon_ctx *ctx;

static struct pid *target_pidp;



static int damon_sample_prcl_after_aggregate(struct damon_ctx *c)

{

	struct damon_target *t;



	damon_for_each_target(t, c) {

		struct damon_region *r;

		unsigned long wss = 0;



		damon_for_each_region(r, t) {

			if (r->nr_accesses > 0)

				wss += r->ar.end - r->ar.start;

		}

		pr_info("wss: %lu\n", wss);

	}

	return 0;

}



static int damon_sample_prcl_start(void)

{

	struct damon_target *target;



	pr_info("start\n");



	ctx = damon_new_ctx();

	if (!ctx)

		return -ENOMEM;

	if (damon_select_ops(ctx, DAMON_OPS_VADDR)) {

		damon_destroy_ctx(ctx);

		return -EINVAL;

	}



	target = damon_new_target();

	if (!target) {

		damon_destroy_ctx(ctx);

		return -ENOMEM;

	}

	damon_add_target(ctx, target);

	target_pidp = find_get_pid(target_pid);

	if (!target_pidp) {

		damon_destroy_ctx(ctx);

		return -EINVAL;

	}

	target->pid = target_pidp;



	ctx->callback.after_aggregation = damon_sample_prcl_after_aggregate;



	return damon_start(&ctx, 1, true);

}



static void damon_sample_prcl_stop(void)

{

	pr_info("stop\n");

	if (ctx) {

		damon_stop(&ctx, 1);

		damon_destroy_ctx(ctx);

	}

	if (target_pidp)

		put_pid(target_pidp);

}



static int damon_sample_prcl_enable_store(

		const char *val, const struct kernel_param *kp)

{

	bool enabled = enable;

	int err;



	err = kstrtobool(val, &enable);

	if (err)

		return err;



	if (enable == enabled)

		return 0;



	if (enable)

		return damon_sample_prcl_start();

	damon_sample_prcl_stop();

	return 0;

}



static int __init damon_sample_prcl_init(void)

{

	return 0;

}



module_init(damon_sample_prcl_init);