def __add_events(self, events): """Add events to the class_definitions If the events are known to trappy just add that class to the class definitions list. Otherwise, register a class to parse that event """ from trappy.dynamic import DynamicTypeFactory, default_init from trappy.base import Base # TODO: scopes should not be hardcoded (nor here nor in the FTrace object) all_scopes = [ self.thermal_classes, self.sched_classes, self.dynamic_classes ] known_events = {k: v for sc in all_scopes for k, v in sc.iteritems()} for event_name in events: for cls in known_events.itervalues(): if (event_name == cls.unique_word) or \ (event_name + ":" == cls.unique_word): self.class_definitions[event_name] = cls break else: kwords = { "__init__": default_init, "unique_word": event_name + ":", "name": event_name, } trace_class = DynamicTypeFactory(event_name, (Base, ), kwords) self.class_definitions[event_name] = trace_class
def add_parsed_event(self, name, dfr, pivot=None): """Add a dataframe to the events in this trace This function lets you add other events that have been parsed by other tools to the collection of events in this instance. For example, assuming you have some events in a csv, you could add them to a trace instance like this: >>> trace = trappy.BareTrace() >>> counters_dfr = pd.DataFrame.from_csv("counters.csv") >>> trace.add_parsed_event("pmu_counters", counters_dfr) Now you can access :code:`trace.pmu_counters` as you would with any other trace event and other trappy classes can interact with them. :param name: The attribute name in this trace instance. As in the example above, if :code:`name` is "pmu_counters", the parsed event will be accessible using :code:`trace.pmu_counters`. :type name: str :param dfr: :mod:`pandas.DataFrame` containing the events. Its index should be time in seconds. Its columns are the events. :type dfr: :mod:`pandas.DataFrame` :param pivot: The data column about which the data can be grouped :type pivot: str """ from trappy.base import Base from trappy.dynamic import DynamicTypeFactory, default_init if hasattr(self, name): raise ValueError("event {} already present".format(name)) kwords = { "__init__": default_init, "unique_word": name + ":", "name": name, } trace_class = DynamicTypeFactory(name, (Base, ), kwords) self.class_definitions[name] = trace_class event = trace_class() self.trace_classes.append(event) event.data_frame = dfr if pivot: event.pivot = pivot setattr(self, name, event)