tests/TraceTest.py

   1 import sys
   2 import os
   3 import shutil
   4 import tempfile
   5 import difflib
   6 import subprocess
   7 from babeltrace import CTFWriter, CTFStringEncoding
   8
   9
  10 class TraceTest():
  11     def __init__(self, delete_trace=True):
  12         self.delete_trace = delete_trace
  13         self._trace_root = tempfile.mkdtemp()
  14         self.trace_path = os.path.join(self.trace_root, "kernel")
  15         self.create_writer()
  16         self.create_stream_class()
  17         self.define_base_types()
  18         self.define_events()
  19         self.create_stream()
  20
  21     def __del__(self):
  22         if self.delete_trace:
  23             self.rm_trace()
  24
  25     @property
  26     def trace_root(self):
  27         return self._trace_root
  28
  29     def rm_trace(self):
  30         shutil.rmtree(self.trace_root)
  31
  32     def flush(self):
  33         self.writer.flush_metadata()
  34         self.stream.flush()
  35
  36     def create_writer(self):
  37         self.clock = CTFWriter.Clock("A_clock")
  38         self.clock.description = "Simple clock"
  39         self.writer = CTFWriter.Writer(self.trace_path)
  40         self.writer.add_clock(self.clock)
  41         self.writer.add_environment_field("Python_version",
  42                                           str(sys.version_info))
  43         self.writer.add_environment_field("tracer_major", 2)
  44         self.writer.add_environment_field("tracer_minor", 8)
  45         self.writer.add_environment_field("tracer_patchlevel", 0)
  46
  47     def create_stream_class(self):
  48         self.stream_class = CTFWriter.StreamClass("test_stream")
  49         self.stream_class.clock = self.clock
  50
  51     def define_base_types(self):
  52         self.char8_type = CTFWriter.IntegerFieldDeclaration(8)
  53         self.char8_type.signed = True
  54         self.char8_type.encoding = CTFStringEncoding.UTF8
  55         self.char8_type.alignment = 8
  56
  57         self.int16_type = CTFWriter.IntegerFieldDeclaration(16)
  58         self.int16_type.signed = True
  59         self.int16_type.alignment = 8
  60
  61         self.uint16_type = CTFWriter.IntegerFieldDeclaration(16)
  62         self.uint16_type.signed = False
  63         self.uint16_type.alignment = 8
  64
  65         self.int32_type = CTFWriter.IntegerFieldDeclaration(32)
  66         self.int32_type.signed = True
  67         self.int32_type.alignment = 8
  68
  69         self.uint32_type = CTFWriter.IntegerFieldDeclaration(32)
  70         self.uint32_type.signed = False
  71         self.uint32_type.alignment = 8
  72
  73         self.int64_type = CTFWriter.IntegerFieldDeclaration(64)
  74         self.int64_type.signed = True
  75         self.int64_type.alignment = 8
  76
  77         self.uint64_type = CTFWriter.IntegerFieldDeclaration(64)
  78         self.uint64_type.signed = False
  79         self.uint64_type.alignment = 8
  80
  81         self.array16_type = CTFWriter.ArrayFieldDeclaration(self.char8_type,
  82                                                             16)
  83
  84         self.string_type = CTFWriter.StringFieldDeclaration()
  85
  86     def add_event(self, event):
  87         event.add_field(self.uint32_type, "_cpu_id")
  88         self.stream_class.add_event_class(event)
  89
  90     def define_sched_switch(self):
  91         self.sched_switch = CTFWriter.EventClass("sched_switch")
  92         self.sched_switch.add_field(self.array16_type, "_prev_comm")
  93         self.sched_switch.add_field(self.int32_type, "_prev_tid")
  94         self.sched_switch.add_field(self.int32_type, "_prev_prio")
  95         self.sched_switch.add_field(self.int64_type, "_prev_state")
  96         self.sched_switch.add_field(self.array16_type, "_next_comm")
  97         self.sched_switch.add_field(self.int32_type, "_next_tid")
  98         self.sched_switch.add_field(self.int32_type, "_next_prio")
  99         self.add_event(self.sched_switch)
 100
 101     def define_softirq_raise(self):
 102         self.softirq_raise = CTFWriter.EventClass("softirq_raise")
 103         self.softirq_raise.add_field(self.uint32_type, "_vec")
 104         self.add_event(self.softirq_raise)
 105
 106     def define_softirq_entry(self):
 107         self.softirq_entry = CTFWriter.EventClass("softirq_entry")
 108         self.softirq_entry.add_field(self.uint32_type, "_vec")
 109         self.add_event(self.softirq_entry)
 110
 111     def define_softirq_exit(self):
 112         self.softirq_exit = CTFWriter.EventClass("softirq_exit")
 113         self.softirq_exit.add_field(self.uint32_type, "_vec")
 114         self.add_event(self.softirq_exit)
 115
 116     def define_irq_handler_entry(self):
 117         self.irq_handler_entry = CTFWriter.EventClass("irq_handler_entry")
 118         self.irq_handler_entry.add_field(self.int32_type, "_irq")
 119         self.irq_handler_entry.add_field(self.string_type, "_name")
 120         self.add_event(self.irq_handler_entry)
 121
 122     def define_irq_handler_exit(self):
 123         self.irq_handler_exit = CTFWriter.EventClass("irq_handler_exit")
 124         self.irq_handler_exit.add_field(self.int32_type, "_irq")
 125         self.irq_handler_exit.add_field(self.int32_type, "_ret")
 126         self.add_event(self.irq_handler_exit)
 127
 128     def define_syscall_entry_write(self):
 129         self.syscall_entry_write = CTFWriter.EventClass("syscall_entry_write")
 130         self.syscall_entry_write.add_field(self.uint32_type, "_fd")
 131         self.syscall_entry_write.add_field(self.uint64_type, "_buf")
 132         self.syscall_entry_write.add_field(self.uint64_type, "_count")
 133         self.add_event(self.syscall_entry_write)
 134
 135     def define_syscall_exit_write(self):
 136         self.syscall_exit_write = CTFWriter.EventClass("syscall_exit_write")
 137         self.syscall_exit_write.add_field(self.int64_type, "_ret")
 138         self.add_event(self.syscall_exit_write)
 139
 140     def define_syscall_entry_read(self):
 141         self.syscall_entry_read = CTFWriter.EventClass("syscall_entry_read")
 142         self.syscall_entry_read.add_field(self.uint32_type, "_fd")
 143         self.syscall_entry_read.add_field(self.uint64_type, "_count")
 144         self.add_event(self.syscall_entry_read)
 145
 146     def define_syscall_exit_read(self):
 147         self.syscall_exit_read = CTFWriter.EventClass("syscall_exit_read")
 148         self.syscall_exit_read.add_field(self.uint64_type, "_buf")
 149         self.syscall_exit_read.add_field(self.int64_type, "_ret")
 150         self.add_event(self.syscall_exit_read)
 151
 152     def define_syscall_entry_open(self):
 153         self.syscall_entry_open = CTFWriter.EventClass("syscall_entry_open")
 154         self.syscall_entry_open.add_field(self.string_type, "_filename")
 155         self.syscall_entry_open.add_field(self.int32_type, "_flags")
 156         self.syscall_entry_open.add_field(self.uint16_type, "_mode")
 157         self.add_event(self.syscall_entry_open)
 158
 159     def define_syscall_exit_open(self):
 160         self.syscall_exit_open = CTFWriter.EventClass("syscall_exit_open")
 161         self.syscall_exit_open.add_field(self.int64_type, "_ret")
 162         self.add_event(self.syscall_exit_open)
 163
 164     def define_lttng_statedump_process_state(self):
 165         self.lttng_statedump_process_state = CTFWriter.EventClass(
 166             "lttng_statedump_process_state")
 167         self.lttng_statedump_process_state.add_field(self.int32_type, "_tid")
 168         self.lttng_statedump_process_state.add_field(self.int32_type, "_vtid")
 169         self.lttng_statedump_process_state.add_field(self.int32_type, "_pid")
 170         self.lttng_statedump_process_state.add_field(self.int32_type, "_vpid")
 171         self.lttng_statedump_process_state.add_field(self.int32_type, "_ppid")
 172         self.lttng_statedump_process_state.add_field(self.int32_type, "_vppid")
 173         self.lttng_statedump_process_state.add_field(self.array16_type,
 174                                                      "_name")
 175         self.lttng_statedump_process_state.add_field(self.int32_type, "_type")
 176         self.lttng_statedump_process_state.add_field(self.int32_type, "_mode")
 177         self.lttng_statedump_process_state.add_field(self.int32_type,
 178                                                      "_submode")
 179         self.lttng_statedump_process_state.add_field(self.int32_type,
 180                                                      "_status")
 181         self.lttng_statedump_process_state.add_field(self.int32_type,
 182                                                      "_ns_level")
 183         self.add_event(self.lttng_statedump_process_state)
 184
 185     def define_lttng_statedump_file_descriptor(self):
 186         self.lttng_statedump_file_descriptor = CTFWriter.EventClass(
 187             "lttng_statedump_file_descriptor")
 188         self.lttng_statedump_file_descriptor.add_field(self.int32_type, "_pid")
 189         self.lttng_statedump_file_descriptor.add_field(self.int32_type, "_fd")
 190         self.lttng_statedump_file_descriptor.add_field(self.uint32_type,
 191                                                        "_flags")
 192         self.lttng_statedump_file_descriptor.add_field(self.uint32_type,
 193                                                        "_fmode")
 194         self.lttng_statedump_file_descriptor.add_field(self.string_type,
 195                                                        "_filename")
 196         self.add_event(self.lttng_statedump_file_descriptor)
 197
 198     def define_sched_wakeup(self):
 199         self.sched_wakeup = CTFWriter.EventClass("sched_wakeup")
 200         self.sched_wakeup.add_field(self.array16_type, "_comm")
 201         self.sched_wakeup.add_field(self.int32_type, "_tid")
 202         self.sched_wakeup.add_field(self.int32_type, "_prio")
 203         self.sched_wakeup.add_field(self.int32_type, "_success")
 204         self.sched_wakeup.add_field(self.int32_type, "_target_cpu")
 205         self.add_event(self.sched_wakeup)
 206
 207     def define_sched_waking(self):
 208         self.sched_waking = CTFWriter.EventClass("sched_waking")
 209         self.sched_waking.add_field(self.array16_type, "_comm")
 210         self.sched_waking.add_field(self.int32_type, "_tid")
 211         self.sched_waking.add_field(self.int32_type, "_prio")
 212         self.sched_waking.add_field(self.int32_type, "_target_cpu")
 213         self.add_event(self.sched_waking)
 214
 215     def define_block_rq_complete(self):
 216         self.block_rq_complete = CTFWriter.EventClass("block_rq_complete")
 217         self.block_rq_complete.add_field(self.uint32_type, "_dev")
 218         self.block_rq_complete.add_field(self.uint64_type, "_sector")
 219         self.block_rq_complete.add_field(self.uint32_type, "_nr_sector")
 220         self.block_rq_complete.add_field(self.int32_type, "_errors")
 221         self.block_rq_complete.add_field(self.uint32_type, "_rwbs")
 222         self.block_rq_complete.add_field(self.uint64_type, "__cmd_length")
 223         self.block_rq_complete.add_field(self.array16_type, "_cmd")
 224         self.add_event(self.block_rq_complete)
 225
 226     def define_block_rq_issue(self):
 227         self.block_rq_issue = CTFWriter.EventClass("block_rq_issue")
 228         self.block_rq_issue.add_field(self.uint32_type, "_dev")
 229         self.block_rq_issue.add_field(self.uint64_type, "_sector")
 230         self.block_rq_issue.add_field(self.uint32_type, "_nr_sector")
 231         self.block_rq_issue.add_field(self.uint32_type, "_bytes")
 232         self.block_rq_issue.add_field(self.int32_type, "_tid")
 233         self.block_rq_issue.add_field(self.uint32_type, "_rwbs")
 234         self.block_rq_issue.add_field(self.uint64_type, "__cmd_length")
 235         self.block_rq_issue.add_field(self.array16_type, "_cmd")
 236         self.block_rq_issue.add_field(self.array16_type, "_comm")
 237         self.add_event(self.block_rq_issue)
 238
 239     def define_net_dev_xmit(self):
 240         self.net_dev_xmit = CTFWriter.EventClass("net_dev_xmit")
 241         self.net_dev_xmit.add_field(self.uint64_type, "_skbaddr")
 242         self.net_dev_xmit.add_field(self.int32_type, "_rc")
 243         self.net_dev_xmit.add_field(self.uint32_type, "_len")
 244         self.net_dev_xmit.add_field(self.string_type, "_name")
 245         self.add_event(self.net_dev_xmit)
 246
 247     def define_netif_receive_skb(self):
 248         self.netif_receive_skb = CTFWriter.EventClass("netif_receive_skb")
 249         self.netif_receive_skb.add_field(self.uint64_type, "_skbaddr")
 250         self.netif_receive_skb.add_field(self.uint32_type, "_len")
 251         self.netif_receive_skb.add_field(self.string_type, "_name")
 252         self.add_event(self.netif_receive_skb)
 253
 254     def define_events(self):
 255         self.define_sched_switch()
 256         self.define_softirq_raise()
 257         self.define_softirq_entry()
 258         self.define_softirq_exit()
 259         self.define_irq_handler_entry()
 260         self.define_irq_handler_exit()
 261         self.define_syscall_entry_write()
 262         self.define_syscall_exit_write()
 263         self.define_syscall_entry_read()
 264         self.define_syscall_exit_read()
 265         self.define_syscall_entry_open()
 266         self.define_syscall_exit_open()
 267         self.define_lttng_statedump_process_state()
 268         self.define_lttng_statedump_file_descriptor()
 269         self.define_sched_wakeup()
 270         self.define_sched_waking()
 271         self.define_block_rq_complete()
 272         self.define_block_rq_issue()
 273         self.define_net_dev_xmit()
 274         self.define_netif_receive_skb()
 275
 276     def create_stream(self):
 277         self.stream = self.writer.create_stream(self.stream_class)
 278
 279     def set_char_array(self, event, string):
 280         if len(string) > 16:
 281             string = string[0:16]
 282         else:
 283             string = "%s" % (string + "\0" * (16 - len(string)))
 284
 285         for i, char in enumerate(string):
 286             event.field(i).value = ord(char)
 287
 288     def set_int(self, event, value):
 289         event.value = value
 290
 291     def set_string(self, event, value):
 292         event.value = value
 293
 294     def write_softirq_raise(self, time_ms, cpu_id, vec):
 295         event = CTFWriter.Event(self.softirq_raise)
 296         self.clock.time = time_ms * 1000000
 297         self.set_int(event.payload("_cpu_id"), cpu_id)
 298         self.set_int(event.payload("_vec"), vec)
 299         self.stream.append_event(event)
 300         self.stream.flush()
 301
 302     def write_softirq_entry(self, time_ms, cpu_id, vec):
 303         event = CTFWriter.Event(self.softirq_entry)
 304         self.clock.time = time_ms * 1000000
 305         self.set_int(event.payload("_cpu_id"), cpu_id)
 306         self.set_int(event.payload("_vec"), vec)
 307         self.stream.append_event(event)
 308         self.stream.flush()
 309
 310     def write_softirq_exit(self, time_ms, cpu_id, vec):
 311         event = CTFWriter.Event(self.softirq_exit)
 312         self.clock.time = time_ms * 1000000
 313         self.set_int(event.payload("_cpu_id"), cpu_id)
 314         self.set_int(event.payload("_vec"), vec)
 315         self.stream.append_event(event)
 316         self.stream.flush()
 317
 318     def write_irq_handler_entry(self, time_ms, cpu_id, irq, name):
 319         event = CTFWriter.Event(self.irq_handler_entry)
 320         self.clock.time = time_ms * 1000000
 321         self.set_int(event.payload("_cpu_id"), cpu_id)
 322         self.set_int(event.payload("_irq"), irq)
 323         self.set_string(event.payload("_name"), name)
 324         self.stream.append_event(event)
 325         self.stream.flush()
 326
 327     def write_irq_handler_exit(self, time_ms, cpu_id, irq, ret):
 328         event = CTFWriter.Event(self.irq_handler_exit)
 329         self.clock.time = time_ms * 1000000
 330         self.set_int(event.payload("_cpu_id"), cpu_id)
 331         self.set_int(event.payload("_irq"), irq)
 332         self.set_int(event.payload("_ret"), ret)
 333         self.stream.append_event(event)
 334         self.stream.flush()
 335
 336     def write_syscall_write(self, time_ms, cpu_id, delay, fd, buf, count, ret):
 337         event_entry = CTFWriter.Event(self.syscall_entry_write)
 338         self.clock.time = time_ms * 1000000
 339         self.set_int(event_entry.payload("_cpu_id"), cpu_id)
 340         self.set_int(event_entry.payload("_fd"), fd)
 341         self.set_int(event_entry.payload("_buf"), buf)
 342         self.set_int(event_entry.payload("_count"), count)
 343         self.stream.append_event(event_entry)
 344
 345         event_exit = CTFWriter.Event(self.syscall_exit_write)
 346         self.clock.time = (time_ms + delay) * 1000000
 347         self.set_int(event_exit.payload("_cpu_id"), cpu_id)
 348         self.set_int(event_exit.payload("_ret"), ret)
 349         self.stream.append_event(event_exit)
 350         self.stream.flush()
 351
 352     def write_syscall_read(self, time_ms, cpu_id, delay, fd, buf, count, ret):
 353         event_entry = CTFWriter.Event(self.syscall_entry_read)
 354         self.clock.time = time_ms * 1000000
 355         self.set_int(event_entry.payload("_cpu_id"), cpu_id)
 356         self.set_int(event_entry.payload("_fd"), fd)
 357         self.set_int(event_entry.payload("_count"), count)
 358         self.stream.append_event(event_entry)
 359
 360         event_exit = CTFWriter.Event(self.syscall_exit_read)
 361         self.clock.time = (time_ms + delay) * 1000000
 362         self.set_int(event_exit.payload("_cpu_id"), cpu_id)
 363         self.set_int(event_exit.payload("_buf"), buf)
 364         self.set_int(event_exit.payload("_ret"), ret)
 365         self.stream.append_event(event_exit)
 366         self.stream.flush()
 367
 368     def write_syscall_open(self, time_ms, cpu_id, delay, filename, flags,
 369                            mode, ret):
 370         event = CTFWriter.Event(self.syscall_entry_open)
 371         self.clock.time = time_ms * 1000000
 372         self.set_int(event.payload("_cpu_id"), cpu_id)
 373         self.set_string(event.payload("_filename"), filename)
 374         self.set_int(event.payload("_flags"), flags)
 375         self.set_int(event.payload("_mode"), mode)
 376         self.stream.append_event(event)
 377         self.stream.flush()
 378
 379         event = CTFWriter.Event(self.syscall_exit_open)
 380         self.clock.time = (time_ms + delay) * 1000000
 381         self.set_int(event.payload("_cpu_id"), cpu_id)
 382         self.set_int(event.payload("_ret"), ret)
 383         self.stream.append_event(event)
 384         self.stream.flush()
 385
 386     def write_lttng_statedump_file_descriptor(self, time_ms, cpu_id, pid, fd,
 387                                               flags, fmode, filename):
 388         event = CTFWriter.Event(self.lttng_statedump_file_descriptor)
 389         self.clock.time = time_ms * 1000000
 390         self.set_int(event.payload("_cpu_id"), cpu_id)
 391         self.set_int(event.payload("_pid"), pid)
 392         self.set_int(event.payload("_fd"), fd)
 393         self.set_int(event.payload("_flags"), flags)
 394         self.set_int(event.payload("_fmode"), fmode)
 395         self.set_string(event.payload("_filename"), filename)
 396         self.stream.append_event(event)
 397         self.stream.flush()
 398
 399     def write_lttng_statedump_process_state(self, time_ms, cpu_id, tid, vtid,
 400                                             pid, vpid, ppid, vppid, name, type,
 401                                             mode, submode, status, ns_level):
 402         event = CTFWriter.Event(self.lttng_statedump_process_state)
 403         self.clock.time = time_ms * 1000000
 404         self.set_int(event.payload("_cpu_id"), cpu_id)
 405         self.set_int(event.payload("_tid"), tid)
 406         self.set_int(event.payload("_vtid"), vtid)
 407         self.set_int(event.payload("_pid"), pid)
 408         self.set_int(event.payload("_vpid"), vpid)
 409         self.set_int(event.payload("_ppid"), ppid)
 410         self.set_int(event.payload("_vppid"), vppid)
 411         self.set_char_array(event.payload("_name"), name)
 412         self.set_int(event.payload("_type"), type)
 413         self.set_int(event.payload("_mode"), mode)
 414         self.set_int(event.payload("_submode"), submode)
 415         self.set_int(event.payload("_status"), status)
 416         self.set_int(event.payload("_ns_level"), ns_level)
 417         self.stream.append_event(event)
 418         self.stream.flush()
 419
 420     def write_sched_wakeup(self, time_ms, cpu_id, comm, tid, prio, target_cpu):
 421         event = CTFWriter.Event(self.sched_wakeup)
 422         self.clock.time = time_ms * 1000000
 423         self.set_int(event.payload("_cpu_id"), cpu_id)
 424         self.set_char_array(event.payload("_comm"), comm)
 425         self.set_int(event.payload("_tid"), tid)
 426         self.set_int(event.payload("_prio"), prio)
 427         self.set_int(event.payload("_target_cpu"), target_cpu)
 428         self.stream.append_event(event)
 429         self.stream.flush()
 430
 431     def write_sched_waking(self, time_ms, cpu_id, comm, tid, prio, target_cpu):
 432         event = CTFWriter.Event(self.sched_waking)
 433         self.clock.time = time_ms * 1000000
 434         self.set_int(event.payload("_cpu_id"), cpu_id)
 435         self.set_char_array(event.payload("_comm"), comm)
 436         self.set_int(event.payload("_tid"), tid)
 437         self.set_int(event.payload("_prio"), prio)
 438         self.set_int(event.payload("_target_cpu"), target_cpu)
 439         self.stream.append_event(event)
 440         self.stream.flush()
 441
 442     def write_block_rq_complete(self, time_ms, cpu_id, dev, sector, nr_sector,
 443                                 errors, rwbs, _cmd_length, cmd):
 444         event = CTFWriter.Event(self.block_rq_complete)
 445         self.clock.time = time_ms * 1000000
 446         self.set_int(event.payload("_cpu_id"), cpu_id)
 447         self.set_int(event.payload("_dev"), dev)
 448         self.set_int(event.payload("_sector"), sector)
 449         self.set_int(event.payload("_nr_sector"), nr_sector)
 450         self.set_int(event.payload("_errors"), errors)
 451         self.set_int(event.payload("_rwbs"), rwbs)
 452         self.set_int(event.payload("__cmd_length"), _cmd_length)
 453         self.set_char_array(event.payload("_cmd"), cmd)
 454         self.stream.append_event(event)
 455         self.stream.flush()
 456
 457     def write_block_rq_issue(self, time_ms, cpu_id, dev, sector, nr_sector,
 458                              bytes, tid, rwbs, _cmd_length, cmd, comm):
 459         event = CTFWriter.Event(self.block_rq_issue)
 460         self.clock.time = time_ms * 1000000
 461         self.set_int(event.payload("_cpu_id"), cpu_id)
 462         self.set_int(event.payload("_dev"), dev)
 463         self.set_int(event.payload("_sector"), sector)
 464         self.set_int(event.payload("_nr_sector"), nr_sector)
 465         self.set_int(event.payload("_bytes"), bytes)
 466         self.set_int(event.payload("_tid"), tid)
 467         self.set_int(event.payload("_rwbs"), rwbs)
 468         self.set_int(event.payload("__cmd_length"), _cmd_length)
 469         self.set_char_array(event.payload("_cmd"), cmd)
 470         self.set_char_array(event.payload("_comm"), comm)
 471         self.stream.append_event(event)
 472         self.stream.flush()
 473
 474     def write_net_dev_xmit(self, time_ms, cpu_id, skbaddr, rc, len, name):
 475         event = CTFWriter.Event(self.net_dev_xmit)
 476         self.clock.time = time_ms * 1000000
 477         self.set_int(event.payload("_cpu_id"), cpu_id)
 478         self.set_int(event.payload("_skbaddr"), skbaddr)
 479         self.set_int(event.payload("_rc"), rc)
 480         self.set_int(event.payload("_len"), len)
 481         self.set_string(event.payload("_name"), name)
 482         self.stream.append_event(event)
 483         self.stream.flush()
 484
 485     def write_netif_receive_skb(self, time_ms, cpu_id, skbaddr, len, name):
 486         event = CTFWriter.Event(self.netif_receive_skb)
 487         self.clock.time = time_ms * 1000000
 488         self.set_int(event.payload("_cpu_id"), cpu_id)
 489         self.set_int(event.payload("_skbaddr"), skbaddr)
 490         self.set_int(event.payload("_len"), len)
 491         self.set_string(event.payload("_name"), name)
 492         self.stream.append_event(event)
 493         self.stream.flush()
 494
 495     def write_sched_switch(self, time_ms, cpu_id, prev_comm, prev_tid,
 496                            next_comm, next_tid, prev_prio=20, prev_state=1,
 497                            next_prio=20):
 498         event = CTFWriter.Event(self.sched_switch)
 499         self.clock.time = time_ms * 1000000
 500         self.set_char_array(event.payload("_prev_comm"), prev_comm)
 501         self.set_int(event.payload("_prev_tid"), prev_tid)
 502         self.set_int(event.payload("_prev_prio"), prev_prio)
 503         self.set_int(event.payload("_prev_state"), prev_state)
 504         self.set_char_array(event.payload("_next_comm"), next_comm)
 505         self.set_int(event.payload("_next_tid"), next_tid)
 506         self.set_int(event.payload("_next_prio"), next_prio)
 507         self.set_int(event.payload("_cpu_id"), cpu_id)
 508         self.stream.append_event(event)
 509         self.stream.flush()
 510
 511     def sched_switch_50pc(self, start_time_ms, end_time_ms, cpu_id, period,
 512                           comm1, tid1, comm2, tid2):
 513         current = start_time_ms
 514         while current < end_time_ms:
 515             self.write_sched_switch(current, cpu_id, comm1, tid1, comm2, tid2)
 516             current += period
 517             self.write_sched_switch(current, cpu_id, comm2, tid2, comm1, tid1)
 518             current += period
 519
 520     def compare_output(self, cmd, expected):
 521         line_sep = '\n'
 522         result = subprocess.getoutput(cmd)
 523         diff = difflib.ndiff(expected.split(line_sep), result.split(line_sep))
 524
 525         for line in diff:
 526             if line[0] != ' ':
 527                 # result doesn't match expected. Print the diff and
 528                 # return False
 529                 print(line_sep.join(diff))
 530                 return False
 531
 532         return True
 533
 534
 535 class AnalysesTest():
 536     def __init__(self, delete_trace=True, verbose=False):
 537         self.verbose = verbose
 538         self.t = TraceTest(delete_trace=delete_trace)
 539         self.common_options = '--no-progress --skip-validation'
 540         self.cmd_root = './'
 541         self.log('Trace in %s' % (self.t.trace_root))
 542
 543     def log(self, msg):
 544         if self.verbose:
 545             print(msg)
 546
 547     def compare_output(self, cmd, expected):
 548         return self.t.compare_output(cmd, expected)
 549
 550     def run(self):
 551         ok = True
 552         self.write_trace()
 553         for t in self.test_list:
 554             ret = t[1]()
 555             self.log('%s: %s' % (t[0], ret))
 556             if not ret:
 557                 ok = False
 558         return ok