esp-idf/tools/esp_app_trace/espytrace/sysview.py

import copy
import json
import re
import struct

import espytrace.apptrace as apptrace

SYSVIEW_EVTID_NOP                 = 0  # Dummy packet.
SYSVIEW_EVTID_OVERFLOW            = 1
SYSVIEW_EVTID_ISR_ENTER           = 2
SYSVIEW_EVTID_ISR_EXIT            = 3
SYSVIEW_EVTID_TASK_START_EXEC     = 4
SYSVIEW_EVTID_TASK_STOP_EXEC      = 5
SYSVIEW_EVTID_TASK_START_READY    = 6
SYSVIEW_EVTID_TASK_STOP_READY     = 7
SYSVIEW_EVTID_TASK_CREATE         = 8
SYSVIEW_EVTID_TASK_INFO           = 9
SYSVIEW_EVTID_TRACE_START         = 10
SYSVIEW_EVTID_TRACE_STOP          = 11
SYSVIEW_EVTID_SYSTIME_CYCLES      = 12
SYSVIEW_EVTID_SYSTIME_US          = 13
SYSVIEW_EVTID_SYSDESC             = 14
SYSVIEW_EVTID_USER_START          = 15
SYSVIEW_EVTID_USER_STOP           = 16
SYSVIEW_EVTID_IDLE                = 17
SYSVIEW_EVTID_ISR_TO_SCHEDULER    = 18
SYSVIEW_EVTID_TIMER_ENTER         = 19
SYSVIEW_EVTID_TIMER_EXIT          = 20
SYSVIEW_EVTID_STACK_INFO          = 21
SYSVIEW_EVTID_MODULEDESC          = 22
SYSVIEW_EVTID_INIT                = 24
SYSVIEW_EVENT_ID_PREDEF_LEN_MAX   = SYSVIEW_EVTID_INIT
SYSVIEW_EVTID_NAME_RESOURCE       = 25
SYSVIEW_EVTID_PRINT_FORMATTED     = 26
SYSVIEW_EVTID_NUMMODULES          = 27
SYSVIEW_EVENT_ID_PREDEF_MAX       = SYSVIEW_EVTID_NUMMODULES

SYSVIEW_EVENT_ID_MAX             = 200

SYSVIEW_MODULE_EVENT_OFFSET      = 512

SYSVIEW_SYNC_LEN                  = 10

_sysview_events_map = {
    'SYS_NOP': SYSVIEW_EVTID_NOP,
    'SYS_OVERFLOW': SYSVIEW_EVTID_OVERFLOW,
    'SYS_ISR_ENTER': SYSVIEW_EVTID_ISR_ENTER,
    'SYS_ISR_EXIT': SYSVIEW_EVTID_ISR_EXIT,
    'SYS_TASK_START_EXEC': SYSVIEW_EVTID_TASK_START_EXEC,
    'SYS_TASK_STOP_EXEC': SYSVIEW_EVTID_TASK_STOP_EXEC,
    'SYS_TASK_START_READY': SYSVIEW_EVTID_TASK_START_READY,
    'SYS_TASK_STOP_READY': SYSVIEW_EVTID_TASK_STOP_READY,
    'SYS_TASK_CREATE': SYSVIEW_EVTID_TASK_CREATE,
    'SYS_TASK_INFO': SYSVIEW_EVTID_TASK_INFO,
    'SYS_TRACE_START': SYSVIEW_EVTID_TRACE_START,
    'SYS_TRACE_STOP': SYSVIEW_EVTID_TRACE_STOP,
    'SYS_SYSTIME_CYCLES': SYSVIEW_EVTID_SYSTIME_CYCLES,
    'SYS_SYSTIME_US': SYSVIEW_EVTID_SYSTIME_US,
    'SYS_SYSDESC': SYSVIEW_EVTID_SYSDESC,
    'SYS_USER_START': SYSVIEW_EVTID_USER_START,
    'SYS_USER_STOP': SYSVIEW_EVTID_USER_STOP,
    'SYS_IDLE': SYSVIEW_EVTID_IDLE,
    'SYS_ISR_TO_SCHEDULER': SYSVIEW_EVTID_ISR_TO_SCHEDULER,
    'SYS_TIMER_ENTER': SYSVIEW_EVTID_TIMER_ENTER,
    'SYS_TIMER_EXIT': SYSVIEW_EVTID_TIMER_EXIT,
    'SYS_STACK_INFO': SYSVIEW_EVTID_STACK_INFO,
    'SYS_MODULEDESC': SYSVIEW_EVTID_INIT,
    'SYS_INIT': SYSVIEW_EVTID_INIT,
    'SYS_NAME_RESOURCE': SYSVIEW_EVTID_NAME_RESOURCE,
    'SYS_PRINT_FORMATTED': SYSVIEW_EVTID_PRINT_FORMATTED,
    'SYS_NUMMODULES': SYSVIEW_EVTID_NUMMODULES
}

_os_events_map = {}


def parse_trace(reader, parser, os_evt_map_file=''):
    """
    Parses trace.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.
    parser : SysViewTraceDataParser
        Top level parser object.
    os_evt_map_file : string
        Path to file containg events format description.
    """
    global _os_events_map
    # parse OS events formats file
    _os_events_map = _read_events_map(os_evt_map_file)
    parser.esp_ext = ('; ESP_Extension\n' in _read_file_header(reader))
    _read_init_seq(reader)
    while True:
        event = parser.read_event(reader, _os_events_map)
        parser.on_new_event(event)


def _read_events_map(os_evt_map_file):
    """
    Reads SystemView events format description from file.

    Parameters
    ----------
    os_evt_map_file : string
        Path to file containg events format description.

    Returns
    -------
    dict
        a dict with event IDs as keys and values as tuples containg event name and a list of parameters.
    """
    os_evt_map = {}
    with open(os_evt_map_file) as f:
        for line in f:
            comps = line.split()
            if len(comps) < 2:
                continue
            params = []
            if len(comps) > 2:
                for p in comps[2:]:
                    sp = p.split('=')
                    if sp[1].startswith('%'):
                        sp[1] = sp[1][1:]
                    if sp[1] == 'u':
                        params.append(SysViewEventParamSimple(sp[0], _decode_u32))
                    elif sp[1] == 's':
                        params.append(SysViewEventParamSimple(sp[0], _decode_str))
                    elif sp[1] == 't' or sp[1] == 'T' or sp[1] == 'I' or sp[1] == 'p':
                        # TODO: handle shrinked task/queue ID and addresses
                        params.append(SysViewEventParamSimple(sp[0], _decode_u32))
            os_evt_map[int(comps[0])] = (comps[1], params)
    return os_evt_map


