<!DOCTYPE html>
<html lang="en" data-content_root="../../">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
<title>API Reference — The Linux Kernel documentation</title>
<link rel="stylesheet" type="text/css" href="../../_static/pygments.css?v=fa44fd50" />
<link rel="stylesheet" type="text/css" href="../../_static/alabaster.css?v=3918102e" />
<script src="../../_static/documentation_options.js?v=5929fcd5"></script>
<script src="../../_static/doctools.js?v=9bcbadda"></script>
<script src="../../_static/sphinx_highlight.js?v=dc90522c"></script>
<link rel="index" title="Index" href="../../genindex.html" />
<link rel="search" title="Search" href="../../search.html" />
<link rel="next" title="Free Page Reporting" href="../free_page_reporting.html" />
<link rel="prev" title="DAMON Moniting Interval Parameters Tuning Example" href="monitoring_intervals_tuning_example.html" />
<link rel="stylesheet" href="../../_static/custom.css" type="text/css" />
</head><body>
<div class="document">
<div class="sphinxsidebar" role="navigation" aria-label="Main">
<div class="sphinxsidebarwrapper">
<p class="logo"><a href="../../index.html">
<img class="logo" src="../../_static/logo.svg" alt="Logo of The Linux Kernel"/>
</a></p>
<h1 class="logo"><a href="../../index.html">The Linux Kernel</a></h1>
<p class="blurb">6.18.50</p>
<search id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../../search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" />
</form>
</div>
</search>
<script>document.getElementById('searchbox').style.display = "block"</script>
<p>
<h3 class="kernel-toc-contents">Contents</h3>
<input type="checkbox" class="kernel-toc-toggle" id = "kernel-toc-toggle" checked>
<label class="kernel-toc-title" for="kernel-toc-toggle"></label>
<div class="kerneltoc" id="kerneltoc">
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../process/development-process.html">Development process</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../process/submitting-patches.html">Submitting patches</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../process/code-of-conduct.html">Code of conduct</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../maintainer/index.html">Maintainer handbook</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../process/index.html">All development-process docs</a></li>
</ul>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../../core-api/index.html">Core API</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../driver-api/index.html">Driver APIs</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="../../subsystem-apis.html">Subsystems</a><ul class="current">
<li class="toctree-l2 current"><a class="reference internal" href="../../subsystem-apis.html#core-subsystems">Core subsystems</a><ul class="current">
<li class="toctree-l3"><a class="reference internal" href="../../core-api/index.html">Core API Documentation</a></li>
<li class="toctree-l3"><a class="reference internal" href="../../driver-api/index.html">Driver implementer’s API guide</a></li>
<li class="toctree-l3 current"><a class="reference internal" href="../index.html">Memory Management Documentation</a></li>
<li class="toctree-l3"><a class="reference internal" href="../../power/index.html">Power Management</a></li>
<li class="toctree-l3"><a class="reference internal" href="../../scheduler/index.html">Scheduler</a></li>
<li class="toctree-l3"><a class="reference internal" href="../../timers/index.html">Timers</a></li>
<li class="toctree-l3"><a class="reference internal" href="../../locking/index.html">Locking</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../../subsystem-apis.html#human-interfaces">Human interfaces</a></li>
<li class="toctree-l2"><a class="reference internal" href="../../subsystem-apis.html#networking-interfaces">Networking interfaces</a></li>
<li class="toctree-l2"><a class="reference internal" href="../../subsystem-apis.html#storage-interfaces">Storage interfaces</a></li>
<li class="toctree-l2"><a class="reference internal" href="../../subsystem-apis.html#other-subsystems">Other subsystems</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../../locking/index.html">Locking</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../process/license-rules.html">Licensing rules</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../doc-guide/index.html">Writing documentation</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../dev-tools/index.html">Development tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../dev-tools/testing-overview.html">Testing guide</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../kernel-hacking/index.html">Hacking guide</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../trace/index.html">Tracing</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../fault-injection/index.html">Fault injection</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../livepatch/index.html">Livepatching</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../rust/index.html">Rust</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../admin-guide/index.html">Administration</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../kbuild/index.html">Build system</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../admin-guide/reporting-issues.html">Reporting issues</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../tools/index.html">Userspace tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../userspace-api/index.html">Userspace API</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../firmware-guide/index.html">Firmware</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../devicetree/index.html">Firmware and Devicetree</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../arch/index.html">CPU architectures</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../staging/index.html">Unsorted documentation</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../translations/index.html">Translations</a></li>
</ul>
</div>
<script type="text/javascript"> <!--
var sbar = document.getElementsByClassName("sphinxsidebar")[0];
let currents = document.getElementsByClassName("current")
if (currents.length) {
sbar.scrollTop = currents[currents.length - 1].offsetTop;
}
--> </script>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../../_sources/mm/damon/api.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
</div>
</div>
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="language-selection">
English
<ul>
<li><a href="../../translations/zh_CN/mm/damon/api.html">Chinese (Simplified)</a></li>
</ul>
</div>
<section id="api-reference">
<h1>API Reference<a class="headerlink" href="#api-reference" title="Link to this heading">¶</a></h1>
<p>Kernel space programs can use every feature of DAMON using below APIs. All you
need to do is including <code class="docutils literal notranslate"><span class="pre">damon.h</span></code>, which is located in <code class="docutils literal notranslate"><span class="pre">include/linux/</span></code> of
the source tree.</p>
<section id="structures">
<h2>Structures<a class="headerlink" href="#structures" title="Link to this heading">¶</a></h2>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_addr_range">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_addr_range</span></span></span><a class="headerlink" href="#c.damon_addr_range" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents an address region of [<strong>start</strong>, <strong>end</strong>).</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_addr_range {
unsigned long start;
unsigned long end;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">start</span></code></dt><dd><p>Start address of the region (inclusive).</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">end</span></code></dt><dd><p>End address of the region (exclusive).</p>
</dd>
</dl>
</div>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_size_range">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_size_range</span></span></span><a class="headerlink" href="#c.damon_size_range" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents size for filter to operate on [<strong>min</strong>, <strong>max</strong>].</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_size_range {
unsigned long min;
unsigned long max;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">min</span></code></dt><dd><p>Min size (inclusive).</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">max</span></code></dt><dd><p>Max size (inclusive).</p>
</dd>
</dl>
</div>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_region">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_region</span></span></span><a class="headerlink" href="#c.damon_region" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents a monitoring target region.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_region {
struct damon_addr_range ar;
unsigned long sampling_addr;
unsigned int nr_accesses;
unsigned int nr_accesses_bp;
struct list_head list;
unsigned int age;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">ar</span></code></dt><dd><p>The address range of the region.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">sampling_addr</span></code></dt><dd><p>Address of the sample for the next access check.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">nr_accesses</span></code></dt><dd><p>Access frequency of this region.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">nr_accesses_bp</span></code></dt><dd><p><strong>nr_accesses</strong> in basis point (0.01%) that updated for
each sampling interval.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">list</span></code></dt><dd><p>List head for siblings.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">age</span></code></dt><dd><p>Age of this region.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p><strong>nr_accesses</strong> is reset to zero for every <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->aggr_interval</span></code></a> and be
increased for every <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->sample_interval</span></code></a> if an access to the region
during the last sampling interval is found. The update of this field should
not be done with direct access but with the helper function,
<a class="reference internal" href="#c.damon_update_region_access_rate" title="damon_update_region_access_rate"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_update_region_access_rate()</span></code></a>.</p>
<p><strong>nr_accesses_bp</strong> is another representation of <strong>nr_accesses</strong> in basis point
(1 in 10,000) that updated for every <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->sample_interval</span></code></a> in a
manner similar to moving sum. By the algorithm, this value becomes
<strong>nr_accesses</strong> * 10000 for every <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_attrs</span></code></a>->aggr_interval. This can
be used when the aggregation interval is too huge and therefore cannot wait
for it before getting the access monitoring results.</p>
<p><strong>age</strong> is initially zero, increased for each aggregation interval, and reset
to zero again if the access frequency is significantly changed. If two
regions are merged into a new region, both <strong>nr_accesses</strong> and <strong>age</strong> of the new
region are set as region size-weighted average of those of the two regions.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_target">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_target</span></span></span><a class="headerlink" href="#c.damon_target" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents a monitoring target.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_target {
struct pid *pid;
unsigned int nr_regions;
struct list_head regions_list;
struct list_head list;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">pid</span></code></dt><dd><p>The PID of the virtual address space to monitor.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">nr_regions</span></code></dt><dd><p>Number of monitoring target regions of this target.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">regions_list</span></code></dt><dd><p>Head of the monitoring target regions of this target.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">list</span></code></dt><dd><p>List head for siblings.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>Each monitoring context could have multiple targets. For example, a context
for virtual memory address spaces could have multiple target processes. The
<strong>pid</strong> should be set for appropriate <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a> including the
virtual address spaces monitoring operations.</p>
<dl class="c enum">
<dt class="sig sig-object c" id="c.damos_action">
<span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_action</span></span></span><a class="headerlink" href="#c.damos_action" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents an action of a Data Access Monitoring-based Operation Scheme.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Constants</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_WILLNEED</span></code></dt><dd><p>Call <code class="docutils literal notranslate"><span class="pre">madvise()</span></code> for the region with MADV_WILLNEED.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_COLD</span></code></dt><dd><p>Call <code class="docutils literal notranslate"><span class="pre">madvise()</span></code> for the region with MADV_COLD.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_PAGEOUT</span></code></dt><dd><p>Reclaim the region.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_HUGEPAGE</span></code></dt><dd><p>Call <code class="docutils literal notranslate"><span class="pre">madvise()</span></code> for the region with MADV_HUGEPAGE.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_NOHUGEPAGE</span></code></dt><dd><p>Call <code class="docutils literal notranslate"><span class="pre">madvise()</span></code> for the region with MADV_NOHUGEPAGE.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_LRU_PRIO</span></code></dt><dd><p>Prioritize the region on its LRU lists.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_LRU_DEPRIO</span></code></dt><dd><p>Deprioritize the region on its LRU lists.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_MIGRATE_HOT</span></code></dt><dd><p>Migrate the regions prioritizing warmer regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_MIGRATE_COLD</span></code></dt><dd><p>Migrate the regions prioritizing colder regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_STAT</span></code></dt><dd><p>Do nothing but count the stat.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">NR_DAMOS_ACTIONS</span></code></dt><dd><p>Total number of DAMOS actions</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>The support of each action is up to running <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>.
Refer to ‘Operation Action’ section of <a class="reference internal" href="design.html"><span class="doc">Design</span></a> for
status of the supports.</p>
<p>Note that DAMOS_PAGEOUT doesn’t trigger demotions.</p>
<dl class="c enum">
<dt class="sig sig-object c" id="c.damos_quota_goal_metric">
<span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_quota_goal_metric</span></span></span><a class="headerlink" href="#c.damos_quota_goal_metric" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents the metric to be used as the goal</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Constants</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_QUOTA_USER_INPUT</span></code></dt><dd><p>User-input value.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_QUOTA_SOME_MEM_PSI_US</span></code></dt><dd><p>System level some memory PSI in us.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_QUOTA_NODE_MEM_USED_BP</span></code></dt><dd><p>MemUsed ratio of a node.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_QUOTA_NODE_MEM_FREE_BP</span></code></dt><dd><p>MemFree ratio of a node.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">NR_DAMOS_QUOTA_GOAL_METRICS</span></code></dt><dd><p>Number of DAMOS quota goal metrics.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>Metrics equal to larger than <strong>NR_DAMOS_QUOTA_GOAL_METRICS</strong> are unsupported.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_quota_goal">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_quota_goal</span></span></span><a class="headerlink" href="#c.damos_quota_goal" title="Link to this definition">¶</a><br /></dt>
<dd><p>DAMOS scheme quota auto-tuning goal.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_quota_goal {
enum damos_quota_goal_metric metric;
unsigned long target_value;
unsigned long current_value;
union {
u64 last_psi_total;
int nid;
};
struct list_head list;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">metric</span></code></dt><dd><p>Metric to be used for representing the goal.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">target_value</span></code></dt><dd><p>Target value of <strong>metric</strong> to achieve with the tuning.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">current_value</span></code></dt><dd><p>Current value of <strong>metric</strong>.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">{unnamed_union}</span></code></dt><dd><p>anonymous</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">last_psi_total</span></code></dt><dd><p>Last measured total PSI</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">nid</span></code></dt><dd><p>Node id.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">list</span></code></dt><dd><p>List head for siblings.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>Data structure for getting the current score of the quota tuning goal. The
score is calculated by how close <strong>current_value</strong> and <strong>target_value</strong> are. Then
the score is entered to DAMON’s internal feedback loop mechanism to get the
auto-tuned quota.</p>
<p>If <strong>metric</strong> is DAMOS_QUOTA_USER_INPUT, <strong>current_value</strong> should be manually
entered by the user, probably inside the kdamond callbacks. Otherwise,
DAMON sets <strong>current_value</strong> with self-measured value of <strong>metric</strong>.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_quota">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_quota</span></span></span><a class="headerlink" href="#c.damos_quota" title="Link to this definition">¶</a><br /></dt>
<dd><p>Controls the aggressiveness of the given scheme.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_quota {
unsigned long reset_interval;
unsigned long ms;
unsigned long sz;
struct list_head goals;
unsigned long esz;
unsigned int weight_sz;
unsigned int weight_nr_accesses;
unsigned int weight_age;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">reset_interval</span></code></dt><dd><p>Charge reset interval in milliseconds.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">ms</span></code></dt><dd><p>Maximum milliseconds that the scheme can use.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">sz</span></code></dt><dd><p>Maximum bytes of memory that the action can be applied.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">goals</span></code></dt><dd><p>Head of quota tuning goals (<a class="reference internal" href="#c.damos_quota_goal" title="damos_quota_goal"><code class="xref c c-type docutils literal notranslate"><span class="pre">damos_quota_goal</span></code></a>) list.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">esz</span></code></dt><dd><p>Effective size quota in bytes.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">weight_sz</span></code></dt><dd><p>Weight of the region’s size for prioritization.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">weight_nr_accesses</span></code></dt><dd><p>Weight of the region’s nr_accesses for prioritization.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">weight_age</span></code></dt><dd><p>Weight of the region’s age for prioritization.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>To avoid consuming too much CPU time or IO resources for applying the
<a class="reference internal" href="#c.damos" title="damos"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos</span></code></a>->action to large memory, DAMON allows users to set time and/or
size quotas. The quotas can be set by writing non-zero values to <code class="xref c c-type docutils literal notranslate"><span class="pre">ms</span></code> and
<code class="xref c c-type docutils literal notranslate"><span class="pre">sz</span></code>, respectively. If the time quota is set, DAMON tries to use only up to
<code class="xref c c-type docutils literal notranslate"><span class="pre">ms</span></code> milliseconds within <code class="xref c c-type docutils literal notranslate"><span class="pre">reset_interval</span></code> for applying the action. If the
size quota is set, DAMON tries to apply the action only up to <code class="xref c c-type docutils literal notranslate"><span class="pre">sz</span></code> bytes
within <code class="xref c c-type docutils literal notranslate"><span class="pre">reset_interval</span></code>.</p>
<p>To convince the different types of quotas and goals, DAMON internally
converts those into one single size quota called “effective quota”. DAMON
internally uses it as the only one real quota. The conversion is made as
follows.</p>
<p>The time quota is transformed to a size quota using estimated throughput of
the scheme’s action. DAMON then compares it against <code class="xref c c-type docutils literal notranslate"><span class="pre">sz</span></code> and uses smaller
one as the effective quota.</p>
<p>If <strong>goals</strong> is not empty, DAMON calculates yet another size quota based on the
goals using its internal feedback loop algorithm, for every <strong>reset_interval</strong>.
Then, if the new size quota is smaller than the effective quota, it uses the
new size quota as the effective quota.</p>
<p>The resulting effective size quota in bytes is set to <strong>esz</strong>.</p>
<p>For selecting regions within the quota, DAMON prioritizes current scheme’s
target memory regions using the <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>->get_scheme_score.
You could customize the prioritization logic by setting <code class="xref c c-type docutils literal notranslate"><span class="pre">weight_sz</span></code>,
<code class="xref c c-type docutils literal notranslate"><span class="pre">weight_nr_accesses</span></code>, and <code class="xref c c-type docutils literal notranslate"><span class="pre">weight_age</span></code>, because monitoring operations are
encouraged to respect those.</p>
<dl class="c enum">
<dt class="sig sig-object c" id="c.damos_wmark_metric">
<span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_wmark_metric</span></span></span><a class="headerlink" href="#c.damos_wmark_metric" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents the watermark metric.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Constants</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_WMARK_NONE</span></code></dt><dd><p>Ignore the watermarks of the given scheme.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_WMARK_FREE_MEM_RATE</span></code></dt><dd><p>Free memory rate of the system in [0,1000].</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">NR_DAMOS_WMARK_METRICS</span></code></dt><dd><p>Total number of DAMOS watermark metrics</p>
</dd>
</dl>
</div>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_watermarks">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_watermarks</span></span></span><a class="headerlink" href="#c.damos_watermarks" title="Link to this definition">¶</a><br /></dt>
<dd><p>Controls when a given scheme should be activated.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_watermarks {
enum damos_wmark_metric metric;
unsigned long interval;
unsigned long high;
unsigned long mid;
unsigned long low;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">metric</span></code></dt><dd><p>Metric for the watermarks.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">interval</span></code></dt><dd><p>Watermarks check time interval in microseconds.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">high</span></code></dt><dd><p>High watermark.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">mid</span></code></dt><dd><p>Middle watermark.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">low</span></code></dt><dd><p>Low watermark.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>If <code class="xref c c-type docutils literal notranslate"><span class="pre">metric</span></code> is <code class="xref c c-type docutils literal notranslate"><span class="pre">DAMOS_WMARK_NONE</span></code>, the scheme is always active. Being active
means DAMON does monitoring and applying the action of the scheme to
appropriate memory regions. Else, DAMON checks <code class="xref c c-type docutils literal notranslate"><span class="pre">metric</span></code> of the system for at
least every <code class="xref c c-type docutils literal notranslate"><span class="pre">interval</span></code> microseconds and works as below.</p>
<p>If <code class="xref c c-type docutils literal notranslate"><span class="pre">metric</span></code> is higher than <code class="xref c c-type docutils literal notranslate"><span class="pre">high</span></code>, the scheme is inactivated. If <code class="xref c c-type docutils literal notranslate"><span class="pre">metric</span></code> is
between <code class="xref c c-type docutils literal notranslate"><span class="pre">mid</span></code> and <code class="xref c c-type docutils literal notranslate"><span class="pre">low</span></code>, the scheme is activated. If <code class="xref c c-type docutils literal notranslate"><span class="pre">metric</span></code> is lower than
<code class="xref c c-type docutils literal notranslate"><span class="pre">low</span></code>, the scheme is inactivated.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_stat">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_stat</span></span></span><a class="headerlink" href="#c.damos_stat" title="Link to this definition">¶</a><br /></dt>
<dd><p>Statistics on a given scheme.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_stat {
unsigned long nr_tried;
unsigned long sz_tried;
unsigned long nr_applied;
unsigned long sz_applied;
unsigned long sz_ops_filter_passed;
unsigned long qt_exceeds;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">nr_tried</span></code></dt><dd><p>Total number of regions that the scheme is tried to be applied.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">sz_tried</span></code></dt><dd><p>Total size of regions that the scheme is tried to be applied.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">nr_applied</span></code></dt><dd><p>Total number of regions that the scheme is applied.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">sz_applied</span></code></dt><dd><p>Total size of regions that the scheme is applied.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">sz_ops_filter_passed</span></code></dt><dd><p>Total bytes that passed ops layer-handled DAMOS filters.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">qt_exceeds</span></code></dt><dd><p>Total number of times the quota of the scheme has exceeded.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>“Tried an action to a region” in this context means the DAMOS core logic
determined the region as eligible to apply the action. The access pattern
(<a class="reference internal" href="#c.damos_access_pattern" title="damos_access_pattern"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_access_pattern</span></code></a>), quotas (<a class="reference internal" href="#c.damos_quota" title="damos_quota"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_quota</span></code></a>), watermarks
(<a class="reference internal" href="#c.damos_watermarks" title="damos_watermarks"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_watermarks</span></code></a>) and filters (<a class="reference internal" href="#c.damos_filter" title="damos_filter"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_filter</span></code></a>) that handled
on core logic can affect this. The core logic asks the operation set
(<a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>) to apply the action to the region.</p>
<p>“Applied an action to a region” in this context means the operation set
(<a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>) successfully applied the action to the region, at
least to a part of the region. The filters (<a class="reference internal" href="#c.damos_filter" title="damos_filter"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_filter</span></code></a>) that
handled on operation set layer and type of the action and pages of the
region can affect this. For example, if a filter is set to exclude
anonymous pages and the region has only anonymous pages, the region will be
failed at applying the action. If the action is <code class="xref c c-type docutils literal notranslate"><span class="pre">DAMOS_PAGEOUT</span></code> and all
pages of the region are already paged out, the region will be failed at
applying the action.</p>
<dl class="c enum">
<dt class="sig sig-object c" id="c.damos_filter_type">
<span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_filter_type</span></span></span><a class="headerlink" href="#c.damos_filter_type" title="Link to this definition">¶</a><br /></dt>
<dd><p>Type of memory for <a class="reference internal" href="#c.damos_filter" title="damos_filter"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_filter</span></code></a></p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Constants</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_ANON</span></code></dt><dd><p>Anonymous pages.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_ACTIVE</span></code></dt><dd><p>Active pages.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_MEMCG</span></code></dt><dd><p>Specific memcg’s pages.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_YOUNG</span></code></dt><dd><p>Recently accessed pages.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_HUGEPAGE_SIZE</span></code></dt><dd><p>Page is part of a hugepage.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_UNMAPPED</span></code></dt><dd><p>Unmapped pages.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_ADDR</span></code></dt><dd><p>Address range.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMOS_FILTER_TYPE_TARGET</span></code></dt><dd><p>Data Access Monitoring target.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">NR_DAMOS_FILTER_TYPES</span></code></dt><dd><p>Number of filter types.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>The anon pages type and memcg type filters are handled by underlying
<a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a> as a part of scheme action trying, and therefore
accounted as ‘tried’. In contrast, other types are handled by core layer
before trying of the action and therefore not accounted as ‘tried’.</p>
<p>The support of the filters that handled by <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a> depend
on the running <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>.
<code class="xref c c-type docutils literal notranslate"><span class="pre">enum</span> <span class="pre">DAMON_OPS_PADDR</span></code> supports both anon pages type and memcg type filters,
while <code class="xref c c-type docutils literal notranslate"><span class="pre">enum</span> <span class="pre">DAMON_OPS_VADDR</span></code> and <code class="xref c c-type docutils literal notranslate"><span class="pre">enum</span> <span class="pre">DAMON_OPS_FVADDR</span></code> don’t support any of
the two types.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_filter">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_filter</span></span></span><a class="headerlink" href="#c.damos_filter" title="Link to this definition">¶</a><br /></dt>
<dd><p>DAMOS action target memory filter.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_filter {
enum damos_filter_type type;
bool matching;
bool allow;
union {
unsigned short memcg_id;
struct damon_addr_range addr_range;
int target_idx;
struct damon_size_range sz_range;
};
struct list_head list;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">type</span></code></dt><dd><p>Type of the target memory.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">matching</span></code></dt><dd><p>Whether this is for <strong>type</strong>-matching memory.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">allow</span></code></dt><dd><p>Whether to include or exclude the <strong>matching</strong> memory.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">{unnamed_union}</span></code></dt><dd><p>anonymous</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">memcg_id</span></code></dt><dd><p>Memcg id of the question if <strong>type</strong> is DAMOS_FILTER_MEMCG.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">addr_range</span></code></dt><dd><p>Address range if <strong>type</strong> is DAMOS_FILTER_TYPE_ADDR.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">target_idx</span></code></dt><dd><p>Index of the <a class="reference internal" href="#c.damon_target" title="damon_target"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_target</span></code></a> of
<a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_ctx->adaptive_targets</span></code></a> if <strong>type</strong> is
DAMOS_FILTER_TYPE_TARGET.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">sz_range</span></code></dt><dd><p>Size range if <strong>type</strong> is DAMOS_FILTER_TYPE_HUGEPAGE_SIZE.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">list</span></code></dt><dd><p>List head for siblings.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>Before applying the <a class="reference internal" href="#c.damos" title="damos"><code class="xref c c-type docutils literal notranslate"><span class="pre">damos->action</span></code></a> to a memory region, DAMOS checks if each
byte of the region matches to this given condition and avoid applying the
action if so. Support of each filter type depends on the running <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span>
<span class="pre">damon_operations</span></code></a> and the type. Refer to <a class="reference internal" href="#c.damos_filter_type" title="damos_filter_type"><code class="xref c c-type docutils literal notranslate"><span class="pre">enum</span> <span class="pre">damos_filter_type</span></code></a> for more
details.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_walk_control">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_walk_control</span></span></span><a class="headerlink" href="#c.damos_walk_control" title="Link to this definition">¶</a><br /></dt>
<dd><p>Control <a class="reference internal" href="#c.damos_walk" title="damos_walk"><code class="xref c c-func docutils literal notranslate"><span class="pre">damos_walk()</span></code></a>.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_walk_control {
void (*walk_fn)(void *data, struct damon_ctx *ctx, struct damon_target *t, struct damon_region *r, struct damos *s, unsigned long sz_filter_passed);
void *data;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">walk_fn</span></code></dt><dd><p>Function to be called back for each region.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">data</span></code></dt><dd><p>Data that will be passed to walk functions.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>Control <a class="reference internal" href="#c.damos_walk" title="damos_walk"><code class="xref c c-func docutils literal notranslate"><span class="pre">damos_walk()</span></code></a>, which requests specific kdamond to invoke the given
function to each region that eligible to apply actions of the kdamond’s
schemes. Refer to <a class="reference internal" href="#c.damos_walk" title="damos_walk"><code class="xref c c-func docutils literal notranslate"><span class="pre">damos_walk()</span></code></a> for more details.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_access_pattern">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_access_pattern</span></span></span><a class="headerlink" href="#c.damos_access_pattern" title="Link to this definition">¶</a><br /></dt>
<dd><p>Target access pattern of the given scheme.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_access_pattern {
unsigned long min_sz_region;
unsigned long max_sz_region;
unsigned int min_nr_accesses;
unsigned int max_nr_accesses;
unsigned int min_age_region;
unsigned int max_age_region;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">min_sz_region</span></code></dt><dd><p>Minimum size of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">max_sz_region</span></code></dt><dd><p>Maximum size of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">min_nr_accesses</span></code></dt><dd><p>Minimum <code class="docutils literal notranslate"><span class="pre">->nr_accesses</span></code> of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">max_nr_accesses</span></code></dt><dd><p>Maximum <code class="docutils literal notranslate"><span class="pre">->nr_accesses</span></code> of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">min_age_region</span></code></dt><dd><p>Minimum age of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">max_age_region</span></code></dt><dd><p>Maximum age of target regions.</p>
</dd>
</dl>
</div>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos_migrate_dests">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_migrate_dests</span></span></span><a class="headerlink" href="#c.damos_migrate_dests" title="Link to this definition">¶</a><br /></dt>
<dd><p>Migration destination nodes and their weights.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos_migrate_dests {
unsigned int *node_id_arr;
unsigned int *weight_arr;
size_t nr_dests;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">node_id_arr</span></code></dt><dd><p>Array of migration destination node ids.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">weight_arr</span></code></dt><dd><p>Array of migration weights for <strong>node_id_arr</strong>.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">nr_dests</span></code></dt><dd><p>Length of the <strong>node_id_arr</strong> and <strong>weight_arr</strong> arrays.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p><strong>node_id_arr</strong> is an array of the ids of migration destination nodes.
<strong>weight_arr</strong> is an array of the weights for those. The weights in
<strong>weight_arr</strong> are for nodes in <strong>node_id_arr</strong> of same array index.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damos">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos</span></span></span><a class="headerlink" href="#c.damos" title="Link to this definition">¶</a><br /></dt>
<dd><p>Represents a Data Access Monitoring-based Operation Scheme.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damos {
struct damos_access_pattern pattern;
enum damos_action action;
unsigned long apply_interval_us;
struct damos_quota quota;
struct damos_watermarks wmarks;
union {
struct {
int target_nid;
struct damos_migrate_dests migrate_dests;
};
};
struct list_head filters;
struct list_head ops_filters;
void *last_applied;
struct damos_stat stat;
struct list_head list;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">pattern</span></code></dt><dd><p>Access pattern of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">action</span></code></dt><dd><p><a class="reference internal" href="#c.damos_action" title="damos_action"><code class="xref c c-type docutils literal notranslate"><span class="pre">damos_action</span></code></a> to be applied to the target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">apply_interval_us</span></code></dt><dd><p>The time between applying the <strong>action</strong>.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">quota</span></code></dt><dd><p>Control the aggressiveness of this scheme.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">wmarks</span></code></dt><dd><p>Watermarks for automated (in)activation of this scheme.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">{unnamed_union}</span></code></dt><dd><p>anonymous</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">{unnamed_struct}</span></code></dt><dd><p>anonymous</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">target_nid</span></code></dt><dd><p>Destination node if <strong>action</strong> is “migrate_{hot,cold}”.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">migrate_dests</span></code></dt><dd><p>Destination nodes if <strong>action</strong> is “migrate_{hot,cold}”.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">filters</span></code></dt><dd><p>Additional set of <a class="reference internal" href="#c.damos_filter" title="damos_filter"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_filter</span></code></a> for <code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code>.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">ops_filters</span></code></dt><dd><p>ops layer handling <a class="reference internal" href="#c.damos_filter" title="damos_filter"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_filter</span></code></a> objects list.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">last_applied</span></code></dt><dd><p>Last <strong>action</strong> applied ops-managing entity.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">stat</span></code></dt><dd><p>Statistics of this scheme.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">list</span></code></dt><dd><p>List head for siblings.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>For each <strong>apply_interval_us</strong>, DAMON finds regions which fit in the
<code class="xref c c-type docutils literal notranslate"><span class="pre">pattern</span></code> and applies <code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code> to those. To avoid consuming too much
CPU time or IO resources for the <code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code>, <code class="xref c c-type docutils literal notranslate"><span class="pre">quota</span></code> is used.</p>
<p>If <strong>apply_interval_us</strong> is zero, <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->aggr_interval</span></code></a> is used instead.</p>
<p>To do the work only when needed, schemes can be activated for specific
system situations using <code class="xref c c-type docutils literal notranslate"><span class="pre">wmarks</span></code>. If all schemes that registered to the
monitoring context are inactive, DAMON stops monitoring either, and just
repeatedly checks the watermarks.</p>
<p><strong>migrate_dests</strong> specifies multiple migration target nodes with different
weights for migrate_hot or migrate_cold actions. <strong>target_nid</strong> is ignored if
this is set.</p>
<p><strong>target_nid</strong> is used to set the migration target node for migrate_hot or
migrate_cold actions, and <strong>migrate_dests</strong> is unset.</p>
<p>Before applying the <code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code> to a memory region, <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>
implementation could check pages of the region and skip <code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code> to respect
<code class="xref c c-type docutils literal notranslate"><span class="pre">filters</span></code></p>
<p>The minimum entity that <strong>action</strong> can be applied depends on the underlying
<a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a>. Since it may not be aligned with the core layer
abstract, namely <a class="reference internal" href="#c.damon_region" title="damon_region"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_region</span></code></a>, <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a> could apply
<strong>action</strong> to same entity multiple times. Large folios that underlying on
multiple <code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon</span></code> region objects could be such examples. The <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span>
<span class="pre">damon_operations</span></code></a> can use <strong>last_applied</strong> to avoid that. DAMOS core logic
unsets <strong>last_applied</strong> when each regions walking for applying the scheme is
finished.</p>
<p>After applying the <code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code> to each region, <code class="xref c c-type docutils literal notranslate"><span class="pre">stat_count</span></code> and <code class="xref c c-type docutils literal notranslate"><span class="pre">stat_sz</span></code> is
updated to reflect the number of regions and total size of regions that the
<code class="xref c c-type docutils literal notranslate"><span class="pre">action</span></code> is applied.</p>
<dl class="c enum">
<dt class="sig sig-object c" id="c.damon_ops_id">
<span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_ops_id</span></span></span><a class="headerlink" href="#c.damon_ops_id" title="Link to this definition">¶</a><br /></dt>
<dd><p>Identifier for each monitoring operations implementation</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Constants</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">DAMON_OPS_VADDR</span></code></dt><dd><p>Monitoring operations for virtual address spaces</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMON_OPS_FVADDR</span></code></dt><dd><p>Monitoring operations for only fixed ranges of virtual
address spaces</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">DAMON_OPS_PADDR</span></code></dt><dd><p>Monitoring operations for the physical address space</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">NR_DAMON_OPS</span></code></dt><dd><p>Number of monitoring operations implementations</p>
</dd>
</dl>
</div>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_operations">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_operations</span></span></span><a class="headerlink" href="#c.damon_operations" title="Link to this definition">¶</a><br /></dt>
<dd><p>Monitoring operations for given use cases.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_operations {
enum damon_ops_id id;
void (*init)(struct damon_ctx *context);
void (*update)(struct damon_ctx *context);
void (*prepare_access_checks)(struct damon_ctx *context);
unsigned int (*check_accesses)(struct damon_ctx *context);
int (*get_scheme_score)(struct damon_ctx *context, struct damon_target *t, struct damon_region *r, struct damos *scheme);
unsigned long (*apply_scheme)(struct damon_ctx *context, struct damon_target *t, struct damon_region *r, struct damos *scheme, unsigned long *sz_filter_passed);
bool (*target_valid)(struct damon_target *t);
void (*cleanup_target)(struct damon_target *t);
void (*cleanup)(struct damon_ctx *context);
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">id</span></code></dt><dd><p>Identifier of this operations set.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">init</span></code></dt><dd><p>Initialize operations-related data structures.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">update</span></code></dt><dd><p>Update operations-related data structures.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">prepare_access_checks</span></code></dt><dd><p>Prepare next access check of target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">check_accesses</span></code></dt><dd><p>Check the accesses to target regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">get_scheme_score</span></code></dt><dd><p>Get the score of a region for a scheme.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">apply_scheme</span></code></dt><dd><p>Apply a DAMON-based operation scheme.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">target_valid</span></code></dt><dd><p>Determine if the target is valid.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">cleanup_target</span></code></dt><dd><p>Clean up each target before deallocation.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">cleanup</span></code></dt><dd><p>Clean up the context.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>DAMON can be extended for various address spaces and usages. For this,
users should register the low level operations for their target address
space and usecase via the <a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_ctx.ops</span></code></a>. Then, the monitoring thread
(<a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_ctx.kdamond</span></code></a>) calls <strong>init</strong> and <strong>prepare_access_checks</strong> before starting
the monitoring, <strong>update</strong> after each <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs.ops_update_interval</span></code></a>, and
<strong>check_accesses</strong>, <strong>target_valid</strong> and <strong>prepare_access_checks</strong> after each
<a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs.sample_interval</span></code></a>.</p>
<p>Each <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a> instance having valid <strong>id</strong> can be registered
via <a class="reference internal" href="#c.damon_register_ops" title="damon_register_ops"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_register_ops()</span></code></a> and selected by <a class="reference internal" href="#c.damon_select_ops" title="damon_select_ops"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_select_ops()</span></code></a> later.
<strong>init</strong> should initialize operations-related data structures. For example,
this could be used to construct proper monitoring target regions and link
those to <strong>damon_ctx.adaptive_targets</strong>.
<strong>update</strong> should update the operations-related data structures. For example,
this could be used to update monitoring target regions for current status.
<strong>prepare_access_checks</strong> should manipulate the monitoring regions to be
prepared for the next access check.
<strong>check_accesses</strong> 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.
<strong>get_scheme_score</strong> should return the priority score of a region for a scheme
as an integer in [0, <code class="xref c c-type docutils literal notranslate"><span class="pre">DAMOS_MAX_SCORE</span></code>].
<strong>apply_scheme</strong> is called from <strong>kdamond</strong> when a region for user provided
DAMON-based operation scheme is found. It should apply the scheme’s action
to the region and return bytes of the region that the action is successfully
applied. It should also report how many bytes of the region has passed
filters (<a class="reference internal" href="#c.damos_filter" title="damos_filter"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_filter</span></code></a>) that handled by itself.
<strong>target_valid</strong> should check whether the target is still valid for the
monitoring.
<strong>cleanup_target</strong> is called before the target will be deallocated.
<strong>cleanup</strong> is called from <strong>kdamond</strong> just before its termination.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_intervals_goal">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_intervals_goal</span></span></span><a class="headerlink" href="#c.damon_intervals_goal" title="Link to this definition">¶</a><br /></dt>
<dd><p>Monitoring intervals auto-tuning goal.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_intervals_goal {
unsigned long access_bp;
unsigned long aggrs;
unsigned long min_sample_us;
unsigned long max_sample_us;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">access_bp</span></code></dt><dd><p>Access events observation ratio to achieve in bp.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">aggrs</span></code></dt><dd><p>Number of aggregations to achieve <strong>access_bp</strong> within.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">min_sample_us</span></code></dt><dd><p>Minimum resulting sampling interval in microseconds.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">max_sample_us</span></code></dt><dd><p>Maximum resulting sampling interval in microseconds.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>DAMON automatically tunes <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->sample_interval</span></code></a> and
<a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->aggr_interval</span></code></a> aiming the ratio in bp (1/10,000) of
DAMON-observed access events to theoretical maximum amount within <strong>aggrs</strong>
aggregations be same to <strong>access_bp</strong>. The logic increases
<a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->aggr_interval</span></code></a> and <a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_attrs->sampling_interval</span></code></a> in same
ratio if the current access events observation ratio is lower than the
target for each <strong>aggrs</strong> aggregations, and vice versa.</p>
<p>If <strong>aggrs</strong> is zero, the tuning is disabled and hence this <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">is</span></code> ignored.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_attrs">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_attrs</span></span></span><a class="headerlink" href="#c.damon_attrs" title="Link to this definition">¶</a><br /></dt>
<dd><p>Monitoring attributes for accuracy/overhead control.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_attrs {
unsigned long sample_interval;
unsigned long aggr_interval;
unsigned long ops_update_interval;
struct damon_intervals_goal intervals_goal;
unsigned long min_nr_regions;
unsigned long max_nr_regions;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">sample_interval</span></code></dt><dd><p>The time between access samplings.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">aggr_interval</span></code></dt><dd><p>The time between monitor results aggregations.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">ops_update_interval</span></code></dt><dd><p>The time between monitoring operations updates.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">intervals_goal</span></code></dt><dd><p>Intervals auto-tuning goal.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">min_nr_regions</span></code></dt><dd><p>The minimum number of adaptive monitoring
regions.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">max_nr_regions</span></code></dt><dd><p>The maximum number of adaptive monitoring
regions.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>For each <strong>sample_interval</strong>, DAMON checks whether each region is accessed or
not during the last <strong>sample_interval</strong>. If such access is found, DAMON
aggregates the information by increasing <a class="reference internal" href="#c.damon_region" title="damon_region"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_region->nr_accesses</span></code></a> for
<strong>aggr_interval</strong> time. For each <strong>aggr_interval</strong>, the count is reset. DAMON
also checks whether the target memory regions need update (e.g., by
<code class="docutils literal notranslate"><span class="pre">mmap()</span></code> calls from the application, in case of virtual memory monitoring)
and applies the changes for each <strong>ops_update_interval</strong>. All time intervals
are in micro-seconds. Please refer to <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span></code></a> and <code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span>
<span class="pre">damon_call_control</span></code> for more detail.</p>
<dl class="c struct">
<dt class="sig sig-object c" id="c.damon_ctx">
<span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_ctx</span></span></span><a class="headerlink" href="#c.damon_ctx" title="Link to this definition">¶</a><br /></dt>
<dd><p>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.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Definition</strong>:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>struct damon_ctx {
struct damon_attrs attrs;
struct task_struct *kdamond;
struct mutex kdamond_lock;
struct damon_operations ops;
unsigned long addr_unit;
unsigned long min_sz_region;
struct list_head adaptive_targets;
struct list_head schemes;
};
</pre></div>
</div>
<p><strong>Members</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">attrs</span></code></dt><dd><p>Monitoring attributes for accuracy/overhead control.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">kdamond</span></code></dt><dd><p>Kernel thread who does the monitoring.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">kdamond_lock</span></code></dt><dd><p>Mutex for the synchronizations with <strong>kdamond</strong>.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">ops</span></code></dt><dd><p>Set of monitoring operations for given use cases.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">addr_unit</span></code></dt><dd><p>Scale factor for core to ops address conversion.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">min_sz_region</span></code></dt><dd><p>Minimum region size.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">adaptive_targets</span></code></dt><dd><p>Head of monitoring targets (<a class="reference internal" href="#c.damon_target" title="damon_target"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_target</span></code></a>) list.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">schemes</span></code></dt><dd><p>Head of schemes (<a class="reference internal" href="#c.damos" title="damos"><code class="xref c c-type docutils literal notranslate"><span class="pre">damos</span></code></a>) list.</p>
</dd>
</dl>
</div>
<p><strong>Description</strong></p>
<p>For each monitoring context, one kernel thread for the monitoring is
created. The pointer to the thread is stored in <strong>kdamond</strong>.</p>
<p>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 <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_operations.target_valid</span></code></a> of <strong>ops</strong>. The
termination can also be explicitly requested by calling <a class="reference internal" href="#c.damon_stop" title="damon_stop"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_stop()</span></code></a>.
The thread sets <strong>kdamond</strong> to NULL when it terminates. Therefore, users can
know whether the monitoring is ongoing or terminated by reading <strong>kdamond</strong>.
Reads and writes to <strong>kdamond</strong> from outside of the monitoring thread must
be protected by <strong>kdamond_lock</strong>.</p>
<p>Note that the monitoring thread protects only <strong>kdamond</strong> via <strong>kdamond_lock</strong>.
Accesses to other fields must be protected by themselves.</p>
</section>
<section id="functions">
<h2>Functions<a class="headerlink" href="#functions" title="Link to this heading">¶</a></h2>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_is_registered_ops">
<span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_is_registered_ops</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ops_id" title="damon_ops_id"><span class="n"><span class="pre">damon_ops_id</span></span></a><span class="w"> </span><span class="n"><span class="pre">id</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_is_registered_ops" title="Link to this definition">¶</a><br /></dt>
<dd><p>Check if a given damon_operations is registered.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">enum</span> <span class="pre">damon_ops_id</span> <span class="pre">id</span></code></dt><dd><p>Id of the damon_operations to check if registered.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<p>true if the ops is set, false otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_register_ops">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_register_ops</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_operations" title="damon_operations"><span class="n"><span class="pre">damon_operations</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ops</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_register_ops" title="Link to this definition">¶</a><br /></dt>
<dd><p>Register a monitoring operations set to DAMON.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_operations</span> <span class="pre">*ops</span></code></dt><dd><p>monitoring operations set to register.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function registers a monitoring operations set of valid <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span>
<span class="pre">damon_operations</span></code></a>->id so that others can find and use them later.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_select_ops">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_select_ops</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span>, <span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ops_id" title="damon_ops_id"><span class="n"><span class="pre">damon_ops_id</span></span></a><span class="w"> </span><span class="n"><span class="pre">id</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_select_ops" title="Link to this definition">¶</a><br /></dt>
<dd><p>Select a monitoring operations to use with the context.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>monitoring context to use the operations.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">enum</span> <span class="pre">damon_ops_id</span> <span class="pre">id</span></code></dt><dd><p>id of the registered monitoring operations to select.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function finds registered monitoring operations set of <strong>id</strong> and make
<strong>ctx</strong> to use it.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damos_filter_for_ops">
<span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_filter_for_ops</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#c.damos_filter_type" title="damos_filter_type"><span class="n"><span class="pre">damos_filter_type</span></span></a><span class="w"> </span><span class="n"><span class="pre">type</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damos_filter_for_ops" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return if the filter is ops-hndled one.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">enum</span> <span class="pre">damos_filter_type</span> <span class="pre">type</span></code></dt><dd><p>type of the filter.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<p>true if the filter of <strong>type</strong> needs to be handled by ops layer, false
otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_set_attrs">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_set_attrs</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><span class="n"><span class="pre">damon_attrs</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">attrs</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_set_attrs" title="Link to this definition">¶</a><br /></dt>
<dd><p>Set attributes for the monitoring.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>monitoring context</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_attrs</span> <span class="pre">*attrs</span></code></dt><dd><p>monitoring attributes</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function should be called while the kdamond is not running, an access
check results aggregation is not ongoing (e.g., from <a class="reference internal" href="#c.damon_call" title="damon_call"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_call()</span></code></a>.</p>
<p>Every time interval is in micro-seconds.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_set_schemes">
<span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_set_schemes</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damos" title="damos"><span class="n"><span class="pre">damos</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">schemes</span></span>, <span class="n"><span class="pre">ssize_t</span></span><span class="w"> </span><span class="n"><span class="pre">nr_schemes</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_set_schemes" title="Link to this definition">¶</a><br /></dt>
<dd><p>Set data access monitoring based operation schemes.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>monitoring context</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos</span> <span class="pre">**schemes</span></code></dt><dd><p>array of the schemes</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">ssize_t</span> <span class="pre">nr_schemes</span></code></dt><dd><p>number of entries in <strong>schemes</strong></p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function should not be called while the kdamond of the context is
running.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damos_commit_quota_goals">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_commit_quota_goals</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damos_quota" title="damos_quota"><span class="n"><span class="pre">damos_quota</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dst</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damos_quota" title="damos_quota"><span class="n"><span class="pre">damos_quota</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damos_commit_quota_goals" title="Link to this definition">¶</a><br /></dt>
<dd><p>Commit DAMOS quota goals to another quota.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_quota</span> <span class="pre">*dst</span></code></dt><dd><p>The commit destination DAMOS quota.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_quota</span> <span class="pre">*src</span></code></dt><dd><p>The commit source DAMOS quota.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Copies user-specified parameters for quota goals from <strong>src</strong> to <strong>dst</strong>. Users
should use this function for quota goals-level parameters update of running
DAMON contexts, instead of manual in-place updates.</p>
<p>This function should be called from parameters-update safe context, like
<a class="reference internal" href="#c.damon_call" title="damon_call"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_call()</span></code></a>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damos_filters_default_reject">
<span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_filters_default_reject</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">list_head</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">filters</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damos_filters_default_reject" title="Link to this definition">¶</a><br /></dt>
<dd><p>decide whether to reject memory that didn’t match with any given filter.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">list_head</span> <span class="pre">*filters</span></code></dt><dd><p>Given DAMOS filters of a group.</p>
</dd>
</dl>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_commit_ctx">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_commit_ctx</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dst</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_commit_ctx" title="Link to this definition">¶</a><br /></dt>
<dd><p>Commit parameters of a DAMON context to another.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*dst</span></code></dt><dd><p>The commit destination DAMON context.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*src</span></code></dt><dd><p>The commit source DAMON context.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function copies user-specified parameters from <strong>src</strong> to <strong>dst</strong> and update
the internal status and results accordingly. Users should use this function
for context-level parameters update of running context, instead of manual
in-place updates.</p>
<p>This function should be called from parameters-update safe context, like
<a class="reference internal" href="#c.damon_call" title="damon_call"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_call()</span></code></a>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_nr_running_ctxs">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_nr_running_ctxs</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">void</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_nr_running_ctxs" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return number of currently running contexts.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">void</span></code></dt><dd><p>no arguments</p>
</dd>
</dl>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_start">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_start</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctxs</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">nr_ctxs</span></span>, <span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="n"><span class="pre">exclusive</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_start" title="Link to this definition">¶</a><br /></dt>
<dd><p>Starts the monitorings for a given group of contexts.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">**ctxs</span></code></dt><dd><p>an array of the pointers for contexts to start monitoring</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">int</span> <span class="pre">nr_ctxs</span></code></dt><dd><p>size of <strong>ctxs</strong></p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">bool</span> <span class="pre">exclusive</span></code></dt><dd><p>exclusiveness of this contexts group</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function starts a group of monitoring threads for a group of monitoring
contexts. One thread per each context is created and run in parallel. The
caller should handle synchronization between the threads by itself. If
<strong>exclusive</strong> is true and a group of threads that created by other
‘<a class="reference internal" href="#c.damon_start" title="damon_start"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_start()</span></code></a>’ call is currently running, this function does nothing but
returns -EBUSY.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_stop">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_stop</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctxs</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">nr_ctxs</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_stop" title="Link to this definition">¶</a><br /></dt>
<dd><p>Stops the monitorings for a given group of contexts.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">**ctxs</span></code></dt><dd><p>an array of the pointers for contexts to stop monitoring</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">int</span> <span class="pre">nr_ctxs</span></code></dt><dd><p>size of <strong>ctxs</strong></p>
</dd>
</dl>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_is_running">
<span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_is_running</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_is_running" title="Link to this definition">¶</a><br /></dt>
<dd><p>Returns if a given DAMON context is running.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>The DAMON context to see if running.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<p>true if <strong>ctx</strong> is running, false otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_kdamond_pid">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_kdamond_pid</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_kdamond_pid" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return pid of a given DAMON context’s worker thread.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>The DAMON context of the question.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<p>pid if <strong>ctx</strong> is running, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_call">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_call</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">damon_call_control</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">control</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_call" title="Link to this definition">¶</a><br /></dt>
<dd><p>Invoke a given function on DAMON worker thread (kdamond).</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>DAMON context to call the function for.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_call_control</span> <span class="pre">*control</span></code></dt><dd><p>Control variable of the call request.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Ask DAMON worker thread (kdamond) of <strong>ctx</strong> to call a function with an
argument data that respectively passed via <code class="xref c c-type docutils literal notranslate"><span class="pre">damon_call_control->fn</span></code> and
<code class="xref c c-type docutils literal notranslate"><span class="pre">damon_call_control->data</span></code> of <strong>control</strong>. If <code class="xref c c-type docutils literal notranslate"><span class="pre">damon_call_control->repeat</span></code> of
<strong>control</strong> is set, further wait until the kdamond finishes handling of the
request. Otherwise, return as soon as the request is made.</p>
<p>The kdamond executes the function with the argument in the main loop, just
after a sampling of the iteration is finished. The function can hence
safely access the internal data of the <a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span></code></a> without additional
synchronization. The return value of the function will be saved in
<code class="xref c c-type docutils literal notranslate"><span class="pre">damon_call_control->return_code</span></code>.</p>
<p>Note that this function should be called only after <a class="reference internal" href="#c.damon_start" title="damon_start"><code class="xref c c-func docutils literal notranslate"><span class="pre">damon_start()</span></code></a> with the
<strong>ctx</strong> has succeeded. Otherwise, this function could fall into an indefinite
wait.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damos_walk">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damos_walk</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><span class="n"><span class="pre">damon_ctx</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">ctx</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damos_walk_control" title="damos_walk_control"><span class="n"><span class="pre">damos_walk_control</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">control</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damos_walk" title="Link to this definition">¶</a><br /></dt>
<dd><p>Invoke a given functions while DAMOS walk regions.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span> <span class="pre">*ctx</span></code></dt><dd><p>DAMON context to call the functions for.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damos_walk_control</span> <span class="pre">*control</span></code></dt><dd><p>Control variable of the walk request.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Ask DAMON worker thread (kdamond) of <strong>ctx</strong> to call a function for each region
that the kdamond will apply DAMOS action to, and wait until the kdamond
finishes handling of the request.</p>
<p>The kdamond executes the given function in the main loop, for each region
just after it applied any DAMOS actions of <strong>ctx</strong> to it. The invocation is
made only within one <a class="reference internal" href="#c.damos" title="damos"><code class="xref c c-type docutils literal notranslate"><span class="pre">damos->apply_interval_us</span></code></a> since <a class="reference internal" href="#c.damos_walk" title="damos_walk"><code class="xref c c-func docutils literal notranslate"><span class="pre">damos_walk()</span></code></a>
invocation, for each scheme. The given callback function can hence safely
access the internal data of <a class="reference internal" href="#c.damon_ctx" title="damon_ctx"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_ctx</span></code></a> and <a class="reference internal" href="#c.damon_region" title="damon_region"><code class="xref c c-type docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_region</span></code></a> that
each of the scheme will apply the action for next interval, without
additional synchronizations against the kdamond. If every scheme of <strong>ctx</strong>
passed at least one <a class="reference internal" href="#c.damos" title="damos"><code class="xref c c-type docutils literal notranslate"><span class="pre">damos->apply_interval_us</span></code></a>, kdamond marks the request as
completed so that <a class="reference internal" href="#c.damos_walk" title="damos_walk"><code class="xref c c-func docutils literal notranslate"><span class="pre">damos_walk()</span></code></a> can wakeup and return.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_set_region_biggest_system_ram_default">
<span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_set_region_biggest_system_ram_default</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_target" title="damon_target"><span class="n"><span class="pre">damon_target</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">t</span></span>, <span class="kt"><span class="pre">unsigned</span></span><span class="w"> </span><span class="kt"><span class="pre">long</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">start</span></span>, <span class="kt"><span class="pre">unsigned</span></span><span class="w"> </span><span class="kt"><span class="pre">long</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">end</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_set_region_biggest_system_ram_default" title="Link to this definition">¶</a><br /></dt>
<dd><p>Set the region of the given monitoring target as requested, or biggest ‘System RAM’.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_target</span> <span class="pre">*t</span></code></dt><dd><p>The monitoring target to set the region.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">unsigned</span> <span class="pre">long</span> <span class="pre">*start</span></code></dt><dd><p>The pointer to the start address of the region.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">unsigned</span> <span class="pre">long</span> <span class="pre">*end</span></code></dt><dd><p>The pointer to the end address of the region.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>This function sets the region of <strong>t</strong> as requested by <strong>start</strong> and <strong>end</strong>. If the
values of <strong>start</strong> and <strong>end</strong> are zero, however, this function finds the biggest
‘System RAM’ resource and sets the region to cover the resource. In the
latter case, this function saves the start and end addresses of the resource
in <strong>start</strong> and <strong>end</strong>, respectively.</p>
<p><strong>Return</strong></p>
<p>0 on success, negative error code otherwise.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_update_region_access_rate">
<span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_update_region_access_rate</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_region" title="damon_region"><span class="n"><span class="pre">damon_region</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">r</span></span>, <span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="n"><span class="pre">accessed</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.damon_attrs" title="damon_attrs"><span class="n"><span class="pre">damon_attrs</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">attrs</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_update_region_access_rate" title="Link to this definition">¶</a><br /></dt>
<dd><p>Update the access rate of a region.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_region</span> <span class="pre">*r</span></code></dt><dd><p>The DAMON region to update for its access check result.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">bool</span> <span class="pre">accessed</span></code></dt><dd><p>Whether the region has accessed during last sampling interval.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">damon_attrs</span> <span class="pre">*attrs</span></code></dt><dd><p>The damon_attrs of the DAMON context.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Update the access rate of a region with the region’s last sampling interval
access check result.</p>
<p>Usually this will be called by <a class="reference internal" href="#c.damon_operations" title="damon_operations"><code class="xref c c-type docutils literal notranslate"><span class="pre">damon_operations->check_accesses</span></code></a> callback.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.damon_initialized">
<span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">damon_initialized</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">void</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.damon_initialized" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return if DAMON is ready to be used.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">void</span></code></dt><dd><p>no arguments</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<p>true if DAMON is ready to be used, false otherwise.</p>
</div>
</section>
</section>
</div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
©The kernel development community.
|
Powered by <a href="https://www.sphinx-doc.org/">Sphinx 8.1.3</a>
& <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
|
<a href="../../_sources/mm/damon/api.rst.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>