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 tuner_val = { 71 'consist': 0, 72 'temporal': 1, 73 } 74 assert_true(dump['goal_tuner'] == tuner_val[quota.goal_tuner], 75 'goal_tuner', dump) 76 assert_true(dump['fail_charge_num'] == quota.fail_charge_num, 77 'fail_charge_num', dump) 78 assert_true(dump['fail_charge_denom'] == quota.fail_charge_denom, 79 'fail_charge_denom', dump) 80 assert_true(dump['weight_sz'] == quota.weight_sz_permil, 'weight_sz', dump) 81 assert_true(dump['weight_nr_accesses'] == quota.weight_nr_accesses_permil, 82 'weight_nr_accesses', dump) 83 assert_true( 84 dump['weight_age'] == quota.weight_age_permil, 'weight_age', dump) 85 86 87def assert_migrate_dests_committed(dests, dump): 88 assert_true(dump['nr_dests'] == len(dests.dests), 'nr_dests', dump) 89 for idx, dest in enumerate(dests.dests): 90 assert_true(dump['node_id_arr'][idx] == dest.id, 'node_id', dump) 91 assert_true(dump['weight_arr'][idx] == dest.weight, 'weight', dump) 92 93def assert_filter_committed(filter_, dump): 94 assert_true(filter_.type_ == dump['type'], 'type', dump) 95 assert_true(filter_.matching == dump['matching'], 'matching', dump) 96 assert_true(filter_.allow == dump['allow'], 'allow', dump) 97 # TODO: check memcg_path and memcg_id if type is memcg 98 if filter_.type_ == 'addr': 99 assert_true([filter_.addr_start, filter_.addr_end] == 100 dump['addr_range'], 'addr_range', dump) 101 elif filter_.type_ == 'target': 102 assert_true(filter_.target_idx == dump['target_idx'], 'target_idx', 103 dump) 104 elif filter_.type_ == 'hugepage_size': 105 assert_true([filter_.min_, filter_.max_] == dump['sz_range'], 106 'sz_range', dump) 107 108def assert_access_pattern_committed(pattern, dump): 109 assert_true(dump['min_sz_region'] == pattern.size[0], 'min_sz_region', 110 dump) 111 assert_true(dump['max_sz_region'] == pattern.size[1], 'max_sz_region', 112 dump) 113 assert_true(dump['min_nr_accesses'] == pattern.nr_accesses[0], 114 'min_nr_accesses', dump) 115 assert_true(dump['max_nr_accesses'] == pattern.nr_accesses[1], 116 'max_nr_accesses', dump) 117 assert_true(dump['min_age_region'] == pattern.age[0], 'min_age_region', 118 dump) 119 assert_true(dump['max_age_region'] == pattern.age[1], 'miaxage_region', 120 dump) 121 122def assert_scheme_committed(scheme, dump): 123 assert_access_pattern_committed(scheme.access_pattern, dump['pattern']) 124 action_val = { 125 'willneed': 0, 126 'cold': 1, 127 'pageout': 2, 128 'hugepage': 3, 129 'nohugeapge': 4, 130 'collapse': 5, 131 'lru_prio': 6, 132 'lru_deprio': 7, 133 'migrate_hot': 8, 134 'migrate_cold': 9, 135 'stat': 10, 136 } 137 assert_true(dump['action'] == action_val[scheme.action], 'action', dump) 138 assert_true(dump['apply_interval_us'] == scheme. apply_interval_us, 139 'apply_interval_us', dump) 140 assert_true(dump['target_nid'] == scheme.target_nid, 'target_nid', dump) 141 assert_migrate_dests_committed(scheme.dests, dump['migrate_dests']) 142 assert_quota_committed(scheme.quota, dump['quota']) 143 assert_watermarks_committed(scheme.watermarks, dump['wmarks']) 144 # TODO: test filters directory 145 for idx, f in enumerate(scheme.core_filters.filters): 146 assert_filter_committed(f, dump['core_filters'][idx]) 147 for idx, f in enumerate(scheme.ops_filters.filters): 148 assert_filter_committed(f, dump['ops_filters'][idx]) 149 150def assert_schemes_committed(schemes, dump): 151 assert_true(len(schemes) == len(dump), 'len_schemes', dump) 152 for idx, scheme in enumerate(schemes): 153 assert_scheme_committed(scheme, dump[idx]) 154 155def assert_monitoring_attrs_committed(attrs, dump): 156 assert_true(dump['sample_interval'] == attrs.sample_us, 'sample_interval', 157 dump) 158 assert_true(dump['aggr_interval'] == attrs.aggr_us, 'aggr_interval', dump) 159 assert_true(dump['intervals_goal']['access_bp'] == 160 attrs.intervals_goal.access_bp, 'access_bp', 161 dump['intervals_goal']) 162 assert_true(dump['intervals_goal']['aggrs'] == attrs.intervals_goal.aggrs, 163 'aggrs', dump['intervals_goal']) 164 assert_true(dump['intervals_goal']['min_sample_us'] == 165 attrs.intervals_goal.min_sample_us, 'min_sample_us', 166 dump['intervals_goal']) 167 assert_true(dump['intervals_goal']['max_sample_us'] == 168 attrs.intervals_goal.max_sample_us, 'max_sample_us', 169 dump['intervals_goal']) 170 171 assert_true(dump['ops_update_interval'] == attrs.update_us, 172 'ops_update_interval', dump) 173 assert_true(dump['min_nr_regions'] == attrs.min_nr_regions, 174 'min_nr_regions', dump) 175 assert_true(dump['max_nr_regions'] == attrs.max_nr_regions, 176 'max_nr_regions', dump) 177 178def assert_monitoring_target_committed(target, dump): 179 # target.pid is the pid "number", while dump['pid'] is 'struct pid' 180 # pointer, and hence cannot be compared. 181 assert_true(dump['obsolete'] == target.obsolete, 'target obsolete', dump) 182 183def assert_monitoring_targets_committed(targets, dump): 184 assert_true(len(targets) == len(dump), 'len_targets', dump) 185 for idx, target in enumerate(targets): 186 assert_monitoring_target_committed(target, dump[idx]) 187 188def assert_ctx_committed(ctx, dump): 189 ops_val = { 190 'vaddr': 0, 191 'fvaddr': 1, 192 'paddr': 2, 193 } 194 assert_true(dump['ops']['id'] == ops_val[ctx.ops], 'ops_id', dump) 195 assert_monitoring_attrs_committed(ctx.monitoring_attrs, dump['attrs']) 196 assert_monitoring_targets_committed(ctx.targets, dump['adaptive_targets']) 197 assert_schemes_committed(ctx.schemes, dump['schemes']) 198 assert_true(dump['pause'] == ctx.pause, 'pause', dump) 199 200def assert_ctxs_committed(kdamonds): 201 ctxs_paused_for_dump = [] 202 kdamonds_paused_for_dump = [] 203 # pause for safe state dumping 204 for kd in kdamonds.kdamonds: 205 for ctx in kd.contexts: 206 if ctx.pause is False: 207 ctx.pause = True 208 ctxs_paused_for_dump.append(ctx) 209 if not kd in kdamonds_paused_for_dump: 210 kdamonds_paused_for_dump.append(kd) 211 if kd in kdamonds_paused_for_dump: 212 err = kd.commit() 213 if err is not None: 214 print('pause fail (%s)' % err) 215 kdamonds.stop() 216 exit(1) 217 218 status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid) 219 if err is not None: 220 print(err) 221 kdamonds.stop() 222 exit(1) 223 224 # resume contexts paused for safe state dumping 225 for ctx in ctxs_paused_for_dump: 226 ctx.pause = False 227 for kd in kdamonds_paused_for_dump: 228 err = kd.commit() 229 if err is not None: 230 print('resume fail (%s)' % err) 231 kdamonds.stop() 232 exit(1) 233 234 # restore for comparison 235 for ctx in ctxs_paused_for_dump: 236 ctx.pause = True 237 238 ctxs = kdamonds.kdamonds[0].contexts 239 dump = status['contexts'] 240 assert_true(len(ctxs) == len(dump), 'ctxs length', dump) 241 for idx, ctx in enumerate(ctxs): 242 assert_ctx_committed(ctx, dump[idx]) 243 244 # restore for the caller 245 for kd in kdamonds.kdamonds: 246 for ctx in kd.contexts: 247 if ctx in ctxs_paused_for_dump: 248 ctx.pause = False 249 250def main(): 251 kdamonds = _damon_sysfs.Kdamonds( 252 [_damon_sysfs.Kdamond( 253 contexts=[_damon_sysfs.DamonCtx( 254 targets=[_damon_sysfs.DamonTarget(pid=-1)], 255 schemes=[_damon_sysfs.Damos()], 256 )])]) 257 err = kdamonds.start() 258 if err is not None: 259 print('kdamond start failed: %s' % err) 260 exit(1) 261 262 assert_ctxs_committed(kdamonds) 263 264 context = _damon_sysfs.DamonCtx( 265 monitoring_attrs=_damon_sysfs.DamonAttrs( 266 sample_us=100000, aggr_us=2000000, 267 intervals_goal=_damon_sysfs.IntervalsGoal( 268 access_bp=400, aggrs=3, min_sample_us=5000, 269 max_sample_us=10000000), 270 update_us=2000000), 271 schemes=[_damon_sysfs.Damos( 272 action='pageout', 273 access_pattern=_damon_sysfs.DamosAccessPattern( 274 size=[4096, 2**10], 275 nr_accesses=[3, 317], 276 age=[5,71]), 277 quota=_damon_sysfs.DamosQuota( 278 sz=100*1024*1024, ms=100, 279 goals=[_damon_sysfs.DamosQuotaGoal( 280 metric='node_mem_used_bp', 281 target_value=9950, 282 nid=1)], 283 goal_tuner='temporal', 284 reset_interval_ms=1500, 285 fail_charge_num=1, 286 fail_charge_denom=4096, 287 weight_sz_permil=20, 288 weight_nr_accesses_permil=200, 289 weight_age_permil=1000), 290 watermarks=_damon_sysfs.DamosWatermarks( 291 metric = 'free_mem_rate', interval = 500000, # 500 ms 292 high = 500, mid = 400, low = 50), 293 target_nid=1, 294 apply_interval_us=1000000, 295 dests=_damon_sysfs.DamosDests( 296 dests=[_damon_sysfs.DamosDest(id=1, weight=30), 297 _damon_sysfs.DamosDest(id=0, weight=70)]), 298 core_filters=[ 299 _damon_sysfs.DamosFilter(type_='addr', matching=True, 300 allow=False, addr_start=42, 301 addr_end=4242), 302 ], 303 ops_filters=[ 304 _damon_sysfs.DamosFilter(type_='anon', matching=True, 305 allow=True), 306 ], 307 )]) 308 context.idx = 0 309 context.kdamond = kdamonds.kdamonds[0] 310 kdamonds.kdamonds[0].contexts = [context] 311 kdamonds.kdamonds[0].commit() 312 313 assert_ctxs_committed(kdamonds) 314 315 # test online commitment of minimum context. 316 context = _damon_sysfs.DamonCtx() 317 context.idx = 0 318 context.kdamond = kdamonds.kdamonds[0] 319 kdamonds.kdamonds[0].contexts = [context] 320 kdamonds.kdamonds[0].commit() 321 322 assert_ctxs_committed(kdamonds) 323 324 kdamonds.stop() 325 326 # test obsolete_target. 327 proc1 = subprocess.Popen(['sh'], stdout=subprocess.PIPE, 328 stderr=subprocess.PIPE) 329 proc2 = subprocess.Popen(['sh'], stdout=subprocess.PIPE, 330 stderr=subprocess.PIPE) 331 proc3 = subprocess.Popen(['sh'], stdout=subprocess.PIPE, 332 stderr=subprocess.PIPE) 333 kdamonds = _damon_sysfs.Kdamonds( 334 [_damon_sysfs.Kdamond( 335 contexts=[_damon_sysfs.DamonCtx( 336 ops='vaddr', 337 targets=[ 338 _damon_sysfs.DamonTarget(pid=proc1.pid), 339 _damon_sysfs.DamonTarget(pid=proc2.pid), 340 _damon_sysfs.DamonTarget(pid=proc3.pid), 341 ], 342 schemes=[_damon_sysfs.Damos()], 343 )])]) 344 err = kdamonds.start() 345 if err is not None: 346 print('kdamond start failed: %s' % err) 347 exit(1) 348 kdamonds.kdamonds[0].contexts[0].targets[1].obsolete = True 349 kdamonds.kdamonds[0].contexts[0].pause = True 350 kdamonds.kdamonds[0].commit() 351 del kdamonds.kdamonds[0].contexts[0].targets[1] 352 assert_ctxs_committed(kdamonds) 353 kdamonds.stop() 354 355if __name__ == '__main__': 356 main() 357