def _read_file_header(reader):
    """
    Reads SystemView trace file header.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Returns
    -------
    list
        a list of header lines.
    """
    empty_count = 0
    lines = []
    while empty_count < 2:
        lines.append(reader.readline(linesep='\n'))
        if lines[-1] == ';\n':
            empty_count += 1
    return lines


def _read_init_seq(reader):
    """
    Reads SystemView trace initial synchronisation sequence of bytes.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Raises
    -------
    SysViewTraceParseError
        If sync sequence is broken.
    """
    SYNC_SEQ_FMT = '<%dB' % SYSVIEW_SYNC_LEN
    sync_bytes = struct.unpack(SYNC_SEQ_FMT, reader.read(struct.calcsize(SYNC_SEQ_FMT)))
    for b in sync_bytes:
        if b != 0:
            raise SysViewTraceParseError('Invalid sync sequense!')


def _decode_u32(reader):
    """
    Reads and decodes unsigned 32-bit integer.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Returns
    -------
    tuple
        a tuple containg number of read bytes and decoded value.
    """
    sz = 0
    val = 0
    while True:
        b, = struct.unpack('<B', reader.read(1))
        if b & 0x80:
            val |= (b & 0x7F) << (7 * sz)
        else:
            val |= b << (7 * sz)
            break
        sz += 1
    return (sz + 1,val)


def _decode_id(reader):
    """
    Reads and decodes ID (task ID, queue handle, semaphore handle etc.).

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Returns
    -------
    tuple
        a tuple containg number of read bytes and decoded value.
    """
    return _decode_u32(reader)


def _decode_u64(reader):
    """
    Reads and decodes unsigned 64-bit integer.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Returns
    -------
    tuple
        a tuple containg number of read bytes and decoded value.
    """
    sz,val = _decode_u32(reader)
    sz2,high = _decode_u32(reader)
    sz += sz2
    return sz,(val | (high << 32))


def _decode_str(reader):
    """
    Reads and decodes string.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Returns
    -------
    tuple
        a tuple containg number of read bytes and decoded value.
    """
    sz = 0
    val = ''
    sz, = struct.unpack('<B', reader.read(1))
    if sz == 0xFF:
        buf = struct.unpack('<2B', reader.read(2))
        sz = (buf[1] << 8) | buf[0]
    val, = struct.unpack('<%ds' % sz, reader.read(sz))
    val = val.decode('utf-8')
    if sz < 0xFF:
        return (sz + 1,val)  # one extra byte for length
    return (sz + 3,val)  # 3 extra bytes for length


def _decode_plen(reader):
    """
    Reads and decodes event's payload length.

    Parameters
    ----------
    reader : apptrace.Reader
        Trace reader object.

    Returns
    -------
    int
        decoded value.
    """
    plen = 0
    b0, = struct.unpack('<B', reader.read(1))
    if b0 & 0x80:
        b1, = struct.unpack('<B', reader.read(1))
        plen = b1  # higher part
        plen = (plen << 7) | (b0 & ~0x80)  # lower 7 bits
    else:
        plen = b0
    return plen


class SysViewTraceParseError(apptrace.ParseError):
    """
    SystemView parse error exception.
    """
    pass


class SysViewEvent(apptrace.TraceEvent):
    """
        Generic SystemView event class. This is a base class for all events.
    """
    def __init__(self, evt_id, core_id, reader, events_fmt_map=None):
        """
            Constructor. Reads and optionally decodes event.

            Parameters
            ----------
            evt_id : int
                Event ID.
            reader : apptrace.Reader
                Trace reader object.
            core_id : int
                Core ID event has been generated on.
            events_fmt_map : dict
                see return value of _read_events_map()
        """
        apptrace.TraceEvent.__init__(self, 'SysViewEvent', core_id, evt_id)
        self.plen = 0
        if self.id >= SYSVIEW_EVENT_ID_PREDEF_LEN_MAX:
            self.plen = _decode_plen(reader)
        if events_fmt_map:
            self._read_payload(reader, events_fmt_map)
        else:
            reader.forward(self.plen)
        _,self.ts = _decode_u32(reader)

    def _read_payload(self, reader, events_fmt_map):
        """
            Reads event's payload and populates its parameters dictionary.

            Parameters
            ----------
            reader : apptrace.Reader
                Trace reader object.
            events_fmt_map : dict
                see return value of _read_events_map()

            Raises
            -------
            SysViewTraceParseError
                if event has unknown or invalid format.
        """
        if self.id not in events_fmt_map:
            raise SysViewTraceParseError('Unknown event ID %d!' % self.id)
        self.name = events_fmt_map[self.id][0]
        evt_params_templates = events_fmt_map[self.id][1]
        params_len = 0
        for i in range(len(evt_params_templates)):
            event_param = copy.deepcopy(evt_params_templates[i])
            try:
                cur_pos = reader.get_pos()
                sz,param_val = event_param.decode(reader, self.plen - params_len)
            except Exception as e:
                raise SysViewTraceParseError('Failed to decode event {}({:d}) {:d} param @ 0x{:x}! {}'.format(self.name, self.id, self.plen, cur_pos, e))
            event_param.idx = i
            event_param.value = param_val
            self.params[event_param.name] = event_param
            params_len += sz
        if self.id >= SYSVIEW_EVENT_ID_PREDEF_LEN_MAX and self.plen != params_len:
            raise SysViewTraceParseError('Invalid event {}({:d}) payload len {:d}! Must be {:d}.'.format(self.name, self.id, self.plen, params_len))

    def __str__(self):
        params = ''
        for param in sorted(self.params.values(), key=lambda x: x.idx):
            params += '{}, '.format(param)
        if len(params):
            params = params[:-2]  # remove trailing ', '
        return '{:.9f} - core[{:d}].{}({:d}), plen {:d}: [{}]'.format(self.ts, self.core_id, self.name, self.id, self.plen, params)


