#!/usr/bin/python -tt
#
# scantrace - scan an ftrace function trace file looking for large latencys
#
# Copyright (c) 2010 Clark Williams <williams@redhat.com>
# This code is free software licenced under the GPLv2
#

import sys
import os
import re
import getopt

class TracePoint(object):
    def __init__(self, match):
        self.cmd = m.group('cmd')
        self.cpu = int(m.group('cpu'))
        self.time = int(m.group('time'))
        self.call = m.group('call')
        self.flags = m.group('flags')

    def irqsoff(self):
        return self.flags[0] == 'd'

    def hardirq(self):
        return self.flags[2] == 'h'

    def softirq(self):
        return self.flags[2] == 's'

    def getirq(self):
        return self.flags[2]

    def needresched(self):
        return self.flags[1] == 'N'

    def preemptdepth(self):
        if self.flags[3] == '.':
            return 0
        return int(self.flags[3])

    def lockdepth(self):
        if self.flags[4] == '.':
            return 0
        return int(self.flags[4])

class IrqsOff(object):
    def __init__(self, threshold):
        self.tracepoints=[]
        self.starttime = None
        self.stoptime = None
        self.delta = 0
        self.measuring = False
        self.threshold = threshold

    def check(self, data):
        irqsoff = data.irqsoff()
        if not self.measuring:
            if irqsoff:
                self.start(data)
        else:
            if irqsoff:
                self.tracepoints.append(data)
            else:
                self.stop(data)

    def start(self, data):
        self.tracepoints = []
        self.tracepoints.append(data)
        self.starttime = data.time
        self.measuring = True

    def stop(self, data):
        self.measuring = False
        self.tracepoints.append(data)
        self.stoptime = data.time
        self.delta = self.stoptime - self.starttime
        if self.delta > self.threshold:
            print "CPU%s:  irq off delta: %dus (trace line number: %d)" % (data.cpu, self.delta, lnum)
            for t in self.tracepoints:
                print "        %10.10s  %s  %dus : %s" %(t.cmd, t.flags, t.time, t.call)
            print ""

class CPU(object):
    def __init__(self, cpu, dotime, doirq, timethreshold, irqthreshold):
        self.cpu = cpu
        self.dotime = dotime
        self.doirq = doirq
        self.timethreshold = timethreshold
        self.irqthreshold = irqthreshold
        self.lasttrace = None
        self.biggestdelta = 0
        self.irq = IrqsOff(self.irqthreshold)

    def checktime(self, data):
        if not self.dotime: return
        if self.lasttrace == None:
            self.lasttrace = data
        else:
            delta = data.time - self.lasttime.time
            if delta > self.timethreshold and delta > self.biggestdelta:
                if self.lasttime.cmd.find('<idle>') == -1:
                    print "CPU%s:  time delta: %dus  (trace line number: %d)" % (data.cpu, delta, lnum)
                    print "        %10.10s  %s  %dus : %s" % (self.lasttime.cmd, 
                                                         self.lasttime.flags,
                                                         self.lasttime.time, 
                                                         self.lasttime.call)
                    print "        %10.10s  %s  %dus : %s" % (data.cmd, data.flags, data.time, data.call)
                    print ""
                    self.biggestdelta = delta
        self.lasttime = data

    def check(self, data):
        if self.dotime:
            self.checktime(data)
        if self.doirq:
            self.irq.check(data)


trace_re = re.compile(r'^\s+(?P<cmd>.+)\s+(?P<cpu>\d+)(?P<flags>.....)\s(?P<time>\d+)us : (?P<call>.*)$')
format_re = re.compile(r'^# tracer: (.+)$')

# ignore deltas less than this
threshold = 50  #default
irqthreshold = 50

def usage():
    print "usage:  scantrace [-I|-T] [-t|--timethreshold=<us>] [-i|--irqthreshold] <tracefile>"
    sys.exit(1)

def openfile(file):
    if file.endswith(".bz2"):
        import bz2
        handle = bz2.BZ2File(file, 'r')
    elif file.endswith(".gz"):
        import gzip
        handle = gzip.GzipFile(file, 'r')
    else:
        handle = open(file, 'r')
    return handle

def checkformat(line):
    m = format_re.search(line)
    if m and m.group(1) != "function":
            raise RuntimeError, "this script only handles function tracer output!\n"

checktime = False
checkirq = False

opts, pargs = getopt.getopt(sys.argv[1:], 'i:t:d:', ["irq=", 'time=', 'delta='])
for o,a in opts:
    if o in ('-i', '--irq'):
        checkirq = True
        irqthreshold = int(a)
    elif o in ('-t', '--time'):
        checktime = True
        timethreshold = int(a)
    elif o in ('-d', '--delta'):
        checkirq = True
        checktime = True
        irqthreshold = timethreshold = int(a)
    else:
        usage()

try:
    file = pargs[0]
except:
    usage()

handle = openfile(file)

cpus = []
for i in range(0, 256):
    cpus.append(CPU(cpu=i, dotime=checktime, doirq=checkirq, 
                    timethreshold=timethreshold, irqthreshold=irqthreshold))

lnum = 0
for line in handle:
    lnum += 1
    if line.startswith("#"): 
        checkformat(line)
        continue
    m = trace_re.search(line)
    if not m:  continue
    d = TracePoint(m)
    cpus[d.cpu].check(d)