Merge branch 'trace-cmd' into trace-view

4 files changed, 310 insertions, 11 deletions

diff --git a/Makefile b/Makefile
index 0f65858..e75e2e0 100644
--- a/Makefile
+++ b/Makefile
@@ -119,10 +119,12 @@ plugin_mac80211.so: plugin_mac80211.o
 
 
 .PHONY: python
-python: $(TCMD_LIB_OBJS) trace-cmd.o trace-read.o
+python: $(TCMD_LIB_OBJS)
         swig -Wall -python -noproxy ctracecmd.i
+        #swig -Wall -python ctracecmd.i
         gcc -fpic -c  `python-config --includes` ctracecmd_wrap.c
         $(CC) --shared $^ ctracecmd_wrap.o -o ctracecmd.so
+        #$(CC) --shared $^ ctracecmd_wrap.o -o _ctracecmd.so
 
 
 .PHONY: force
diff --git a/ctracecmd.i b/ctracecmd.i
index a9d3ca5..f0b0eb7 100644
--- a/ctracecmd.i
+++ b/ctracecmd.i
@@ -2,14 +2,23 @@
 %module ctracecmd
 %include typemaps.i
 
+/* return a (rec,cpu) tuple in python */
+extern struct record *tracecmd_read_at(struct tracecmd_input *handle, 
+                                       unsigned long long offset,
+                                       int *OUTPUT);
+
+
 %{
 #include "trace-cmd.h"
 %}
 
+
+/* return python longs from unsigned long long functions */
 %typemap(out) unsigned long long {
 $result = PyLong_FromUnsignedLongLong((unsigned long long) $1);
 }
 