class SysViewEventParam:
    """
        Abstract base SystemView event's parameter class. This is a base class for all event's parameters.
    """
    def __init__(self, name, decode_func):
        """
            Constructor.

            Parameters
            ----------
            name : string
                Event parameter name.
            decode_func : callable object
                Parameter decoding function.
        """
        self.name = name
        self.decode_func = decode_func
        self.value = None
        # positional index, used for sorting parameters before printing to make them looking as they appear in the event
        self.idx = 0

    def decode(self, reader, max_sz):
        """
            Reads and decodes events parameter.

            Parameters
            ----------
            reader : apptrace.Reader
                Trace reader object.
            max_sz : int
                Maximum number of bytes to read.

            Returns
            -------
            tuple
                a tuple containg number of read bytes and decoded value.
        """
        pass

    def __str__(self):
        return '{}: {}'.format(self.name, self.value)

    def to_jsonable(self):
        return {self.name: self.value}


class SysViewEventParamSimple(SysViewEventParam):
    """
        Simple SystemView event's parameter class.
    """
    def decode(self, reader, max_sz):
        """
            see SysViewEventParam.decode()
        """
        return self.decode_func(reader)


class SysViewEventParamArray(SysViewEventParamSimple):
    """
        Array SystemView event's parameter class.
    """
    def __init__(self, name, decode_func, size=-1):
        """
            Constructor.

            Parameters
            ----------
            name : string
                see SysViewEventParam.__init__()
            decode_func : callable object
                see SysViewEventParam.__init__()
            size : int
                Array's size. If -1 decode() will try to read all bytes from reader.
        """
        SysViewEventParamSimple.__init__(self, name, decode_func)
        self.arr_size = size

    def decode(self, reader, max_sz):
        """
            see SysViewEventParam.decode()
        """
        tottal_sz = 0
        vals = []
        i = 0
        while tottal_sz < max_sz:
            sz,val = self.decode_func(reader)
            vals.append(val)
            tottal_sz += sz
            i += 1
            if self.arr_size != -1 and i == self.arr_size:
                break
        return tottal_sz,vals


class SysViewPredefinedEvent(SysViewEvent):
    """
        Pre-defined SystemView events class.
    """
    _predef_events_fmt = {
        SYSVIEW_EVTID_NOP:              ('svNop', []),
        SYSVIEW_EVTID_OVERFLOW:         ('svOverflow', [SysViewEventParamSimple('drop_cnt', _decode_u32)]),
        SYSVIEW_EVTID_ISR_ENTER:        ('svIsrEnter', [SysViewEventParamSimple('irq_num', _decode_u32)]),
        SYSVIEW_EVTID_ISR_EXIT:         ('svIsrExit', []),
        SYSVIEW_EVTID_TASK_START_EXEC:  ('svTaskStartExec', [SysViewEventParamSimple('tid', _decode_id)]),
        SYSVIEW_EVTID_TASK_STOP_EXEC:   ('svTaskStopExec', []),
        SYSVIEW_EVTID_TASK_START_READY: ('svTaskStartReady', [SysViewEventParamSimple('tid', _decode_id)]),
        SYSVIEW_EVTID_TASK_STOP_READY:  ('svTaskStopReady', [SysViewEventParamSimple('tid', _decode_id),
                                                             SysViewEventParamSimple('cause', _decode_u32)]),
        SYSVIEW_EVTID_TASK_CREATE:      ('svTaskCreate', [SysViewEventParamSimple('tid', _decode_id)]),
        SYSVIEW_EVTID_TASK_INFO:        ('svTaskInfo', [SysViewEventParamSimple('tid', _decode_id),
                                                        SysViewEventParamSimple('prio', _decode_u32),
                                                        SysViewEventParamSimple('name', _decode_str)]),
        SYSVIEW_EVTID_TRACE_START:      ('svTraceStart', []),
        SYSVIEW_EVTID_TRACE_STOP:       ('svTraceStop', []),
        SYSVIEW_EVTID_SYSTIME_CYCLES:   ('svSysTimeCycles', [SysViewEventParamSimple('cycles', _decode_u32)]),
        SYSVIEW_EVTID_SYSTIME_US:       ('svSysTimeUs', [SysViewEventParamSimple('time', _decode_u64)]),
        SYSVIEW_EVTID_SYSDESC:          ('svSysDesc', [SysViewEventParamSimple('desc', _decode_str)]),
        SYSVIEW_EVTID_USER_START:       ('svUserStart', [SysViewEventParamSimple('user_id', _decode_u32)]),
        SYSVIEW_EVTID_USER_STOP:        ('svUserStart', [SysViewEventParamSimple('user_id', _decode_u32)]),
        SYSVIEW_EVTID_IDLE:             ('svIdle', []),
        SYSVIEW_EVTID_ISR_TO_SCHEDULER: ('svExitIsrToScheduler', []),
        SYSVIEW_EVTID_TIMER_ENTER:      ('svTimerEnter', [SysViewEventParamSimple('tim_id', _decode_u32)]),
        SYSVIEW_EVTID_TIMER_EXIT:       ('svTimerExit', []),
        SYSVIEW_EVTID_STACK_INFO:       ('svStackInfo', [SysViewEventParamSimple('tid', _decode_id),
                                                         SysViewEventParamSimple('base', _decode_u32),
                                                         SysViewEventParamSimple('sz', _decode_u32),
                                                         SysViewEventParamSimple('unused', _decode_u32)]),
        SYSVIEW_EVTID_MODULEDESC:       ('svModuleDesc', [SysViewEventParamSimple('mod_id', _decode_u32),
                                                          SysViewEventParamSimple('evt_off', _decode_u32),
                                                          SysViewEventParamSimple('desc', _decode_str)]),
        SYSVIEW_EVTID_INIT:             ('svInit', [SysViewEventParamSimple('sys_freq', _decode_u32),
                                                    SysViewEventParamSimple('cpu_freq', _decode_u32),
                                                    SysViewEventParamSimple('ram_base', _decode_u32),
                                                    SysViewEventParamSimple('id_shift', _decode_u32)]),
        SYSVIEW_EVTID_NAME_RESOURCE:    ('svNameResource', [SysViewEventParamSimple('res_id', _decode_u32),
                                                            SysViewEventParamSimple('name', _decode_str)]),
        SYSVIEW_EVTID_PRINT_FORMATTED:  ('svPrint', [SysViewEventParamSimple('msg', _decode_str),
                                                     SysViewEventParamSimple('lvl', _decode_u32),
                                                     SysViewEventParamSimple('unused', _decode_u32)]),
        SYSVIEW_EVTID_NUMMODULES:       ('svNumModules', [SysViewEventParamSimple('mod_cnt', _decode_u32)]),
    }

    def __init__(self, evt_id, core_id, reader):
        """
            see SysViewEvent.__init__()
        """
        SysViewEvent.__init__(self, evt_id, core_id, reader, self._predef_events_fmt)
        # self.name = 'SysViewPredefinedEvent'


