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 27kdamonds = None 28def fail(expectation, status): 29 print('unexpected %s' % expectation) 30 print(json.dumps(status, indent=4)) 31 if kdamonds is not None: 32 kdamonds.stop() 33 exit(1) 34 35def assert_true(condition, expectation, status): 36 if condition is not True: 37 fail(expectation, status) 38 39def assert_watermarks_committed(watermarks, dump): 40 wmark_metric_val = { 41 'none': 0, 42 'free_mem_rate': 1, 43 } 44 assert_true(dump['metric'] == wmark_metric_val[watermarks.metric], 45 'metric', dump) 46 assert_true(dump['interval'] == watermarks.interval, 'interval', dump) 47 assert_true(dump['high'] == watermarks.high, 'high', dump) 48 assert_true(dump['mid'] == watermarks.mid, 'mid', dump) 49 assert_true(dump['low'] == watermarks.low, 'low', dump) 50 51def assert_quota_goal_committed(qgoal, dump): 52 metric_val = { 53 'user_input': 0, 54 'some_mem_psi_us': 1, 55 'node_mem_used_bp': 2, 56 'node_mem_free_bp': 3, 57 } 58 assert_true(dump['metric'] == metric_val[qgoal.metric], 'metric', dump) 59 assert_true(dump['target_value'] == qgoal.target_value, 'target_value', 60 dump) 61 if qgoal.metric == 'user_input': 62 assert_true(dump['current_value'] == qgoal.current_value, 63 'current_value', dump) 64 assert_true(dump['nid'] == qgoal.nid, 'nid', dump) 65 66def assert_quota_committed(quota, dump): 67 assert_true(dump['reset_interval'] == quota.reset_interval_ms, 68 'reset_interval', dump) 69 assert_true(dump['ms'] == quota.ms, 'ms', dump) 70 assert_true(dump['sz'] == quota.sz, 'sz', dump) 71 for idx, qgoal in enumerate(quota.goals): 72 assert_quota_goal_committed(qgoal, dump['goals'][idx]) 73 tuner_val = { 74 'consist': 0, 75 'temporal': 1, 76 } 77 assert_true(dump['goal_tuner'] == tuner_val[quota.goal_tuner], 78 'goal_tuner', dump) 79 assert_true(dump['fail_charge_num'] == quota.fail_charge_num, 80 'fail_charge_num', dump) 81 assert_true(dump['fail_charge_denom'] == quota.fail_charge_denom, 82 'fail_charge_denom', dump) 83 assert_true(dump['weight_sz'] == quota.weight_sz_permil, 'weight_sz', dump) 84 assert_true(dump['weight_nr_accesses'] == quota.weight_nr_accesses_permil, 85 'weight_nr_accesses', dump) 86 assert_true( 87 dump['weight_age'] == quota.weight_age_permil, 'weight_age', dump) 88 89 90def assert_migrate_dests_committed(dests, dump): 91 assert_true(dump['nr_dests'] == len(dests.dests), 'nr_dests', dump) 92 for idx, dest in enumerate(dests.dests): 93 assert_true(dump['node_id_arr'][idx] == dest.id, 'node_id', dump) 94 assert_true(dump['weight_arr'][idx] == dest.weight, 'weight', dump) 95 96def assert_filter_committed(filter_, dump): 97 assert_true(filter_.type_ == dump['type'], 'type', dump) 98 assert_true(filter_.matching == dump['matching'], 'matching', dump) 99 assert_true(filter_.allow == dump['allow'], 'allow', dump) 100 # TODO: check memcg_path and memcg_id if type is memcg 101 if filter_.type_ == 'addr': 102 assert_true([filter_.addr_start, filter_.addr_end] == 103 dump['addr_range'], 'addr_range', dump) 104 elif filter_.type_ == 'target': 105 assert_true(filter_.target_idx == dump['target_idx'], 'target_idx', 106 dump) 107 elif filter_.type_ == 'hugepage_size': 108 assert_true([filter_.min_, filter_.max_] == dump['sz_range'], 109 'sz_range', dump) 110 111def assert_access_pattern_committed(pattern, dump): 112 assert_true(dump['min_sz_region'] == pattern.size[0], 'min_sz_region', 113 dump) 114 assert_true(dump['max_sz_region'] == pattern.size[1], 'max_sz_region', 115 dump) 116 assert_true(dump['min_nr_accesses'] == pattern.nr_accesses[0], 117 'min_nr_accesses', dump) 118 assert_true(dump['max_nr_accesses'] == pattern.nr_accesses[1], 119 'max_nr_accesses', dump) 120 assert_true(dump['min_age_region'] == pattern.age[0], 'min_age_region', 121 dump) 122 assert_true(dump['max_age_region'] == pattern.age[1], 'max_age_region', 123 dump) 124 125def assert_scheme_committed(scheme, dump): 126 assert_access_pattern_committed(scheme.access_pattern, dump['pattern']) 127 action_val = { 128 'willneed': 0, 129 'cold': 1, 130 'pageout': 2, 131 'hugepage': 3, 132 'nohugepage': 4, 133 'collapse': 5, 134 'lru_prio': 6, 135 'lru_deprio': 7, 136 'migrate_hot': 8, 137 'migrate_cold': 9, 138 'stat': 10, 139 } 140 assert_true(dump['action'] == action_val[scheme.action], 'action', dump) 141 assert_true(dump['apply_interval_us'] == scheme. apply_interval_us, 142 'apply_interval_us', dump) 143 assert_true(dump['target_nid'] == scheme.target_nid, 'target_nid', dump) 144 assert_migrate_dests_committed(scheme.dests, dump['migrate_dests']) 145 assert_quota_committed(scheme.quota, dump['quota']) 146 assert_watermarks_committed(scheme.watermarks, dump['wmarks']) 147 # TODO: test filters directory 148 for idx, f in enumerate(scheme.core_filters.filters): 149 assert_filter_committed(f, dump['core_filters'][idx]) 150 for idx, f in enumerate(scheme.ops_filters.filters): 151 assert_filter_committed(f, dump['ops_filters'][idx]) 152 153def assert_schemes_committed(schemes, dump): 154 assert_true(len(schemes) == len(dump), 'len_schemes', dump) 155 for idx, scheme in enumerate(schemes): 156 assert_scheme_committed(scheme, dump[idx]) 157 158def assert_monitoring_attrs_committed(attrs, dump): 159 assert_true(dump['sample_interval'] == attrs.sample_us, 'sample_interval', 160 dump) 161 assert_true(dump['aggr_interval'] == attrs.aggr_us, 'aggr_interval', dump) 162 assert_true(dump['intervals_goal']['access_bp'] == 163 attrs.intervals_goal.access_bp, 'access_bp', 164 dump['intervals_goal']) 165 assert_true(dump['intervals_goal']['aggrs'] == attrs.intervals_goal.aggrs, 166 'aggrs', dump['intervals_goal']) 167 assert_true(dump['intervals_goal']['min_sample_us'] == 168 attrs.intervals_goal.min_sample_us, 'min_sample_us', 169 dump['intervals_goal']) 170 assert_true(dump['intervals_goal']['max_sample_us'] == 171 attrs.intervals_goal.max_sample_us, 'max_sample_us', 172 dump['intervals_goal']) 173 174 assert_true(dump['ops_update_interval'] == attrs.update_us, 175 'ops_update_interval', dump) 176 assert_true(dump['min_nr_regions'] == attrs.min_nr_regions, 177 'min_nr_regions', dump) 178 assert_true(dump['max_nr_regions'] == attrs.max_nr_regions, 179 'max_nr_regions', dump) 180 181def assert_damon_filters_committed(filters, dump): 182 assert_true(len(dump) == len(filters.filters), 'probe filters', dump) 183 for idx, damon_filter in enumerate(filters.filters): 184 filter_dump = dump[idx] 185 assert_true(filter_dump['type'] == damon_filter.type_, 'type', 186 filter_dump) 187 assert_true(filter_dump['matching'] == damon_filter.matching, 188 'matching', filter_dump) 189 assert_true(filter_dump['allow'] == damon_filter.allow, 'allow', 190 filter_dump) 191 192def assert_probes_committed(probes, dump): 193 assert_true(len(dump) == len(probes.probes), 'probes length', dump) 194 for idx, probe in enumerate(probes.probes): 195 probe_dump = dump[idx] 196 assert_true(probe.weight == probe_dump['weight'], 'weight', probe_dump) 197 assert_damon_filters_committed(probe.filters, probe_dump['filters']) 198 199def assert_monitoring_target_committed(target, dump): 200 # target.pid is the pid "number", while dump['pid'] is 'struct pid' 201 # pointer, and hence cannot be compared. 202 assert_true(dump['obsolete'] == target.obsolete, 'target obsolete', dump) 203 204def assert_monitoring_targets_committed(targets, dump): 205 assert_true(len(targets) == len(dump), 'len_targets', dump) 206 for idx, target in enumerate(targets): 207 assert_monitoring_target_committed(target, dump[idx]) 208 209def assert_ctx_committed(ctx, dump): 210 ops_val = { 211 'vaddr': 0, 212 'fvaddr': 1, 213 'paddr': 2, 214 } 215 assert_true(dump['ops']['id'] == ops_val[ctx.ops], 'ops_id', dump) 216 assert_monitoring_attrs_committed(ctx.monitoring_attrs, dump['attrs']) 217 assert_probes_committed(ctx.monitoring_attrs.probes, dump['probes']) 218 assert_monitoring_targets_committed(ctx.targets, dump['adaptive_targets']) 219 assert_schemes_committed(ctx.schemes, dump['schemes']) 220 assert_true(dump['pause'] == ctx.pause, 'pause', dump) 221 222def assert_ctxs_committed(kdamonds): 223 ctxs_paused_for_dump = [] 224 kdamonds_paused_for_dump = [] 225 # pause for safe state dumping 226 for kd in kdamonds.kdamonds: 227 for ctx in kd.contexts: 228 if ctx.pause is False: 229 ctx.pause = True 230 ctxs_paused_for_dump.append(ctx) 231 if not kd in kdamonds_paused_for_dump: 232 kdamonds_paused_for_dump.append(kd) 233 if kd in kdamonds_paused_for_dump: 234 err = kd.commit() 235 if err is not None: 236 print('pause fail (%s)' % err) 237 kdamonds.stop() 238 exit(1) 239 240 status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid) 241 if err is not None: 242 print(err) 243 kdamonds.stop() 244 exit(1) 245 246 # resume contexts paused for safe state dumping 247 for ctx in ctxs_paused_for_dump: 248 ctx.pause = False 249 for kd in kdamonds_paused_for_dump: 250 err = kd.commit() 251 if err is not None: 252 print('resume fail (%s)' % err) 253 kdamonds.stop() 254 exit(1) 255 256 # restore for comparison 257 for ctx in ctxs_paused_for_dump: 258 ctx.pause = True 259 260 ctxs = kdamonds.kdamonds[0].contexts 261 dump = status['contexts'] 262 assert_true(len(ctxs) == len(dump), 'ctxs length', dump) 263 for idx, ctx in enumerate(ctxs): 264 assert_ctx_committed(ctx, dump[idx]) 265 266 # restore for the caller 267 for kd in kdamonds.kdamonds: 268 for ctx in kd.contexts: 269 if ctx in ctxs_paused_for_dump: 270 ctx.pause = False 271 272def test_memcg_filter_memcg_path_staging(): 273 global kdamonds 274 memcg_filter = _damon_sysfs.DamosFilter( 275 type_='memcg', matching=True, allow=True, memcg_path='/') 276 kdamonds = _damon_sysfs.Kdamonds( 277 [_damon_sysfs.Kdamond( 278 contexts=[_damon_sysfs.DamonCtx( 279 targets=[_damon_sysfs.DamonTarget(pid=-1)], 280 schemes=[_damon_sysfs.Damos( 281 ops_filters=[memcg_filter])], 282 )])]) 283 kdamonds.start() 284 285 shown, rd_err = _damon_sysfs.read_file( 286 os.path.join(memcg_filter.sysfs_dir(), 'memcg_path')) 287 if rd_err is not None: 288 print('memcg_path staging: sysfs read (%s)' % rd_err) 289 kdamonds.stop() 290 exit(1) 291 if shown.rstrip('\n') != memcg_filter.memcg_path: 292 print('memcg_path staging: memcg_path readback ' 293 '(shown=%s, expected=%s)' % 294 (shown.rstrip('\n'), memcg_filter.memcg_path)) 295 kdamonds.stop() 296 exit(1) 297 298 kdamonds.stop() 299 kdamonds = None 300 301def main(): 302 global kdamonds 303 kdamonds = _damon_sysfs.Kdamonds( 304 [_damon_sysfs.Kdamond( 305 contexts=[_damon_sysfs.DamonCtx( 306 targets=[_damon_sysfs.DamonTarget(pid=-1)], 307 schemes=[_damon_sysfs.Damos()], 308 )])]) 309 err = kdamonds.start() 310 if err is not None: 311 print('kdamond start failed: %s' % err) 312 exit(1) 313 314 assert_ctxs_committed(kdamonds) 315 316 context = _damon_sysfs.DamonCtx( 317 monitoring_attrs=_damon_sysfs.DamonAttrs( 318 sample_us=100000, aggr_us=2000000, 319 intervals_goal=_damon_sysfs.IntervalsGoal( 320 access_bp=400, aggrs=3, min_sample_us=5000, 321 max_sample_us=10000000), 322 update_us=2000000, 323 probes=_damon_sysfs.DamonProbes( 324 probes=[_damon_sysfs.DamonProbe( 325 weight=42, 326 filters=_damon_sysfs.DamonFilters( 327 filters=[ 328 _damon_sysfs.DamonFilter( 329 type_='anon', 330 matching=True, 331 allow=True, 332 ), 333 ]), 334 ), 335 ]), 336 ), 337 schemes=[_damon_sysfs.Damos( 338 action='pageout', 339 access_pattern=_damon_sysfs.DamosAccessPattern( 340 size=[4096, 2**10], 341 nr_accesses=[3, 317], 342 age=[5,71]), 343 quota=_damon_sysfs.DamosQuota( 344 sz=100*1024*1024, ms=100, 345 goals=[_damon_sysfs.DamosQuotaGoal( 346 metric='node_mem_used_bp', 347 target_value=9950, 348 nid=1)], 349 goal_tuner='temporal', 350 reset_interval_ms=1500, 351 fail_charge_num=1, 352 fail_charge_denom=4096, 353 weight_sz_permil=20, 354 weight_nr_accesses_permil=200, 355 weight_age_permil=1000), 356 watermarks=_damon_sysfs.DamosWatermarks( 357 metric = 'free_mem_rate', interval = 500000, # 500 ms 358 high = 500, mid = 400, low = 50), 359 target_nid=1, 360 apply_interval_us=1000000, 361 dests=_damon_sysfs.DamosDests( 362 dests=[_damon_sysfs.DamosDest(id=1, weight=30), 363 _damon_sysfs.DamosDest(id=0, weight=70)]), 364 core_filters=[ 365 _damon_sysfs.DamosFilter(type_='addr', matching=True, 366 allow=False, addr_start=42, 367 addr_end=4242), 368 ], 369 ops_filters=[ 370 _damon_sysfs.DamosFilter(type_='anon', matching=True, 371 allow=True), 372 ], 373 )]) 374 context.idx = 0 375 context.kdamond = kdamonds.kdamonds[0] 376 kdamonds.kdamonds[0].contexts = [context] 377 kdamonds.kdamonds[0].commit() 378 379 assert_ctxs_committed(kdamonds) 380 381 # test online commitment of minimum context. 382 context = _damon_sysfs.DamonCtx() 383 context.idx = 0 384 context.kdamond = kdamonds.kdamonds[0] 385 kdamonds.kdamonds[0].contexts = [context] 386 kdamonds.kdamonds[0].commit() 387 388 assert_ctxs_committed(kdamonds) 389 390 kdamonds.stop() 391 392 # test obsolete_target. 393 proc1 = subprocess.Popen(['sh'], stdout=subprocess.PIPE, 394 stderr=subprocess.PIPE) 395 proc2 = subprocess.Popen(['sh'], stdout=subprocess.PIPE, 396 stderr=subprocess.PIPE) 397 proc3 = subprocess.Popen(['sh'], stdout=subprocess.PIPE, 398 stderr=subprocess.PIPE) 399 kdamonds = _damon_sysfs.Kdamonds( 400 [_damon_sysfs.Kdamond( 401 contexts=[_damon_sysfs.DamonCtx( 402 ops='vaddr', 403 targets=[ 404 _damon_sysfs.DamonTarget(pid=proc1.pid), 405 _damon_sysfs.DamonTarget(pid=proc2.pid), 406 _damon_sysfs.DamonTarget(pid=proc3.pid), 407 ], 408 schemes=[_damon_sysfs.Damos()], 409 )])]) 410 err = kdamonds.start() 411 if err is not None: 412 print('kdamond start failed: %s' % err) 413 exit(1) 414 kdamonds.kdamonds[0].contexts[0].targets[1].obsolete = True 415 kdamonds.kdamonds[0].contexts[0].pause = True 416 kdamonds.kdamonds[0].commit() 417 del kdamonds.kdamonds[0].contexts[0].targets[1] 418 assert_ctxs_committed(kdamonds) 419 kdamonds.stop() 420 421 for proc in (proc1, proc2, proc3): 422 proc.terminate() 423 proc.communicate() 424 425 test_memcg_filter_memcg_path_staging() 426 427if __name__ == '__main__': 428 main() 429