esp/tests: Syncs tracing tests with IDF changes

Author: gerekon

testing/esp/debug_backend_tests.py

@@ -291,12 +291,12 @@ def step_in(self):
         rsn = self.gdb.wait_target_state(dbg.Gdb.TARGET_STATE_STOPPED, 5)
         self.assertEqual(rsn, dbg.Gdb.TARGET_STOP_REASON_STEPPED)
 
-    def step_out(self):
+    def step_out(self, tmo=None):
         """ Runs until current function retunrs (step out, "finish" command in GDB)
         """
         self.gdb.exec_finish()
         self.gdb.wait_target_state(dbg.Gdb.TARGET_STATE_RUNNING, 5)
-        rsn = self.gdb.wait_target_state(dbg.Gdb.TARGET_STATE_STOPPED, 5)
+        rsn = self.gdb.wait_target_state(dbg.Gdb.TARGET_STATE_STOPPED, 5 if tmo is None else tmo)
         self.assertEqual(rsn, dbg.Gdb.TARGET_STOP_REASON_FN_FINISHED)
 
 class DebuggerTestAppTests(DebuggerTestsBase):
@@ -368,7 +368,7 @@ def select_sub_test(self, sub_test_num):
 
     def run_to_bp(self, exp_rsn, func_name):
         self.resume_exec()
-        rsn = self.gdb.wait_target_state(dbg.Gdb.TARGET_STATE_STOPPED, 5)
+        rsn = self.gdb.wait_target_state(dbg.Gdb.TARGET_STATE_STOPPED, 20)
         self.assertEqual(rsn, exp_rsn)
         cur_frame = self.gdb.get_current_frame()
         self.assertEqual(cur_frame['func'], func_name)

testing/esp/extra/espytrace/README.md

@@ -1,2 +1,5 @@
-# espytrace
+# espytrace Python package
 
+This package implements base routines and classes for processing ESP32 application level trace data.
+- `apptrace.py` includes functionality which is common for all types of trace data.
+- `sysview.py` includes functionality which is specific for SystemView trace data format.

testing/esp/extra/espytrace/apptrace.py

@@ -1,3 +1,4 @@
+import sys
 import os
 try:
     from urlparse import urlparse
@@ -16,6 +17,13 @@
 import elftools.elf.constants as elfconst
 
 
+def clock():
+    if sys.version_info >= (3, 3):
+        return time.process_time()
+    else:
+        return time.clock()
+
+
 def addr2line(toolchain, elf_path, addr):
     """
         Creates trace reader.
@@ -170,12 +178,12 @@ def read(self, sz):
             see Reader.read()
         """
         data = b''
-        start_tm = time.clock()
+        start_tm = clock()
         while not self.need_stop:
             data += self.trace_file.read(sz - len(data))
             if len(data) == sz:
                 break
-            if self.timeout != -1 and time.clock() >= start_tm + self.timeout:
+            if self.timeout != -1 and clock() >= start_tm + self.timeout:
                 raise ReaderTimeoutError(self.timeout, sz)
         if self.need_stop:
             raise ReaderShutdownRequest()
@@ -192,17 +200,17 @@ def get_pos(self):
         """
         return self.trace_file.tell()
 
-    def readline(self):
+    def readline(self, linesep=os.linesep):
         """
             see Reader.read()
         """
         line = ''
-        start_tm = time.clock()
+        start_tm = clock()
         while not self.need_stop:
             line += self.trace_file.readline().decode("utf-8")
-            if line.endswith(os.linesep):
+            if line.endswith(linesep):
                 break
-            if self.timeout != -1 and time.clock() >= start_tm + self.timeout:
+            if self.timeout != -1 and clock() >= start_tm + self.timeout:
                 raise ReaderTimeoutError(self.timeout, 1)
         if self.need_stop:
             raise ReaderShutdownRequest()
@@ -213,12 +221,12 @@ def forward(self, sz):
             see Reader.read()
         """
         cur_pos = self.trace_file.tell()
-        start_tm = time.clock()
+        start_tm = clock()
         while not self.need_stop:
             file_sz = os.path.getsize(self.trace_file_path)
             if file_sz - cur_pos >= sz:
                 break
-            if self.timeout != -1 and time.clock() >= start_tm + self.timeout:
+            if self.timeout != -1 and clock() >= start_tm + self.timeout:
                 raise ReaderTimeoutError(self.timeout, sz)
         if self.need_stop:
             raise ReaderShutdownRequest()
@@ -351,6 +359,34 @@ def reader_create(trc_src, tmo):
     return None
 
 
+class TraceEvent:
+    """
+        Base class for all trace events.
+    """
+    def __init__(self, name, core_id, evt_id):
+        self.name = name
+        self.ctx_name = 'None'
+        self.in_irq = False
+        self.core_id = core_id
+        self.id = evt_id
+        self.ts = 0
+        self.params = {}
+
+    @property
+    def ctx_desc(self):
+        if self.in_irq:
+            return 'IRQ "%s"' % self.ctx_name
+        return 'task "%s"' % self.ctx_name
+
+    def to_jsonable(self):
+        res = self.__dict__
+        params = {}
+        for p in self.params:
+            params.update(self.params[p].to_jsonable())
+        res['params'] = params
+        return res
+
+
 class TraceDataProcessor:
     """
         Base abstract class for all trace data processors.
@@ -432,17 +468,21 @@ def get_str_from_elf(felf, str_addr):
         string
             string or None if it was not found
     """
