8 files changed, 1157 insertions, 0 deletions

diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
index 1dc464ee2ca8..aad7525bca1d 100644
--- a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
@@ -89,3 +89,33 @@ def trace_flag_str(value):
             value &= ~idx
 
     return string
+
+
+def taskState(state):
+        states = {
+                0 : "R",
+                1 : "S",
+                2 : "D",
+                64: "DEAD"
+        }
+
+        if state not in states:
+                return "Unknown"
+
+        return states[state]
+
+
+class EventHeaders:
+        def __init__(self, common_cpu, common_secs, common_nsecs,
+                     common_pid, common_comm):
+                self.cpu = common_cpu
+                self.secs = common_secs
+                self.nsecs = common_nsecs
+                self.pid = common_pid
+                self.comm = common_comm
+
+        def ts(self):
+                return (self.secs * (10 ** 9)) + self.nsecs
+
+        def ts_format(self):
+                return "%d.%d" % (self.secs, int(self.nsecs / 1000))
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/SchedGui.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/SchedGui.py
new file mode 100644
index 000000000000..ae9a56e43e05
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/SchedGui.py
@@ -0,0 +1,184 @@
+# SchedGui.py - Python extension for perf trace, basic GUI code for
+#               traces drawing and overview.
+#
+# Copyright (C) 2010 by Frederic Weisbecker <fweisbec@gmail.com>
+#
+# This software is distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+
+try:
+        import wx
+except ImportError:
+        raise ImportError, "You need to install the wxpython lib for this script"
+
+
+class RootFrame(wx.Frame):
+        Y_OFFSET = 100
+        RECT_HEIGHT = 100
+        RECT_SPACE = 50
+        EVENT_MARKING_WIDTH = 5
+
+        def __init__(self, sched_tracer, title, parent = None, id = -1):
+                wx.Frame.__init__(self, parent, id, title)
+
+                (self.screen_width, self.screen_height) = wx.GetDisplaySize()
+                self.screen_width -= 10
+                self.screen_height -= 10
+                self.zoom = 0.5
+                self.scroll_scale = 20
+                self.sched_tracer = sched_tracer
+                self.sched_tracer.set_root_win(self)
+                (self.ts_start, self.ts_end) = sched_tracer.interval()
+                self.update_width_virtual()
+                self.nr_rects = sched_tracer.nr_rectangles() + 1
+                self.height_virtual = RootFrame.Y_OFFSET + (self.nr_rects * (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE))
+
+                # whole window panel
+                self.panel = wx.Panel(self, size=(self.screen_width, self.screen_height))
+
+                # scrollable container
+                self.scroll = wx.ScrolledWindow(self.panel)
+                self.scroll.SetScrollbars(self.scroll_scale, self.scroll_scale, self.width_virtual / self.scroll_scale, self.height_virtual / self.scroll_scale)
+                self.scroll.EnableScrolling(True, True)
+                self.scroll.SetFocus()
+
+                # scrollable drawing area
+                self.scroll_panel = wx.Panel(self.scroll, size=(self.screen_width - 15, self.screen_height / 2))
+                self.scroll_panel.Bind(wx.EVT_PAINT, self.on_paint)
+                self.scroll_panel.Bind(wx.EVT_KEY_DOWN, self.on_key_press)
+                self.scroll_panel.Bind(wx.EVT_LEFT_DOWN, self.on_mouse_down)
+                self.scroll.Bind(wx.EVT_PAINT, self.on_paint)
+                self.scroll.Bind(wx.EVT_KEY_DOWN, self.on_key_press)
+                self.scroll.Bind(wx.EVT_LEFT_DOWN, self.on_mouse_down)
+
+                self.scroll.Fit()
+                self.Fit()
+
+                self.scroll_panel.SetDimensions(-1, -1, self.width_virtual, self.height_virtual, wx.SIZE_USE_EXISTING)
+
+                self.txt = None
+
+                self.Show(True)
+
+        def us_to_px(self, val):
+                return val / (10 ** 3) * self.zoom
+
+        def px_to_us(self, val):
+                return (val / self.zoom) * (10 ** 3)
+
+        def scroll_start(self):
+                (x, y) = self.scroll.GetViewStart()
+                return (x * self.scroll_scale, y * self.scroll_scale)
+
+        def scroll_start_us(self):
+                (x, y) = self.scroll_start()
+                return self.px_to_us(x)
+
+        def paint_rectangle_zone(self, nr, color, top_color, start, end):
+                offset_px = self.us_to_px(start - self.ts_start)
+                width_px = self.us_to_px(end - self.ts_start)
+
+                offset_py = RootFrame.Y_OFFSET + (nr * (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE))
+                width_py = RootFrame.RECT_HEIGHT
+
+                dc = self.dc
+
+                if top_color is not None:
+                        (r, g, b) = top_color
+                        top_color = wx.Colour(r, g, b)
+                        brush = wx.Brush(top_color, wx.SOLID)
+                        dc.SetBrush(brush)
+                        dc.DrawRectangle(offset_px, offset_py, width_px, RootFrame.EVENT_MARKING_WIDTH)
+                        width_py -= RootFrame.EVENT_MARKING_WIDTH
+                        offset_py += RootFrame.EVENT_MARKING_WIDTH
+
+                (r ,g, b) = color
+                color = wx.Colour(r, g, b)
+                brush = wx.Brush(color, wx.SOLID)
+                dc.SetBrush(brush)
+                dc.DrawRectangle(offset_px, offset_py, width_px, width_py)
+
+        def update_rectangles(self, dc, start, end):
+                start += self.ts_start
+                end += self.ts_start
+                self.sched_tracer.fill_zone(start, end)
+
+        def on_paint(self, event):
+                dc = wx.PaintDC(self.scroll_panel)
+                self.dc = dc
+
+                width = min(self.width_virtual, self.screen_width)
+                (x, y) = self.scroll_start()
+                start = self.px_to_us(x)
+                end = self.px_to_us(x + width)
+                self.update_rectangles(dc, start, end)
+
+        def rect_from_ypixel(self, y):
+                y -= RootFrame.Y_OFFSET
+                rect = y / (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE)
+                height = y % (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE)
+
+                if rect < 0 or rect > self.nr_rects - 1 or height > RootFrame.RECT_HEIGHT:
+                        return -1
+
+                return rect
+
+        def update_summary(self, txt):
+                if self.txt:
+                        self.txt.Destroy()
+                self.txt = wx.StaticText(self.panel, -1, txt, (0, (self.screen_height / 2) + 50))
+
+
+        def on_mouse_down(self, event):
+                (x, y) = event.GetPositionTuple()
+                rect = self.rect_from_ypixel(y)
+                if rect == -1:
+                        return
+
+                t = self.px_to_us(x) + self.ts_start
+
+                self.sched_tracer.mouse_down(rect, t)
+
+
+        def update_width_virtual(self):
+                self.width_virtual = self.us_to_px(self.ts_end - self.ts_start)
+
+        def __zoom(self, x):
+                self.update_width_virtual()
+                (xpos, ypos) = self.scroll.GetViewStart()
+                xpos = self.us_to_px(x) / self.scroll_scale
+                self.scroll.SetScrollbars(self.scroll_scale, self.scroll_scale, self.width_virtual / self.scroll_scale, self.height_virtual / self.scroll_scale, xpos, ypos)
+                self.Refresh()
+
+        def zoom_in(self):
+                x = self.scroll_start_us()
+                self.zoom *= 2
+                self.__zoom(x)
+
+        def zoom_out(self):
+                x = self.scroll_start_us()
+                self.zoom /= 2
+                self.__zoom(x)
+
+
+        def on_key_press(self, event):
+                key = event.GetRawKeyCode()
+                if key == ord("+"):
+                        self.zoom_in()
+                        return
+                if key == ord("-"):
+                        self.zoom_out()
+                        return
+
+                key = event.GetKeyCode()
+                (x, y) = self.scroll.GetViewStart()
+                if key == wx.WXK_RIGHT:
+                        self.scroll.Scroll(x + 1, y)
+                elif key == wx.WXK_LEFT:
+                        self.scroll.Scroll(x - 1, y)
+                elif key == wx.WXK_DOWN:
+                        self.scroll.Scroll(x, y + 1)
+                elif key == wx.WXK_UP:
+                        self.scroll.Scroll(x, y - 1)
diff --git a/tools/perf/scripts/python/bin/netdev-times-record b/tools/perf/scripts/python/bin/netdev-times-record
new file mode 100644
index 000000000000..d931a828126b
--- /dev/null
+++ b/tools/perf/scripts/python/bin/netdev-times-record
@@ -0,0 +1,8 @@
+#!/bin/bash
+perf record -a -e net:net_dev_xmit -e net:net_dev_queue         \
+                -e net:netif_receive_skb -e net:netif_rx                \
+                -e skb:consume_skb -e skb:kfree_skb                     \
+                -e skb:skb_copy_datagram_iovec -e napi:napi_poll        \
+                -e irq:irq_handler_entry -e irq:irq_handler_exit        \
+                -e irq:softirq_entry -e irq:softirq_exit                \
+                -e irq:softirq_raise $@
diff --git a/tools/perf/scripts/python/bin/netdev-times-report b/tools/perf/scripts/python/bin/netdev-times-report
new file mode 100644
index 000000000000..c3d0a638123d
--- /dev/null
+++ b/tools/perf/scripts/python/bin/netdev-times-report
@@ -0,0 +1,5 @@
+#!/bin/bash
+# description: display a process of packet and processing time
+# args: [tx] [rx] [dev=] [debug]
+
+perf trace -s ~/libexec/perf-core/scripts/python/netdev-times.py $@
diff --git a/tools/perf/scripts/python/bin/sched-migration-record b/tools/perf/scripts/python/bin/sched-migration-record
new file mode 100644
index 000000000000..17a3e9bd9e8f
--- /dev/null
+++ b/tools/perf/scripts/python/bin/sched-migration-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -m 16384 -a -e sched:sched_wakeup -e sched:sched_wakeup_new -e sched:sched_switch -e sched:sched_migrate_task $@
diff --git a/tools/perf/scripts/python/bin/sched-migration-report b/tools/perf/scripts/python/bin/sched-migration-report
new file mode 100644
index 000000000000..61d05f72e443
--- /dev/null
+++ b/tools/perf/scripts/python/bin/sched-migration-report
@@ -0,0 +1,3 @@
+#!/bin/bash
+# description: sched migration overview
+perf trace $@ -s ~/libexec/perf-core/scripts/python/sched-migration.py
diff --git a/tools/perf/scripts/python/netdev-times.py b/tools/perf/scripts/python/netdev-times.py
new file mode 100644
index 000000000000..9aa0a32972e8
--- /dev/null
+++ b/tools/perf/scripts/python/netdev-times.py
@@ -0,0 +1,464 @@
+# Display a process of packets and processed time.
+# It helps us to investigate networking or network device.
+#
+# options
+# tx: show only tx chart
+# rx: show only rx chart
+# dev=: show only thing related to specified device
+# debug: work with debug mode. It shows buffer status.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from Util import *
+
+all_event_list = []; # insert all tracepoint event related with this script
+irq_dic = {}; # key is cpu and value is a list which stacks irqs
+              # which raise NET_RX softirq
+net_rx_dic = {}; # key is cpu and value include time of NET_RX softirq-entry
+                 # and a list which stacks receive
+receive_hunk_list = []; # a list which include a sequence of receive events
+rx_skb_list = []; # received packet list for matching
+                       # skb_copy_datagram_iovec
+
+buffer_budget = 65536; # the budget of rx_skb_list, tx_queue_list and
+                       # tx_xmit_list
+of_count_rx_skb_list = 0; # overflow count
+
+tx_queue_list = []; # list of packets which pass through dev_queue_xmit
+of_count_tx_queue_list = 0; # overflow count
+
+tx_xmit_list = [];  # list of packets which pass through dev_hard_start_xmit
+of_count_tx_xmit_list = 0; # overflow count
+
+tx_free_list = [];  # list of packets which is freed
+
+# options
+show_tx = 0;
+show_rx = 0;
+dev = 0; # store a name of device specified by option "dev="
+debug = 0;
+
+# indices of event_info tuple
+EINFO_IDX_NAME=   0
+EINFO_IDX_CONTEXT=1
+EINFO_IDX_CPU=    2
+EINFO_IDX_TIME=   3
+EINFO_IDX_PID=    4
+EINFO_IDX_COMM=   5
+
+# Calculate a time interval(msec) from src(nsec) to dst(nsec)
+def diff_msec(src, dst):
+        return (dst - src) / 1000000.0
+
+# Display a process of transmitting a packet
+def print_transmit(hunk):
+        if dev != 0 and hunk['dev'].find(dev) < 0:
+                return
+        print "%7s %5d %6d.%06dsec %12.3fmsec      %12.3fmsec" % \
+                (hunk['dev'], hunk['len'],
+                nsecs_secs(hunk['queue_t']),
+                nsecs_nsecs(hunk['queue_t'])/1000,
+                diff_msec(hunk['queue_t'], hunk['xmit_t']),
+                diff_msec(hunk['xmit_t'], hunk['free_t']))
+
+# Format for displaying rx packet processing
+PF_IRQ_ENTRY= "  irq_entry(+%.3fmsec irq=%d:%s)"
+PF_SOFT_ENTRY="  softirq_entry(+%.3fmsec)"
+PF_NAPI_POLL= "  napi_poll_exit(+%.3fmsec %s)"
+PF_JOINT=     "         |"
+PF_WJOINT=    "         |            |"
+PF_NET_RECV=  "         |---netif_receive_skb(+%.3fmsec skb=%x len=%d)"
+PF_NET_RX=    "         |---netif_rx(+%.3fmsec skb=%x)"
+PF_CPY_DGRAM= "         |      skb_copy_datagram_iovec(+%.3fmsec %d:%s)"
+PF_KFREE_SKB= "         |      kfree_skb(+%.3fmsec location=%x)"
+PF_CONS_SKB=  "         |      consume_skb(+%.3fmsec)"
+
+# Display a process of received packets and interrputs associated with
+# a NET_RX softirq
+def print_receive(hunk):
+        show_hunk = 0
+        irq_list = hunk['irq_list']
+        cpu = irq_list[0]['cpu']
+        base_t = irq_list[0]['irq_ent_t']
+        # check if this hunk should be showed
+        if dev != 0:
+                for i in range(len(irq_list)):
+                        if irq_list[i]['name'].find(dev) >= 0:
+                                show_hunk = 1
+                                break
+        else:
+                show_hunk = 1
+        if show_hunk == 0:
+                return
+
+        print "%d.%06dsec cpu=%d" % \
+                (nsecs_secs(base_t), nsecs_nsecs(base_t)/1000, cpu)
+        for i in range(len(irq_list)):
+                print PF_IRQ_ENTRY % \
+                        (diff_msec(base_t, irq_list[i]['irq_ent_t']),
+                        irq_list[i]['irq'], irq_list[i]['name'])
+                print PF_JOINT
+                irq_event_list = irq_list[i]['event_list']
+                for j in range(len(irq_event_list)):
+                        irq_event = irq_event_list[j]
+                        if irq_event['event'] == 'netif_rx':
+                                print PF_NET_RX % \
+                                        (diff_msec(base_t, irq_event['time']),
+                                        irq_event['skbaddr'])
+                                print PF_JOINT
+        print PF_SOFT_ENTRY % \
+                diff_msec(base_t, hunk['sirq_ent_t'])
+        print PF_JOINT
+        event_list = hunk['event_list']
+        for i in range(len(event_list)):
+                event = event_list[i]
+                if event['event_name'] == 'napi_poll':
+                        print PF_NAPI_POLL % \
+                            (diff_msec(base_t, event['event_t']), event['dev'])
+                        if i == len(event_list) - 1:
+                                print ""
+                        else:
+                                print PF_JOINT
+                else:
+                        print PF_NET_RECV % \
+                            (diff_msec(base_t, event['event_t']), event['skbaddr'],
+                                event['len'])
+                        if 'comm' in event.keys():
+                                print PF_WJOINT
+                                print PF_CPY_DGRAM % \
+                                        (diff_msec(base_t, event['comm_t']),
+                                        event['pid'], event['comm'])
+                        elif 'handle' in event.keys():
+                                print PF_WJOINT
+                                if event['handle'] == "kfree_skb":
+                                        print PF_KFREE_SKB % \
+                                                (diff_msec(base_t,
+                                                event['comm_t']),
+                                                event['location'])
+                                elif event['handle'] == "consume_skb":
+                                        print PF_CONS_SKB % \
+                                                diff_msec(base_t,
+                                                        event['comm_t'])
+                        print PF_JOINT
+
+def trace_begin():
+        global show_tx
+        global show_rx
+        global dev
+        global debug
+
+        for i in range(len(sys.argv)):
+                if i == 0:
+                        continue
+                arg = sys.argv[i]
+                if arg == 'tx':
+                        show_tx = 1
+                elif arg =='rx':
+                        show_rx = 1
+                elif arg.find('dev=',0, 4) >= 0:
+                        dev = arg[4:]
+                elif arg == 'debug':
+                        debug = 1
+        if show_tx == 0  and show_rx == 0:
+                show_tx = 1
+                show_rx = 1
+
+def trace_end():
+        # order all events in time
+        all_event_list.sort(lambda a,b :cmp(a[EINFO_IDX_TIME],
+                                            b[EINFO_IDX_TIME]))
+        # process all events
+        for i in range(len(all_event_list)):
+                event_info = all_event_list[i]
+                name = event_info[EINFO_IDX_NAME]
+                if name == 'irq__softirq_exit':
+                        handle_irq_softirq_exit(event_info)
+                elif name == 'irq__softirq_entry':
+                        handle_irq_softirq_entry(event_info)
+                elif name == 'irq__softirq_raise':
+                        handle_irq_softirq_raise(event_info)
+                elif name == 'irq__irq_handler_entry':
+                        handle_irq_handler_entry(event_info)
+                elif name == 'irq__irq_handler_exit':
+                        handle_irq_handler_exit(event_info)
+                elif name == 'napi__napi_poll':
+                        handle_napi_poll(event_info)
+                elif name == 'net__netif_receive_skb':
+                        handle_netif_receive_skb(event_info)
+                elif name == 'net__netif_rx':
+                        handle_netif_rx(event_info)
+                elif name == 'skb__skb_copy_datagram_iovec':
+                        handle_skb_copy_datagram_iovec(event_info)
+                elif name == 'net__net_dev_queue':
+                        handle_net_dev_queue(event_info)
+                elif name == 'net__net_dev_xmit':
+                        handle_net_dev_xmit(event_info)
+                elif name == 'skb__kfree_skb':
+                        handle_kfree_skb(event_info)
+                elif name == 'skb__consume_skb':
+                        handle_consume_skb(event_info)
+        # display receive hunks
+        if show_rx:
+                for i in range(len(receive_hunk_list)):
+                        print_receive(receive_hunk_list[i])
+        # display transmit hunks
+        if show_tx:
+                print "   dev    len      Qdisc        " \
+                        "       netdevice             free"
+                for i in range(len(tx_free_list)):
+                        print_transmit(tx_free_list[i])
+        if debug:
+                print "debug buffer status"
+                print "----------------------------"
+                print "xmit Qdisc:remain:%d overflow:%d" % \
+                        (len(tx_queue_list), of_count_tx_queue_list)
+                print "xmit netdevice:remain:%d overflow:%d" % \
+                        (len(tx_xmit_list), of_count_tx_xmit_list)
+                print "receive:remain:%d overflow:%d" % \
+                        (len(rx_skb_list), of_count_rx_skb_list)
+
+# called from perf, when it finds a correspoinding event
+def irq__softirq_entry(name, context, cpu, sec, nsec, pid, comm, vec):
+        if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
+                return
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
+        all_event_list.append(event_info)
+
+def irq__softirq_exit(name, context, cpu, sec, nsec, pid, comm, vec):
+        if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
+                return
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
+        all_event_list.append(event_info)
+
+def irq__softirq_raise(name, context, cpu, sec, nsec, pid, comm, vec):
+        if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
+                return
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
+        all_event_list.append(event_info)
+
+def irq__irq_handler_entry(name, context, cpu, sec, nsec, pid, comm,
+                        irq, irq_name):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        irq, irq_name)
+        all_event_list.append(event_info)
+
+def irq__irq_handler_exit(name, context, cpu, sec, nsec, pid, comm, irq, ret):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, irq, ret)
+        all_event_list.append(event_info)
+
+def napi__napi_poll(name, context, cpu, sec, nsec, pid, comm, napi, dev_name):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        napi, dev_name)
+        all_event_list.append(event_info)
+
+def net__netif_receive_skb(name, context, cpu, sec, nsec, pid, comm, skbaddr,
+                        skblen, dev_name):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr, skblen, dev_name)
+        all_event_list.append(event_info)
+
+def net__netif_rx(name, context, cpu, sec, nsec, pid, comm, skbaddr,
+                        skblen, dev_name):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr, skblen, dev_name)
+        all_event_list.append(event_info)
+
+def net__net_dev_queue(name, context, cpu, sec, nsec, pid, comm,
+                        skbaddr, skblen, dev_name):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr, skblen, dev_name)
+        all_event_list.append(event_info)
+
+def net__net_dev_xmit(name, context, cpu, sec, nsec, pid, comm,
+                        skbaddr, skblen, rc, dev_name):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr, skblen, rc ,dev_name)
+        all_event_list.append(event_info)
+
+def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm,
+                        skbaddr, protocol, location):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr, protocol, location)
+        all_event_list.append(event_info)
+
+def skb__consume_skb(name, context, cpu, sec, nsec, pid, comm, skbaddr):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr)
+        all_event_list.append(event_info)
+
+def skb__skb_copy_datagram_iovec(name, context, cpu, sec, nsec, pid, comm,
+        skbaddr, skblen):
+        event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
+                        skbaddr, skblen)
+        all_event_list.append(event_info)
+
+def handle_irq_handler_entry(event_info):
+        (name, context, cpu, time, pid, comm, irq, irq_name) = event_info
+        if cpu not in irq_dic.keys():
+                irq_dic[cpu] = []
+        irq_record = {'irq':irq, 'name':irq_name, 'cpu':cpu, 'irq_ent_t':time}
+        irq_dic[cpu].append(irq_record)
+
+def handle_irq_handler_exit(event_info):
+        (name, context, cpu, time, pid, comm, irq, ret) = event_info
+        if cpu not in irq_dic.keys():
+                return
+        irq_record = irq_dic[cpu].pop()
+        if irq != irq_record['irq']:
+                return
+        irq_record.update({'irq_ext_t':time})
+        # if an irq doesn't include NET_RX softirq, drop.
+        if 'event_list' in irq_record.keys():
+                irq_dic[cpu].append(irq_record)
+
+def handle_irq_softirq_raise(event_info):
+        (name, context, cpu, time, pid, comm, vec) = event_info
+        if cpu not in irq_dic.keys() \
+        or len(irq_dic[cpu]) == 0:
+                return
+        irq_record = irq_dic[cpu].pop()
+        if 'event_list' in irq_record.keys():
+                irq_event_list = irq_record['event_list']
+        else:
+                irq_event_list = []
+        irq_event_list.append({'time':time, 'event':'sirq_raise'})
+        irq_record.update({'event_list':irq_event_list})
+        irq_dic[cpu].append(irq_record)
+
+def handle_irq_softirq_entry(event_info):
+        (name, context, cpu, time, pid, comm, vec) = event_info
+        net_rx_dic[cpu] = {'sirq_ent_t':time, 'event_list':[]}
+
+def handle_irq_softirq_exit(event_info):
+        (name, context, cpu, time, pid, comm, vec) = event_info
+        irq_list = []
+        event_list = 0
+        if cpu in irq_dic.keys():
+                irq_list = irq_dic[cpu]
+                del irq_dic[cpu]
+        if cpu in net_rx_dic.keys():
+                sirq_ent_t = net_rx_dic[cpu]['sirq_ent_t']
+                event_list = net_rx_dic[cpu]['event_list']
+                del net_rx_dic[cpu]
+        if irq_list == [] or event_list == 0:
+                return
+        rec_data = {'sirq_ent_t':sirq_ent_t, 'sirq_ext_t':time,
+                    'irq_list':irq_list, 'event_list':event_list}
+        # merge information realted to a NET_RX softirq
+        receive_hunk_list.append(rec_data)
+
+def handle_napi_poll(event_info):
+        (name, context, cpu, time, pid, comm, napi, dev_name) = event_info
+        if cpu in net_rx_dic.keys():
+                event_list = net_rx_dic[cpu]['event_list']
+                rec_data = {'event_name':'napi_poll',
+                                'dev':dev_name, 'event_t':time}
+                event_list.append(rec_data)
+
+def handle_netif_rx(event_info):
+        (name, context, cpu, time, pid, comm,
+                skbaddr, skblen, dev_name) = event_info
+        if cpu not in irq_dic.keys() \
+        or len(irq_dic[cpu]) == 0:
+                return
+        irq_record = irq_dic[cpu].pop()
+        if 'event_list' in irq_record.keys():
+                irq_event_list = irq_record['event_list']
+        else:
+                irq_event_list = []
+        irq_event_list.append({'time':time, 'event':'netif_rx',
+                'skbaddr':skbaddr, 'skblen':skblen, 'dev_name':dev_name})
+        irq_record.update({'event_list':irq_event_list})
+        irq_dic[cpu].append(irq_record)
+
+def handle_netif_receive_skb(event_info):
+        global of_count_rx_skb_list
+
+        (name, context, cpu, time, pid, comm,
+                skbaddr, skblen, dev_name) = event_info
+        if cpu in net_rx_dic.keys():
+                rec_data = {'event_name':'netif_receive_skb',
+                            'event_t':time, 'skbaddr':skbaddr, 'len':skblen}
+                event_list = net_rx_dic[cpu]['event_list']
+                event_list.append(rec_data)
+                rx_skb_list.insert(0, rec_data)
+                if len(rx_skb_list) > buffer_budget:
+                        rx_skb_list.pop()
+                        of_count_rx_skb_list += 1
+
+def handle_net_dev_queue(event_info):
+        global of_count_tx_queue_list
+
+        (name, context, cpu, time, pid, comm,
+                skbaddr, skblen, dev_name) = event_info
+        skb = {'dev':dev_name, 'skbaddr':skbaddr, 'len':skblen, 'queue_t':time}
+        tx_queue_list.insert(0, skb)
+        if len(tx_queue_list) > buffer_budget:
+                tx_queue_list.pop()
+                of_count_tx_queue_list += 1
+
+def handle_net_dev_xmit(event_info):
+        global of_count_tx_xmit_list
+
+        (name, context, cpu, time, pid, comm,
+                skbaddr, skblen, rc, dev_name) = event_info
+        if rc == 0: # NETDEV_TX_OK
+                for i in range(len(tx_queue_list)):
+                        skb = tx_queue_list[i]
+                        if skb['skbaddr'] == skbaddr:
+                                skb['xmit_t'] = time
+                                tx_xmit_list.insert(0, skb)
+                                del tx_queue_list[i]
+                                if len(tx_xmit_list) > buffer_budget:
+                                        tx_xmit_list.pop()
+                                        of_count_tx_xmit_list += 1
+                                return
+
+def handle_kfree_skb(event_info):
+        (name, context, cpu, time, pid, comm,
+                skbaddr, protocol, location) = event_info
+        for i in range(len(tx_queue_list)):
+                skb = tx_queue_list[i]
+                if skb['skbaddr'] == skbaddr:
+                        del tx_queue_list[i]
+                        return
+        for i in range(len(tx_xmit_list)):
+                skb = tx_xmit_list[i]
+                if skb['skbaddr'] == skbaddr:
+                        skb['free_t'] = time
+                        tx_free_list.append(skb)
+                        del tx_xmit_list[i]
+                        return
+        for i in range(len(rx_skb_list)):
+                rec_data = rx_skb_list[i]
+                if rec_data['skbaddr'] == skbaddr:
+                        rec_data.update({'handle':"kfree_skb",
+                                        'comm':comm, 'pid':pid, 'comm_t':time})
+                        del rx_skb_list[i]
+                        return
+
+def handle_consume_skb(event_info):
+        (name, context, cpu, time, pid, comm, skbaddr) = event_info
+        for i in range(len(tx_xmit_list)):
+                skb = tx_xmit_list[i]
+                if skb['skbaddr'] == skbaddr:
+                        skb['free_t'] = time
+                        tx_free_list.append(skb)
+                        del tx_xmit_list[i]
+                        return
+
+def handle_skb_copy_datagram_iovec(event_info):
+        (name, context, cpu, time, pid, comm, skbaddr, skblen) = event_info
+        for i in range(len(rx_skb_list)):
+                rec_data = rx_skb_list[i]
+                if skbaddr == rec_data['skbaddr']:
+                        rec_data.update({'handle':"skb_copy_datagram_iovec",
+                                        'comm':comm, 'pid':pid, 'comm_t':time})
+                        del rx_skb_list[i]
+                        return
diff --git a/tools/perf/scripts/python/sched-migration.py b/tools/perf/scripts/python/sched-migration.py
new file mode 100644
index 000000000000..b934383c3364
--- /dev/null
+++ b/tools/perf/scripts/python/sched-migration.py
@@ -0,0 +1,461 @@
+#!/usr/bin/python
+#
+# Cpu task migration overview toy
+#
+# Copyright (C) 2010 Frederic Weisbecker <fweisbec@gmail.com>
+#
+# perf trace event handlers have been generated by perf trace -g python
+#
+# This software is distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+
+import os
+import sys
+
+from collections import defaultdict
+from UserList import UserList
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+sys.path.append('scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from SchedGui import *
+
+
+threads = { 0 : "idle"}
+
+def thread_name(pid):
+        return "%s:%d" % (threads[pid], pid)
+
+class RunqueueEventUnknown:
+        @staticmethod
+        def color():
+                return None
+
+        def __repr__(self):
+                return "unknown"
+
+class RunqueueEventSleep:
+        @staticmethod
+        def color():
+                return (0, 0, 0xff)
+
+        def __init__(self, sleeper):
+                self.sleeper = sleeper
+
+        def __repr__(self):
+                return "%s gone to sleep" % thread_name(self.sleeper)
+
+class RunqueueEventWakeup:
+        @staticmethod
+        def color():
+                return (0xff, 0xff, 0)
+
+        def __init__(self, wakee):
+                self.wakee = wakee
+
+        def __repr__(self):
+                return "%s woke up" % thread_name(self.wakee)
+
+class RunqueueEventFork:
+        @staticmethod
+        def color():
+                return (0, 0xff, 0)
+
+        def __init__(self, child):
+                self.child = child
+
+        def __repr__(self):
+                return "new forked task %s" % thread_name(self.child)
+
+class RunqueueMigrateIn:
+        @staticmethod
+        def color():
+                return (0, 0xf0, 0xff)
+
+        def __init__(self, new):
+                self.new = new
+
+        def __repr__(self):
+                return "task migrated in %s" % thread_name(self.new)
+
+class RunqueueMigrateOut:
+        @staticmethod
+        def color():
+                return (0xff, 0, 0xff)
+
+        def __init__(self, old):
+                self.old = old
+
+        def __repr__(self):
+                return "task migrated out %s" % thread_name(self.old)
+
+class RunqueueSnapshot:
+        def __init__(self, tasks = [0], event = RunqueueEventUnknown()):
+                self.tasks = tuple(tasks)
+                self.event = event
+
+        def sched_switch(self, prev, prev_state, next):
+                event = RunqueueEventUnknown()
+
+                if taskState(prev_state) == "R" and next in self.tasks \
+                        and prev in self.tasks:
+                        return self
+
+                if taskState(prev_state) != "R":
+                        event = RunqueueEventSleep(prev)
+
+                next_tasks = list(self.tasks[:])
+                if prev in self.tasks:
+                        if taskState(prev_state) != "R":
+                                next_tasks.remove(prev)
+                elif taskState(prev_state) == "R":
+                        next_tasks.append(prev)
+
+                if next not in next_tasks:
+                        next_tasks.append(next)
+
+                return RunqueueSnapshot(next_tasks, event)
+
+        def migrate_out(self, old):
+                if old not in self.tasks:
+                        return self
+                next_tasks = [task for task in self.tasks if task != old]
+
+                return RunqueueSnapshot(next_tasks, RunqueueMigrateOut(old))
+
+        def __migrate_in(self, new, event):
+                if new in self.tasks:
+                        self.event = event
+                        return self
+                next_tasks = self.tasks[:] + tuple([new])
+
+                return RunqueueSnapshot(next_tasks, event)
+
+        def migrate_in(self, new):
+                return self.__migrate_in(new, RunqueueMigrateIn(new))
+
+        def wake_up(self, new):
+                return self.__migrate_in(new, RunqueueEventWakeup(new))
+
+        def wake_up_new(self, new):
+                return self.__migrate_in(new, RunqueueEventFork(new))
+
+        def load(self):
+                """ Provide the number of tasks on the runqueue.
+                    Don't count idle"""
+                return len(self.tasks) - 1
+
+        def __repr__(self):
+                ret = self.tasks.__repr__()
+                ret += self.origin_tostring()
+
+                return ret
+
+class TimeSlice:
+        def __init__(self, start, prev):
+                self.start = start
+                self.prev = prev
+                self.end = start
+                # cpus that triggered the event
+                self.event_cpus = []
+                if prev is not None:
+                        self.total_load = prev.total_load
+                        self.rqs = prev.rqs.copy()
+                else:
+                        self.rqs = defaultdict(RunqueueSnapshot)
+                        self.total_load = 0
+
+        def __update_total_load(self, old_rq, new_rq):
+                diff = new_rq.load() - old_rq.load()
+                self.total_load += diff
+
+        def sched_switch(self, ts_list, prev, prev_state, next, cpu):
+                old_rq = self.prev.rqs[cpu]
+                new_rq = old_rq.sched_switch(prev, prev_state, next)
+
+                if old_rq is new_rq:
+                        return
+
+                self.rqs[cpu] = new_rq
+                self.__update_total_load(old_rq, new_rq)
+                ts_list.append(self)
+                self.event_cpus = [cpu]
+
+        def migrate(self, ts_list, new, old_cpu, new_cpu):
+                if old_cpu == new_cpu:
+                        return
+                old_rq = self.prev.rqs[old_cpu]
+                out_rq = old_rq.migrate_out(new)
+                self.rqs[old_cpu] = out_rq
+                self.__update_total_load(old_rq, out_rq)
+
+                new_rq = self.prev.rqs[new_cpu]
+                in_rq = new_rq.migrate_in(new)
+                self.rqs[new_cpu] = in_rq
+                self.__update_total_load(new_rq, in_rq)
+
+                ts_list.append(self)
+
+                if old_rq is not out_rq:
+                        self.event_cpus.append(old_cpu)
+                self.event_cpus.append(new_cpu)
+
+        def wake_up(self, ts_list, pid, cpu, fork):
+                old_rq = self.prev.rqs[cpu]
+                if fork:
+                        new_rq = old_rq.wake_up_new(pid)
+                else:
+                        new_rq = old_rq.wake_up(pid)
+
+                if new_rq is old_rq:
+                        return
+                self.rqs[cpu] = new_rq
+                self.__update_total_load(old_rq, new_rq)
+                ts_list.append(self)
+                self.event_cpus = [cpu]
+
+        def next(self, t):
+                self.end = t
+                return TimeSlice(t, self)
+
+class TimeSliceList(UserList):
+        def __init__(self, arg = []):
+                self.data = arg
+
+        def get_time_slice(self, ts):
+                if len(self.data) == 0:
+                        slice = TimeSlice(ts, TimeSlice(-1, None))
+                else:
+                        slice = self.data[-1].next(ts)
+                return slice
+
+        def find_time_slice(self, ts):
+                start = 0
+                end = len(self.data)
+                found = -1
+                searching = True
+                while searching:
+                        if start == end or start == end - 1:
+                                searching = False
+
+                        i = (end + start) / 2
+                        if self.data[i].start <= ts and self.data[i].end >= ts:
+                                found = i
+                                end = i
+                                continue
+
+                        if self.data[i].end < ts:
+                                start = i
+
+                        elif self.data[i].start > ts:
+                                end = i
+
+                return found
+
+        def set_root_win(self, win):
+                self.root_win = win
+
+        def mouse_down(self, cpu, t):
+                idx = self.find_time_slice(t)
+                if idx == -1:
+                        return
+
+                ts = self[idx]
+                rq = ts.rqs[cpu]
+                raw = "CPU: %d\n" % cpu
+                raw += "Last event : %s\n" % rq.event.__repr__()
+                raw += "Timestamp : %d.%06d\n" % (ts.start / (10 ** 9), (ts.start % (10 ** 9)) / 1000)
+                raw += "Duration : %6d us\n" % ((ts.end - ts.start) / (10 ** 6))
+                raw += "Load = %d\n" % rq.load()
+                for t in rq.tasks:
+                        raw += "%s \n" % thread_name(t)
+
+                self.root_win.update_summary(raw)
+
+        def update_rectangle_cpu(self, slice, cpu):
+                rq = slice.rqs[cpu]
+
+                if slice.total_load != 0:
+                        load_rate = rq.load() / float(slice.total_load)
+                else:
+                        load_rate = 0
+
+                red_power = int(0xff - (0xff * load_rate))
+                color = (0xff, red_power, red_power)
+
+                top_color = None
+
+                if cpu in slice.event_cpus:
+                        top_color = rq.event.color()
+
+                self.root_win.paint_rectangle_zone(cpu, color, top_color, slice.start, slice.end)
+
+        def fill_zone(self, start, end):
+                i = self.find_time_slice(start)
+                if i == -1:
+                        return
+
+                for i in xrange(i, len(self.data)):
+                        timeslice = self.data[i]
+                        if timeslice.start > end:
+                                return
+
+                        for cpu in timeslice.rqs:
+                                self.update_rectangle_cpu(timeslice, cpu)
+
+        def interval(self):
+                if len(self.data) == 0:
+                        return (0, 0)
+
+                return (self.data[0].start, self.data[-1].end)
+
+        def nr_rectangles(self):
+                last_ts = self.data[-1]
+                max_cpu = 0
+                for cpu in last_ts.rqs:
+                        if cpu > max_cpu:
+                                max_cpu = cpu
+                return max_cpu
+
+
+class SchedEventProxy:
+        def __init__(self):
+                self.current_tsk = defaultdict(lambda : -1)
+                self.timeslices = TimeSliceList()
+
+        def sched_switch(self, headers, prev_comm, prev_pid, prev_prio, prev_state,
+                         next_comm, next_pid, next_prio):
+                """ Ensure the task we sched out this cpu is really the one
+                    we logged. Otherwise we may have missed traces """
+
+                on_cpu_task = self.current_tsk[headers.cpu]
+
+                if on_cpu_task != -1 and on_cpu_task != prev_pid:
+                        print "Sched switch event rejected ts: %s cpu: %d prev: %s(%d) next: %s(%d)" % \
+                                (headers.ts_format(), headers.cpu, prev_comm, prev_pid, next_comm, next_pid)
+
+                threads[prev_pid] = prev_comm
+                threads[next_pid] = next_comm
+                self.current_tsk[headers.cpu] = next_pid
+
+                ts = self.timeslices.get_time_slice(headers.ts())
+                ts.sched_switch(self.timeslices, prev_pid, prev_state, next_pid, headers.cpu)
+
+        def migrate(self, headers, pid, prio, orig_cpu, dest_cpu):
+                ts = self.timeslices.get_time_slice(headers.ts())
+                ts.migrate(self.timeslices, pid, orig_cpu, dest_cpu)
+
+        def wake_up(self, headers, comm, pid, success, target_cpu, fork):
+                if success == 0:
+                        return
+                ts = self.timeslices.get_time_slice(headers.ts())
+                ts.wake_up(self.timeslices, pid, target_cpu, fork)
+
+
+def trace_begin():
+        global parser
+        parser = SchedEventProxy()
+
+def trace_end():
+        app = wx.App(False)
+        timeslices = parser.timeslices
+        frame = RootFrame(timeslices, "Migration")
+        app.MainLoop()
+
+def sched__sched_stat_runtime(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, runtime, vruntime):
+        pass
+
+def sched__sched_stat_iowait(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, delay):
+        pass
+
+def sched__sched_stat_sleep(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, delay):
+        pass
+
+def sched__sched_stat_wait(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, delay):
+        pass
+
+def sched__sched_process_fork(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        parent_comm, parent_pid, child_comm, child_pid):
+        pass
+
+def sched__sched_process_wait(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_process_exit(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_process_free(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_migrate_task(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio, orig_cpu,
+        dest_cpu):
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.migrate(headers, pid, prio, orig_cpu, dest_cpu)
+
+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):
+
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.sched_switch(headers, prev_comm, prev_pid, prev_prio, prev_state,
+                         next_comm, next_pid, next_prio)
+
+def sched__sched_wakeup_new(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio, success,
+        target_cpu):
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.wake_up(headers, comm, pid, success, target_cpu, 1)
+
+def sched__sched_wakeup(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio, success,
+        target_cpu):
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.wake_up(headers, comm, pid, success, target_cpu, 0)
+
+def sched__sched_wait_task(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_kthread_stop_ret(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        ret):
+        pass
+
+def sched__sched_kthread_stop(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid):
+        pass
+
+def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm):
+        pass