# SPDX-License-Identifier: GPL-2.0
import os
ksft_skip=4
sysfs_root = None
with open('/proc/mounts', 'r') as f:
for line in f:
dev_name, mount_point, dev_fs = line.split()[:3]
if dev_fs == 'sysfs':
sysfs_root = '%s/kernel/mm/damon/admin' % mount_point
break
if sysfs_root is None:
print('Seems sysfs not mounted?')
exit(ksft_skip)
def write_file(path, string):
"Returns error string if failed, or None otherwise"
string = '%s' % string
try:
with open(path, 'w') as f:
f.write(string)
except Exception as e:
return '%s' % e
return None
def read_file(path):
'''Returns the read content and error string. The read content is None if
the reading failed'''
try:
with open(path, 'r') as f:
return f.read(), None
except Exception as e:
return None, '%s' % e
class DamosAccessPattern:
size = None
nr_accesses = None
age = None
scheme = None
def __init__(self, size=None, nr_accesses=None, age=None):
self.size = size
self.nr_accesses = nr_accesses
self.age = age
if self.size is None:
self.size = [0, 2**64 - 1]
if self.nr_accesses is None:
self.nr_accesses = [0, 2**64 - 1]
if self.age is None:
self.age = [0, 2**64 - 1]
def sysfs_dir(self):
return os.path.join(self.scheme.sysfs_dir(), 'access_pattern')
def stage(self):
err = write_file(
os.path.join(self.sysfs_dir(), 'sz', 'min'), self.size[0])
if err is not None:
return err
err = write_file(
os.path.join(self.sysfs_dir(), 'sz', 'max'), self.size[1])
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'nr_accesses', 'min'),
self.nr_accesses[0])
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'nr_accesses', 'max'),
self.nr_accesses[1])
if err is not None:
return err
err = write_file(
os.path.join(self.sysfs_dir(), 'age', 'min'), self.age[0])
if err is not None:
return err
err = write_file(
os.path.join(self.sysfs_dir(), 'age', 'max'), self.age[1])
if err is not None:
return err
qgoal_metric_user_input = 'user_input'
qgoal_metric_some_mem_psi_us = 'some_mem_psi_us'
qgoal_metrics = [qgoal_metric_user_input, qgoal_metric_some_mem_psi_us]
class DamosQuotaGoal:
metric = None
target_value = None
current_value = None
effective_bytes = None
quota = None # owner quota
idx = None
def __init__(self, metric, target_value=10000, current_value=0):
self.metric = metric
self.target_value = target_value
self.current_value = current_value
def sysfs_dir(self):
return os.path.join(self.quota.sysfs_dir(), 'goals', '%d' % self.idx)
def stage(self):
err = write_file(os.path.join(self.sysfs_dir(), 'target_metric'),
self.metric)
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'target_value'),
self.target_value)
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'current_value'),
self.current_value)
if err is not None:
return err
return None
class DamosQuota:
sz = None # size quota, in bytes
ms = None # time quota
goals = None # quota goals
reset_interval_ms = None # quota reset interval
scheme = None # owner scheme
def __init__(self, sz=0, ms=0, goals=None, reset_interval_ms=0):
self.sz = sz
self.ms = ms
self.reset_interval_ms = reset_interval_ms
self.goals = goals if goals is not None else []
for idx, goal in enumerate(self.goals):
goal.idx = idx
goal.quota = self
def sysfs_dir(self):
return os.path.join(self.scheme.sysfs_dir(), 'quotas')
def stage(self):
err = write_file(os.path.join(self.sysfs_dir(), 'bytes'), self.sz)
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'ms'), self.ms)
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'reset_interval_ms'),
self.reset_interval_ms)
if err is not None:
return err
nr_goals_file = os.path.join(self.sysfs_dir(), 'goals', 'nr_goals')
content, err = read_file(nr_goals_file)
if err is not None:
return err
if int(content) != len(self.goals):
err = write_file(nr_goals_file, len(self.goals))
if err is not None:
return err
for goal in self.goals:
err = goal.stage()
if err is not None:
return err
return None
class DamosStats:
nr_tried = None
sz_tried = None
nr_applied = None
sz_applied = None
qt_exceeds = None
def __init__(self, nr_tried, sz_tried, nr_applied, sz_applied, qt_exceeds):
self.nr_tried = nr_tried
self.sz_tried = sz_tried
self.nr_applied = nr_applied
self.sz_applied = sz_applied
self.qt_exceeds = qt_exceeds
class DamosTriedRegion:
def __init__(self, start, end, nr_accesses, age):
self.start = start
self.end = end
self.nr_accesses = nr_accesses
self.age = age
class Damos:
action = None
access_pattern = None
quota = None
apply_interval_us = None
# todo: Support watermarks, stats
idx = None
context = None
tried_bytes = None
stats = None
tried_regions = None
def __init__(self, action='stat', access_pattern=DamosAccessPattern(),
quota=DamosQuota(), apply_interval_us=0):
self.action = action
self.access_pattern = access_pattern
self.access_pattern.scheme = self
self.quota = quota
self.quota.scheme = self
self.apply_interval_us = apply_interval_us
def sysfs_dir(self):
return os.path.join(
self.context.sysfs_dir(), 'schemes', '%d' % self.idx)
def stage(self):
err = write_file(os.path.join(self.sysfs_dir(), 'action'), self.action)
if err is not None:
return err
err = self.access_pattern.stage()
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'apply_interval_us'),
'%d' % self.apply_interval_us)
if err is not None:
return err
err = self.quota.stage()
if err is not None:
return err
# disable watermarks
err = write_file(
os.path.join(self.sysfs_dir(), 'watermarks', 'metric'), 'none')
if err is not None:
return err
# disable filters
err = write_file(
os.path.join(self.sysfs_dir(), 'filters', 'nr_filters'), '0')
if err is not None:
return err
class DamonTarget:
pid = None
# todo: Support target regions if test is made
idx = None
context = None
def __init__(self, pid):
self.pid = pid
def sysfs_dir(self):
return os.path.join(
self.context.sysfs_dir(), 'targets', '%d' % self.idx)
def stage(self):
err = write_file(
os.path.join(self.sysfs_dir(), 'regions', 'nr_regions'), '0')
if err is not None:
return err
return write_file(
os.path.join(self.sysfs_dir(), 'pid_target'), self.pid)
class DamonAttrs:
sample_us = None
aggr_us = None
update_us = None
min_nr_regions = None
max_nr_regions = None
context = None
def __init__(self, sample_us=5000, aggr_us=100000, update_us=1000000,
min_nr_regions=10, max_nr_regions=1000):
self.sample_us = sample_us
self.aggr_us = aggr_us
self.update_us = update_us
self.min_nr_regions = min_nr_regions
self.max_nr_regions = max_nr_regions
def interval_sysfs_dir(self):
return os.path.join(self.context.sysfs_dir(), 'monitoring_attrs',
'intervals')
def nr_regions_range_sysfs_dir(self):
return os.path.join(self.context.sysfs_dir(), 'monitoring_attrs',
'nr_regions')
def stage(self):
err = write_file(os.path.join(self.interval_sysfs_dir(), 'sample_us'),
self.sample_us)
if err is not None:
return err
err = write_file(os.path.join(self.interval_sysfs_dir(), 'aggr_us'),
self.aggr_us)
if err is not None:
return err
err = write_file(os.path.join(self.interval_sysfs_dir(), 'update_us'),
self.update_us)
if err is not None:
return err
err = write_file(
os.path.join(self.nr_regions_range_sysfs_dir(), 'min'),
self.min_nr_regions)
if err is not None:
return err
err = write_file(
os.path.join(self.nr_regions_range_sysfs_dir(), 'max'),
self.max_nr_regions)
if err is not None:
return err
class DamonCtx:
ops = None
monitoring_attrs = None
targets = None
schemes = None
kdamond = None
idx = None
def __init__(self, ops='paddr', monitoring_attrs=DamonAttrs(), targets=[],
schemes=[]):
self.ops = ops
self.monitoring_attrs = monitoring_attrs
self.monitoring_attrs.context = self
self.targets = targets
for idx, target in enumerate(self.targets):
target.idx = idx
target.context = self
self.schemes = schemes
for idx, scheme in enumerate(self.schemes):
scheme.idx = idx
scheme.context = self
def sysfs_dir(self):
return os.path.join(self.kdamond.sysfs_dir(), 'contexts',
'%d' % self.idx)
def stage(self):
err = write_file(
os.path.join(self.sysfs_dir(), 'operations'), self.ops)
if err is not None:
return err
err = self.monitoring_attrs.stage()
if err is not None:
return err
nr_targets_file = os.path.join(
self.sysfs_dir(), 'targets', 'nr_targets')
content, err = read_file(nr_targets_file)
if err is not None:
return err
if int(content) != len(self.targets):
err = write_file(nr_targets_file, '%d' % len(self.targets))
if err is not None:
return err
for target in self.targets:
err = target.stage()
if err is not None:
return err
nr_schemes_file = os.path.join(
self.sysfs_dir(), 'schemes', 'nr_schemes')
content, err = read_file(nr_schemes_file)
if err is not None:
return err
if int(content) != len(self.schemes):
err = write_file(nr_schemes_file, '%d' % len(self.schemes))
if err is not None:
return err
for scheme in self.schemes:
err = scheme.stage()
if err is not None:
return err
return None
class Kdamond:
state = None
pid = None
contexts = None
idx = None # index of this kdamond between siblings
kdamonds = None # parent
def __init__(self, contexts=[]):
self.contexts = contexts
for idx, context in enumerate(self.contexts):
context.idx = idx
context.kdamond = self
def sysfs_dir(self):
return os.path.join(self.kdamonds.sysfs_dir(), '%d' % self.idx)
def start(self):
nr_contexts_file = os.path.join(self.sysfs_dir(),
'contexts', 'nr_contexts')
content, err = read_file(nr_contexts_file)
if err is not None:
return err
if int(content) != len(self.contexts):
err = write_file(nr_contexts_file, '%d' % len(self.contexts))
if err is not None:
return err
for context in self.contexts:
err = context.stage()
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'on')
return err
def stop(self):
err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'off')
return err
def update_schemes_tried_regions(self):
err = write_file(os.path.join(self.sysfs_dir(), 'state'),
'update_schemes_tried_regions')
if err is not None:
return err
for context in self.contexts:
for scheme in context.schemes:
tried_regions = []
tried_regions_dir = os.path.join(
scheme.sysfs_dir(), 'tried_regions')
for filename in os.listdir(
os.path.join(scheme.sysfs_dir(), 'tried_regions')):
tried_region_dir = os.path.join(tried_regions_dir, filename)
if not os.path.isdir(tried_region_dir):
continue
region_values = []
for f in ['start', 'end', 'nr_accesses', 'age']:
content, err = read_file(
os.path.join(tried_region_dir, f))
if err is not None:
return err
region_values.append(int(content))
tried_regions.append(DamosTriedRegion(*region_values))
scheme.tried_regions = tried_regions
def update_schemes_tried_bytes(self):
err = write_file(os.path.join(self.sysfs_dir(), 'state'),
'update_schemes_tried_bytes')
if err is not None:
return err
for context in self.contexts:
for scheme in context.schemes:
content, err = read_file(os.path.join(scheme.sysfs_dir(),
'tried_regions', 'total_bytes'))
if err is not None:
return err
scheme.tried_bytes = int(content)
def update_schemes_stats(self):
err = write_file(os.path.join(self.sysfs_dir(), 'state'),
'update_schemes_stats')
if err is not None:
return err
for context in self.contexts:
for scheme in context.schemes:
stat_values = []
for stat in ['nr_tried', 'sz_tried', 'nr_applied',
'sz_applied', 'qt_exceeds']:
content, err = read_file(
os.path.join(scheme.sysfs_dir(), 'stats', stat))
if err is not None:
return err
stat_values.append(int(content))
scheme.stats = DamosStats(*stat_values)
def update_schemes_effective_quotas(self):
err = write_file(os.path.join(self.sysfs_dir(), 'state'),
'update_schemes_effective_quotas')
if err is not None:
return err
for context in self.contexts:
for scheme in context.schemes:
for goal in scheme.quota.goals:
content, err = read_file(
os.path.join(scheme.quota.sysfs_dir(),
'effective_bytes'))
if err is not None:
return err
goal.effective_bytes = int(content)
return None
def commit(self):
nr_contexts_file = os.path.join(self.sysfs_dir(),
'contexts', 'nr_contexts')
content, err = read_file(nr_contexts_file)
if err is not None:
return err
if int(content) != len(self.contexts):
err = write_file(nr_contexts_file, '%d' % len(self.contexts))
if err is not None:
return err
for context in self.contexts:
err = context.stage()
if err is not None:
return err
err = write_file(os.path.join(self.sysfs_dir(), 'state'), 'commit')
return err
def commit_schemes_quota_goals(self):
for context in self.contexts:
for scheme in context.schemes:
for goal in scheme.quota.goals:
err = goal.stage()
if err is not None:
print('commit_schemes_quota_goals failed stagign: %s'%
err)
exit(1)
return write_file(os.path.join(self.sysfs_dir(), 'state'),
'commit_schemes_quota_goals')
class Kdamonds:
kdamonds = []
def __init__(self, kdamonds=[]):
self.kdamonds = kdamonds
for idx, kdamond in enumerate(self.kdamonds):
kdamond.idx = idx
kdamond.kdamonds = self
def sysfs_dir(self):
return os.path.join(sysfs_root, 'kdamonds')
def start(self):
err = write_file(os.path.join(self.sysfs_dir(), 'nr_kdamonds'),
'%s' % len(self.kdamonds))
if err is not None:
return err
for kdamond in self.kdamonds:
err = kdamond.start()
if err is not None:
return err
return None
def stop(self):
for kdamond in self.kdamonds:
err = kdamond.stop()
if err is not None:
return err
return None
Codebase Browser
linux