Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#!/usr/bin/env python3
2# SPDX-License-Identifier: GPL-2.0
3
4import json
5import os
6import subprocess
7
8import _damon_sysfs
9
10def dump_damon_status_dict(pid):
11 try:
12 subprocess.check_output(['which', 'drgn'], stderr=subprocess.DEVNULL)
13 except:
14 return None, 'drgn not found'
15 file_dir = os.path.dirname(os.path.abspath(__file__))
16 dump_script = os.path.join(file_dir, 'drgn_dump_damon_status.py')
17 rc = subprocess.call(['drgn', dump_script, pid, 'damon_dump_output'],
18 stderr=subprocess.DEVNULL)
19 if rc != 0:
20 return None, 'drgn fail'
21 try:
22 with open('damon_dump_output', 'r') as f:
23 return json.load(f), None
24 except Exception as e:
25 return None, 'json.load fail (%s)' % e
26
27def fail(expectation, status):
28 print('unexpected %s' % expectation)
29 print(json.dumps(status, indent=4))
30 exit(1)
31
32def assert_true(condition, expectation, status):
33 if condition is not True:
34 fail(expectation, status)
35
36def assert_watermarks_committed(watermarks, dump):
37 wmark_metric_val = {
38 'none': 0,
39 'free_mem_rate': 1,
40 }
41 assert_true(dump['metric'] == wmark_metric_val[watermarks.metric],
42 'metric', dump)
43 assert_true(dump['interval'] == watermarks.interval, 'interval', dump)
44 assert_true(dump['high'] == watermarks.high, 'high', dump)
45 assert_true(dump['mid'] == watermarks.mid, 'mid', dump)
46 assert_true(dump['low'] == watermarks.low, 'low', dump)
47
48def assert_quota_goal_committed(qgoal, dump):
49 metric_val = {
50 'user_input': 0,
51 'some_mem_psi_us': 1,
52 'node_mem_used_bp': 2,
53 'node_mem_free_bp': 3,
54 }
55 assert_true(dump['metric'] == metric_val[qgoal.metric], 'metric', dump)
56 assert_true(dump['target_value'] == qgoal.target_value, 'target_value',
57 dump)
58 if qgoal.metric == 'user_input':
59 assert_true(dump['current_value'] == qgoal.current_value,
60 'current_value', dump)
61 assert_true(dump['nid'] == qgoal.nid, 'nid', dump)
62
63def assert_quota_committed(quota, dump):
64 assert_true(dump['reset_interval'] == quota.reset_interval_ms,
65 'reset_interval', dump)
66 assert_true(dump['ms'] == quota.ms, 'ms', dump)
67 assert_true(dump['sz'] == quota.sz, 'sz', dump)
68 for idx, qgoal in enumerate(quota.goals):
69 assert_quota_goal_committed(qgoal, dump['goals'][idx])
70 assert_true(dump['weight_sz'] == quota.weight_sz_permil, 'weight_sz', dump)
71 assert_true(dump['weight_nr_accesses'] == quota.weight_nr_accesses_permil,
72 'weight_nr_accesses', dump)
73 assert_true(
74 dump['weight_age'] == quota.weight_age_permil, 'weight_age', dump)
75
76
77def assert_migrate_dests_committed(dests, dump):
78 assert_true(dump['nr_dests'] == len(dests.dests), 'nr_dests', dump)
79 for idx, dest in enumerate(dests.dests):
80 assert_true(dump['node_id_arr'][idx] == dest.id, 'node_id', dump)
81 assert_true(dump['weight_arr'][idx] == dest.weight, 'weight', dump)
82
83def assert_filter_committed(filter_, dump):
84 assert_true(filter_.type_ == dump['type'], 'type', dump)
85 assert_true(filter_.matching == dump['matching'], 'matching', dump)
86 assert_true(filter_.allow == dump['allow'], 'allow', dump)
87 # TODO: check memcg_path and memcg_id if type is memcg
88 if filter_.type_ == 'addr':
89 assert_true([filter_.addr_start, filter_.addr_end] ==
90 dump['addr_range'], 'addr_range', dump)
91 elif filter_.type_ == 'target':
92 assert_true(filter_.target_idx == dump['target_idx'], 'target_idx',
93 dump)
94 elif filter_.type_ == 'hugepage_size':
95 assert_true([filter_.min_, filter_.max_] == dump['sz_range'],
96 'sz_range', dump)
97
98def assert_access_pattern_committed(pattern, dump):
99 assert_true(dump['min_sz_region'] == pattern.size[0], 'min_sz_region',
100 dump)
101 assert_true(dump['max_sz_region'] == pattern.size[1], 'max_sz_region',
102 dump)
103 assert_true(dump['min_nr_accesses'] == pattern.nr_accesses[0],
104 'min_nr_accesses', dump)
105 assert_true(dump['max_nr_accesses'] == pattern.nr_accesses[1],
106 'max_nr_accesses', dump)
107 assert_true(dump['min_age_region'] == pattern.age[0], 'min_age_region',
108 dump)
109 assert_true(dump['max_age_region'] == pattern.age[1], 'miaxage_region',
110 dump)
111
112def assert_scheme_committed(scheme, dump):
113 assert_access_pattern_committed(scheme.access_pattern, dump['pattern'])
114 action_val = {
115 'willneed': 0,
116 'cold': 1,
117 'pageout': 2,
118 'hugepage': 3,
119 'nohugeapge': 4,
120 'lru_prio': 5,
121 'lru_deprio': 6,
122 'migrate_hot': 7,
123 'migrate_cold': 8,
124 'stat': 9,
125 }
126 assert_true(dump['action'] == action_val[scheme.action], 'action', dump)
127 assert_true(dump['apply_interval_us'] == scheme. apply_interval_us,
128 'apply_interval_us', dump)
129 assert_true(dump['target_nid'] == scheme.target_nid, 'target_nid', dump)
130 assert_migrate_dests_committed(scheme.dests, dump['migrate_dests'])
131 assert_quota_committed(scheme.quota, dump['quota'])
132 assert_watermarks_committed(scheme.watermarks, dump['wmarks'])
133 # TODO: test filters directory
134 for idx, f in enumerate(scheme.core_filters.filters):
135 assert_filter_committed(f, dump['core_filters'][idx])
136 for idx, f in enumerate(scheme.ops_filters.filters):
137 assert_filter_committed(f, dump['ops_filters'][idx])
138
139def assert_schemes_committed(schemes, dump):
140 assert_true(len(schemes) == len(dump), 'len_schemes', dump)
141 for idx, scheme in enumerate(schemes):
142 assert_scheme_committed(scheme, dump[idx])
143
144def assert_monitoring_attrs_committed(attrs, dump):
145 assert_true(dump['sample_interval'] == attrs.sample_us, 'sample_interval',
146 dump)
147 assert_true(dump['aggr_interval'] == attrs.aggr_us, 'aggr_interval', dump)
148 assert_true(dump['intervals_goal']['access_bp'] ==
149 attrs.intervals_goal.access_bp, 'access_bp',
150 dump['intervals_goal'])
151 assert_true(dump['intervals_goal']['aggrs'] == attrs.intervals_goal.aggrs,
152 'aggrs', dump['intervals_goal'])
153 assert_true(dump['intervals_goal']['min_sample_us'] ==
154 attrs.intervals_goal.min_sample_us, 'min_sample_us',
155 dump['intervals_goal'])
156 assert_true(dump['intervals_goal']['max_sample_us'] ==
157 attrs.intervals_goal.max_sample_us, 'max_sample_us',
158 dump['intervals_goal'])
159
160 assert_true(dump['ops_update_interval'] == attrs.update_us,
161 'ops_update_interval', dump)
162 assert_true(dump['min_nr_regions'] == attrs.min_nr_regions,
163 'min_nr_regions', dump)
164 assert_true(dump['max_nr_regions'] == attrs.max_nr_regions,
165 'max_nr_regions', dump)
166
167def assert_monitoring_target_committed(target, dump):
168 # target.pid is the pid "number", while dump['pid'] is 'struct pid'
169 # pointer, and hence cannot be compared.
170 assert_true(dump['obsolete'] == target.obsolete, 'target obsolete', dump)
171
172def assert_monitoring_targets_committed(targets, dump):
173 assert_true(len(targets) == len(dump), 'len_targets', dump)
174 for idx, target in enumerate(targets):
175 assert_monitoring_target_committed(target, dump[idx])
176
177def assert_ctx_committed(ctx, dump):
178 ops_val = {
179 'vaddr': 0,
180 'fvaddr': 1,
181 'paddr': 2,
182 }
183 assert_true(dump['ops']['id'] == ops_val[ctx.ops], 'ops_id', dump)
184 assert_monitoring_attrs_committed(ctx.monitoring_attrs, dump['attrs'])
185 assert_monitoring_targets_committed(ctx.targets, dump['adaptive_targets'])
186 assert_schemes_committed(ctx.schemes, dump['schemes'])
187
188def assert_ctxs_committed(kdamonds):
189 status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid)
190 if err is not None:
191 print(err)
192 kdamonds.stop()
193 exit(1)
194
195 ctxs = kdamonds.kdamonds[0].contexts
196 dump = status['contexts']
197 assert_true(len(ctxs) == len(dump), 'ctxs length', dump)
198 for idx, ctx in enumerate(ctxs):
199 assert_ctx_committed(ctx, dump[idx])
200
201def main():
202 kdamonds = _damon_sysfs.Kdamonds(
203 [_damon_sysfs.Kdamond(
204 contexts=[_damon_sysfs.DamonCtx(
205 targets=[_damon_sysfs.DamonTarget(pid=-1)],
206 schemes=[_damon_sysfs.Damos()],
207 )])])
208 err = kdamonds.start()
209 if err is not None:
210 print('kdamond start failed: %s' % err)
211 exit(1)
212
213 assert_ctxs_committed(kdamonds)
214
215 context = _damon_sysfs.DamonCtx(
216 monitoring_attrs=_damon_sysfs.DamonAttrs(
217 sample_us=100000, aggr_us=2000000,
218 intervals_goal=_damon_sysfs.IntervalsGoal(
219 access_bp=400, aggrs=3, min_sample_us=5000,
220 max_sample_us=10000000),
221 update_us=2000000),
222 schemes=[_damon_sysfs.Damos(
223 action='pageout',
224 access_pattern=_damon_sysfs.DamosAccessPattern(
225 size=[4096, 2**10],
226 nr_accesses=[3, 317],
227 age=[5,71]),
228 quota=_damon_sysfs.DamosQuota(
229 sz=100*1024*1024, ms=100,
230 goals=[_damon_sysfs.DamosQuotaGoal(
231 metric='node_mem_used_bp',
232 target_value=9950,
233 nid=1)],
234 reset_interval_ms=1500,
235 weight_sz_permil=20,
236 weight_nr_accesses_permil=200,
237 weight_age_permil=1000),
238 watermarks=_damon_sysfs.DamosWatermarks(
239 metric = 'free_mem_rate', interval = 500000, # 500 ms
240 high = 500, mid = 400, low = 50),
241 target_nid=1,
242 apply_interval_us=1000000,
243 dests=_damon_sysfs.DamosDests(
244 dests=[_damon_sysfs.DamosDest(id=1, weight=30),
245 _damon_sysfs.DamosDest(id=0, weight=70)]),
246 core_filters=[
247 _damon_sysfs.DamosFilter(type_='addr', matching=True,
248 allow=False, addr_start=42,
249 addr_end=4242),
250 ],
251 ops_filters=[
252 _damon_sysfs.DamosFilter(type_='anon', matching=True,
253 allow=True),
254 ],
255 )])
256 context.idx = 0
257 context.kdamond = kdamonds.kdamonds[0]
258 kdamonds.kdamonds[0].contexts = [context]
259 kdamonds.kdamonds[0].commit()
260
261 assert_ctxs_committed(kdamonds)
262
263 # test online commitment of minimum context.
264 context = _damon_sysfs.DamonCtx()
265 context.idx = 0
266 context.kdamond = kdamonds.kdamonds[0]
267 kdamonds.kdamonds[0].contexts = [context]
268 kdamonds.kdamonds[0].commit()
269
270 assert_ctxs_committed(kdamonds)
271
272 kdamonds.stop()
273
274 # test obsolete_target.
275 proc1 = subprocess.Popen(['sh'], stdout=subprocess.PIPE,
276 stderr=subprocess.PIPE)
277 proc2 = subprocess.Popen(['sh'], stdout=subprocess.PIPE,
278 stderr=subprocess.PIPE)
279 proc3 = subprocess.Popen(['sh'], stdout=subprocess.PIPE,
280 stderr=subprocess.PIPE)
281 kdamonds = _damon_sysfs.Kdamonds(
282 [_damon_sysfs.Kdamond(
283 contexts=[_damon_sysfs.DamonCtx(
284 ops='vaddr',
285 targets=[
286 _damon_sysfs.DamonTarget(pid=proc1.pid),
287 _damon_sysfs.DamonTarget(pid=proc2.pid),
288 _damon_sysfs.DamonTarget(pid=proc3.pid),
289 ],
290 schemes=[_damon_sysfs.Damos()],
291 )])])
292 err = kdamonds.start()
293 if err is not None:
294 print('kdamond start failed: %s' % err)
295 exit(1)
296 kdamonds.kdamonds[0].contexts[0].targets[1].obsolete = True
297 kdamonds.kdamonds[0].commit()
298 del kdamonds.kdamonds[0].contexts[0].targets[1]
299 assert_ctxs_committed(kdamonds)
300 kdamonds.stop()
301
302if __name__ == '__main__':
303 main()