class SysViewOSEvent(SysViewEvent):
    """
        OS related SystemView events class.
    """
    def __init__(self, evt_id, core_id, reader, events_fmt_map):
        """
            see SysViewEvent.__init__()
        """
        SysViewEvent.__init__(self, evt_id, core_id, reader, events_fmt_map)
        # self.name = 'SysViewOSEvent'


class SysViewHeapEvent(SysViewEvent):
    """
        Heap related SystemView events class.

        Attributes
        ----------
        events_fmt : dict
            see return value of _read_events_map()
    """
    events_fmt = {
        0:       ('esp_sysview_heap_trace_alloc', [SysViewEventParamSimple('addr', _decode_u32),
                                                   SysViewEventParamSimple('size', _decode_u32),
                                                   SysViewEventParamArray('callers', _decode_u32)]),
        1:       ('esp_sysview_heap_trace_free', [SysViewEventParamSimple('addr', _decode_u32),
                                                  SysViewEventParamArray('callers', _decode_u32)]),
    }

    def __init__(self, evt_id, core_id, events_off, reader):
        """
            Constructor. Reads and optionally decodes event.

            Parameters
            ----------
            evt_id : int
                see SysViewEvent.__init__()
            events_off : int
                Offset for heap events IDs. Greater or equal to SYSVIEW_MODULE_EVENT_OFFSET.
            reader : apptrace.Reader
                see SysViewEvent.__init__()
            core_id : int
                see SysViewEvent.__init__()
        """
        cur_events_map = {}
        for id in self.events_fmt:
            cur_events_map[events_off + id] = self.events_fmt[id]
        SysViewEvent.__init__(self, evt_id, core_id, reader, cur_events_map)
        # self.name = 'SysViewHeapEvent'


class SysViewTraceDataParser(apptrace.TraceDataProcessor):
    """
        Base SystemView trace data parser class.

        Attributes
        ----------
        STREAMID_SYS : int
            system events stream ID. Reserved for internal uses.
        STREAMID_LOG : int
            log events stream ID.
        STREAMID_HEAP : int
            heap events stream ID.
    """
    STREAMID_SYS = -1
    STREAMID_LOG = 0
    STREAMID_HEAP = 1

    def __init__(self, print_events=False, core_id=0):
        """
            Constructor.

            Parameters
            ----------
            print_events : bool
                see apptrace.TraceDataProcessor.__init__()
            core_id : int
                id of the core this parser object relates to.
        """
        apptrace.TraceDataProcessor.__init__(self, print_events=print_events, keep_all_events=True)
        self.sys_info = None
        self._last_ts = 0
        self.irqs_info = {}
        self.tasks_info = {}
        self.core_id = core_id
        self.esp_ext = False

    def _parse_irq_desc(self, desc):
        """
            Parses IRQ description.

            Parameters
            ----------
            desc : string
                IRQ description string.

            Returns
            -------
            tuple
                a tuple with IRQ number and name or None on error.
        """
        m = re.match('I#([0-9]+)=(.+)', desc)
        if m:
            return m.group(2),m.group(1)
        return None

    def _update_ts(self, ts):
        """
            Calculates real event timestamp.

            Parameters
            ----------
            ts : int
                Event timestamp offset.

            Returns
            -------
            float
                real event timestamp.
        """
        self._last_ts += ts
        return float(self._last_ts) / self.sys_info.params['sys_freq'].value

    def read_extension_event(self, evt_id, core_id, reader):
        """
            Reads extension event.
            Default implementation which just reads out event.

            Parameters
            ----------
            evt_id : int
                Event ID.
            reader : apptrace.Reader
                Trace reader object.

            Returns
            -------
            SysViewEvent
                if this is top level parser returns object for generic event,
                otherwise returns None indicating to the calling top level parser
                that extension event are not supported.
        """
        if self.root_proc == self:
            # by default just read out and skip unknown event
            return SysViewEvent(evt_id, core_id, reader)
        return None  # let decide to root parser

    @staticmethod
    def _decode_core_id(high_b):
        if high_b & (1 << 6):
            core_id = 1
            high_b &= ~(1 << 6)
        else:
            core_id = 0
        return high_b,core_id

    def read_event(self, reader, os_evt_map):
        """
            Reads pre-defined or OS-related event.

            Parameters
            ----------
            reader : apptrace.Reader
                Trace reader object.
            os_evt_map : dict
                see return value of _read_events_map()

            Returns
            -------
            SysViewEvent
                pre-defined, OS-related or extension event object.
        """
        evt_hdr, = struct.unpack('<B', reader.read(1))
        # read ID and core num
        evt_id = 0
        if evt_hdr & 0x80:
            # evt_id (2 bytes)
            b, = struct.unpack('<B', reader.read(1))
            # higher part
            if self.esp_ext:
                evt_id,core_id = self._decode_core_id(b)
            else:
                evt_id = b
                core_id = self.core_id
            evt_id = (evt_id << 7) | (evt_hdr & ~0x80)  # lower 7 bits
        else:
            # evt_id (1 byte)
            if self.esp_ext:
                evt_id,core_id = self._decode_core_id(evt_hdr)
            else:
                evt_id = evt_hdr
                core_id = self.core_id
        if evt_id <= SYSVIEW_EVENT_ID_PREDEF_MAX:
            return SysViewPredefinedEvent(evt_id, core_id, reader)
        elif evt_id < SYSVIEW_MODULE_EVENT_OFFSET:
            return SysViewOSEvent(evt_id, core_id, reader, os_evt_map)
        else:
            return self.read_extension_event(evt_id, core_id, reader)

    def event_supported(self, event):
        return False

    def on_new_event(self, event):
        """
            Does essential processing of event. Must be called for every read event.
            Assigns real timestamp to event. Updates global system info: system description,
            mapping of tasks IDs to names and IRQ names to numbers.

            Parameters
            ----------
            event : SysViewEvent
                Event object.
        """
        if event.id == SYSVIEW_EVTID_TRACE_START:
            event.ts = 0
            self._last_ts = 0
        elif self.sys_info:
            event.ts = self._update_ts(event.ts)

        if event.id == SYSVIEW_EVTID_INIT:
            self.sys_info = event
            event.ts = self._update_ts(event.ts)
        elif event.id == SYSVIEW_EVTID_TASK_INFO:
            self.tasks_info[event.params['tid'].value] = event.params['name'].value
        elif event.id == SYSVIEW_EVTID_SYSDESC:
            irq = self._parse_irq_desc(event.params['desc'].value)
            if irq:
                irq_num = int(irq[1])
                self.irqs_info[irq_num] = irq[0]
        # count event and save it to the list
        apptrace.TraceDataProcessor.on_new_event(self, event)


