def unregister_ftrace_parser(ftrace_parser):
"""Unregister an ftrace parser
:param ftrace_parser: An ftrace parser class that was registered
with register_ftrace_parser() or register_dynamic_ftrace().
If done with the latter, the cls parameter is the return value
of register_dynamic_ftrace()
:type ftrace_parser: class derived from :mod:`trappy.base.Base`
"""
FTrace.unregister_parser(ftrace_parser)
def register_dynamic_ftrace(class_name, unique_word, scope="all",
parse_raw=False, pivot=None):
"""Create a Dynamic FTrace parser and register it with the FTrace class
:param class_name: The name of the class to be registered
(Should be in CamelCase)
:type class_name: str
:param unique_word: The unique_word to be matched in the
trace
:type unique_word: str
:param scope: Registry Scope (Can be used to constrain
the parsing of events and group them together)
:type scope: str
:param parse_raw: If, true, raw trace output (-R flag)
will be used
:type parse_raw: bool
:param pivot: The data column about which the data can be grouped
:type pivot: str
For example if a new unique word :code:`my_unique_word` has
to be registered with TRAPpy:
::
import trappy
custom_class = trappy.register_dynamic_ftrace("MyEvent", "my_unique_word")
trace = trappy.FTrace("/path/to/trace_file")
# New data member created in the ftrace object
trace.my_event
.. note:: The name of the member is :code:`my_event` from **MyEvent**
:return: A class object of type :mod:`trappy.base.Base`
"""
kwords = {
"__init__": default_init,
"unique_word": unique_word,
"name": _get_name(class_name),
"parse_raw" : parse_raw,
}
if pivot:
kwords["pivot"] = pivot
dyn_class = DynamicTypeFactory(class_name, (Base,), kwords)
FTrace.register_parser(dyn_class, scope)
return dyn_class
def register_ftrace_parser(cls):
"""Register a new FTrace parser class implementation
Should be used when the class has complex helper methods and does
not expect to use the default constructor.
:param cls: The class to be registered for
enabling the parsing of an event in trace
:type cls: :mod:`trappy.base.Base`
"""
# Check the argspec of the class
FTrace.register_parser(cls)
unique_word="thermal_power_allocator_pid"
"""The event name in the trace"""
def plot_controller(self, title="", width=None, height=None, ax=None):
"""Plot a summary of the controller data
:param ax: Axis instance
:type ax: :mod:`matplotlib.Axis`
:param title: The title of the plot
:type title: str
:param width: The width of the plot
:type width: int
:param height: The height of the plot
:type int: int
"""
import trappy.plot_utils
title = trappy.plot_utils.normalize_title("PID", title)
if not ax:
ax = trappy.plot_utils.pre_plot_setup(width, height)
self.data_frame[["output", "p", "i", "d"]].plot(ax=ax)
trappy.plot_utils.post_plot_setup(ax, title=title)
FTrace.register_parser(PIDController, "thermal")
"""The unique word that will be matched in a trace line"""
_cpu_mask_column = "cpus"
pivot = "cpus"
"""The Pivot along which the data is orthogonal"""
def finalize_object(self):
"""This condition is necessary to force column 'cpus' to be printed
as 8 digits w/ leading 0
"""
if self._cpu_mask_column in self.data_frame.columns:
dfr = self.data_frame[self._cpu_mask_column].apply('{:0>8}'.format)
self.data_frame[self._cpu_mask_column] = dfr
FTrace.register_parser(SchedLoadAvgSchedGroup, "sched")
class SchedLoadAvgTask(Base):
"""Corresponds to Linux kernel trace event sched_load_avg_task"""
unique_word = "sched_load_avg_task:"
"""The unique word that will be matched in a trace line"""
pivot = "pid"
"""The Pivot along which the data is orthogonal"""
def get_pids(self, key=""):
"""Returns a list of (comm, pid) that contain
'key' in their 'comm'."""
dfr = self.data_frame.drop_duplicates(subset=['comm', 'pid'])
dfr = dfr.ix[:, ['comm', 'pid']]
def get_all_freqs(self, mapping_label):
"""Get a :mod:`pandas.DataFrame` with the maximum frequencies allowed by the governor
:param mapping_label: A dictionary that maps cpumasks to name
of the cpu.
:type mapping_label: dict
:return: freqs are in MHz
"""
dfr = self.data_frame
return pivot_with_labels(dfr, "freq", "cpus", mapping_label) / 1000
FTrace.register_parser(CpuOutPower, "thermal")
class CpuInPower(Base):
"""Process the cpufreq cooling power actor data in a ftrace dump
"""
unique_word = "thermal_power_cpu_get"
"""The unique word that will be matched in a trace line"""
name = "cpu_in_power"
"""The name of the :mod:`pandas.DataFrame` member that will be created in a
:mod:`trappy.ftrace.FTrace` object"""
pivot = "cpus"
"""The Pivot along which the data is orthogonal"""
:param ax: Axis instance
:type ax: :mod:`matplotlib.Axis`
:param title: The title of the plot
:type title: str
"""
from trappy.plot_utils import normalize_title, plot_hist
temps = self.data_frame["temp"] / 1000
title = normalize_title("Temperature", title)
xlim = (0, temps.max())
plot_hist(temps, ax, title, "C", 30, "Temperature", xlim, "default")
FTrace.register_parser(Thermal, "thermal")
class ThermalGovernor(Base):
"""Process the power allocator data in a ftrace dump"""
unique_word = "thermal_power_allocator:"
"""The unique word that will be matched in a trace line"""
name = "thermal_governor"
"""The name of the :mod:`pandas.DataFrame` member that will be created in a
:mod:`trappy.ftrace.FTrace` object"""
pivot = "thermal_zone_id"
"""The Pivot along which the data is orthogonal"""
def plot_temperature(self, title="", width=None, height=None, ylim="range",
unique_word="thermal_power_devfreq_get_power:"
"""The event name in the trace"""
def get_all_freqs(self):
"""Return a :mod:`pandas.DataFrame` with
the frequencies for the devfreq device
The format should be the same as the one for
:code:`CpuInPower().get_all_freqs()`.
.. note:: Frequencies are in MHz.
"""
return pd.DataFrame(self.data_frame["freq"] / 1000000)
FTrace.register_parser(DevfreqInPower, "thermal")
class DevfreqOutPower(Base):
"""Process de devfreq cooling device data regarding power2state in an
ftrace dump"""
name = "devfreq_out_power"
"""The name of the :mod:`pandas.DataFrame` member that will be created in a
:mod:`trappy.ftrace.FTrace` object"""
unique_word="thermal_power_devfreq_limit:"
"""The event name in the trace"""
def get_all_freqs(self):
"""Return a :mod:`pandas.DataFrame` with