Proper use of pandas indexing, saving time.

from scipy.stats.stats import pearsonr

import sys

def _get_timestamp(df, event, idx):

    """

    get the timestamp of an event

    """

    return list(df[event])[idx]

def _get_cyclestamp(df, event, idx):

    """

    get the cyclestamp related to an *_T event

    # TODO: this function is probably terribly slow

    cname = str(event)[:-2] + "_C"

    cycleevent = [x for x in list(df) if str(x) == cname][0]

    return list(df[cycleevent])[idx]

    return df[cycleevent].iloc[idx]

def _get_thread_for_event(config, e):

    for name, data in config['stamps'].items():

        if name == str(e)[:-2]:

            return data['Thread']

    name = str(e)[:-2]

    try:

        question = config["stamps"][name]["Thread"]

        return question

    except KeyError:

        print("Cannot find %s".format(name), file=sys.stderr)

        return None

def _happens_before(df, a, b, config):

    tb = _get_thread_for_event(config, b)

    if (ta == tb and ta != None and tb != None):

        for i in range(l):

            tsa = _get_timestamp(df, a, i)

            tsb = _get_timestamp(df, b, i)

            tsa = df[a].iloc[i]

            tsb = df[b].iloc[i]

            if tsa > tsb:

                return False

            csa = _get_cyclestamp(df, a, i)

    # since a and b occur in different threads, we cannot compare cyclestamps.

    # If in doubt, a and b are concurrent.

    for i in range(l):

        if _get_timestamp(df, a, i) >= _get_timestamp(df, b, i):

        if df[a].iloc[i] >= df[b].iloc[i]:

            return False

    return True

            #if _locally_happens_directly_before(df, event1, event2, hb, config):

            if _happens_directly_before(df, event1, event2, hb):

                # compute the correlation between e2e latency and event1-event2 latency

                l1 = list(df[event1])

                l2 = list(df[event2])

                l3 = []

                for i in range(len(l1)):

                    l3 += [_get_timestamp(df,event2,i) - _get_timestamp(df,event1,i)]

                l3 = list(df[event2] - df[event1])

                if any(map(lambda x: x != 0, l3)):

                    correlation = pearsonr(l3, e2e)[0]

                else:

    _plot_controlflow_graph(df, hdb)

    _plot_critical_regions(df, hdb)