path: root/scripts/tracing/dma-api/trace.py

"""Main program and stuff"""

#from pprint import pprint
from sys import stdin
import os.path
import re
from argparse import ArgumentParser
import cPickle as pickle
from collections import namedtuple
from plotting import plotseries, disp_pic
import smmu

class TracelineParser(object):
    """Parse the needed information out of an ftrace line"""
    #            <...>-6     [000] d..2     5.287079: dmadebug_iommu_map_page: device=sdhci-tegra.3, addr=0x01048000, size=4096 page=c13e7214 archdata=ed504640
    def __init__(self):
        self.pattern = re.compile("device=(?P<dev>.*), addr=(?P<addr>.*), size=(?P<size>.*) page=(?P<page>.*) archdata=(?P<archdata>.*)")
    def parse(self, args):
        args = self.pattern.match(args)
        return (args.group("dev"), int(args.group("addr"), 16),
                int(args.group("size")), int(args.group("page"), 16),
                int(args.group("archdata"), 16))

def biggest_indices(items, n):
    """Return list of indices of n biggest elements in items"""
    with_indices = [(x, i) for i, x in enumerate(items)]
    ordered = sorted(with_indices)
    return [i for x, i in ordered[-n:]]

def by_indices(xs, ids):
    """Get elements from the list xs by their indices"""
    return [xs[i] for i in ids]

"""Event represents one input line"""
Event = namedtuple("Event", ["time", "dev", "data", "delta"])

class Trace(object):
    def __init__(self, args):
        smmu.VERBOSITY = args.verbosity
        self._args = args
        self.devlist = []
        self.events = []
        self.metrics = {
                "max_peak": self._usage_peak,
                "activity_rate": self._usage_activity,
                "average_mem": self._usage_avg
        }
        self.traceliner = TracelineParser()

    @staticmethod
    def get_metrics():
        """What filter metrics to get max users"""
        return ["max_peak", "activity_rate", "average_mem"]

    def show(self):
        """Shuffle events around, build plots, and show them"""
        if self._args.max_plots:
            evs = self.merge_events()
        else:
            evs = self.events
        series, devlist = self.unload(evs)
        if not self._args.no_plots:
            self.plot(series, devlist)

    def _get_usage(self, evs):
        """Return a metric of how active the events in evs are"""
        return self.metrics[self._args.max_metric](evs)

    def _usage_peak(self, evs):
        """Return the biggest peak"""
        return max(e.data for e in evs)

    def _usage_activity(self, evs):
        """Return the activity count: simply the length of the event list"""
        return len(evs)

    def _usage_avg(self, evs):
        """Return the average over all points"""
        # FIXME: the data points are not uniform in time, so this might be
        # somewhat off.
        return float(sum(e.data for e in evs)) / len(e)

    def merge_events(self):
        """Find out biggest users, keep them and flatten others to a single user"""
        sizes = []
        dev_evs = []
        for i, dev in enumerate(self.devlist):
            dev_evs.append([e for e in self.events if e.dev == dev])
            sizes.append(self._get_usage(dev_evs[i]))

        # indices of the devices
        biggestix = biggest_indices(sizes, self._args.max_plots)
        print biggestix
        is_big = {}
        for i, dev in enumerate(self.devlist):
            is_big[dev] = i in biggestix

        evs = []
        for e in self.events:
            if not is_big[e.dev]:
                e = Event(e.time, "others", e.data, e.delta)
            evs.append(e)

        self.devlist.append("others")
        return evs

    def unload(self, events):
        """Prepare the event list for plotting

        series ends up as [([time0], [data0]), ([time1], [data1]), ...]
        """
        # ([x], [y]) for matplotlib
        series = [([], []) for x in self.devlist]
        devidx = dict([(d, i) for i, d in enumerate(self.devlist)])

        for event in events:
            devid = devidx[event.dev]
            series[devid][0].append(event.time)
            series[devid][1].append(event.data) # self.dev_data(event.dev))

        series_out = []
        devlist_out = []

        for ser, dev in zip(series, self.devlist):
            if len(ser[0]) > 0:
                series_out.append(ser)
                devlist_out.append(dev)

        return series_out, devlist_out

    def plot(self, series, devlist):
        """Display the plots"""
        #series, devlist = flatten_axes(self.series, self.devlist,
        #        self._args.max_plots)
        devinfo = (series, map(str, devlist))
        allocfreeinfo = (self.allocsfrees, ["allocd", "freed", "current"])
        plotseries(devinfo, allocfreeinfo)
        #plotseries(devinfo)

    def dev_data(self, dev):
        """what data to plot against time"""
        return dev._cur_alloc

    def _cache_hash(self, filename):
        """The trace files are probably not of the same size"""
        return str(os.path.getsize(filename))

    def load_cache(self):
        """Get the trace data from a database file, if one exists"""
        has = self._cache_hash(self._args.filename)
        try:
            cache = open("trace." + has)
        except IOError:
            pass
        else:
            self._load_cache(pickle.load(cache))
            return True
        return False

    def save_cache(self):
        """Store the raw trace data to a database"""
        data = self._save_cache()
        fh = open("trace." + self._cache_hash(self._args.filename), "w")
        pickle.dump(data, fh)

    def _save_cache(self):
        """Return the internal data that is needed to be pickled"""
        return self.events, self.devlist, self.allocsfrees

    def _load_cache(self, data):
        """Get the data from an unpickled object"""
        self.events, self.devlist, self.allocsfrees = data

    def load_events(self):
        """Get the internal data from a trace file or cache"""
        if self._args.filename:
            if self._args.cache and self.load_cache():
                return
            fh = open(self._args.filename)
        else:
            fh = stdin

        self.parse(fh)

        if self._args.cache and self._args.filename:
            self.save_cache()

    def parse(self, fh):
        """Parse the trace file in fh, store data to self"""
        mems = {}
        dev_by_name = {}
        devlist = []
        buf_owners = {}
        events = []
        allocsfrees = [([], []), ([], []), ([], [])] # allocs, frees, current
        allocs = 0
        frees = 0
        curbufs = 0

        mem_bytes = 1024 * 1024 * 1024
        npages = mem_bytes / 4096
        ncols = 512
        le_pic = [0] * npages
        lastupd = 0

        for lineidx, line in enumerate(fh):
            # no comments
            if line.startswith("#"):
                continue

            taskpid, cpu, flags, timestamp, func, args = line.strip().split(None, 5)
            func = func[:-len(":")]
            # unneeded events may be there too
            if not func.startswith("dmadebug"):
                continue

            if self._args.verbosity >= 3:
                print line.rstrip()

            timestamp = float(timestamp[:-1])
            if timestamp < self._args.start:
                continue
            if timestamp >= self._args.end:
                break

            devname, addr, size, page, archdata = self.traceliner.parse(args)
            if self._args.processes:
                devname = taskpid.split("-")[0]
            mapping = archdata

            try:
                memmap = mems[mapping]
            except KeyError:
                memmap = mem(mapping)
                mems[mapping] = memmap

            try:
                dev = dev_by_name[devname]
            except KeyError:
                dev = smmu.Device(devname, memmap)
                dev_by_name[devname] = dev
                devlist.append(dev)

            allocfuncs = ["dmadebug_map_page", "dmadebug_map_sg", "dmadebug_alloc_coherent"]
            freefuncs = ["dmadebug_unmap_page", "dmadebug_unmap_sg", "dmadebug_free_coherent"]
            ignfuncs = []

            if timestamp-lastupd > 0.1:
                # just some debug prints for now
                lastupd = timestamp
                print lineidx,timestamp
                le_pic2 = [le_pic[i:i+ncols] for i in range(0, npages, ncols)]
                #disp_pic(le_pic2)

            # animating the bitmap would be cool
            #for row in le_pic:
            #    for i, a in enumerate(row):
            #        pass
                    #row[i] = 0.09 * a

            if func in allocfuncs:
                pages = dev_by_name[devname].alloc(addr, size)
                for p in pages:
                    le_pic[p] = 1
                buf_owners[addr] = dev_by_name[devname]
                allocs += 1
                curbufs += 1
                allocsfrees[0][0].append(timestamp)
                allocsfrees[0][1].append(allocs)
            elif func in freefuncs:
                if addr not in buf_owners:
                    if self._args.verbosity >= 1:
                        print "warning: %s unmapping unmapped %s" % (dev, addr)
                    buf_owners[addr] = dev
                # fixme: move this to bitmap handling
                # get to know the owners of bits
                # allocs/frees calls should be traced separately from maps?
                # map_pages is traced per page :(
                if buf_owners[addr] != dev and self._args.verbosity >= 2:
                    print "note: %s unmapping [%d,%d) mapped by %s" % (
                            dev, addr, addr+size, buf_owners[addr])
                pages = buf_owners[addr].free(addr, size)
                for p in pages:
                    le_pic[p] = 0
                frees -= 1
                curbufs -= 1
                allocsfrees[1][0].append(timestamp)
                allocsfrees[1][1].append(frees)
            elif func not in ignfuncs:
                raise ValueError("unhandled %s" % func)

            allocsfrees[2][0].append(timestamp)
            allocsfrees[2][1].append(curbufs)

            events.append(Event(timestamp, dev, self.dev_data(dev), size))

        self.events = events
        self.devlist = devlist
        self.allocsfrees = allocsfrees

        le_pic2 = [le_pic[i:i+ncols] for i in range(0, npages, ncols)]
        # FIXME: not quite ready yet
        disp_pic(le_pic2)

        return

