dynamic: ensure dynamic methods refer to ftrace

Now that we can have traces coming from sources other than ftrace,
rename register_dynamic() and register_class() to
register_dynamic_ftrace() and register_ftrace_parser() to make it clear
that they are only available for traces coming from ftrace.

13 files changed, 66 insertions, 57 deletions

diff --git a/doc/Dynamic traces.ipynb b/doc/Dynamic traces.ipynb
index 0270b3f..26385f6 100644
--- a/doc/Dynamic traces.ipynb
+++ b/doc/Dynamic traces.ipynb
@@ -34,7 +34,7 @@
       "\n",
       "    kworker/6:1-457   [006]   144.439566: bprint:               0xc042f8a0f: thermal_gpu_power_get: frequency=177 load=0\n",
       "\n",
-      "You can add this event to the trace instance using `register_dynamic()`"
+      "You can add this event to the trace instance using `register_dynamic_ftrace()`"
      ]
     },
     {
@@ -77,7 +77,7 @@
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "trappy.register_dynamic(\"gpu_power_in\", \"thermal_gpu_power_get\")"
+      "trappy.register_dynamic_ftrace(\"gpu_power_in\", \"thermal_gpu_power_get\")"
      ],
      "language": "python",
      "metadata": {},
@@ -237,7 +237,7 @@
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "`register_dynamic()` is useful for simple traces in which you don't need to do any post-processing.  If you need to register a full-featured trace class you can use `trappy.register_class()` for this.  For example, a class that parses trace for `capacity_per_group:` and wants to limit the cpumasks to 8-digit could declare it like this:"
+      "`register_dynamic_ftrace()` is useful for simple traces in which you don't need to do any post-processing.  If you need to register a full-featured trace class you can use `trappy.register_ftrace_parser()` for this.  For example, a class that parses trace for `capacity_per_group:` and wants to limit the cpumasks to 8-digit could declare it like this:"
      ]
     },
     {
@@ -260,7 +260,7 @@
       "        if self._cpus_column in self.data_frame.columns:\n",
       "            self.data_frame[self._cpus_column] = self.data_frame[self._cpus_column].apply('{:0>8}'.format)\n",
       "\n",
-      "trappy.register_class(GroupCapacity)"
+      "trappy.register_ftrace_parser(GroupCapacity)"
      ],
      "language": "python",
      "metadata": {},
diff --git a/tests/test_base.py b/tests/test_base.py
index 8f8c841..24ada6f 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -122,7 +122,7 @@ class TestBase(utils_tests.SetupDirectory):
         with open("trace.txt", "w") as fout:
             fout.write(in_data)
 
-        trappy.register_dynamic('Event0', 'event0', scope="sched")
+        trappy.register_dynamic_ftrace("Event0", "event0", scope="sched")
         trace = trappy.FTrace()
         dfr = trace.event0.data_frame
 
@@ -146,8 +146,8 @@ class TestBase(utils_tests.SetupDirectory):
         with open("trace.txt", "w") as fout:
             fout.write(in_data)
 
-        trappy.register_dynamic('sched_stat_runtime', 'my_sched_stat_runtime',
-                             scope="sched")
+        trappy.register_dynamic_ftrace("sched_stat_runtime",
+                                       "my_sched_stat_runtime", scope="sched")
         trace = trappy.FTrace()
         dfr = trace.sched_stat_runtime.data_frame
 
diff --git a/tests/test_dynamic.py b/tests/test_dynamic.py
index aee0beb..d5f3923 100644
--- a/tests/test_dynamic.py
+++ b/tests/test_dynamic.py
@@ -40,7 +40,7 @@ class TestDynamicEvents(BaseTestSched):
            Test if the dynamic events are populated
            in the data frame
         """
-        trappy.register_dynamic("DynamicEvent", "dynamic_test_key")
+        trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key")
         t = trappy.FTrace(name="first")
         self.assertTrue(len(t.dynamic_event.data_frame) == 1)
 
@@ -49,7 +49,7 @@ class TestDynamicEvents(BaseTestSched):
            Test the attibutes of the dynamically
            generated class
         """
-        cls = trappy.register_dynamic("DynamicEvent", "dynamic_test_key",
+        cls = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key",
               pivot="test_pivot")
         self.assertEquals(cls.__name__, "DynamicEvent")
         self.assertEquals(cls.name, "dynamic_event")
@@ -60,7 +60,7 @@ class TestDynamicEvents(BaseTestSched):
         """Test if plotter can accept a dynamic class
             for a template argument"""
 
