add st-draw: a pycairo based drawing tool for st_trace schedules

6 files changed, 754 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index 2f993ac..8cdbb63 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,9 @@
 .sconsign.dblite
 *.o
 *.d
+*.pyc
+*.pdf
+*.bin
 ~*
 *~
 ftcat
diff --git a/sched_trace/__init__.py b/sched_trace/__init__.py
new file mode 100644
index 0000000..5db2c2d
--- /dev/null
+++ b/sched_trace/__init__.py
@@ -0,0 +1,202 @@
+from __future__ import division
+
+from collections import defaultdict
+from itertools import imap
+
+import heapq
+
+from .format import event, EVENTS_WITHOUT_TIMESTAMP, EVENTS
+from .file import SchedTraceFile
+
+def event_id(unpacked_record):
+    "Given a tuple from format.unpack(), return the ID of the event"
+    return unpacked_record[0]
+
+def event_cpu(unpacked_record):
+    "Given a tuple from format.unpack(), return the CPU that recorded the event"
+    return unpacked_record[1]
+
+def event_pid(unpacked_record):
+    "Given a tuple from format.unpack(), return the process ID of the event"
+    return unpacked_record[2]
+
+def event_job_id(unpacked_record):
+    "Given a tuple from format.unpack(), return the job ID of the event"
+    return unpacked_record[3]
+
+def event_name(unpacked_record):
+    "Given a tuple from format.unpack(), return the name of the event"
+    # first element of tuple from format.unpack() is event type
+    return event(unpacked_record[0])
+
+def event_time(unpacked_record):
+    "Given a tuple from format.unpack(), return the time of the event"
+    if unpacked_record[0] in EVENTS_WITHOUT_TIMESTAMP:
+        return 0
+    else:
+        return unpacked_record[4]
+
+def lookup_ids(events):
+    wanted = set()
+    for e in events:
+        if type(e) == int:
+            # directly add numeric IDs
+            wanted.add(e)
+        else:
+            # translate strings
+            wanted.add(EVENTS[e])
+    return wanted
+
+
+def cached(trace_attr):
+    cached_val = []
+    def check_cache(*args, **kargs):
+        if not cached_val:
+            cached_val.append(trace_attr(*args, **kargs))
+        return cached_val[0]
+    return check_cache
+
+class SchedTrace(object):
+    def __init__(self, trace_files):
+        self.traces = [SchedTraceFile(f) for f in trace_files]
+
+        self._names = None
+        self._wcets = None
+        self._periods = None
+        self._phases = None
+        self._partitions = None
+        self._sys_rels = None
+
+    def __len__(self):
+        return sum((len(t) for t in self.traces))
+
+    def __iter__(self):
+        for t in self.traces:
+            for rec in t:
+                yield rec
+
+    def events_of_type(self, *events):
+        wanted = lookup_ids(events)
+        for t in self.traces:
+            for rec in t.events_of_type(wanted):
+                yield rec
+
+    def events_of_type_chrono(self, *events):
+        wanted = lookup_ids(events)
+
+        def by_event_time(rec):
+            return (event_time(rec), rec)
+
+        trace_iters = [imap(by_event_time, t.events_of_type(wanted))
+                       for t in self.traces]
+
+        for (when, rec) in heapq.merge(*trace_iters):
+            yield rec
+
+    def events_in_range_of_type(self, start=0, end=0, *events, **kargs):
+        if 'sorted' in kargs and kargs['sorted']:
+            all = self.events_of_type_chrono(*events)
+        else:
+            all = self.events_of_type(*events)
+
+        for rec in all:
+            if start <= event_time(rec) <= end:
+                yield rec
+
+    def active_in_interval(self, start=0, end=0):
+        tasks = set()
+        cores = set()
+        for rec in self.events_of_type('ST_SWITCH_TO', 'ST_SWITCH_AWAY', 'ST_RELEASE'):
+            if start <= event_time(rec) <= end:
+                tasks.add(event_pid(rec))
+                cores.add(event_cpu(rec))
+        return tasks, cores
+
+    def scheduling_intervals(self):
+        for t in self.traces:
+            for interval in t.scheduling_intervals():
+                yield interval
+
+    def scheduling_intervals_in_range(self, start=0, end=0):
+        for t in self.traces:
+            for (to, away) in t.scheduling_intervals():
+                if not (end < event_time(to) or event_time(away) < start):
+                    yield (to, away)
+
+    def identify_tasks(self):
+        self._names      = defaultdict(str)
+        self._wcets      = defaultdict(int)
+        self._periods    = defaultdict(int)
+        self._phases     = defaultdict(int)
+        self._partitions = defaultdict(int)
+        param_id = EVENTS['ST_PARAM']
+        name_id = EVENTS['ST_NAME']
+        for rec in self.events_of_type(param_id, name_id):
+            pid = rec[2]
+            if rec[0] == param_id:
+                wcet, period, phase, partition = rec[-4:]
+                self._wcets[pid]   = wcet
+                self._periods[pid] = period
+                self._phases[pid]  = phase
+                self._partitions[pid] = partition
+            elif rec[0] == name_id:
+                self._names[pid] = rec[-1]
+
+    @property
+    def task_wcets(self):
+        if self._wcets is None:
+            self.identify_tasks()
+        return self._wcets
+
+    @property
+    def task_periods(self):
+        if self._periods is None:
+            self.identify_tasks()
+        return self._periods
+
+    @property
+    def task_phases(self):
+        if self._phases is None:
+            self.identify_tasks()
+        return self._phases
+
+    @property
+    def task_partitions(self):
+        if self._partitions is None:
+            self.identify_tasks()
+        return self._partitions
+
+    @property
+    def task_names(self):
+        if self._names is None:
+            self.identify_tasks()
+        return self._names
+
+    @property
+    @cached
+    def system_releases(self):
+        return [rec[-1] for rec in self.events_of_type('ST_SYS_RELEASE')]
+
+    @property
+    @cached
+    def earliest_event_time(self):
+        earliest = None
+        for t in self.traces:
+            for rec in t:
+                if event_time(rec) > 0:
+                    if earliest is None or event_time(rec) < earliest:
+                        earliest = event_time(rec)
+                    break
+        return earliest
+
+    @property
+    @cached
+    def latest_event_time(self):
+        latest = None
+        for t in self.traces:
+            for rec in reversed(t):
+                if event_time(rec) > 0:
+                    if latest is None or event_time(rec) > latest:
+                        latest = event_time(rec)
+                    break
+        return latest
diff --git a/sched_trace/draw.py b/sched_trace/draw.py
new file mode 100644
index 0000000..4ccf245
--- /dev/null
+++ b/sched_trace/draw.py
@@ -0,0 +1,231 @@
+from __future__ import division
+
+import sys
+import cairo
+
+from math import ceil
+
+from .format import EVENTS
+
+from . import event_time, event_pid, event_cpu
+
+ARROW_LINE_WIDTH = 2 # (pts)
+ARROW_WIDTH      = 12 # (pts)
+ARROW_HEIGHT     = 0.8 # (relative)
+ALLOC_HEIGHT     = 0.5 # (relative)
+
+COLORS = [
+    (0, 0, 0),
+    (1, 0, 0),
+    (0, 0, 1),
+    (0, 1, 0),
+    (1, 1, 0),
+    (1, 0, 1),
+    (0, 1, 1),
+]
+
+def cpu_color(cpu):
+    return COLORS[cpu % len(COLORS)]
+
+MAJOR_TICK_FONT_SIZE = 24
+TASK_LABEL_FONT_SIZE = 18
+TASK_LABEL_COLOR = (0, 0, 0)
+
+GRID_WIDTH       = 2
+MAJOR_TICK_WIDTH = 2
+MINOR_TICK_WIDTH = 1
+
+MAJOR_TICK_COLOR = (0.7, 0.7, 0.7)
+MINOR_TICK_COLOR = (0.8, 0.8, 0.8)
+
+GRID_COLOR = (0.7, 0.7, 0.7)
+
+JOB_EVENT_COLOR = (0, 0, 0)
+
+YRES = 100
+
+
+
+XLABEL_MARGIN = 72
+YLABEL_MARGIN = 200
+
+def center_text(c, x, y, msg):
+    x_bear, y_bear, width, height, x_adv, y_adv = c.text_extents(msg)
+    c.move_to(x, y)
+    c.rel_move_to(-width / 2, height)
+    c.show_text(msg)
+
+def vcenter_right_align_text(c, x, y, msg):
+    x_bear, y_bear, width, height, x_adv, y_adv = c.text_extents(msg)
+    c.move_to(x, y)
+    c.rel_move_to(-width, height/2)
+    c.show_text(msg)
+    return y_adv
+
+def render(opts, trace):
+    if opts.verbose:
+        print '[II] Identifying relevant tasks and CPUs...',
+        sys.stdout.flush()
+    tasks, cores = trace.active_in_interval(opts.start, opts.end)
+    if opts.verbose:
+        print '%d tasks, %d cores.' % (len(tasks), len(cores))
+
+    # scale is given in points/ms, we need points/ns
+    xscale = opts.xscale/1E6
+    yscale = opts.yscale/YRES
+    width  = ceil(opts.margin * 2 + (opts.end - opts.start) * xscale + YLABEL_MARGIN)
+
+    height = ceil(opts.margin * 2 + (len(tasks) * YRES)  * yscale + XLABEL_MARGIN)
+
+    if opts.verbose:
+        print '[II] Canvas size: %dpt x %dpt' % (width, height)
+
+    pdf = cairo.PDFSurface(opts.output, width, height)
+
+    task_idx = {}
+    for i, t in enumerate(sorted(tasks)):
+        task_idx[t] = i
+
+
+    c = cairo.Context(pdf)
+    c.translate(opts.margin + YLABEL_MARGIN, opts.margin)
+
+    # draw box
+#     c.rectangle(0, 0, width - opts.margin * 2, height - opts.margin * 2)
+#     c.stroke()
+
+    def xpos(x):
+        return (x - opts.start) * xscale
+
+    def ypos(y):
+        return (y * YRES) * yscale
+
+#    c.scale(xscale, yscale)
+
+    # draw minor tick lines
+    if opts.minor_ticks:
+        c.set_source_rgb(*MINOR_TICK_COLOR)
+        c.set_line_width(MINOR_TICK_WIDTH)
+        time = opts.start
+        while time <= opts.end:
+            x = xpos(time)
+            y = ypos(len(tasks))
+            c.new_path()
+            c.move_to(x, y)
+            c.line_to(x, 0)
+            c.stroke()
+            time += opts.minor_ticks * 1E6
+
+
+    # draw major tick lines
+    if opts.major_ticks:
+        c.set_source_rgb(*MAJOR_TICK_COLOR)
+        c.set_line_width(MAJOR_TICK_WIDTH)
+        c.set_font_size(MAJOR_TICK_FONT_SIZE)
+        time = opts.start
+        while time <= opts.end:
+            x = xpos(time)
+            y = ypos(len(tasks) + 0.2)
+            c.new_path()
+            c.move_to(x, y)
+            c.line_to(x, 0)
+            c.stroke()
+            y = ypos(len(tasks) + 0.3)
+            center_text(c, x, y, "%dms" % ((time - opts.start) / 1E6))
+            time += opts.major_ticks * 1E6
+
+
+    # raw allocations
+    box_height = ALLOC_HEIGHT * YRES * yscale
+    for (to, away) in trace.scheduling_intervals_in_range(opts.start, opts.end):
+        delta = (event_time(away) - event_time(to)) * xscale
+        pid = event_pid(to)
+        y = ypos(task_idx[pid] + ALLOC_HEIGHT)
+        x = xpos(event_time(to))
+        c.new_path()
+        c.rectangle(x, y, delta, box_height)
+        c.set_source_rgb(*cpu_color(event_cpu(to)))
+        c.fill()
+
+    # draw task base lines
+    c.set_source_rgb(*GRID_COLOR)
+    c.set_line_width(GRID_WIDTH)
+    for t in tasks:
+        c.new_path()
+        y = ypos(task_idx[t] + 1)
+        x = xpos(opts.start)
+        c.move_to(x, y)
+        x = xpos(opts.end)
+        c.line_to(x, y)
+        c.stroke()
+
+    # draw releases and deadlines
+    c.set_source_rgb(*JOB_EVENT_COLOR)
+    c.set_line_width(ARROW_LINE_WIDTH)
+#    c.set_line_cap(cairo.LINE_JOIN_ROUND)
+    c.set_line_join(cairo.LINE_JOIN_ROUND)
+    arrow_width  = ARROW_WIDTH / 2
+    arrow_height = ARROW_HEIGHT * YRES * yscale
+    for rec in trace.events_in_range_of_type(opts.start, opts.end, 'ST_RELEASE'):
+        pid = event_pid(rec)
+        y   = ypos(task_idx[pid] + 1)
+
+        rel = xpos(event_time(rec))
+        c.new_path()
+        c.move_to(rel, y - (GRID_WIDTH - 1))
+        c.rel_line_to(0, -arrow_height)
+        c.rel_line_to(-arrow_width, arrow_width)
+        c.rel_move_to(arrow_width, -arrow_width)
+        c.rel_line_to(arrow_width, arrow_width)
+        c.stroke()
+
+        dl  = xpos(rec[-1])
+        c.new_path()
+        c.move_to(dl, y - arrow_height - (GRID_WIDTH - 1))
+        c.rel_line_to(0, arrow_height)
+        c.rel_line_to(-arrow_width, -arrow_width)
+        c.rel_move_to(arrow_width, arrow_width)
+        c.rel_line_to(arrow_width, -arrow_width)
+        c.stroke()
+
+    # draw job completions
+    for rec in trace.events_in_range_of_type(opts.start, opts.end, 'ST_COMPLETION'):
+        pid = event_pid(rec)
+        y   = ypos(task_idx[pid] + 1)
+        x   = xpos(event_time(rec))
+        c.new_path()
+        c.move_to(x, y - (GRID_WIDTH - 1))
+        c.rel_line_to(0, -arrow_height)
+        c.rel_move_to(-arrow_width, 0)
+        c.rel_line_to(2 * arrow_width, 0)
+        c.stroke()
+
+
+    # draw task labels
+    c.set_font_size(TASK_LABEL_FONT_SIZE)
+    c.set_source_rgb(*TASK_LABEL_COLOR)
+    for pid in tasks:
+        x = -24
+        y = ypos(task_idx[pid] + 0.25)
+        vcenter_right_align_text(c, x, y, "%s/%d" % (trace.task_names[pid], pid))
+        y = ypos(task_idx[pid] + 0.75)
+        vcenter_right_align_text(c, x, y,
+            "(%.2fms, %.2fms)" % (trace.task_wcets[pid] / 1E6,
+                                  trace.task_periods[pid] / 1E6))
+
+
+    if opts.verbose:
+        print '[II] Finishing PDF...',
+        sys.stdout.flush()
+    pdf.finish()
+    if opts.verbose:
+        print 'done.'
+
+    if opts.verbose:
+        print '[II] Flushing PDF...',
+        sys.stdout.flush()
+    pdf.flush()
+    if opts.verbose:
+        print 'done.'
+
+    del pdf
diff --git a/sched_trace/file.py b/sched_trace/file.py
new file mode 100644
index 0000000..5c18163
--- /dev/null
+++ b/sched_trace/file.py
@@ -0,0 +1,58 @@
+"""Convenience wrapper around mmap'ed sched_trace binary files.
+"""
+
+from .format import RECORD_LEN, unpack, get_event, EVENTS
+
+import mmap
+
+class SchedTraceFile(object):
+    def __init__(self, fname):
+        self.source = fname
+        with open(fname, 'rw') as f:
+            self.mem = mmap.mmap(f.fileno(), 0, mmap.MAP_PRIVATE)
+
+    def __len__(self):
+        return len(self.mem) / RECORD_LEN
+
+    def events_of_type(self, event_ids):
+        for i in xrange(len(self)):
+            if get_event(self.mem, i) in event_ids:
+                record = self.mem[i * RECORD_LEN:]
+                yield unpack(record)
+
+    def __iter__(self):
+        for i in xrange(len(self)):
+            record = self.mem[i * RECORD_LEN:]
+            yield unpack(record)
+
+    def __reversed__(self):
+        for i in reversed(xrange(len(self))):
+            record = self.mem[i * RECORD_LEN:]
+            yield unpack(record)
+
+    def raw_iter(self):
+        for i in xrange(len(self)):
+            record = self.mem[i * RECORD_LEN:(i + 1) * RECORD_LEN]
+            yield record
+
+    def scheduling_intervals(self):
+        to_id = EVENTS['ST_SWITCH_TO']
+        away_id = EVENTS['ST_SWITCH_AWAY']
+
+        # assumption: we are looking at a per-CPU trace
+        events = self.events_of_type(set((to_id, away_id)))
+
+        rec = events.next()
+        while True:
+            # fast-forward to next SWITCH_TO
+            while rec[0] != to_id:
+                rec = events.next()
+
+            to = rec
+            # next one on this CPU should be a SWITCH_AWAY
+            rec = events.next()
+            away = rec
+            # check for event ID and matching PID and CPU and monotonic time
+            if away[0] == away_id and away[1] == to[1] and away[2] == to[2] \
+               and to[4] <= away[4]:
+                yield (to, away)
diff --git a/sched_trace/format.py b/sched_trace/format.py
new file mode 100644
index 0000000..ca44a9a
--- /dev/null
+++ b/sched_trace/format.py
@@ -0,0 +1,118 @@
+"""Functions for reading and interpreting binary sched_trace files.
+"""
+
+import struct
+
+HEADER_LEN  =  8 # bytes
+PAYLOAD_LEN = 16 # bytes
+RECORD_LEN  = 24 # bytes
+
+EVENT_NAMES = [
+    "ST_NAME",
+    "ST_PARAM",
+    "ST_RELEASE",
+    "ST_ASSIGNED",
+    "ST_SWITCH_TO",
+    "ST_SWITCH_AWAY",
+    "ST_COMPLETION",
+    "ST_BLOCK",
+    "ST_RESUME",
+    "ST_ACTION",
+    "ST_SYS_RELEASE"
+]
+
+EVENTS = {}
+for i, ev in enumerate(EVENT_NAMES):
+    EVENTS[ev] = i + 1
+    EVENTS[i + 1] = ev
+
+def event(id):
+    return EVENTS[id] if id in EVENTS else id
+
+# struct st_trace_header {
+#       u8      type;           /* Of what type is this record?  */
+#       u8      cpu;            /* On which CPU was it recorded? */
+#       u16     pid;            /* PID of the task.              */
+#       u32     job;            /* The job sequence number.      */
+# };
+
+def get_event(mmaped_trace, index):
+    offset = index * RECORD_LEN
+    # first byte in the record is the event type ID
+    return ord(mmaped_trace[offset])
+#    return struct.unpack("B", raw_data[:1])[0]
+
+def unpack_header(raw_data):
+    """Returns (type, cpu, pid, job id)"""
+    return struct.unpack("BBHI", raw_data[:HEADER_LEN])
+
+def unpack_release(raw_data):
+    """Returns (release, deadline)"""
+    return struct.unpack("QQ", raw_data[HEADER_LEN:RECORD_LEN])
+
+def unpack_switch_to(raw_data):
+    """Returns (when, exec_time_so_far)"""
+    return struct.unpack("QI", raw_data[HEADER_LEN:RECORD_LEN - 4])
+
+def unpack_switch_away(raw_data):
+    """Returns (when, exec_time_so_far)"""
+    return struct.unpack("QQ", raw_data[HEADER_LEN:RECORD_LEN])
+
+def unpack_completion(raw_data):
+    """Returns (when, exec_time, forced)"""
+    (when, exec_time) = struct.unpack("QQ", raw_data[HEADER_LEN:RECORD_LEN])
+    return (when, exec_time >> 1, exec_time & 0x1)
+
+def unpack_block(raw_data):
+    """Returns (when,)"""
+    return struct.unpack("Q", raw_data[HEADER_LEN:RECORD_LEN - 8])
+
+def unpack_resume(raw_data):
+    """Returns (when,)"""
+    return struct.unpack("Q", raw_data[HEADER_LEN:RECORD_LEN - 8])
+
+def unpack_sys_release(raw_data):
+    """Returns (when, release)"""
+    return struct.unpack("QQ", raw_data[HEADER_LEN:RECORD_LEN])
+
+def unpack_name(raw_data):
+    """Returns (name,)"""
+    data = raw_data[HEADER_LEN:RECORD_LEN]
+    null_byte_idx = data.find('\0')
+    if null_byte_idx > -1:
+        data = data[:null_byte_idx]
+    return (data,)
+
+def unpack_param(raw_data):
+    """Returns (WCET, period, phase, partition)"""
+    return struct.unpack("IIIB", raw_data[HEADER_LEN:RECORD_LEN - 3])
+
+UNPACK = {
+    EVENTS['ST_RELEASE']:       unpack_release,
+    EVENTS['ST_SWITCH_TO']:     unpack_switch_to,
+    EVENTS['ST_SWITCH_AWAY']:   unpack_switch_away,
+    EVENTS['ST_COMPLETION']:    unpack_completion,
+    EVENTS['ST_BLOCK']:         unpack_block,
+    EVENTS['ST_RESUME']:        unpack_resume,
+    EVENTS['ST_SYS_RELEASE']:   unpack_sys_release,
+    EVENTS['ST_NAME']:          unpack_name,
+    EVENTS['ST_PARAM']:         unpack_param,
+}
+
+EVENTS_WITHOUT_TIMESTAMP = frozenset([
+    EVENTS['ST_NAME'],
+    EVENTS['ST_PARAM'],
+])
+
+def when(raw_data):
+    ev = get_event(raw_data)
+    if ev in EVENTS_WITHOUT_TIMESTAMP:
+        return 0
+    else:
+        # always first element for all others
+        return UNPACK[ev](raw_data)[0]
+
+def unpack(raw_data):
+    hdr = unpack_header(raw_data)
+    payload = UNPACK[hdr[0]](raw_data)
+    return hdr + payload
diff --git a/st-draw b/st-draw
new file mode 100755
index 0000000..45b96f1
--- /dev/null
+++ b/st-draw
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import os.path
+
+import cairo
+
+from sched_trace import event_name, event_time, SchedTrace
+
+import sched_trace.draw
+
+def s2ns(secs):
+    return secs * 1E9
+
+def ms2ns(millis):
+    return millis * 1E6
+
+def ns2s(nanos):
+    return nanos / 1E9
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Render a LITMUS^RT schedule trace as a PDF.")
+
+    parser.add_argument('-o', '--output',
+        help='name of the generated PDF file')
+
+    parser.add_argument('-x', '--xscale', type=float, default=36,
+        help="how many points (1/72'') per millisecond?")
+    parser.add_argument('-y', '--yscale', type=float, default=72,
+        help="how many points (1/72'') per task/core?")
+    parser.add_argument('--margin', type=float, default=36,
+        help="how many points (1/72'') of margin around the schedule?")
+
+    parser.add_argument('--major-ticks', type=float, default=10,
+        help="how many milliseconds per major tick? (zero means off)")
+    parser.add_argument('--minor-ticks', type=float, default=1,
+        help="how many milliseconds per minor tick? (zero means off)")
+
+    parser.add_argument('-f', '--from', type=float, dest='start',
+        help='draw schedule starting at time TIME', metavar='TIME')
+    parser.add_argument('-u', '--until', type=float, dest='end',
+        help='draw schedule up to time TIME', metavar='TIME')
+    parser.add_argument('-l', '--length', type=float, default=1000,
+        help='draw schedule for LENGTH time units')
+    parser.add_argument('-r', '--relative', action='store_true',
+        help='interpret -f/-u options relative to system release')
+
+    parser.add_argument('-v', '--verbose', action='store_true', default=False,
+        help='output some information while drawing')
+
+    parser.add_argument('file', nargs='*',
+        help='the binary trace files collected with st-trace')
+
+    return parser.parse_args()
+
+
+def default_output_name(input_files):
+    if not input_files:
+        return 'schedule.pdf'
+    candidate = input_files[0]
+    for i in xrange(len(candidate)):
+        if not all([f[i] == candidate[i] for f in input_files]):
+            break
+    candidate = os.path.basename(candidate[:i])
+    if candidate.endswith('_cpu='):
+        candidate = candidate.replace('_cpu=', '')
+    if not candidate:
+        return 'schedule.pdf'
+    return candidate + '.pdf'
+
+def main(args=sys.argv[1:]):
+    opts = parse_args()
+
+    if not opts.output:
+        opts.output = default_output_name(opts.file)
+
+    try:
+        trace = SchedTrace(opts.file)
+    except IOError, msg:
+        print 'Could not load trace files (%s)' % msg
+        sys.exit(1)
+
+    if opts.start:
+        # convert from ms
+        opts.start = ms2ns(opts.start)
+        # check if a relative time is given
+        if opts.relative:
+            if trace.system_releases:
+                opts.start += trace.system_releases[0]
+            else:
+                opts.start += trace.find_earliest_event
+
+    if opts.end:
+        # convert from ms
+        opts.end = ms2ns(opts.end)
+        # check if a relative time is given
+        if opts.relative:
+            if trace.system_releases:
+                opts.end += trace.system_releases[0]
+            else:
+                opts.end += trace.find_earliest_event
+
+    if not opts.start:
+        if opts.end and opts.length:
+            opts.start = opts.end - ms2ns(opts.length)
+        elif trace.system_releases:
+            opts.start = trace.system_releases[0]
+        else:
+            opts.start = trace.find_earliest_event
+
+    if not opts.end:
+        if opts.start and opts.length:
+            opts.end = opts.start + ms2ns(opts.length)
+        else:
+            opts.end = trace.latest_event_time
+
+    if opts.verbose:
+        print '[II] Rendering into file: %s' % opts.output
+        print '[II] Drawing %.2f seconds from time %.4fs until time %.4fs.' % \
+            (ns2s(opts.end - opts.start), ns2s(opts.start), ns2s(opts.end))
+        if len(trace.system_releases) == 1:
+            print '[II] The trace contains a system release at time %.4fs.' % \
+                (ns2s(trace.system_releases[0]))
+        elif len(trace.system_releases) > 1:
+            print '[!!] The trace contains multiple system releases: %s' % \
+                (' '.join(['%.4fs' % ns2s(x) for x in trace.system_releases]))
+        else:
+            print '[II] The trace does not contain a system release.'
+
+    sched_trace.draw.render(opts, trace)
+
+#     for pid in trace.task_names:
+#         print pid, '->', trace.task_names[pid], trace.task_wcets[pid], trace.task_periods[pid]
+
+#     for (to, away) in trace.scheduling_intervals_in_range(trace.system_releases[0], trace.system_releases[0] + 1E9):
+#         print to, away
+
+
+if __name__ == '__main__':
+    main()