class SysViewTraceDataExtEventParser(SysViewTraceDataParser):
    def __init__(self, events_num, print_events=False, core_id=0):
        """
            Constructor.

            Parameters
            ----------
            print_events : bool
                see apptrace.TraceDataProcessor.__init__()
            core_id : int
                id of the core this parser object relates to.
        """
        SysViewTraceDataParser.__init__(self, core_id=core_id, print_events=print_events)
        self.events_off = 0
        self.events_num = events_num

    def event_supported(self, event):
        return False if (self.events_off < SYSVIEW_MODULE_EVENT_OFFSET or event.id < self.events_off or
                        event.id >= (self.events_off + self.events_num)) else True


class SysViewMultiTraceDataParser(SysViewTraceDataParser):
    """
        SystemView trace data parser supporting multiple event streams.
    """
    def __init__(self, print_events=False, core_id=0):
        """
            see SysViewTraceDataParser.__init__()
        """
        SysViewTraceDataParser.__init__(self, print_events, core_id)
        self.stream_parsers = {}

    def add_stream_parser(self, stream_id, parser):
        """
            Assigns parser for events stream.

            Parameters
            ----------
            stream_id : int
                stream ID. See SysViewTraceDataParser.STREAMID_xxx.
                Parsers for SysViewTraceDataParser.STREAMID_SYS are ignored.
                Top level parser is the default for SysViewTraceDataParser.STREAMID_SYS.
            parser : SysViewTraceDataParser
                parser object.
        """
        if stream_id == SysViewTraceDataParser.STREAMID_SYS:
            return
        parser.root_proc = self
        self.stream_parsers[stream_id] = parser

    def read_extension_event(self, evt_id, core_id, reader):
        """
            Reads extension event.
            Iterates over registered stream parsers trying to find one which supports that type of event.

            Parameters
            ----------
            evt_id : int
                see SysViewTraceDataParser.read_extension_event()
            reader : apptrace.Reader
                see SysViewTraceDataParser.read_extension_event()

            Returns
            -------
            SysViewEvent
                object for extension event, if extension event is not supported return SysViewEvent instance.
        """
        for stream_id in self.stream_parsers:
            evt = self.stream_parsers[stream_id].read_extension_event(evt_id, core_id, reader)
            if evt:
                return evt
        return SysViewTraceDataParser.read_extension_event(self, evt_id, core_id, reader)

    def on_new_event(self, event):
        """
            Iterates over registered stream parsers allowing them to do
            essential processing of event. Must be called for every read event.

            Parameters
            ----------
            event : SysViewEvent
                Event object.
        """
        SysViewTraceDataParser.on_new_event(self, event)
        for stream_id in self.stream_parsers:
            self.stream_parsers[stream_id].on_new_event(event)


class SysViewEventContext():
    """
        SystemView event context.
    """
    def __init__(self, handle, irq, name=''):
        """
            Constructor.

            Parameters
            ----------
            handle : int
                handle of the context: task ID or IRQ number.
            irq : bool
                flag indicating whether this is IRQ or task context.
            name : string
                name of the context: task or IRQ name. Empty if context is unknown.
       """
        self.handle = handle
        self.irq = irq
        self.name = name