-        cls = trappy.register_dynamic("DynamicEvent", "dynamic_test_key")
+        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)
@@ -70,16 +70,16 @@ class TestDynamicEvents(BaseTestSched):
 	registered. it should appear in both thermal and sched
 	ftrace class definitions when scoped ftrace objects are created
 	"""
-        cls = trappy.register_dynamic("DynamicEvent", "dynamic_test_key")
+        cls = trappy.register_dynamic_ftrace("DynamicEvent", "dynamic_test_key")
         t1 = trappy.FTrace(name="first")
 	self.assertTrue(t1.class_definitions.has_key(cls.name))
 
-    def test_register_class(self):
-        trappy.register_class(DynamicEvent)
+    def test_register_ftrace_parser(self):
+        trappy.register_ftrace_parser(DynamicEvent)
         t = trappy.FTrace(name="first")
         self.assertTrue(len(t.dynamic_event.data_frame) == 1)
 
     def test_no_none_pivot(self):
-        """register_dynamic() with default value for pivot doesn't create a class with a pivot=None"""
-        cls = trappy.register_dynamic("MyEvent", "my_dyn_test_key")
+        """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"))
diff --git a/tests/test_ftrace.py b/tests/test_ftrace.py
index c9e5494..82fa404 100644
--- a/tests/test_ftrace.py
+++ b/tests/test_ftrace.py
@@ -82,7 +82,7 @@ class TestFTrace(BaseTestThermal):
         for attr in trace.sched_classes.iterkeys():
             self.assertFalse(hasattr(trace, attr))
 
-        trappy.register_dynamic("ADynamicEvent", "a_dynamic_event")
+        trappy.register_dynamic_ftrace("ADynamicEvent", "a_dynamic_event")
         trace = trappy.FTrace(scope="custom")
 
         self.assertTrue(hasattr(trace, "a_dynamic_event"))
diff --git a/trappy/__init__.py b/trappy/__init__.py
index ec1f790..6058cbb 100644
--- a/trappy/__init__.py
+++ b/trappy/__init__.py
@@ -15,6 +15,7 @@
 
 
 import pkg_resources
+import warnings
 from trappy.bare_trace import BareTrace
 from trappy.compare_runs import summary_plots, compare_runs
 from trappy.ftrace import FTrace
@@ -29,16 +30,27 @@ try:
     from trappy.plotter.EventPlot import EventPlot
 except ImportError:
     pass
-from trappy.dynamic import register_dynamic, register_class
+from trappy.dynamic import register_dynamic_ftrace, register_ftrace_parser
 
 # For backwards compatibility.  Remove by 2016-12-31
 class Run(FTrace):
     """This class is deprecated.  Use trappy.FTrace instead"""
     def __init__(self, *args, **kwargs):
-        import warnings
         warnings.warn("The Run object is deprecated.  Use trappy.FTrace instead")
         super(Run, self).__init__(*args, **kwargs)
 
+# For backwards compatibility.  Remove by 2016-12-31
+def register_dynamic(*args, **kwargs):
+    """register_dynamic() is deprecated.  Use register_dynamic_ftrace() instead"""
+    warnings.warn("register_dynamic() is deprecated.  Use register_dynamic_ftrace() instead")
+    return register_dynamic_ftrace(*args, **kwargs)
+
+# For backwards compatibility.  Remove by 2016-12-31
+def register_class(*args, **kwargs):
+    """register_class() is deprecated.  Use register_ftrace_parser() instead"""
+    warnings.warn("register_class() is deprecated.  Use register_ftrace_parser() instead")
+    return register_ftrace_parser(*args, **kwargs)
+
 # Load all the modules to make sure all classes are registered with FTrace
 import os
 for fname in os.listdir(os.path.dirname(__file__)):
diff --git a/trappy/cpu_power.py b/trappy/cpu_power.py
index b540b70..a4d6c22 100644
--- a/trappy/cpu_power.py
+++ b/trappy/cpu_power.py
@@ -120,7 +120,7 @@ class CpuOutPower(Base):
 
         return pivot_with_labels(dfr, "freq", "cpus", mapping_label) / 1000
 
-FTrace.register_class(CpuOutPower, "thermal")
+FTrace.register_parser(CpuOutPower, "thermal")
 
 class CpuInPower(Base):
     """Process the cpufreq cooling power actor data in a ftrace dump
@@ -195,4 +195,4 @@ class CpuInPower(Base):
 
         return pivot_with_labels(dfr, "freq", "cpus", mapping_label) / 1000
 
