[DO NOT COMMIT] Refactor systrace to support new clock sync design

systrace/systrace/tracing_agents/ftrace_agent.py

 # Copyright (c) 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import os
 import sys
 import time
 
-from systrace import systrace_agent
-
+from systrace.tracing_agents import TracingAgent, TraceResults

[Zhen Wang, 2016/03/24 22:13:05]

Separate this to 2 lines

[alexandermont, 2016/03/24 23:54:09]

Done

 
 class FtraceAgentIo(object):
 
   @staticmethod
   def writeFile(path, data):
     with open(path, 'w') as f:
       f.write(data)
 
   @staticmethod
   def readFile(path):
@@ skipping 62 matching lines @@
     }
 }
 
 
 def try_create_agent(options, categories):
   if options.target != 'linux':
     return False
   return FtraceAgent(options, categories, FtraceAgentIo)
 
 
-class FtraceAgent(systrace_agent.SystraceAgent):
+class FtraceAgent(TracingAgent):
 
   def __init__(self, options, categories, fio=FtraceAgentIo):
     """Initialize a systrace agent.
 
     Args:
       options: The command-line options.
       categories: The trace categories to capture.
     """
-    super(FtraceAgent, self).__init__(options, categories)
-    if not self._categories:
+    super(FtraceAgent, self).__init__()
+    if not categories:
       self._categories = ["sched"]
+    else:
+      self._categories = categories
     self._fio = fio
+    self._options = options
     self._categories = [x for x in self._categories
                         if self._is_category_available(x)]
-    self._expect_trace = False
+    self._should_output_trace = False
 
   def _get_trace_buffer_size(self):
     buffer_size = 4096
     if ((self._options.trace_buf_size is not None)
         and (self._options.trace_buf_size > 0)):
       buffer_size = self._options.trace_buf_size
     return buffer_size
 
   def _get_trace_time(self):
     wait_time = 5
     if ((self._options.trace_time is not None)
         and (self._options.trace_time > 0)):
       wait_time = self._options.trace_time
     return wait_time
 
-  def start(self):
+  def StartAgentTracing(self):
     """Start tracing.
     """
     if self._options.list_categories or len(self._categories) == 0:
-      self._expect_trace = False
+      self._should_output_trace = False
     else:
-      self._expect_trace = True
+      self._should_output_trace = True
 
       self._fio.writeFile(FT_BUFFER_SIZE, str(self._get_trace_buffer_size()))
 
       self._fio.writeFile(FT_CLOCK, 'global')
       self._fio.writeFile(FT_TRACER, 'nop')
       self._fio.writeFile(FT_OVERWRITE, "0")
 
       # TODO: riandrews to push necessary patches for TGID option to upstream
       # linux kernel
       # self._fio.writeFile(FT_PRINT_TGID, '1')
 
       for category in self._categories:
         self._category_enable(category)
 
       self._fio.writeFile(FT_TRACE, '')
 
       print "starting tracing."
       sys.stdout.flush()
 
       self._fio.writeFile(FT_TRACE_ON, '1')
+    return True
 
-  def collect_result(self):
+  def StopAgentTracing(self):
     """Collect the result of tracing.
 
     This function will block while collecting the result. For sync mode, it
     reads the data, e.g., from stdout, until it finishes. For async mode, it
     blocks until the agent is stopped and the data is ready.
     """
     if self._options.list_categories or len(self._categories) == 0:
       self._print_avail_categories()
     else:
       try:
         time.sleep(self._get_trace_time())
       except KeyboardInterrupt:
         pass
       self._fio.writeFile(FT_TRACE_ON, '0')
       for category in self._categories:
         self._category_disable(category)
       if self._options.fix_threads:
         print "WARN: thread name fixing is not yet supported."
       if self._options.fix_tgids:
         print "WARN: tgid fixing is not yet supported."
       if self._options.fix_circular:
         print "WARN: circular buffer fixups are not yet supported."
+    return True
 
-  def expect_trace(self):
-    """Check if the agent is returning a trace or not.
-
-    This will be determined in collect_result().
-    Returns:
-      Whether the agent is expecting a trace or not.
-    """
-    return self._expect_trace
-
-  def get_trace_data(self):
+  def GetResults(self):
     """Get the trace data.
 
     Returns:
       The trace data.
     """
     d = self._fio.readFile(FT_TRACE)
     self._fio.writeFile(FT_BUFFER_SIZE, "1")
-    return d
+    return TraceResults('systemTraceEvents', d, self._should_output_trace)
 
-  def get_class_name(self):
-    return 'trace-data'
+  def SupportsExplicitClockSync(self):
+    return False
+
+  def RecordClockSyncMarker(self, sync_id, callback):
+    raise NotImplementedError
 
   def _is_category_available(self, category):
     if category not in all_categories:
       return False
     events_dir = FT_DIR + "events/"
     req_events = all_categories[category]["req"]
     for event in req_events:
       event_full_path = events_dir + event + "enable"
       if not self._fio.haveWritePermissions(event_full_path):
         return False
@@ skipping 29 matching lines @@
         if self._fio.haveWritePermissions(event_full_path):
           yield event_full_path
 
   def _category_enable(self, category):
     for path in self._category_enable_paths(category):
       self._fio.writeFile(path, "1")
 
   def _category_disable(self, category):
     for path in self._category_enable_paths(category):
       self._fio.writeFile(path, "0")