-    tgt_str = ""
+    tgt_str = ''
     for sect in felf.iter_sections():
         if sect['sh_addr'] == 0 or (sect['sh_flags'] & elfconst.SH_FLAGS.SHF_ALLOC) == 0:
             continue
         if str_addr < sect['sh_addr'] or str_addr >= sect['sh_addr'] + sect['sh_size']:
             continue
         sec_data = sect.data()
         for i in range(str_addr - sect['sh_addr'], sect['sh_size']):
-            if sec_data[i] == "\0":
+            if type(sec_data) is str:
+                ch = sec_data[i]
+            else:
+                ch = str(chr(sec_data[i]))
+            if ch == '\0':
                 break
-            tgt_str += sec_data[i]
+            tgt_str += ch
         if len(tgt_str) > 0:
             return tgt_str
     return None
@@ -488,9 +528,8 @@ def get_message(self, felf):
         fmt_str = get_str_from_elf(felf, self.fmt_addr)
         if not fmt_str:
             raise LogTraceParseError('Failed to find format string for 0x%x' % self.fmt_addr)
-        i = 0
         prcnt_idx = 0
-        while i < len(self.args):
+        for i, arg in enumerate(self.args):
             prcnt_idx = fmt_str.find('%', prcnt_idx, -2)  # TODO: check str ending with %
             if prcnt_idx == -1:
                 break
@@ -502,7 +541,6 @@ def get_message(self, felf):
                     self.args[i] = arg_str
                 else:
                     self.args[i] = '<None>'
-            i += 1
         fmt_str = fmt_str.replace('%p', '%x')
         return fmt_str % tuple(self.args)
 
@@ -591,66 +629,63 @@ class HeapTraceEvent:
     """
         Heap trace event.
     """
-    def __init__(self, ctx_name, in_irq, core_id, ts, alloc, size, addr, callers, toolchain='', elf_path=''):
+    def __init__(self, trace_event, alloc, toolchain='', elf_path=''):
         """
             Constructor.
 
             Parameters
             ----------
-            ctx_name : string
-                name of event context (task or IRQ name)
-            in_irq : bool
-                True if event has been generated in IRQ context, otherwise False
-            core_id : int
-                core which generated the event
-            ts : float
-                event timestamp
+            sys_view_event : TraceEvent
+                trace event object related to this heap event
             alloc : bool
                 True for allocation event, otherwise False
-            size : int
-                size of allocation; has no meaning for de-allocation event
-            addr : int
-                address of allocation/de-allocation
-            callers : list
-                list of callers (callstack) for event
             toolchain_pref : string
                 toolchain prefix to retrieve source line locations using addresses
             elf_path : string
                 path to ELF file to retrieve format strings for log messages
         """
-        self.ctx_name = ctx_name
-        self.in_irq = in_irq
-        self.core_id = core_id
-        self.ts = ts
+        self.trace_event = trace_event
         self.alloc = alloc
-        self.size = size
-        self.addr = addr
-        self.callers = callers
         self.toolchain = toolchain
         self.elf_path = elf_path
+        if self.alloc:
+            self.size = self.trace_event.params['size'].value
+        else:
+            self.size = None
+
+    @property
+    def addr(self):
+        return self.trace_event.params['addr'].value
+
+    @property
+    def callers(self):
+        return self.trace_event.params['callers'].value
 
     def __repr__(self):
         if len(self.toolchain) and len(self.elf_path):
             callers = os.linesep
-            for addr in self.callers:
+            for addr in self.trace_event.params['callers'].value:
+                if addr == 0:
+                    break
                 callers += '{}'.format(addr2line(self.toolchain, self.elf_path, addr))
         else:
             callers = ''
-            for addr in self.callers:
+            for addr in self.trace_event.params['callers'].value:
+                if addr == 0:
+                    break
                 if len(callers):
                     callers += ':'
                 callers += '0x{:x}'.format(addr)
-        if self.in_irq:
-            ctx_desc = 'IRQ "%s"' % self.ctx_name
-        else:
-            ctx_desc = 'task "%s"' % self.ctx_name
         if self.alloc:
-            return "[{:.9f}] HEAP: Allocated {:d} bytes @ 0x{:x} from {} on core {:d} by: {}".format(self.ts, self.size,
-                                                                                                     self.addr, ctx_desc,
-                                                                                                     self.core_id, callers)
+            return "[{:.9f}] HEAP: Allocated {:d} bytes @ 0x{:x} from {} on core {:d} by: {}".format(self.trace_event.ts,
+                                                                                                     self.size, self.addr,
+                                                                                                     self.trace_event.ctx_desc,
+                                                                                                     self.trace_event.core_id,
+                                                                                                     callers)
         else:
-            return "[{:.9f}] HEAP: Freed bytes @ 0x{:x} from {} on core {:d} by: {}".format(self.ts, self.addr, ctx_desc,
-                                                                                            self.core_id, callers)
+            return "[{:.9f}] HEAP: Freed bytes @ 0x{:x} from {} on core {:d} by: {}".format(self.trace_event.ts,
+                                                                                            self.addr, self.trace_event.ctx_desc,
+                                                                                            self.trace_event.core_id, callers)
 
 
 class BaseHeapTraceDataProcessorImpl: