tools/perf/tests/attr.py

   1 # SPDX-License-Identifier: GPL-2.0
   2
   3 import os
   4 import sys
   5 import glob
   6 import optparse
   7 import tempfile
   8 import logging
   9 import shutil
  10 import ConfigParser
  11
  12 def data_equal(a, b):
  13     # Allow multiple values in assignment separated by '|'
  14     a_list = a.split('|')
  15     b_list = b.split('|')
  16
  17     for a_item in a_list:
  18         for b_item in b_list:
  19             if (a_item == b_item):
  20                 return True
  21             elif (a_item == '*') or (b_item == '*'):
  22                 return True
  23
  24     return False
  25
  26 class Fail(Exception):
  27     def __init__(self, test, msg):
  28         self.msg = msg
  29         self.test = test
  30     def getMsg(self):
  31         return '\'%s\' - %s' % (self.test.path, self.msg)
  32
  33 class Notest(Exception):
  34     def __init__(self, test, arch):
  35         self.arch = arch
  36         self.test = test
  37     def getMsg(self):
  38         return '[%s] \'%s\'' % (self.arch, self.test.path)
  39
  40 class Unsup(Exception):
  41     def __init__(self, test):
  42         self.test = test
  43     def getMsg(self):
  44         return '\'%s\'' % self.test.path
  45
  46 class Event(dict):
  47     terms = [
  48         'cpu',
  49         'flags',
  50         'type',
  51         'size',
  52         'config',
  53         'sample_period',
  54         'sample_type',
  55         'read_format',
  56         'disabled',
  57         'inherit',
  58         'pinned',
  59         'exclusive',
  60         'exclude_user',
  61         'exclude_kernel',
  62         'exclude_hv',
  63         'exclude_idle',
  64         'mmap',
  65         'comm',
  66         'freq',
  67         'inherit_stat',
  68         'enable_on_exec',
  69         'task',
  70         'watermark',
  71         'precise_ip',
  72         'mmap_data',
  73         'sample_id_all',
  74         'exclude_host',
  75         'exclude_guest',
  76         'exclude_callchain_kernel',
  77         'exclude_callchain_user',
  78         'wakeup_events',
  79         'bp_type',
  80         'config1',
  81         'config2',
  82         'branch_sample_type',
  83         'sample_regs_user',
  84         'sample_stack_user',
  85     ]
  86
  87     def add(self, data):
  88         for key, val in data:
  89             log.debug("      %s = %s" % (key, val))
  90             self[key] = val
  91
  92     def __init__(self, name, data, base):
  93         log.debug("    Event %s" % name);
  94         self.name  = name;
  95         self.group = ''
  96         self.add(base)
  97         self.add(data)
  98
  99     def equal(self, other):
 100         for t in Event.terms:
 101             log.debug("      [%s] %s %s" % (t, self[t], other[t]));
 102             if not self.has_key(t) or not other.has_key(t):
 103                 return False
 104             if not data_equal(self[t], other[t]):
 105                 return False
 106         return True
 107
 108     def optional(self):
 109         if self.has_key('optional') and self['optional'] == '1':
 110             return True
 111         return False
 112
 113     def diff(self, other):
 114         for t in Event.terms:
 115             if not self.has_key(t) or not other.has_key(t):
 116                 continue
 117             if not data_equal(self[t], other[t]):
 118                 log.warning("expected %s=%s, got %s" % (t, self[t], other[t]))
 119
 120 # Test file description needs to have following sections:
 121 # [config]
 122 #   - just single instance in file
 123 #   - needs to specify:
 124 #     'command' - perf command name
 125 #     'args'    - special command arguments
 126 #     'ret'     - expected command return value (0 by default)
 127 #     'arch'    - architecture specific test (optional)
 128 #                 comma separated list, ! at the beginning
 129 #                 negates it.
 130 #
 131 # [eventX:base]
 132 #   - one or multiple instances in file
 133 #   - expected values assignments
 134 class Test(object):
 135     def __init__(self, path, options):
 136         parser = ConfigParser.SafeConfigParser()
 137         parser.read(path)
 138
 139         log.warning("running '%s'" % path)
 140
 141         self.path     = path
 142         self.test_dir = options.test_dir
 143         self.perf     = options.perf
 144         self.command  = parser.get('config', 'command')
 145         self.args     = parser.get('config', 'args')
 146
 147         try:
 148             self.ret  = parser.get('config', 'ret')
 149         except:
 150             self.ret  = 0
 151
 152         try:
 153             self.arch  = parser.get('config', 'arch')
 154             log.warning("test limitation '%s'" % self.arch)
 155         except:
 156             self.arch  = ''
 157
 158         self.expect   = {}
 159         self.result   = {}
 160         log.debug("  loading expected events");
 161         self.load_events(path, self.expect)
 162
 163     def is_event(self, name):
 164         if name.find("event") == -1:
 165             return False
 166         else:
 167             return True
 168
 169     def skip_test(self, myarch):
 170         # If architecture not set always run test
 171         if self.arch == '':
 172             # log.warning("test for arch %s is ok" % myarch)
 173             return False
 174
 175         # Allow multiple values in assignment separated by ','
 176         arch_list = self.arch.split(',')
 177
 178         # Handle negated list such as !s390x,ppc
 179         if arch_list[0][0] == '!':
 180             arch_list[0] = arch_list[0][1:]
 181             log.warning("excluded architecture list %s" % arch_list)
 182             for arch_item in arch_list:
 183                 # log.warning("test for %s arch is %s" % (arch_item, myarch))
 184                 if arch_item == myarch:
 185                     return True
 186             return False
 187
 188         for arch_item in arch_list:
 189             # log.warning("test for architecture '%s' current '%s'" % (arch_item, myarch))
 190             if arch_item == myarch:
 191                 return False
 192         return True
 193
 194     def load_events(self, path, events):
 195         parser_event = ConfigParser.SafeConfigParser()
 196         parser_event.read(path)
 197
 198         # The event record section header contains 'event' word,
 199         # optionaly followed by ':' allowing to load 'parent
 200         # event' first as a base
 201         for section in filter(self.is_event, parser_event.sections()):
 202
 203             parser_items = parser_event.items(section);
 204             base_items   = {}
 205
 206             # Read parent event if there's any
 207             if (':' in section):
 208                 base = section[section.index(':') + 1:]
 209                 parser_base = ConfigParser.SafeConfigParser()
 210                 parser_base.read(self.test_dir + '/' + base)
 211                 base_items = parser_base.items('event')
 212
 213             e = Event(section, parser_items, base_items)
 214             events[section] = e
 215
 216     def run_cmd(self, tempdir):
 217         junk1, junk2, junk3, junk4, myarch = (os.uname())
 218
 219         if self.skip_test(myarch):
 220             raise Notest(self, myarch)
 221
 222         cmd = "PERF_TEST_ATTR=%s %s %s -o %s/perf.data %s" % (tempdir,
 223               self.perf, self.command, tempdir, self.args)
 224         ret = os.WEXITSTATUS(os.system(cmd))
 225
 226         log.info("  '%s' ret '%s', expected '%s'" % (cmd, str(ret), str(self.ret)))
 227
 228         if not data_equal(str(ret), str(self.ret)):
 229             raise Unsup(self)
 230
 231     def compare(self, expect, result):
 232         match = {}
 233
 234         log.debug("  compare");
 235
 236         # For each expected event find all matching
 237         # events in result. Fail if there's not any.
 238         for exp_name, exp_event in expect.items():
 239             exp_list = []
 240             res_event = {}
 241             log.debug("    matching [%s]" % exp_name)
 242             for res_name, res_event in result.items():
 243                 log.debug("      to [%s]" % res_name)
 244                 if (exp_event.equal(res_event)):
 245                     exp_list.append(res_name)
 246                     log.debug("    ->OK")
 247                 else:
 248                     log.debug("    ->FAIL");
 249
 250             log.debug("    match: [%s] matches %s" % (exp_name, str(exp_list)))
 251
 252             # we did not any matching event - fail
 253             if not exp_list:
 254                 if exp_event.optional():
 255                     log.debug("    %s does not match, but is optional" % exp_name)
 256                 else:
 257                     if not res_event:
 258                         log.debug("    res_event is empty");
 259                     else:
 260                         exp_event.diff(res_event)
 261                     raise Fail(self, 'match failure');
 262
 263             match[exp_name] = exp_list
 264
 265         # For each defined group in the expected events
 266         # check we match the same group in the result.
 267         for exp_name, exp_event in expect.items():
 268             group = exp_event.group
 269
 270             if (group == ''):
 271                 continue
 272
 273             for res_name in match[exp_name]:
 274                 res_group = result[res_name].group
 275                 if res_group not in match[group]:
 276                     raise Fail(self, 'group failure')
 277
 278                 log.debug("    group: [%s] matches group leader %s" %
 279                          (exp_name, str(match[group])))
 280
 281         log.debug("  matched")
 282
 283     def resolve_groups(self, events):
 284         for name, event in events.items():
 285             group_fd = event['group_fd'];
 286             if group_fd == '-1':
 287                 continue;
 288
 289             for iname, ievent in events.items():
 290                 if (ievent['fd'] == group_fd):
 291                     event.group = iname
 292                     log.debug('[%s] has group leader [%s]' % (name, iname))
 293                     break;
 294
 295     def run(self):
 296         tempdir = tempfile.mkdtemp();
 297
 298         try:
 299             # run the test script
 300             self.run_cmd(tempdir);
 301
 302             # load events expectation for the test
 303             log.debug("  loading result events");
 304             for f in glob.glob(tempdir + '/event*'):
 305                 self.load_events(f, self.result);
 306
 307             # resolve group_fd to event names
 308             self.resolve_groups(self.expect);
 309             self.resolve_groups(self.result);
 310
 311             # do the expectation - results matching - both ways
 312             self.compare(self.expect, self.result)
 313             self.compare(self.result, self.expect)
 314
 315         finally:
 316             # cleanup
 317             shutil.rmtree(tempdir)
 318
 319
 320 def run_tests(options):
 321     for f in glob.glob(options.test_dir + '/' + options.test):
 322         try:
 323             Test(f, options).run()
 324         except Unsup, obj:
 325             log.warning("unsupp  %s" % obj.getMsg())
 326         except Notest, obj:
 327             log.warning("skipped %s" % obj.getMsg())
 328
 329 def setup_log(verbose):
 330     global log
 331     level = logging.CRITICAL
 332
 333     if verbose == 1:
 334         level = logging.WARNING
 335     if verbose == 2:
 336         level = logging.INFO
 337     if verbose >= 3:
 338         level = logging.DEBUG
 339
 340     log = logging.getLogger('test')
 341     log.setLevel(level)
 342     ch  = logging.StreamHandler()
 343     ch.setLevel(level)
 344     formatter = logging.Formatter('%(message)s')
 345     ch.setFormatter(formatter)
 346     log.addHandler(ch)
 347
 348 USAGE = '''%s [OPTIONS]
 349   -d dir  # tests dir
 350   -p path # perf binary
 351   -t test # single test
 352   -v      # verbose level
 353 ''' % sys.argv[0]
 354
 355 def main():
 356     parser = optparse.OptionParser(usage=USAGE)
 357
 358     parser.add_option("-t", "--test",
 359                       action="store", type="string", dest="test")
 360     parser.add_option("-d", "--test-dir",
 361                       action="store", type="string", dest="test_dir")
 362     parser.add_option("-p", "--perf",
 363                       action="store", type="string", dest="perf")
 364     parser.add_option("-v", "--verbose",
 365                       action="count", dest="verbose")
 366
 367     options, args = parser.parse_args()
 368     if args:
 369         parser.error('FAILED wrong arguments %s' %  ' '.join(args))
 370         return -1
 371
 372     setup_log(options.verbose)
 373
 374     if not options.test_dir:
 375         print 'FAILED no -d option specified'
 376         sys.exit(-1)
 377
 378     if not options.test:
 379         options.test = 'test*'
 380
 381     try:
 382         run_tests(options)
 383
 384     except Fail, obj:
 385         print "FAILED %s" % obj.getMsg();
 386         sys.exit(-1)
 387
 388     sys.exit(0)
 389
 390 if __name__ == '__main__':
 391     main()