def mem(asid):
    """Create a new memory object for the given asid space"""
    SZ_2G = 2 * 1024 * 1024 * 1024
    SZ_1M = 1 * 1024 * 1024
    # arch/arm/mach-tegra/include/mach/iomap.h TEGRA_SMMU_(BASE|SIZE)
    base = 0x80000000
    size = SZ_2G - SZ_1M
    return smmu.Memory(base, size, asid)

def get_args():
    """Eat command line arguments, return argparse namespace for settings"""
    parser = ArgumentParser()
    parser.add_argument("filename", nargs="?",
            help="trace file dump, stdin if not given")
    parser.add_argument("-s", "--start", type=float, default=0,
            help="start timestamp")
    parser.add_argument("-e", "--end", type=float, default=1e9,
            help="end timestamp")
    parser.add_argument("-v", "--verbosity", action="count", default=0,
            help="amount of extra information: once for warns (dup addrs), "
            "twice for notices (different client in map/unmap), "
            "three for echoing all back")
    parser.add_argument("-p", "--processes", action="store_true",
            help="use processes as memory clients instead of devices")
    parser.add_argument("-n", "--no-plots", action="store_true",
            help="Don't draw the plots, only read the trace")
    parser.add_argument("-c", "--cache", action="store_true",
            help="Pickle the data and make a cache file for fast reloading")
    parser.add_argument("-m", "--max-plots", type=int,
            help="Maximum number of clients to show; show biggest and sum others")
    parser.add_argument("-M", "--max-metric", choices=Trace.get_metrics(),
            default=Trace.get_metrics()[0],
            help="Metric to use when choosing clients in --max-plots")
    return parser.parse_args()

def main():
    args = get_args()
    trace = Trace(args)
    trace.load_events()
    trace.show()

if __name__ == "__main__":
    main()