#!/usr/bin/env python3 # SPDX-License-Identifier: GPL-2.0 import json import os import subprocess import _damon_sysfs def dump_damon_status_dict(pid): try: subprocess.check_output(['which', 'drgn'], stderr=subprocess.DEVNULL) except: return None, 'drgn not found' file_dir = os.path.dirname(os.path.abspath(__file__)) dump_script = os.path.join(file_dir, 'drgn_dump_damon_status.py') rc = subprocess.call(['drgn', dump_script, pid, 'damon_dump_output'], stderr=subprocess.DEVNULL) if rc != 0: return None, 'drgn fail' try: with open('damon_dump_output', 'r') as f: return json.load(f), None except Exception as e: return None, 'json.load fail (%s)' % e def fail(expectation, status): print('unexpected %s' % expectation) print(json.dumps(status, indent=4)) exit(1) def assert_true(condition, expectation, status): if condition is not True: fail(expectation, status) def assert_watermarks_committed(watermarks, dump): wmark_metric_val = { 'none': 0, 'free_mem_rate': 1, } assert_true(dump['metric'] == wmark_metric_val[watermarks.metric], 'metric', dump) assert_true(dump['interval'] == watermarks.interval, 'interval', dump) assert_true(dump['high'] == watermarks.high, 'high', dump) assert_true(dump['mid'] == watermarks.mid, 'mid', dump) assert_true(dump['low'] == watermarks.low, 'low', dump) def assert_quota_goal_committed(qgoal, dump): metric_val = { 'user_input': 0, 'some_mem_psi_us': 1, 'node_mem_used_bp': 2, 'node_mem_free_bp': 3, } assert_true(dump['metric'] == metric_val[qgoal.metric], 'metric', dump) assert_true(dump['target_value'] == qgoal.target_value, 'target_value', dump) if qgoal.metric == 'user_input': assert_true(dump['current_value'] == qgoal.current_value, 'current_value', dump) assert_true(dump['nid'] == qgoal.nid, 'nid', dump) def assert_quota_committed(quota, dump): assert_true(dump['reset_interval'] == quota.reset_interval_ms, 'reset_interval', dump) assert_true(dump['ms'] == quota.ms, 'ms', dump) assert_true(dump['sz'] == quota.sz, 'sz', dump) for idx, qgoal in enumerate(quota.goals): assert_quota_goal_committed(qgoal, dump['goals'][idx]) assert_true(dump['weight_sz'] == quota.weight_sz_permil, 'weight_sz', dump) assert_true(dump['weight_nr_accesses'] == quota.weight_nr_accesses_permil, 'weight_nr_accesses', dump) assert_true( dump['weight_age'] == quota.weight_age_permil, 'weight_age', dump) def assert_migrate_dests_committed(dests, dump): assert_true(dump['nr_dests'] == len(dests.dests), 'nr_dests', dump) for idx, dest in enumerate(dests.dests): assert_true(dump['node_id_arr'][idx] == dest.id, 'node_id', dump) assert_true(dump['weight_arr'][idx] == dest.weight, 'weight', dump) def assert_filter_committed(filter_, dump): assert_true(filter_.type_ == dump['type'], 'type', dump) assert_true(filter_.matching == dump['matching'], 'matching', dump) assert_true(filter_.allow == dump['allow'], 'allow', dump) # TODO: check memcg_path and memcg_id if type is memcg if filter_.type_ == 'addr': assert_true([filter_.addr_start, filter_.addr_end] == dump['addr_range'], 'addr_range', dump) elif filter_.type_ == 'target': assert_true(filter_.target_idx == dump['target_idx'], 'target_idx', dump) elif filter_.type_ == 'hugepage_size': assert_true([filter_.min_, filter_.max_] == dump['sz_range'], 'sz_range', dump) def assert_access_pattern_committed(pattern, dump): assert_true(dump['min_sz_region'] == pattern.size[0], 'min_sz_region', dump) assert_true(dump['max_sz_region'] == pattern.size[1], 'max_sz_region', dump) assert_true(dump['min_nr_accesses'] == pattern.nr_accesses[0], 'min_nr_accesses', dump) assert_true(dump['max_nr_accesses'] == pattern.nr_accesses[1], 'max_nr_accesses', dump) assert_true(dump['min_age_region'] == pattern.age[0], 'min_age_region', dump) assert_true(dump['max_age_region'] == pattern.age[1], 'miaxage_region', dump) def assert_scheme_committed(scheme, dump): assert_access_pattern_committed(scheme.access_pattern, dump['pattern']) action_val = { 'willneed': 0, 'cold': 1, 'pageout': 2, 'hugepage': 3, 'nohugeapge': 4, 'lru_prio': 5, 'lru_deprio': 6, 'migrate_hot': 7, 'migrate_cold': 8, 'stat': 9, } assert_true(dump['action'] == action_val[scheme.action], 'action', dump) assert_true(dump['apply_interval_us'] == scheme. apply_interval_us, 'apply_interval_us', dump) assert_true(dump['target_nid'] == scheme.target_nid, 'target_nid', dump) assert_migrate_dests_committed(scheme.dests, dump['migrate_dests']) assert_quota_committed(scheme.quota, dump['quota']) assert_watermarks_committed(scheme.watermarks, dump['wmarks']) # TODO: test filters directory for idx, f in enumerate(scheme.core_filters.filters): assert_filter_committed(f, dump['filters'][idx]) for idx, f in enumerate(scheme.ops_filters.filters): assert_filter_committed(f, dump['ops_filters'][idx]) def assert_schemes_committed(schemes, dump): assert_true(len(schemes) == len(dump), 'len_schemes', dump) for idx, scheme in enumerate(schemes): assert_scheme_committed(scheme, dump[idx]) def assert_monitoring_attrs_committed(attrs, dump): assert_true(dump['sample_interval'] == attrs.sample_us, 'sample_interval', dump) assert_true(dump['aggr_interval'] == attrs.aggr_us, 'aggr_interval', dump) assert_true(dump['intervals_goal']['access_bp'] == attrs.intervals_goal.access_bp, 'access_bp', dump['intervals_goal']) assert_true(dump['intervals_goal']['aggrs'] == attrs.intervals_goal.aggrs, 'aggrs', dump['intervals_goal']) assert_true(dump['intervals_goal']['min_sample_us'] == attrs.intervals_goal.min_sample_us, 'min_sample_us', dump['intervals_goal']) assert_true(dump['intervals_goal']['max_sample_us'] == attrs.intervals_goal.max_sample_us, 'max_sample_us', dump['intervals_goal']) assert_true(dump['ops_update_interval'] == attrs.update_us, 'ops_update_interval', dump) assert_true(dump['min_nr_regions'] == attrs.min_nr_regions, 'min_nr_regions', dump) assert_true(dump['max_nr_regions'] == attrs.max_nr_regions, 'max_nr_regions', dump) def assert_ctx_committed(ctx, dump): ops_val = { 'vaddr': 0, 'fvaddr': 1, 'paddr': 2, } assert_true(dump['ops']['id'] == ops_val[ctx.ops], 'ops_id', dump) assert_monitoring_attrs_committed(ctx.monitoring_attrs, dump['attrs']) assert_schemes_committed(ctx.schemes, dump['schemes']) def assert_ctxs_committed(ctxs, dump): assert_true(len(ctxs) == len(dump), 'ctxs length', dump) for idx, ctx in enumerate(ctxs): assert_ctx_committed(ctx, dump[idx]) def main(): kdamonds = _damon_sysfs.Kdamonds( [_damon_sysfs.Kdamond( contexts=[_damon_sysfs.DamonCtx( targets=[_damon_sysfs.DamonTarget(pid=-1)], schemes=[_damon_sysfs.Damos()], )])]) err = kdamonds.start() if err is not None: print('kdamond start failed: %s' % err) exit(1) status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid) if err is not None: print(err) kdamonds.stop() exit(1) assert_ctxs_committed(kdamonds.kdamonds[0].contexts, status['contexts']) context = _damon_sysfs.DamonCtx( monitoring_attrs=_damon_sysfs.DamonAttrs( sample_us=100000, aggr_us=2000000, intervals_goal=_damon_sysfs.IntervalsGoal( access_bp=400, aggrs=3, min_sample_us=5000, max_sample_us=10000000), update_us=2000000), schemes=[_damon_sysfs.Damos( action='pageout', access_pattern=_damon_sysfs.DamosAccessPattern( size=[4096, 2**10], nr_accesses=[3, 317], age=[5,71]), quota=_damon_sysfs.DamosQuota( sz=100*1024*1024, ms=100, goals=[_damon_sysfs.DamosQuotaGoal( metric='node_mem_used_bp', target_value=9950, nid=1)], reset_interval_ms=1500, weight_sz_permil=20, weight_nr_accesses_permil=200, weight_age_permil=1000), watermarks=_damon_sysfs.DamosWatermarks( metric = 'free_mem_rate', interval = 500000, # 500 ms high = 500, mid = 400, low = 50), target_nid=1, apply_interval_us=1000000, dests=_damon_sysfs.DamosDests( dests=[_damon_sysfs.DamosDest(id=1, weight=30), _damon_sysfs.DamosDest(id=0, weight=70)]), core_filters=[ _damon_sysfs.DamosFilter(type_='addr', matching=True, allow=False, addr_start=42, addr_end=4242), ], ops_filters=[ _damon_sysfs.DamosFilter(type_='anon', matching=True, allow=True), ], )]) context.idx = 0 context.kdamond = kdamonds.kdamonds[0] kdamonds.kdamonds[0].contexts = [context] kdamonds.kdamonds[0].commit() status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid) if err is not None: print(err) exit(1) assert_ctxs_committed(kdamonds.kdamonds[0].contexts, status['contexts']) # test online commitment of minimum context. context = _damon_sysfs.DamonCtx() context.idx = 0 context.kdamond = kdamonds.kdamonds[0] kdamonds.kdamonds[0].contexts = [context] kdamonds.kdamonds[0].commit() status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid) if err is not None: print(err) exit(1) assert_ctxs_committed(kdamonds.kdamonds[0].contexts, status['contexts']) kdamonds.stop() if __name__ == '__main__': main()