-FTrace.register_class(CpuInPower, "thermal")
+FTrace.register_parser(CpuInPower, "thermal")
diff --git a/trappy/devfreq_power.py b/trappy/devfreq_power.py
index d4b9a5b..7ebb106 100644
--- a/trappy/devfreq_power.py
+++ b/trappy/devfreq_power.py
@@ -46,7 +46,7 @@ FTrace dump"""
 
         return pd.DataFrame(self.data_frame["freq"] / 1000000)
 
-FTrace.register_class(DevfreqInPower, "thermal")
+FTrace.register_parser(DevfreqInPower, "thermal")
 
 
 class DevfreqOutPower(Base):
@@ -72,4 +72,4 @@ ftrace dump"""
 
         return pd.DataFrame(self.data_frame["freq"] / 1000000)
 
-FTrace.register_class(DevfreqOutPower, "thermal")
+FTrace.register_parser(DevfreqOutPower, "thermal")
diff --git a/trappy/dynamic.py b/trappy/dynamic.py
index bcd7c50..4af7379 100644
--- a/trappy/dynamic.py
+++ b/trappy/dynamic.py
@@ -46,7 +46,7 @@ class DynamicTypeFactory(type):
     """Override the type class to create
     a dynamic type on the fly. This Factory
     class is used internally by
-    :mod:`trappy.dynamic.register_dynamic`
+    :mod:`trappy.dynamic.register_dynamic_ftrace`
     """
 
     def __new__(mcs, name, bases, dct):
@@ -65,10 +65,9 @@ def _get_name(name):
     return re.sub('(?!^)([A-Z]+)', r'_\1', name).lower()
 
 
-def register_dynamic(class_name, unique_word, scope="all",
-                     parse_raw=False, pivot=None):
-    """Create a Dynamic Type and register
-    it with the TRAPpy Framework
+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)
@@ -94,7 +93,7 @@ def register_dynamic(class_name, unique_word, scope="all",
     ::
 
         import trappy
-        custom_class = trappy.register_dynamic("MyEvent", "my_unique_word")
+        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
@@ -117,15 +116,15 @@ def register_dynamic(class_name, unique_word, scope="all",
         kwords["pivot"] = pivot
 
     dyn_class = DynamicTypeFactory(class_name, (Base,), kwords)
-    FTrace.register_class(dyn_class, scope)
+    FTrace.register_parser(dyn_class, scope)
     return dyn_class
 
 
-def register_class(cls):
-    """Register a new class implementation
-    Should be used when the class has
-    complex helper methods and does not
-    expect to use the default constructor
+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
@@ -133,4 +132,4 @@ def register_class(cls):
     """
 
     # Check the argspec of the class
-    FTrace.register_class(cls)
+    FTrace.register_parser(cls)
diff --git a/trappy/ftrace.py b/trappy/ftrace.py
index de76dff..14857a1 100644
--- a/trappy/ftrace.py
+++ b/trappy/ftrace.py
@@ -205,14 +205,14 @@ class FTrace(BareTrace):
             fout.write(raw_out)
 
     @classmethod
-    def register_class(cls, cobject, scope="all"):
+    def register_parser(cls, cobject, scope="all"):
         """Register the class as an Event. This function
         can be used to register a class which is associated
         with an FTrace unique word.
 
         .. seealso::
 