+
 %inline %{
 PyObject *pevent_read_number_field_py(struct format_field *f, void *data)
 {
diff --git a/event-viewer.py b/event-viewer.py
new file mode 100755
index 0000000..6f35642
--- /dev/null
+++ b/event-viewer.py
@@ -0,0 +1,272 @@
+#!/usr/bin/env python
+
+import getopt
+from gobject import *
+import gtk
+from tracecmd import *
+import time
+
+app = None
+data_func_cnt = 0
+
+# In a "real" app these width should be determined at runtime testing max length
+# strings in the current font.
+TS_COL_W    = 150
+CPU_COL_W   = 35
+EVENT_COL_W = 150
+PID_COL_W   = 75
+COMM_COL_W  = 250
+
+
+def timing(func):
+  def wrapper(*arg):
+      start = time.time()
+      ret = func(*arg)
+      end = time.time()
+      print '@%s took %0.3f s' % (func.func_name, (end-start))
+      return ret
+  return wrapper
+
+
+class EventStore(gtk.GenericTreeModel):
+    class EventRef(object):
+        '''Inner class to build the trace event index'''
+        def __init__(self, index, timestamp, offset, cpu):
+            self.index = index
+            self.offset = offset
+            self.ts = timestamp
+            self.cpu = cpu
+
+        def __cmp__(self, other):
+            if self.ts < other.ts:
+                return -1
+            if self.ts > other.ts:
+                return 1
+            if self.offset < other.offset:
+                return -1
+            if self.offset > other.offset:
+                return 1
+            return 0
+
+    # The store only returns the record offset into the trace
+    # The view is responsible for looking up the Event with the offset
+    column_types = (long,)
+
+    @timing
+    def __init__(self, trace):
+        gtk.GenericTreeModel.__init__(self)
+        self.trace = trace
+        self.refs = []
+        self._load_trace()
+        self._sort()
+        self._reindex()
+
+    @timing
+    def _load_trace(self):
+        print "Building trace index..."
+        index = 0
+        for cpu in range(0, trace.cpus):
+            rec = tracecmd_read_data(self.trace.handle, cpu)
+            while rec:
+                offset = record_offset_get(rec)
+                ts = record_ts_get(rec)
+                self.refs.append(self.EventRef(index, ts, offset, cpu))
+                index = index + 1
+                rec = tracecmd_read_data(self.trace.handle, cpu)
+        print "Loaded %d events from trace" % (index)
+
+    @timing
+    def _sort(self):
+        self.refs.sort()
+
+    @timing
+    def _reindex(self):
+        for i in range(0, len(self.refs)):
+            self.refs[i].index = i
+
+    def on_get_flags(self):
+        return gtk.TREE_MODEL_LIST_ONLY | gtk.TREE_MODEL_ITERS_PERSIST
+
+    def on_get_n_columns(self):
+        return len(self.column_types)
+
+    def on_get_column_type(self, col):
+        return self.column_types[col]
+
+    def on_get_iter(self, path):
+        return self.refs[path[0]]
+
+    def on_get_path(self, ref):
+        return ref.index
+
+    def on_get_value(self, ref, col):
+        '''
+        The Event record was getting deleted when passed back via this
+        method, now it just returns the ref itself. Use get_event() instead.
+        '''
+        if col == 0:
+            #return self.trace.read_event_at(ref.offset)
+            return ref
+        return None
+
+    def on_iter_next(self, ref):
+        try:
+            return self.refs[ref.index+1]
+        except IndexError:
+            return None
+
+    def on_iter_children(self, ref):
+        if ref:
+            return None
+        return self.refs[0]
+
+    def on_iter_has_child(self, ref):
+        return False
+
+    def on_iter_n_children(self, ref):
+        if ref:
+            return 0
+        return len(self.refs)
+
+    def on_iter_nth_child(self, ref, n):
+        if ref:
+            return None
+        try:
+            return self.refs[n]
+        except IndexError:
+            return None
+
+    def on_iter_parent(self, child):
+        return None
+
+    def get_event(self, iter):
+        '''This allocates a record which must be freed by the caller'''
+        try:
+            ref = self.refs[self.get_path(iter)[0]]
+            ev = self.trace.read_event_at(ref.offset)
+            return ev
+        except IndexError:
+            return None
+
+
+class EventView(gtk.TreeView):
+    def __init__(self, model):
+        gtk.TreeView.__init__(self, model)
+        self.set_fixed_height_mode(True)
+
+        ts_col = gtk.TreeViewColumn("Time (s)")
+        ts_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        ts_col.set_fixed_width(TS_COL_W)
+        ts_cell = gtk.CellRendererText()
+        ts_col.pack_start(ts_cell, False)
+        ts_col.set_cell_data_func(ts_cell, self.data_func, "ts")
+        self.append_column(ts_col)
+
+        cpu_col = gtk.TreeViewColumn("CPU")
+        cpu_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        cpu_col.set_fixed_width(CPU_COL_W)
+        cpu_cell = gtk.CellRendererText()
+        cpu_col.pack_start(cpu_cell, False)
+        cpu_col.set_cell_data_func(cpu_cell, self.data_func, "cpu")
+        self.append_column(cpu_col)
+
+        event_col = gtk.TreeViewColumn("Event")
+        event_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        event_col.set_fixed_width(EVENT_COL_W)
+        event_cell = gtk.CellRendererText()
+        event_col.pack_start(event_cell, False)
+        event_col.set_cell_data_func(event_cell, self.data_func, "event")
+        self.append_column(event_col)
+
+        pid_col = gtk.TreeViewColumn("PID")
+        pid_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        pid_col.set_fixed_width(PID_COL_W)
+        pid_cell = gtk.CellRendererText()
+        pid_col.pack_start(pid_cell, False)
+        pid_col.set_cell_data_func(pid_cell, self.data_func, "pid")
+        self.append_column(pid_col)
+
+        comm_col = gtk.TreeViewColumn("Comm")
+        comm_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        comm_col.set_fixed_width(COMM_COL_W)
+        comm_cell = gtk.CellRendererText()
+        comm_col.pack_start(comm_cell, False)
+        comm_col.set_cell_data_func(comm_cell, self.data_func, "comm")
+        self.append_column(comm_col)
+
+    def data_func(self, col, cell, model, iter, data):
+        global app, data_func_cnt
+
+        ev = model.get_event(iter)
+        #ev = model.get_value(iter, 0)
+        if not ev:
+            return False
+
+        if data == "ts":
+            cell.set_property("markup", "%d.%d" % (ev.ts/1000000000,
+                                                   ev.ts%1000000000))
+            data_func_cnt = data_func_cnt + 1
+            if app:
+                app.inc_data_func()
+        elif data == "cpu":
+            cell.set_property("markup", ev.cpu)
+        elif data == "event":
+            cell.set_property("markup", ev.name)
+        elif data == "pid":
+            cell.set_property("markup", ev.pid)
+        elif data == "comm":
+            cell.set_property("markup", ev.comm)
+        else:
+            print "Unknown Column:", data
+            return False
+
+        return True
+
+
+class EventViewerApp(gtk.Window):
+    def __init__(self, trace):
+        gtk.Window.__init__(self)
+
+        self.set_size_request(650, 400)
+        self.set_position(gtk.WIN_POS_CENTER)
+
+        self.connect("destroy", gtk.main_quit)
+        self.set_title("Event Viewer")
+
+        store = EventStore(trace)
+        view = EventView(store)
+
+        sw = gtk.ScrolledWindow()
+        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
+        sw.add(view)
+
+        # track how often the treeview data_func is called
+        self.data_func_label = gtk.Label("0")
+        hbox = gtk.HBox()
+        hbox.pack_start(gtk.Label("TS Data Func Calls:"), False, False)
+        hbox.pack_start(self.data_func_label, False, False)
+
+        vbox = gtk.VBox()
+        vbox.pack_start(hbox, False)
+        vbox.pack_end(sw)
+
+        self.add(vbox)
+        self.show_all()
+
+    def inc_data_func(self):
+        global data_func_cnt
+        self.data_func_label.set_text(str(data_func_cnt))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) >=2:
+        filename = sys.argv[1]
+    else:
+        filename = "trace.dat"
+
+    print "Initializing trace..."
+    trace = Trace(filename)
+    print "Initializing app..."
+    app = EventViewerApp(trace)
+    print "Go!"
+    gtk.main()
diff --git a/tracecmd.py b/tracecmd.py
index f9a2708..e7ea5f6 100644
--- a/tracecmd.py
+++ b/tracecmd.py
@@ -32,15 +32,20 @@ TODO: consider a complete class hierarchy of ftrace events...
 """
 
 class Event(object):
-    def __init__(self, trace, record):
+    def __init__(self, trace, record, cpu):
         self.trace = trace
         self.rec = record
+        self.cpu = cpu
         type = pevent_data_type(trace.pe, record)
-        self.ec = pevent_data_event_from_type(trace.pe, type)
+        self.format = pevent_data_event_from_type(trace.pe, type)
 
     def __str__(self):
-        return "%d.%d %s: pid=%d comm=%s type=%d" % \
-               (self.ts/1000000000, self.ts%1000000000, self.name, self.num_field("common_pid"), self.comm, self.type)
+        return "%d.%d CPU%d %s: pid=%d comm=%s type=%d" % \
+               (self.ts/1000000000, self.ts%1000000000, self.cpu, self.name,
+                self.num_field("common_pid"), self.comm, self.type)
+
+    def __del__(self):
+        free_record(self.rec);
 
 
     # TODO: consider caching the results of the properties
@@ -50,7 +55,7 @@ class Event(object):
 
     @property
     def name(self):
-        return event_name_get(self.ec)
+        return event_format_name_get(self.format)
 
     @property
     def pid(self):
@@ -65,7 +70,7 @@ class Event(object):
         return pevent_data_type(self.trace.pe, self.rec)
 
     def num_field(self, name):
-        f = pevent_find_any_field(self.ec, name)
+        f = pevent_find_any_field(self.format, name)
         val = pevent_read_number_field_py(f, record_data_get(self.rec))
         return val
 
@@ -82,9 +87,7 @@ class Trace(object):
         self.pe = None
 
         try:
-            file = open(filename)
-            self.handle = tracecmd_open(file.fileno())
-            print "self.handle: ", self.handle
+            self.handle = tracecmd_open(filename)
             #FIXME: check if these throw exceptions automatically or if we have
             #       to check return codes manually
             tracecmd_read_headers(self.handle)
@@ -100,9 +103,22 @@ class Trace(object):
     def read_event(self, cpu):
         rec = tracecmd_read_data(self.handle, cpu)
         if rec:
-            return Event(self, rec)
+            #rec.acquire()
+            #rec.thisown = 1
+            return Event(self, rec, cpu)
         return None
 
+    def read_event_at(self, offset):
+        res = tracecmd_read_at(self.handle, offset)
+        # SWIG only returns the CPU if the record is None for some reason
+        if isinstance(res, int):
+            return None
+        rec,cpu = res
+        #rec.acquire()
+        #rec.thisown = 1
+        ev = Event(self, rec, cpu)
+        return ev
+
     def peek_event(self, cpu):
         pass