class SysViewTraceDataProcessor(apptrace.TraceDataProcessor):
    """
        Base SystemView trace data processor class.
    """
    def __init__(self, traces, root_proc=None, print_events=False, keep_all_events=False):
        """
            Constructor.

            Parameters
            ----------
            traces : list
                list of parsers to process data from.
            print_events : bool
                see apptrace.TraceDataProcessor.__init__()
            keep_all_events : bool
                see apptrace.TraceDataProcessor.__init__()
        """
        apptrace.TraceDataProcessor.__init__(self, print_events, keep_all_events)
        self.event_ids = {}
        self.name = ''
        self.root_proc = root_proc if root_proc else self
        self.traces = {}
        self.ctx_stack = {}
        self.prev_ctx = {}
        self.no_ctx_events = []
        for t in traces:
            self.traces[t.core_id] = t
            # current context item is a tuple of task ID or IRQ num and 'in_irq' flag
            # empty list means IDLE context or self.start_ctx
            self.ctx_stack[t.core_id] = []
            # context is undefined, we do not know have we started the tracing in task/IDLE or IRQ context
            # in general there are three scenarious when we can start tracing: when core is in task, IDLE task or IRQ context
            self.prev_ctx[t.core_id] = None

    def _get_curr_context(self, core_id):
        """
            Returns current context.

            Parameters
            ----------
            core_id : int
                core ID for requested context.

            Returns
            -------
            SysViewEventContext
                context object
            None
                if there current is undefined
        """
        if len(self.root_proc.ctx_stack[core_id]):
            return self.root_proc.ctx_stack[core_id][-1]
        if self._get_prev_context(core_id):
            return SysViewEventContext(None, False, 'IDLE%d' % core_id)
        return None

    def _get_prev_context(self, core_id):
        """
            Returns current context.

            Parameters
            ----------
            core_id : int
                core ID for requested context.

            Returns
            -------
            SysViewEventContext
                context object
        """
        return self.root_proc.prev_ctx[core_id]

    def get_trace_stream(self, core_id, stream_id):
        """
            Retrieves parser for specified stream and core.

            Parameters
            ----------
            core_id : int
                Parser's core ID.
            stream_id : int
                Parser's stream ID.

            Returns
            -------
            SysViewTraceDataParser
                parser object for specified stream and core
        """
        if self.root_proc == self:
            return self.traces[core_id]
        return self.root_proc.get_trace_stream(core_id, stream_id)

    def event_supported(self, e):
        """
            Should be overriden in child class.
        """
        return False

    def handle_event(self, e):
        """
            Should be overriden in child class.
        """
        pass

    def print_report(self):
        """
            see apptrace.TraceDataProcessor.print_report()
        """
        apptrace.TraceDataProcessor.print_report(self)

    def _process_event(self, event):
        """
            Processes event.
            Keeps track of execution context on every core.

            Parameters
            ----------
            event : SysViewEvent
                Event object.

            Raises
            ----------
            SysViewTraceParseError
                if there is no parser for event's core or
                if SYSVIEW_EVTID_ISR_ENTER is received for unknown IRQ or
                if SYSVIEW_EVTID_TASK_START_EXEC or SYSVIEW_EVTID_TASK_STOP_READY is received for unknown task.
        """
        if event.core_id not in self.traces:
            if 0 in self.traces and self.traces[0].esp_ext:
                # for Espressif extension there is one trace for all cores
                trace = self.traces[0]
                if event.core_id not in self.ctx_stack:
                    self.ctx_stack[event.core_id] = []
                if event.core_id not in self.prev_ctx:
                    self.prev_ctx[event.core_id] = None
            else:
                raise SysViewTraceParseError('Event for unknown core %d' % event.core_id)
        else:
            trace = self.traces[event.core_id]
        if event.id == SYSVIEW_EVTID_ISR_ENTER:
            if event.params['irq_num'].value not in trace.irqs_info:
                raise SysViewTraceParseError('Enter unknown ISR %d' % event.params['irq_num'].value)
            if len(self.ctx_stack[event.core_id]):
                self.prev_ctx[event.core_id] = self.ctx_stack[event.core_id][-1]
            else:
                # the 1st context switching event after trace start is SYSVIEW_EVTID_ISR_ENTER, so we have been in IDLE context
                self.prev_ctx[event.core_id] = SysViewEventContext(None, False, 'IDLE%d' % event.core_id)
            # put new ISR context on top of the stack (the last in the list)
            self.ctx_stack[event.core_id].append(SysViewEventContext(event.params['irq_num'].value, True, trace.irqs_info[event.params['irq_num'].value]))
        elif event.id == SYSVIEW_EVTID_ISR_EXIT or event.id == SYSVIEW_EVTID_ISR_TO_SCHEDULER:
            if len(self.ctx_stack[event.core_id]):
                # return to the previous context (the last in the list)
                self.prev_ctx[event.core_id] = self.ctx_stack[event.core_id].pop()
            else:
                # the 1st context switching event after trace start is SYSVIEW_EVTID_ISR_EXIT, so we have been in ISR context,
                # but we do not know which one because SYSVIEW_EVTID_ISR_EXIT do not include the IRQ number
                self.prev_ctx[event.core_id] = SysViewEventContext(None, True, 'IRQ_oncore%d' % event.core_id)
        elif event.id == SYSVIEW_EVTID_TASK_START_EXEC:
            if event.params['tid'].value not in trace.tasks_info:
                raise SysViewTraceParseError('Start exec unknown task 0x%x' % event.params['tid'].value)
            if len(self.ctx_stack[event.core_id]):
                # return to the previous context (the last in the list)
                self.prev_ctx[event.core_id] = self.ctx_stack[event.core_id][-1]
            else:
                # the 1st context switching event after trace start is SYSVIEW_EVTID_TASK_START_EXEC, so we have been in IDLE context
                self.prev_ctx[event.core_id] = SysViewEventContext(None, False, 'IDLE%d' % event.core_id)
            # only one task at a time in context stack (can be interrupted by a bunch of ISRs)
            self.ctx_stack[event.core_id] = [SysViewEventContext(event.params['tid'].value, False, trace.tasks_info[event.params['tid'].value])]
        elif event.id == SYSVIEW_EVTID_TASK_STOP_EXEC:
            # delete task from context stack
            for ctx in self.ctx_stack[event.core_id]:
                if not ctx.irq:
                    if len(self.ctx_stack[event.core_id]) == 1:
                        # if this is the only ctx in context stack
                        self.prev_ctx[event.core_id] = ctx
                    del ctx
                    break
        elif event.id == SYSVIEW_EVTID_TASK_STOP_READY:
            if event.params['tid'].value not in trace.tasks_info:
                raise SysViewTraceParseError('Stop ready unknown task 0x%x' % event.params['tid'].value)
            if len(self.ctx_stack[event.core_id]):
                if (not self.ctx_stack[event.core_id][-1].irq and event.params['tid'].value == self.ctx_stack[event.core_id][-1].handle):
                    # return to the previous context (the last in the list)
                    self.prev_ctx[event.core_id] = self.ctx_stack[event.core_id].pop()
            else:
                # the 1st context switching event after trace start is SYSVIEW_EVTID_TASK_STOP_READY, so we have been in task context
                self.prev_ctx[event.core_id] = SysViewEventContext(event.params['tid'].value, False, trace.tasks_info[event.params['tid'].value])

    def on_new_event(self, event):
        """
            Processes heap events.
        """
        if self.root_proc == self:
            SysViewTraceDataProcessor._process_event(self, event)
        curr_ctx = self._get_curr_context(event.core_id)
        if not curr_ctx:
            # postpone events handling till their context is known
            self.no_ctx_events.append(event)
            return
        event.in_irq = curr_ctx.irq
        event.ctx_name = curr_ctx.name
        # here we know the previous context: we switched from it or implied upon the 1st context switching event
        prev_ctx = self._get_prev_context(event.core_id)
        if len(self.no_ctx_events):
            for cached_evt in self.no_ctx_events:
                cached_evt.ctx_name = prev_ctx.name
                cached_evt.in_irq = prev_ctx.irq
                # count and save the event
                apptrace.TraceDataProcessor.on_new_event(self, cached_evt)
                if self.event_supported(event):
                    self.handle_event(event)
            del self.no_ctx_events[:]
        # count and save the event
        apptrace.TraceDataProcessor.on_new_event(self, event)
        if self.event_supported(event):
            self.handle_event(event)

    def merge_and_process(self):
        """
            Merges events from all registered parsers, sorts them by timestamp and processes them.
        """
        all_events = []
        for t in self.traces.values():
            all_events.extend(t.events)
        all_events.sort(key=lambda x: x.ts)
        for event in all_events:
            self.on_new_event(event)