-            :mod:`trappy.dynamic.register_dynamic` :mod:`trappy.dynamic.register_class`
+            :mod:`trappy.dynamic.register_dynamic_ftrace` :mod:`trappy.dynamic.register_ftrace_parser`
 
         """
 
diff --git a/trappy/pid_controller.py b/trappy/pid_controller.py
index 4bde73c..e33b2e2 100644
--- a/trappy/pid_controller.py
+++ b/trappy/pid_controller.py
@@ -57,4 +57,4 @@ class PIDController(Base):
         self.data_frame[["output", "p", "i", "d"]].plot(ax=ax)
         trappy.plot_utils.post_plot_setup(ax, title=title)
 
-FTrace.register_class(PIDController, "thermal")
+FTrace.register_parser(PIDController, "thermal")
diff --git a/trappy/sched.py b/trappy/sched.py
index fb69566..bb351e1 100644
--- a/trappy/sched.py
+++ b/trappy/sched.py
@@ -17,7 +17,7 @@
 """Definitions of scheduler events registered by the FTrace class"""
 
 from trappy.base import Base
-from trappy.dynamic import register_dynamic
+from trappy.dynamic import register_dynamic_ftrace
 from trappy.ftrace import FTrace
 
 class SchedLoadAvgSchedGroup(Base):
@@ -39,7 +39,7 @@ class SchedLoadAvgSchedGroup(Base):
             dfr = self.data_frame[self._cpu_mask_column].apply('{:0>8}'.format)
             self.data_frame[self._cpu_mask_column] = dfr
 
-FTrace.register_class(SchedLoadAvgSchedGroup, "sched")
+FTrace.register_parser(SchedLoadAvgSchedGroup, "sched")
 
 class SchedLoadAvgTask(Base):
     """Corresponds to Linux kernel trace event sched_load_avg_task"""
@@ -58,18 +58,18 @@ class SchedLoadAvgTask(Base):
 
         return dfr[dfr['comm'].str.contains(key)].values.tolist()
 
-FTrace.register_class(SchedLoadAvgTask, "sched")
+FTrace.register_parser(SchedLoadAvgTask, "sched")
 
 # pylint doesn't like globals that are not ALL_CAPS
 # pylint: disable=invalid-name
-SchedLoadAvgCpu = register_dynamic("SchedLoadAvgCpu",
-                                   "sched_load_avg_cpu:",
-                                   "sched", pivot="cpu")
+SchedLoadAvgCpu = register_dynamic_ftrace("SchedLoadAvgCpu",
+                                          "sched_load_avg_cpu:", "sched",
+                                          pivot="cpu")
 """Load and Utilization Signals for CPUs"""
 
-SchedContribScaleFactor = register_dynamic("SchedContribScaleFactor",
-                                           "sched_contrib_scale_f:",
-                                           "sched")
+SchedContribScaleFactor = register_dynamic_ftrace("SchedContribScaleFactor",
+                                                  "sched_contrib_scale_f:",
+                                                  "sched")
 """Event to register tracing of contrib factor"""
 
 class SchedCpuCapacity(Base):
@@ -89,12 +89,10 @@ class SchedCpuCapacity(Base):
         self.data_frame.rename(columns={'cpu_id':'cpu'}, inplace=True)
         self.data_frame.rename(columns={'state' :'capacity'}, inplace=True)
 
-FTrace.register_class(SchedCpuCapacity, "sched")
+FTrace.register_parser(SchedCpuCapacity, "sched")
 
-SchedSwitch = register_dynamic("SchedSwitch",
-                               "sched_switch",
-                               "sched",
-                               parse_raw=True)
+SchedSwitch = register_dynamic_ftrace("SchedSwitch", "sched_switch", "sched",
+                                      parse_raw=True)
 """Register SchedSwitch Event"""
 # pylint: enable=invalid-name
 
@@ -115,4 +113,4 @@ class SchedCpuFrequency(Base):
         self.data_frame.rename(columns={'cpu_id':'cpu'}, inplace=True)
         self.data_frame.rename(columns={'state' :'frequency'}, inplace=True)
 
-FTrace.register_class(SchedCpuFrequency, "sched")
+FTrace.register_parser(SchedCpuFrequency, "sched")
diff --git a/trappy/stats/grammar.py b/trappy/stats/grammar.py
index 7a0839e..e097c98 100644
--- a/trappy/stats/grammar.py
+++ b/trappy/stats/grammar.py
@@ -283,7 +283,7 @@ class Parser(object):
             from trappy.stats.grammar import Parser
 
             # Register Dynamic Event
-            cls = trappy.register_dynamic("my_unique_word", "event_name")
+            cls = trappy.register_dynamic_ftrace("my_unique_word", "event_name")
 
             pvars = {}
             pvars["CUSTOM"] = cls
@@ -291,7 +291,7 @@ class Parser(object):
             parser = Parser(trace)
             parser.solve("CUSTOM:col * 2")
 
-        .. seealso:: :mod:`trappy.dynamic.register_dynamic`
+        .. seealso:: :mod:`trappy.dynamic.register_dynamic_ftrace`
 
     """
 
diff --git a/trappy/thermal.py b/trappy/thermal.py
index 09af331..5b439d0 100644
--- a/trappy/thermal.py
+++ b/trappy/thermal.py
@@ -103,7 +103,7 @@ class Thermal(Base):
 
         plot_hist(temps, ax, title, "C", 30, "Temperature", xlim, "default")
 
-FTrace.register_class(Thermal, "thermal")
+FTrace.register_parser(Thermal, "thermal")
 
 class ThermalGovernor(Base):
     """Process the power allocator data in a ftrace dump"""
@@ -295,4 +295,4 @@ class ThermalGovernor(Base):
             this_title = normalize_title(actor, title)
             dfr[cols].plot(title=this_title)
 
-FTrace.register_class(ThermalGovernor, "thermal")
+FTrace.register_parser(ThermalGovernor, "thermal")