python-perf: simplify support using patch to python-perf

Signed-off-by: Pierre Tardy <tardyp@gmail.com>

2 files changed, 32 insertions, 64 deletions

diff --git a/timechart.py b/timechart.py
index d1c0669..1f8b4cb 100755
--- a/timechart.py
+++ b/timechart.py
@@ -16,9 +16,10 @@ if os.name=="posix":
     fontManager.defaultFont = fontManager.findfont(font)
 
 class Event():
-	def __init__(self,sec,nsec,**kw):
+	def __init__(self,name,kw):
 		self.__dict__=kw
-		self.timestamp = sec*1000000+nsec/1000
+                self.event = name
+		self.timestamp = self.common_s*1000000+self.common_ns/1000
 
 def trace_begin():
 	global proj
@@ -30,43 +31,10 @@ def trace_end():
 	window = TimechartWindow(project = proj)
 	window.configure_traits()
 
-def sched__sched_switch(event_name, context, common_cpu,
-	common_secs, common_nsecs, common_pid, common_comm,
-	prev_comm, prev_pid, prev_prio, prev_state, 
-	next_comm, next_pid, next_prio):
-	proj.do_event_sched_switch(
-		Event(common_secs, common_nsecs,cpu=common_cpu,
-		      prev_pid=prev_pid,prev_comm=prev_comm,prev_prio=prev_prio,prev_state=prev_state,
-		      next_pid=next_pid,next_comm=next_comm,next_prio=next_prio))
 
-def sched__sched_wakeup(event_name, context, common_cpu,
-	common_secs, common_nsecs, common_pid, common_comm,
-	comm, pid, prio, success, 
-	target_cpu):
-	proj.do_event_sched_wakeup(
-		Event(common_secs, common_nsecs,cpu=common_cpu,
-		      pid=common_pid,comm=common_comm,
-		      wakee_comm=comm,wakee_pid=pid,success=success))
-
-def power__power_end(event_name, context, common_cpu,
-	common_secs, common_nsecs, common_pid, common_comm,
-	dummy):
-	proj.do_event_power_end(Event(common_secs, common_nsecs,cpu=common_cpu))
-
-def power__power_frequency(event_name, context, common_cpu,
-	common_secs, common_nsecs, common_pid, common_comm,
-	type, state):
-	global proj
-	proj.do_event_power_frequency(Event(common_secs, common_nsecs,cpu=common_cpu,type=type,state=state))
-
-def power__power_start(event_name, context, common_cpu,
-	common_secs, common_nsecs, common_pid, common_comm,
-	type, state):
-	proj.do_event_power_start(Event(common_secs, common_nsecs,cpu=common_cpu,type=type,state=state))
-
-def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
-		common_pid, common_comm):
-	print "unhandled!",event_name
+def trace_unhandled(event_name, context, field_dict):
+    event_name = event_name[event_name.find("__")+2:]
+    proj.ftrace_callback(Event(event_name,field_dict))
 
 
 import wx
diff --git a/timechart/timechart.py b/timechart/timechart.py
index 84d6ea3..7e326c4 100755
--- a/timechart/timechart.py
+++ b/timechart/timechart.py
@@ -239,7 +239,7 @@ class TimechartProject(HasTraits):
             process['end_ts'].append(event.timestamp)
 
         self.cur_process_by_pid[process['pid']] = process
-        p_stack = self.cur_process[event.cpu]
+        p_stack = self.cur_process[event.common_cpu]
         if p_stack:
             p = p_stack[-1]
             if len(p['start_ts'])>len(p['end_ts']):
@@ -247,25 +247,25 @@ class TimechartProject(HasTraits):
             # mark old process to wait for cpu 
             p['start_ts'].append(int(event.timestamp))
             p['types'].append(2) 
-            p['cpus'].append(event.cpu)
+            p['cpus'].append(event.common_cpu)
             p_stack.append(process)
         else:
-            self.cur_process[event.cpu] = [process]
+            self.cur_process[event.common_cpu] = [process]
         # mark process to use cpu
         process['start_ts'].append(event.timestamp)
         process['types'].append(1) 
-        process['cpus'].append(event.cpu)
+        process['cpus'].append(event.common_cpu)
 
     def generic_process_end(self,process,event):
         if process['comm']=='swapper' and process['pid']==0:
             return # ignore swapper event
         if len(process['start_ts'])>len(process['end_ts']):
             process['end_ts'].append(event.timestamp)
-        p_stack = self.cur_process[event.cpu]
+        p_stack = self.cur_process[event.common_cpu]
         if p_stack:
             p = p_stack.pop()
             if p['pid'] != process['pid']:
-                print  "warning: process premption stack following failure on CPU",event.cpu, p['comm'],p['pid'],process['comm'],process['pid'],map(lambda a:"%s:%d"%(a['comm'],a['pid']),p_stack),event.linenumber
+                print  "warning: process premption stack following failure on CPU",event.common_cpu, p['comm'],p['pid'],process['comm'],process['pid'],map(lambda a:"%s:%d"%(a['comm'],a['pid']),p_stack),event.linenumber
                 p_stack = []
             if p_stack:
                 p = p_stack[-1]
@@ -274,7 +274,7 @@ class TimechartProject(HasTraits):
                 # mark old process to run on cpu 
                 p['start_ts'].append(event.timestamp)
                 p['types'].append(1)
-                p['cpus'].append(event.cpu)
+                p['cpus'].append(event.common_cpu)
         
     def do_event_sched_switch(self,event):
         prev = self.generic_find_process(event.prev_pid,event.prev_comm)
@@ -285,17 +285,17 @@ class TimechartProject(HasTraits):
         if event.__dict__.has_key('prev_state') and event.prev_state == 'R':# mark prev to be waiting for cpu
             prev['start_ts'].append(event.timestamp)
             prev['types'].append(2) 
-            prev['cpus'].append(event.cpu)
+            prev['cpus'].append(event.common_cpu)
 
         self.generic_process_start(next,event)
         
     def do_event_sched_wakeup(self,event):
-        p_stack = self.cur_process[event.cpu]
+        p_stack = self.cur_process[event.common_cpu]
         if p_stack:
             p = p_stack[-1]
-            self.wake_events.append(((p['comm'],p['pid']),(event.wakee_comm,event.wakee_pid),event.timestamp))
+            self.wake_events.append(((p['comm'],p['pid']),(event.comm,event.pid),event.timestamp))
         else:
-            self.wake_events.append(((event.comm,event.pid),event.wakee_pid,event.timestamp))
+            self.wake_events.append(((event.common_comm,event.common_pid),event.pid,event.timestamp))
     def do_event_irq_handler_entry(self,event,soft=""):
         process = self.generic_find_process(0,"%sirq%d:%s"%(soft,event.irq,event.handler))
         self.last_irq[(event.irq,soft)] = process
@@ -329,16 +329,16 @@ class TimechartProject(HasTraits):
         self.generic_process_end(process,event)
         
     def do_event_power_frequency(self,event):
-        self.ensure_cpu_allocated(event.cpu)
+        self.ensure_cpu_allocated(event.common_cpu)
         if event.type==2:# p_state
-            tc = self.tmp_p_states[event.cpu]
+            tc = self.tmp_p_states[event.common_cpu]
             tc['start_ts'].append(event.timestamp)
             tc['types'].append(event.state)
 
     def do_event_power_start(self,event):
-        self.ensure_cpu_allocated(event.cpu)
+        self.ensure_cpu_allocated(event.common_cpu)
         if event.type==1:# c_state
-            tc = self.tmp_c_states[event.cpu]
+            tc = self.tmp_c_states[event.common_cpu]
             if len(tc['start_ts'])>len(tc['end_ts']):
                 tc['end_ts'].append(event.timestamp)
                 self.missed_power_end +=1
@@ -351,18 +351,18 @@ class TimechartProject(HasTraits):
             tc['types'].append(event.state)
 
     def do_event_power_end(self,event):
-        self.ensure_cpu_allocated(event.cpu)
+        self.ensure_cpu_allocated(event.common_cpu)
 
-        tc = self.tmp_c_states[event.cpu]
+        tc = self.tmp_c_states[event.common_cpu]
         if len(tc['start_ts'])>len(tc['end_ts']):
             tc['end_ts'].append(event.timestamp)
 
-    def do_event_function_default(self,event):
+    def do_function_default(self,event):
         process = self.generic_find_process(0,"kernel function:%s"%(event.callee))
         self.generic_process_start(process,event)
         self.generic_process_end(process,event)
 
-    def do_event_event_default(self,event):
+    def do_event_default(self,event):
         process = self.generic_find_process(0,"event:%s"%(event.event))
         self.generic_process_start(process,event)
         self.generic_process_end(process,event)
@@ -378,6 +378,11 @@ class TimechartProject(HasTraits):
         self.last_irq={}
         self.last_spi=[]
         self.missed_power_end = 0
+        self.methods = {}
+        for name in dir(self):
+            method = getattr(self, name)
+            if callable(method):
+                self.methods[name] = method
 
     def finish_parsing(self):
         #put generated data in unresizable numpy format
@@ -441,17 +446,12 @@ class TimechartProject(HasTraits):
         if self.methods.has_key(callback):
             self.methods[callback](event)
         elif event.event=='function':
-            self.ftrace_function_default(event)
+            self.do_function_default(event)
         else:
-            self.ftrace_event_default(event)
+            self.do_event_default(event)
 
     def load_ftrace(self,filename):
         from ftrace import parse_ftrace
-        self.methods = {}
-        for name in dir(self):
-            method = getattr(self, name)
-            if callable(method):
-                self.methods[name] = method
         self.start_parsing()
         parse_ftrace(filename,self.ftrace_callback)
         self.finish_parsing()