class SysViewMultiStreamTraceDataProcessor(SysViewTraceDataProcessor):
    """
        SystemView trace data processor supporting multiple event streams.
    """
    def __init__(self, traces, print_events=False, keep_all_events=False):
        """
            see SysViewTraceDataProcessor.__init__()
        """
        SysViewTraceDataProcessor.__init__(self, traces, print_events=print_events, keep_all_events=keep_all_events)
        self.stream_procs = {}

    def add_stream_processor(self, stream_id, proc):
        """
            Assigns processor for events stream.

            Parameters
            ----------
            stream_id : int
                stream ID. See SysViewTraceDataParser.STREAMID_xxx.
                Parsers for SysViewTraceDataParser.STREAMID_SYS are ignored.
                Top level parser is the default for SysViewTraceDataParser.STREAMID_SYS.
            proc : SysViewTraceDataProcessor
                processor object.
        """
        if stream_id == SysViewTraceDataParser.STREAMID_SYS:
            return
        proc.root_proc = self  # common processing data is kept by this processor
        self.stream_procs[stream_id] = proc

    def get_trace_stream(self, core_id, stream_id):
        """
            Retrieves parser for specified stream and core.

            Parameters
            ----------
            core_id : int
                Parser's core ID.
            stream_id : int
                Parser's stream ID.

            Returns
            -------
            SysViewTraceDataParser
                parser object for specified stream and core
        """
        if core_id not in self.traces and 0 in self.traces and self.traces[0].esp_ext:
            # for Espressif extension there is one trace for all cores
            trace = self.traces[0]
        else:
            trace = self.traces[core_id]
        if stream_id == SysViewTraceDataParser.STREAMID_SYS:
            return trace
        if isinstance(trace, SysViewMultiTraceDataParser):
            return trace.stream_parsers[stream_id]
        return trace

    def print_report(self):
        """
            Iterates over registered stream processors and prints their reports.
        """
        SysViewTraceDataProcessor.print_report(self)
        # need to sort stream procs by keys to print reports in the same order regardless of Python version
        stream_ids = list(self.stream_procs.keys())
        stream_ids.sort()
        for stream_id in stream_ids:
            self.stream_procs[stream_id].print_report()

    def cleanup(self):
        """
            Iterates over registered stream processors and cleans them up.
        """
        for stream_id in self.stream_procs:
            self.stream_procs[stream_id].cleanup()
        SysViewTraceDataProcessor.cleanup(self)

    def on_new_event(self, event):
        """
            Iterates over registered stream processors allowing them to do
            the processing of event.

            Parameters
            ----------
            event : SysViewEvent
                Event object.
        """
        SysViewTraceDataProcessor.on_new_event(self, event)
        for stream_id in self.stream_procs:
            self.stream_procs[stream_id].on_new_event(event)


class SysViewTraceDataJsonEncoder(json.JSONEncoder):
    JSON_TRACE_VER = '1.0'

    def default(self, obj):
        global _sysview_events_map
        global _os_events_map
        if isinstance(obj, SysViewMultiStreamTraceDataProcessor):
            json_event_ids = {'system': _sysview_events_map, 'os': {}}
            for eid in _os_events_map:
                ename = _os_events_map[eid][0]
                json_event_ids['os'][ename] = eid
            for stream in obj.stream_procs.values():
                json_event_ids[stream.name] = stream.event_ids
            json_events = []
            for e in obj.events:
                for stream in obj.stream_procs.values():
                    if stream.event_supported(e):
                        json_events.append(e)
                        break
                # include also OS and pre-defined events
                if isinstance(e, SysViewPredefinedEvent) or isinstance(e, SysViewOSEvent):
                    json_events.append(e)
            return {'version': self.JSON_TRACE_VER, 'streams': json_event_ids, 'events': json_events}
        if isinstance(obj, SysViewHeapEvent):
            blk_size = 0
            if 'size' in obj.params:
                blk_size = obj.params['size'].value
            blk_addr = '0x{:x}'.format(obj.params['addr'].value)
            callers = []
            for addr in obj.params['callers'].value:
                callers.append('0x{:x}'.format(addr))
            return {'ctx_name': obj.ctx_name, 'in_irq': obj.in_irq, 'id': obj.id, 'core_id': obj.core_id,
                    'ts': obj.ts, 'addr': blk_addr, 'size': blk_size, 'callers': callers}
        if isinstance(obj, SysViewPredefinedEvent) and obj.id == SYSVIEW_EVTID_PRINT_FORMATTED:
            return {'ctx_name': obj.ctx_name, 'in_irq': obj.in_irq, 'id': obj.id, 'core_id': obj.core_id,
                    'ts': obj.ts, 'msg': obj.params['msg'].value, 'lvl': obj.params['lvl'].value}
        if isinstance(obj, SysViewEvent):
            jobj = obj.to_jsonable()
            # remove unused fields
            if 'name' in jobj:
                del jobj['name']
            if 'plen' in jobj:
                del jobj['plen']
            return jobj
        # Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)


