def test_parse_values_concatenation(self):
"""TestBase: Trace with space separated values created a valid DataFrame"""
in_data = """ rcu_preempt-7 [000] 73.604532: my_sched_stat_runtime: comm=Space separated taskname pid=7 runtime=262875 [ns] vruntime=17096359856 [ns]"""
expected_columns = set([
"__comm", "__pid", "__cpu", "__line", "comm", "pid", "runtime",
"vruntime"
])
with open("trace.txt", "w") as fout:
fout.write(in_data)
ftrace_parser = trappy.register_dynamic_ftrace("sched_stat_runtime",
"my_sched_stat_runtime",
scope="sched")
trace = trappy.FTrace()
dfr = trace.sched_stat_runtime.data_frame
self.assertEquals(set(dfr.columns), expected_columns)
self.assertEquals(dfr["comm"].iloc[0], "Space separated taskname")
self.assertEquals(dfr["pid"].iloc[0], 7)
self.assertEquals(dfr["runtime"].iloc[0], 262875)
self.assertEquals(dfr["vruntime"].iloc[0], 17096359856)
trappy.unregister_dynamic_ftrace(ftrace_parser)
def test_ftrace_unique_but_no_fields(self):
"""Test with a matching unique but no special fields"""
version_parser = trappy.register_dynamic_ftrace("Version", "version")
with self.assertRaises(ValueError):
trappy.FTrace(scope="custom")
trappy.unregister_dynamic_ftrace(version_parser)
def test_dynamic_data_frame(self):
"""
Test if the dynamic events are populated
in the data frame
"""
parse_class = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key")
t = trappy.FTrace(name="first")
self.assertTrue(len(t.dynamic_event.data_frame) == 1)
trappy.unregister_dynamic_ftrace(parse_class)
def test_dynamic_event_scope(self):
"""Test the case when an "all" scope class is
registered. it should appear in both thermal and sched
ftrace class definitions when scoped ftrace objects are created
"""
cls = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key")
t1 = trappy.FTrace(name="first")
self.assertTrue(t1.class_definitions.has_key(cls.name))
trappy.unregister_dynamic_ftrace(cls)
def test_dynamic_event_plot(self):
"""Test if plotter can accept a dynamic class
for a template argument"""
cls = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key")
t = trappy.FTrace(name="first")
l = trappy.LinePlot(t, cls, column="load")
l.view(test=True)
trappy.unregister_dynamic_ftrace(cls)
def test_ftrace_unique_but_no_fields(self):
"""Test with a matching unique but no special fields"""
version_parser = trappy.register_dynamic_ftrace("Version", "version")
# Append invalid line to file
with open("trace.txt", "a") as fil:
fil.write("version = 6")
trace = trappy.FTrace(scope="all")
trappy.unregister_dynamic_ftrace(version_parser)
def test_parse_special_fields(self):
"""TestBase: Task name, PID, CPU and timestamp are properly paresed """
events = {
# Trace events using [global] clock format ([us] resolution)
1001.456789 : { 'task': 'rcu_preempt', 'pid': 1123, 'cpu': 001 },
1002.456789 : { 'task': 'rs:main', 'pid': 2123, 'cpu': 002 },
1003.456789 : { 'task': 'AsyncTask #1', 'pid': 3123, 'cpu': 003 },
1004.456789 : { 'task': 'kworker/1:1H', 'pid': 4123, 'cpu': 004 },
1005.456789 : { 'task': 'jbd2/sda2-8', 'pid': 5123, 'cpu': 005 },
1006.456789 : { 'task': 'IntentService[', 'pid': 6123, 'cpu': 005 },
1006.456789 : { 'task': r'/system/bin/.s$_?.u- \a]}c\./ef[.12]*[[l]in]ger',
'pid': 1234, 'cpu': 666 },
# Trace events using [boot] clock format ([ns] resolution)
1011456789000: { 'task': 'rcu_preempt', 'pid': 1123, 'cpu': 001 },
1012456789000: { 'task': 'rs:main', 'pid': 2123, 'cpu': 002 },
1013456789000: { 'task': 'AsyncTask #1', 'pid': 3123, 'cpu': 003 },
1014456789000: { 'task': 'kworker/1:1H', 'pid': 4123, 'cpu': 004 },
1015456789000: { 'task': 'jbd2/sda2-8', 'pid': 5123, 'cpu': 005 },
1016456789000: { 'task': 'IntentService[', 'pid': 6123, 'cpu': 005 },
1016456789000: { 'task': r'/system/bin/.s$_?.u- \a]}c\./ef[.12]*[[l]in]ger',
'pid': 1234, 'cpu': 666 },
}
in_data = """"""
for timestamp in sorted(events):
in_data+="{0:>16s}-{1:d} [{2:04d}] {3}: event0: tag=value\n".\
format(
events[timestamp]['task'],
events[timestamp]['pid'],
events[timestamp]['cpu'],
timestamp
)
expected_columns = set(["__comm", "__pid", "__tgid", "__cpu", "__line", "tag"])
with open("trace.txt", "w") as fout:
fout.write(in_data)
ftrace_parser = trappy.register_dynamic_ftrace("Event0", "event0", scope="sched")
trace = trappy.FTrace(normalize_time=False)
dfr = trace.event0.data_frame
self.assertEquals(set(dfr.columns), expected_columns)
for timestamp, event in events.iteritems():
if type(timestamp) == int:
timestamp = float(timestamp) / 1e9
self.assertEquals(dfr["__comm"].loc[timestamp], event['task'])
self.assertEquals(dfr["__pid"].loc[timestamp], event['pid'])
self.assertEquals(dfr["__cpu"].loc[timestamp], event['cpu'])
trappy.unregister_dynamic_ftrace(ftrace_parser)
def test_dynamic_class_attr(self):
"""
Test the attibutes of the dynamically
generated class
"""
cls = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key",
pivot="test_pivot")
self.assertEquals(cls.__name__, "DynamicEvent")
self.assertEquals(cls.name, "dynamic_event")
self.assertEquals(cls.unique_word, "dynamic_test_key")
self.assertEquals(cls.pivot, "test_pivot")
trappy.unregister_dynamic_ftrace(cls)
def test_ftrace_has_no_classes_scope_dynamic(self):
"""The FTrace() class has only dynamically registered classes with scope=custom"""
trace = trappy.FTrace(scope="custom")
for attr in trace.thermal_classes.iterkeys():
self.assertFalse(hasattr(trace, attr))
for attr in trace.sched_classes.iterkeys():
self.assertFalse(hasattr(trace, attr))
ftrace_parser = trappy.register_dynamic_ftrace("ADynamicEvent",
"a_dynamic_event")
trace = trappy.FTrace(scope="custom")
self.assertTrue(hasattr(trace, "a_dynamic_event"))
trappy.unregister_dynamic_ftrace(ftrace_parser)
def test_ftrace_has_no_classes_scope_dynamic(self):
"""The FTrace() class has only dynamically registered classes with scope=custom"""
trace = trappy.FTrace(scope="custom")
for attr in trace.thermal_classes.keys():
self.assertFalse(hasattr(trace, attr))
for attr in trace.sched_classes.keys():
self.assertFalse(hasattr(trace, attr))
ftrace_parser = trappy.register_dynamic_ftrace("ADynamicEvent",
"a_dynamic_event")
trace = trappy.FTrace(scope="custom")
self.assertTrue(hasattr(trace, "a_dynamic_event"))
trappy.unregister_dynamic_ftrace(ftrace_parser)
def test_cache_dynamic_events(self):
"""Test that caching works if new event parsers have been registered"""
# Parse the trace to create a cache
GenericFTrace.disable_cache = False
trace1 = trappy.FTrace()
# Check we're actually testing what we think we are
if hasattr(trace1, 'dynamic_event'):
raise RuntimeError('Test bug: found unexpected event in trace')
# Now register a new event type, call the constructor again, and check
# that the newly added event (which is not present in the cache) is
# parsed.
parse_class = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key")
trace2 = trappy.FTrace()
self.assertTrue(len(trace2.dynamic_event.data_frame) == 1)
trappy.unregister_dynamic_ftrace(parse_class)
def test_parse_special_fields(self):
"""TestBase: Task name, PID, CPU and timestamp are properly paresed """
events = {
'1001.456789' : { 'task': 'rcu_preempt', 'pid': 1123, 'cpu': 001 },
'1002.456789' : { 'task': 'rs:main', 'pid': 2123, 'cpu': 002 },
'1003.456789' : { 'task': 'AsyncTask #1', 'pid': 3123, 'cpu': 003 },
'1004.456789' : { 'task': 'kworker/1:1H', 'pid': 4123, 'cpu': 004 },
'1005.456789' : { 'task': 'jbd2/sda2-8', 'pid': 5123, 'cpu': 005 },
}
in_data = """"""
for timestamp in sorted(events):
in_data+="{0:>16s}-{1:d} [{2:04d}] {3:s}: event0: tag=value\n".\
format(
events[timestamp]['task'],
events[timestamp]['pid'],
events[timestamp]['cpu'],
timestamp
)
expected_columns = set(["__comm", "__pid", "__cpu", "tag"])
with open("trace.txt", "w") as fout:
fout.write(in_data)
ftrace_parser = trappy.register_dynamic_ftrace("Event0", "event0", scope="sched")
trace = trappy.FTrace()
dfr = trace.event0.data_frame
self.assertEquals(set(dfr.columns), expected_columns)
for idx in range(len(events)):
timestap = str( dfr.index[idx]+float(events.keys()[0]))
self.assertTrue(timestamp in events)
self.assertEquals(dfr["__comm"].iloc[idx], events[timestap]['task'])
self.assertEquals(dfr["__pid"].iloc[idx], events[timestap]['pid'])
self.assertEquals(dfr["__cpu"].iloc[idx], events[timestap]['cpu'])
trappy.unregister_dynamic_ftrace(ftrace_parser)
def test_parse_values_concatenation(self):
"""TestBase: Trace with space separated values created a valid DataFrame"""
in_data = """ rcu_preempt-7 [000] 73.604532: my_sched_stat_runtime: comm=Space separated taskname pid=7 runtime=262875 [ns] vruntime=17096359856 [ns]"""
expected_columns = set(["__comm", "__pid", "__cpu", "comm", "pid", "runtime", "vruntime"])
with open("trace.txt", "w") as fout:
fout.write(in_data)
ftrace_parser = trappy.register_dynamic_ftrace("sched_stat_runtime",
"my_sched_stat_runtime", scope="sched")
trace = trappy.FTrace()
dfr = trace.sched_stat_runtime.data_frame
self.assertEquals(set(dfr.columns), expected_columns)
self.assertEquals(dfr["comm"].iloc[0], "Space separated taskname")
self.assertEquals(dfr["pid"].iloc[0], 7)
self.assertEquals(dfr["runtime"].iloc[0], 262875)
self.assertEquals(dfr["vruntime"].iloc[0], 17096359856)
trappy.unregister_dynamic_ftrace(ftrace_parser)
def test_unregister_dynamic_ftrace(self):
"""Test that dynamic events can be unregistered"""
dyn_event = trappy.register_dynamic_ftrace("DynamicEvent",
"dynamic_test_key")
trace = trappy.FTrace(name="first")
self.assertTrue(len(trace.dynamic_event.data_frame) == 1)
trappy.unregister_dynamic_ftrace(dyn_event)
trace = trappy.FTrace(name="first")
self.assertFalse(hasattr(trace, "dynamic_event"))
dyn_event = trappy.register_dynamic_ftrace("DynamicEvent",
"dynamic_test_key",
scope="sched")
trace = trappy.FTrace(name="first")
self.assertTrue(len(trace.dynamic_event.data_frame) == 1)
trappy.unregister_dynamic_ftrace(dyn_event)
trace = trappy.FTrace(name="first")
self.assertFalse(hasattr(trace, "dynamic_event"))
def test_unregister_dynamic_ftrace(self):
"""Test that dynamic events can be unregistered"""
dyn_event = trappy.register_dynamic_ftrace("DynamicEvent",
"dynamic_test_key")
trace = trappy.FTrace(name="first")
self.assertTrue(len(trace.dynamic_event.data_frame) == 1)
trappy.unregister_dynamic_ftrace(dyn_event)
trace = trappy.FTrace(name="first")
self.assertFalse(hasattr(trace, "dynamic_event"))
dyn_event = trappy.register_dynamic_ftrace("DynamicEvent",
"dynamic_test_key",
scope="sched")
trace = trappy.FTrace(name="first")
self.assertTrue(len(trace.dynamic_event.data_frame) == 1)
trappy.unregister_dynamic_ftrace(dyn_event)
trace = trappy.FTrace(name="first")
self.assertFalse(hasattr(trace, "dynamic_event"))
def test_no_none_pivot(self):
"""register_dynamic_ftrace() with default value for pivot doesn't create a class with a pivot=None"""
cls = trappy.register_dynamic_ftrace("MyEvent", "my_dyn_test_key")
self.assertFalse(hasattr(cls, "pivot"))
trappy.unregister_dynamic_ftrace(cls)
def test_no_none_pivot(self):
"""register_dynamic_ftrace() with default value for pivot doesn't create a class with a pivot=None"""
cls = trappy.register_dynamic_ftrace("MyEvent", "my_dyn_test_key")
self.assertFalse(hasattr(cls, "pivot"))
trappy.unregister_dynamic_ftrace(cls)