class SysViewHeapTraceDataParser(SysViewTraceDataExtEventParser):
    """
        SystemView trace data parser supporting heap events.
    """
    def __init__(self, print_events=False, core_id=0):
        """
            SystemView trace data parser supporting multiple event streams.
            see SysViewTraceDataExtEventParser.__init__()
        """
        SysViewTraceDataExtEventParser.__init__(self, events_num=len(SysViewHeapEvent.events_fmt.keys()), core_id=core_id, print_events=print_events)

    def read_extension_event(self, evt_id, core_id, reader):
        """
            Reads heap event.
            see SysViewTraceDataParser.read_extension_event()
        """
        if (self.events_off >= SYSVIEW_MODULE_EVENT_OFFSET and evt_id >= self.events_off and
                evt_id < self.events_off + self.events_num):
            return SysViewHeapEvent(evt_id, core_id, self.events_off, reader)
        return SysViewTraceDataParser.read_extension_event(self, evt_id, core_id, reader)

    def on_new_event(self, event):
        """
            Keeps track of heap module descriptions.
        """
        if self.root_proc == self:
            SysViewTraceDataParser.on_new_event(self, event)
        if event.id == SYSVIEW_EVTID_MODULEDESC and event.params['desc'].value == 'ESP32 SystemView Heap Tracing Module':
            self.events_off = event.params['evt_off'].value


class SysViewHeapTraceDataProcessor(SysViewTraceDataProcessor, apptrace.BaseHeapTraceDataProcessorImpl):
    """
        SystemView trace data processor supporting heap events.
    """
    def __init__(self, toolchain_pref, elf_path, root_proc=None, traces=[], print_events=False, print_heap_events=False):
        """
            Constructor.
            see SysViewTraceDataProcessor.__init__()
            see apptrace.BaseHeapTraceDataProcessorImpl.__init__()
        """
        SysViewTraceDataProcessor.__init__(self, traces, root_proc=root_proc, print_events=print_events)
        apptrace.BaseHeapTraceDataProcessorImpl.__init__(self, print_heap_events)
        self.toolchain = toolchain_pref
        self.elf_path = elf_path
        # self.no_ctx_events = []
        self.name = 'heap'
        stream = self.root_proc.get_trace_stream(0, SysViewTraceDataParser.STREAMID_HEAP)
        self.event_ids = {'alloc': stream.events_off, 'free': stream.events_off + 1}

    def event_supported(self, event):
        heap_stream = self.root_proc.get_trace_stream(event.core_id, SysViewTraceDataParser.STREAMID_HEAP)
        return heap_stream.event_supported(event)

    def handle_event(self, event):
        heap_stream = self.root_proc.get_trace_stream(event.core_id, SysViewTraceDataParser.STREAMID_HEAP)
        if (event.id - heap_stream.events_off) == 0:
            heap_event = apptrace.HeapTraceEvent(event, True, toolchain=self.toolchain,
                                                 elf_path=self.elf_path)
        else:
            heap_event = apptrace.HeapTraceEvent(event, False, toolchain=self.toolchain,
                                                 elf_path=self.elf_path)
        apptrace.BaseHeapTraceDataProcessorImpl.on_new_event(self, heap_event)

    def print_report(self):
        """
            see apptrace.TraceDataProcessor.print_report()
        """
        if self.root_proc == self:
            SysViewTraceDataProcessor.print_report(self)
        apptrace.BaseHeapTraceDataProcessorImpl.print_report(self)


class SysViewLogTraceEvent(apptrace.LogTraceEvent):
    """
        SystemView log event.
    """
    def __init__(self, ts, msg):
        """
            Constructor.

            Parameters
            ----------
            msg : string
                Log message string.
        """
        self.msg = msg
        self.ts = ts

    def get_message(self, unused):
        """
            Retrieves log message.

            Returns
            -------
            string
                formatted log message
        """
        return '[{:.9f}] LOG: {}'.format(self.ts, self.msg)


class SysViewLogTraceDataParser(SysViewTraceDataParser):
    """
        SystemView trace data parser supporting log events.
    """
    def event_supported(self, event):
        return event.id == SYSVIEW_EVTID_PRINT_FORMATTED

    def on_new_event(self, event):
        """
            see SysViewTraceDataParser.on_new_event()
        """
        if self.root_proc == self:
            SysViewTraceDataParser.on_new_event(self, event)


class SysViewLogTraceDataProcessor(SysViewTraceDataProcessor, apptrace.BaseLogTraceDataProcessorImpl):
    """
        SystemView trace data processor supporting heap events.
    """
    def __init__(self, traces=[], root_proc=None, print_events=False, print_log_events=False):
        """
            Constructor.
            see SysViewTraceDataProcessor.__init__()
            see apptrace.BaseLogTraceDataProcessorImpl.__init__()
        """
        SysViewTraceDataProcessor.__init__(self, traces, root_proc=root_proc, print_events=print_events)
        apptrace.BaseLogTraceDataProcessorImpl.__init__(self, print_log_events)
        self.name = 'log'
        self.event_ids = {'print': SYSVIEW_EVTID_PRINT_FORMATTED}

    def event_supported(self, event):
        return event.id == SYSVIEW_EVTID_PRINT_FORMATTED

    def on_new_event(self, event):
        """
            Processes log events.
        """
        if self.root_proc == self:
            SysViewTraceDataProcessor.on_new_event(self, event)
        if event.id == SYSVIEW_EVTID_PRINT_FORMATTED:
            log_evt = SysViewLogTraceEvent(event.ts, event.params['msg'].value)
            apptrace.BaseLogTraceDataProcessorImpl.on_new_event(self, log_evt)

    def print_report(self):
        """
            see apptrace.TraceDataProcessor.print_report()
        """
        if self.root_proc == self:
            SysViewTraceDataProcessor.print_report(self)
        apptrace.BaseLogTraceDataProcessorImpl.print_report(self)