| #!/usr/bin/python |
| |
| # |
| # Copyright (c) 2016 Intel Corporation. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| # A S ==> R B, A goes to sleep state, A runtime is timestamp_switch - previous_timestamp. |
| # B state goes to running |
| # A R ==> R B, A goes to queue state, A runtime is timestamp_switch - previous_timestamp. |
| # B state goes to running |
| |
| # IMPORTANT: timeslice must be lower than max running time of tasks |
| |
| import os, sys, re, collections |
| from operator import itemgetter |
| from collections import defaultdict |
| from optparse import OptionParser |
| import pylab as P |
| import matplotlib |
| import array |
| import Tkinter as Tk |
| from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg |
| from random import randint |
| |
| sys.path.append(os.path.dirname(sys.argv[0])) |
| |
| ### Timestamp handling functions |
| |
| timestamp_ref_module = False |
| |
| try: |
| from timestamp_ref import * |
| timestamp_ref_module = True |
| except: |
| pass |
| |
| if not timestamp_ref_module: |
| class Timestamp_Ref: |
| def __init__(self): |
| self.convert = 1.0 / 1000 |
| |
| def convert_t32k_absolute(self, t32k): |
| return (t32k * self.convert) |
| |
| def convert_t32k_offset(self, t32k): |
| return (t32k * self.convert) |
| |
| def set_32k_offset(self, ts): |
| return |
| |
| global ref_ts |
| ref_ts = Timestamp_Ref() |
| |
| class IRQTrace: |
| def __init__(self): |
| self.compiled_regexp = [] |
| self.timestamp_start_b = 0 |
| self.timestamp_end_b = 0 |
| self.irqtable = {} |
| self.irqstack = {} |
| self.last_ts = {} |
| self.duration = {} |
| self.plotx = [] |
| self.ploty = [] |
| |
| REGEXP_GLOSSARY = [ |
| # backup rule |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d)\s+irqin\s+(?P<irq_id>\d+)\s+\S+\s+' \ |
| '(?P<irq_name>[\w \.#-_/]+)\s+0x\S+.*$', self.callback_irq_start], |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d)\s+irqin\s+x(?P<hexa_irq_id>[0-9a-fA-F]+)' \ |
| '\s+\S+\s+(?P<irq_name>[\w \.#-_/{}]+)\s+0x\S+.*$', self.callback_irq_start], |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d)\s+irqout\s+(?P<irq_id>\d+).*$', |
| self.callback_irq_stop |
| ], |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d)\s+irqout\s+x(?P<hexa_irq_id>[0-9a-fA-F]+).*$', |
| self.callback_irq_stop], |
| ['^Last timestamp:\s*(?P<last_timestamp>\d+).*$', self.callback_end], |
| ['^.*$', self.callback_no_rule] |
| ] |
| |
| # Compile all regexp |
| for regexp_string, regexp_rules in REGEXP_GLOSSARY: |
| self.compiled_regexp.append([re.compile(regexp_string), regexp_rules]) |
| |
| def filter_line(self, line, line_number): |
| # Parse all regexps |
| for regexp, regexp_rules in self.compiled_regexp: |
| # Test if regexp matches |
| res = regexp.search(line) |
| # if regexp match |
| if res: |
| # Execute regexp_rules |
| if regexp_rules: |
| regexp_rules(res, line, line_number) |
| # Only one regexp per line |
| break |
| |
| def callback_irq_stop(self, res, line, line_number): |
| ts = int(res.group('timestamp')) |
| timestamp = ref_ts.convert_t32k_offset(ts) |
| |
| if (timestamp < self.timestamp_start_b) or (timestamp > self.timestamp_end_b): |
| return |
| |
| try: |
| irqid = int(res.group('irq_id')) |
| except IndexError: |
| irqid = int(res.group('hexa_irq_id'), 16) |
| cpu_id = int(res.group('cpu_id')) |
| |
| irq_current = self.irqstack[cpu_id].pop() |
| if (irq_current != irqid): |
| print "WARNING: removing %u but %u on irq stack" % (irqid, irq_current) |
| self.irqstack[cpu_id].append(irq_current) |
| return |
| |
| irq_prev = self.irqstack[cpu_id][len(self.irqstack[cpu_id]) - 1] |
| self.plotx[cpu_id] += [timestamp, timestamp] |
| self.ploty[cpu_id] += [irqid, irq_prev] |
| |
| if self.last_ts[str(cpu_id)+str(irqid)] != -1: |
| if self.duration.has_key(irqid): |
| self.duration[irqid] += timestamp - self.last_ts[str(cpu_id)+str(irqid)] |
| else: |
| self.duration[irqid] = timestamp - self.last_ts[str(cpu_id)+str(irqid)] |
| else: |
| print "ERROR: missing start event in line", line |
| return |
| |
| self.last_ts[str(cpu_id)+str(irqid)] = -1 |
| |
| def callback_irq_start(self, res, line, line_number): |
| ts = int(res.group('timestamp')) |
| timestamp = ref_ts.convert_t32k_offset(ts) |
| |
| if (timestamp < self.timestamp_start_b) or (timestamp > self.timestamp_end_b): |
| return |
| |
| try: |
| irqid = int(res.group('irq_id')) |
| except IndexError: |
| irqid = int(res.group('hexa_irq_id'), 16) |
| cpu_id = int(res.group('cpu_id')) |
| |
| if (cpu_id + 1) > len(self.plotx): |
| for i in range(len(self.plotx), cpu_id + 1): |
| self.plotx.append([]) |
| self.ploty.append([]) |
| self.irqtable[-i-1] = 'noirq_cpu'+str(i) |
| self.irqstack[i] = [-cpu_id - 1] |
| |
| irqid_prev = self.irqstack[cpu_id][len(self.irqstack[cpu_id]) - 1] |
| self.plotx[cpu_id] += [timestamp, timestamp] |
| self.ploty[cpu_id] += [irqid_prev, irqid] |
| self.irqstack[cpu_id].append(irqid) |
| |
| self.irqtable[irqid] = res.group('irq_name') |
| self.last_ts[str(cpu_id)+str(irqid)] = timestamp |
| |
| |
| def callback_no_rule(self, res, line, line_number): |
| return |
| |
| def callback_end(self, res, line, line_number): |
| return |
| |
| # goal is to keep only some contributors in their contribution order then put rest as |
| # others then tid 0 |
| def draw(self): |
| ploty_final = [] |
| plot_conv = {} |
| count = 1 |
| |
| for i in range(0, len(self.plotx)): |
| ploty_final.append([]) |
| plot_conv[-i-1] = -i-1 |
| |
| items = self.duration.items() |
| items.sort(key = itemgetter(1), reverse=True) |
| |
| # class processes, <= 0 at bottom then up by order of frequence |
| for irqid, duration in items: |
| if irqid >= 0: |
| plot_conv[irqid] = count |
| count += 1 |
| |
| # prepare y axe. <= 0 do not move, other processes are classified |
| for i in range(0, len(self.plotx)): |
| for irqid in self.ploty[i]: |
| ploty_final[i].append(plot_conv[irqid]) |
| |
| ticks_pos = [] |
| ticks_names = [] |
| |
| for key, value in self.irqtable.items(): |
| ticks_pos.append(plot_conv[key]) |
| if key >= 0: |
| ticks_names.append(value + ":" + str(key)) |
| else: |
| ticks_names.append(value) |
| colors = [ 'blue', 'green', 'magenta', 'cyan', 'brown', 'orange' ] |
| |
| for i in range(0, len(self.plotx)): |
| P.plot(self.plotx[i], ploty_final[i], colors[i % len(colors)]) |
| P.yticks(ticks_pos, ticks_names) |
| P.ylabel('IRQs') |
| P.gca().grid(True) |
| |
| y1, y2 = P.ylim() |
| if y2 > 15: |
| y2 = 15 |
| P.ylim(-3, y2) |
| |
| class FilterTrace: |
| def __init__(self): |
| self.filename = "" |
| self.compiled_regexp = [] |
| self.pid_names = {} |
| self.timestamp_start_b = 0 # start boundary in tick |
| self.timestamp_end_b = 0 # stop boundary in tick |
| self.filename = "" # used to label figure |
| self.run_time = defaultdict(int) # run time per tid, computed on basis of 1 timeslice |
| # then reset |
| self.plotx = [] |
| self.ploty = [] |
| self.last_timestamp = 0 |
| self.label_enh = {} |
| |
| REGEXP_GLOSSARY = [ |
| # backup rule |
| ['^.*psel.*$', None], |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d+)\s+(?P<task_name>[\w \.#-_/]+):(?P<tid>-?\d+)' \ |
| '\s+(?P<state>\w+)\s+(?P<duration>\d+).*$', |
| self.callback_context_switch |
| ], |
| # End |
| ['^Last timestamp:\s*(?P<last_timestamp>\d+).*$', self.callback_end], |
| ['^Ref timestamp:\s*(?P<ref_time>\d+)$', self.callback_reference_timestamp], |
| ['^.*$', self.callback_no_rule] |
| ] |
| |
| # Compile all regexp |
| for regexp_string, regexp_rules in REGEXP_GLOSSARY: |
| self.compiled_regexp.append([re.compile(regexp_string), regexp_rules]) |
| |
| def filter_line(self, line, line_number): |
| # Parse all regexps |
| for regexp, regexp_rules in self.compiled_regexp: |
| # Test if regexp matches |
| res = regexp.search(line) |
| # if regexp match |
| if res: |
| # Execute regexp_rules |
| if regexp_rules: |
| regexp_rules(res, line, line_number) |
| # Only one regexp per line |
| break |
| |
| def callback_context_switch(self, res, line, line_number): |
| ts = int(res.group('timestamp')) |
| timestamp = ref_ts.convert_t32k_offset(ts) |
| |
| if (timestamp < self.timestamp_start_b) or (timestamp > self.timestamp_end_b): |
| return |
| |
| # only update on running processes |
| if (res.group('state') != 'R'): |
| return |
| |
| # before start but eventually timestamp + duration crosses boundary |
| duration = ref_ts.convert_t32k_absolute(int(res.group('duration'))) |
| |
| cpu_id = int(res.group('cpu_id')) |
| |
| if (cpu_id + 1) > len(self.plotx): |
| for i in range(0, cpu_id + 1 - len(self.plotx)): |
| self.plotx.append([]) |
| self.ploty.append([]) |
| |
| run_tid = int(res.group('tid')) |
| self.pid_names[run_tid] = res.group('task_name').rstrip(' ') + ":" + "%d" % run_tid |
| self.run_time[run_tid] += duration |
| self.plotx[cpu_id] += [timestamp, timestamp + duration] |
| self.ploty[cpu_id] += [run_tid, run_tid] |
| |
| |
| def callback_no_rule(self, res, line, line_number): |
| return |
| |
| def callback_end(self, res, line, line_number): |
| ts = int(res.group('last_timestamp')) |
| self.last_timestamp = ref_ts.convert_t32k_offset(ts) |
| |
| def callback_reference_timestamp(self, res, line, line_number): |
| ref_ts.set_32k_offset(int(res.group('ref_time'))) |
| |
| # goal is to keep only some contributors in their contribution order then put rest as |
| # others then tid 0 |
| def draw(self): |
| ploty_final = [] |
| plot_conv = {} |
| count = 2 |
| for i in range(0, len(self.plotx)): |
| ploty_final.append([]) |
| plot_conv[-i] = -i |
| |
| items = self.run_time.items() |
| items.sort(key = itemgetter(1), reverse=True) |
| |
| # class pirocesses, <= 0 at bottom then up by order of frequence |
| plot_conv[1] = 1 |
| plot_conv[0] = 0 |
| for run_tid, duration in items: |
| if run_tid > 1: |
| plot_conv[run_tid] = count |
| count += 1 |
| |
| # prepare y axe. <= 0 do not move, other processes are classified |
| |
| for i in range(0, len(self.plotx)): |
| for run_tid in self.ploty[i]: |
| ploty_final[i].append(plot_conv[run_tid]) |
| |
| ticks_pos = [] |
| ticks_names = [] |
| for key, value in self.pid_names.items(): |
| ticks_pos.append(plot_conv[key]) |
| ticks_names.append(value) |
| colors = [ 'blue', 'green', 'magenta', 'cyan', 'brown', 'orange' ] |
| |
| for i in range(0, len(self.plotx)): |
| P.plot(self.plotx[i], ploty_final[i], colors[i]) |
| |
| P.yticks(ticks_pos, ticks_names) |
| P.ylabel('Running threads') |
| P.title(self.filename) |
| |
| y1, y2 = P.ylim() |
| if y2 > 30: |
| y2 = 30 |
| P.ylim(-3, y2) |
| |
| P.gca().grid(True, linestyle=':', color='Grey') |
| |
| class FilterTrace_ts: |
| def __init__(self): |
| self.compiled_regexp_pre = [] |
| self.compiled_regexp = [] |
| self.pid_names = {} |
| self.pid_state = {} |
| self.timestamp_start_b = 0 # start boundary in ms |
| self.timestamp_end_b = 0 # stop boundary in ms |
| self.timeslice_ms = 0 # timeslice duration in ms |
| self.plots = {} # all run-time per tid and timeslice |
| self.leftstamp = [] # left of histograms |
| self.widthslices = [] # width of histogram |
| self.countplots = 0 # exact number of bars to trace TODO is it not size of plots ? |
| self.filename = "" # used to label figure |
| self.run_time = defaultdict(int) # run time per tid, computed on basis of 1 timeslice |
| # then reset |
| self.timestamp_end = 0 # end of current timeslice in tick |
| self.ref_time = 0 |
| self.num_of_cores = 0 |
| self.previous_timestamp = 0 |
| self.durationperfreq = [] |
| self.mhz = False |
| |
| REGEXP_GLOSSARY_PRE = [ |
| # backup rule |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d+)\s+(?P<task_name>[\w \.#-_/]+):(?P<tid>-?\d+)' \ |
| '\s+(?P<state>\w+)\s+(?P<duration>\d+).*$', |
| self.callback_context_switch_pre |
| ], |
| ['^.*$', self.callback_no_rule] |
| ] |
| |
| REGEXP_GLOSSARY = [ |
| # backup rule |
| ['^.*psel.*$', None], |
| ['^(?P<timestamp>\d+)\s+(?P<cpu_id>\d+)\s+(?P<task_name>[\w \.#-_/]+):(?P<tid>-?\d+)' \ |
| '\s+(?P<state>\w+)\s+(?P<duration>\d+).*$', |
| self.callback_context_switch |
| ], |
| ['^Last timestamp:\s*(?P<last_timestamp>\d+).*$', self.callback_end], |
| ['^Last timestamp:\s*(?P<last_timestamp>\d+).*$', self.callback_end], |
| ['^Ref timestamp:\s*(?P<ref_time>\d+)$', self.callback_reference_timestamp], |
| ['^.*$', self.callback_no_rule] |
| ] |
| |
| # Compile all regexp |
| for regexp_string, regexp_rules in REGEXP_GLOSSARY_PRE: |
| self.compiled_regexp_pre.append([re.compile(regexp_string), regexp_rules]) |
| for regexp_string, regexp_rules in REGEXP_GLOSSARY: |
| self.compiled_regexp.append([re.compile(regexp_string), regexp_rules]) |
| |
| def filter_line_pre(self, line, line_number): |
| # Parse all regexps |
| for regexp, regexp_rules in self.compiled_regexp_pre: |
| # Test if regexp matches |
| res = regexp.search(line) |
| # if regexp match |
| if res: |
| # Execute regexp_rules |
| if regexp_rules: |
| regexp_rules(res, line, line_number) |
| # Only one regexp per line |
| break |
| |
| def filter_line(self, line, line_number): |
| # Parse all regexps |
| for regexp, regexp_rules in self.compiled_regexp: |
| # Test if regexp matches |
| res = regexp.search(line) |
| # if regexp match |
| if res: |
| # Execute regexp_rules |
| if regexp_rules: |
| regexp_rules(res, line, line_number) |
| # Only one regexp per line |
| break |
| |
| def callback_context_switch_pre(self, res, line, line_number): |
| cpu_id = int(res.group('cpu_id')) |
| if (cpu_id + 1 > self.num_of_cores): |
| self.num_of_cores = cpu_id + 1 |
| #print("Found %d core(s)") % (cpu_id + 1) |
| |
| def callback_context_switch(self, res, line, line_number): |
| if self.timestamp_start_b == 0: |
| self.timestamp_start_b = ref_ts.convert_t32k_offset(0) |
| |
| # 1st slice time |
| if (self.timestamp_end == 0): |
| self.timestamp_end = self.timestamp_start_b + self.timeslice_ms |
| self.previous_timestamp = self.timestamp_start_b |
| # pre-create idle tasks as others = num_of_cores - tids_to_draw - idle load |
| for i in range(0, self.num_of_cores): |
| self.plots[0 - i] = [] |
| self.pid_names[0 - i] = "main_task" |
| |
| timestamp = ref_ts.convert_t32k_offset(int(res.group('timestamp'))) |
| current_tid = int(res.group('tid')) |
| self.pid_names[current_tid] = res.group('task_name').rstrip(' ') |
| |
| # if process is seen for the 1st time, plots are missing.Add them set to 0 to draw histogram |
| if current_tid not in self.plots: |
| self.plots[current_tid] = [] |
| for i in range(0, self.countplots): |
| self.plots[current_tid].append(0) |
| |
| if (timestamp >= self.timestamp_end_b) or (timestamp < self.timestamp_start_b): # after end |
| if (res.group('state') != 'R'): |
| self.pid_state[current_tid] = 'S' |
| else: |
| self.pid_state[current_tid] = 'R' |
| |
| return |
| |
| # potentially conclude current slice and several other slices |
| while timestamp > self.timestamp_end: |
| # start by adding reamining time until timestamp_end |
| for tid in self.pid_state: |
| if self.pid_state[tid] == 'R': |
| self.run_time[tid] += self.timestamp_end - self.previous_timestamp |
| |
| # get only items contributing to this slice and sort them to display them by order of |
| # contribution |
| items = self.run_time.items() |
| items.sort(key = itemgetter(1), reverse=True) # inverse key and value to sort by value |
| |
| timestamp_start = self.timestamp_start_b + (self.countplots * self.timeslice_ms) |
| timeslice = self.timestamp_end - timestamp_start |
| |
| # update all thread with %, even if no contribution so as to plot them after (Note: if |
| # will create keys in run_time so do it before print of contributors) |
| for tid in self.plots: |
| self.plots[tid].append(self.run_time[tid] * 100.0 / timeslice) |
| self.widthslices.append(timeslice) |
| self.leftstamp.append(timestamp_start) |
| |
| # start next slice, start is timestamp_end and end is start + timeslice |
| self.run_time.clear() |
| self.countplots += 1 |
| self.previous_timestamp = self.timestamp_end |
| self.timestamp_end = self.timestamp_start_b + ((self.countplots + 1) * self.timeslice_ms) |
| |
| # accumulate running times from previous_timestamp to current_timestamp |
| for tid in self.pid_state: |
| if self.pid_state[tid] == 'R': |
| self.run_time[tid] += timestamp - self.previous_timestamp |
| |
| # current process state shall be updated |
| if (res.group('state') != 'R'): |
| self.pid_state[current_tid] = 'S' |
| else: |
| self.pid_state[current_tid] = 'R' |
| |
| # update previous_timestamp to current one |
| self.previous_timestamp = timestamp |
| |
| |
| def callback_reference_timestamp(self, res, line, line_number): |
| self.ref_time = int(res.group('ref_time')) |
| |
| def callback_no_rule(self, res, line, line_number): |
| return |
| |
| def callback_end(self, res, line, line_number): |
| return |
| |
| def draw(self): |
| |
| total_per_cpu = [] |
| x_val = [] |
| |
| for j in range(0, self.num_of_cores): |
| total_per_cpu.append([]) |
| |
| for i in range(0, self.countplots): |
| # Remove idle |
| for j in range(0, self.num_of_cores): |
| load = 100 - self.plots[0 - j][i] |
| |
| if self.mhz: |
| # Process average CPU clock speed |
| clock = filterMaster.getClock("MPU", self.leftstamp[i], |
| self.leftstamp[i] + self.timeslice_ms) |
| load *= clock / 100 |
| |
| # Append twice (stairs effect) |
| total_per_cpu[j].append(load) |
| total_per_cpu[j].append(load) |
| x_val.append(self.leftstamp[i]) |
| if i < (len(self.leftstamp) -1): |
| x_val.append(self.leftstamp[i+1]) |
| else: |
| x_val.append(self.leftstamp[i] + self.timeslice_ms) |
| |
| colors = [ 'blue', 'green', 'magenta', 'cyan', 'brown', 'orange' ] |
| |
| for j in range(0, self.num_of_cores): |
| P.plot(x_val, total_per_cpu[j], colors[j], label='CPU'+str(j)) |
| |
| if self.mhz: |
| P.ylabel('CPU load (MHz per core)') |
| else: |
| P.yticks([0, 20, 40, 60, 80, 100]) |
| P.ylim(-10, 110) |
| P.ylabel('CPU load (% per core)') |
| |
| P.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=self.num_of_cores, mode="expand", |
| borderaxespad=0., prop={'size':11}) |
| P.gca().grid(True) |
| |
| |
| global filterMaster |
| filterMaster = FilterTrace() |
| |
| global filterMaster_ts |
| filterMaster_ts = FilterTrace_ts() |
| |
| global irqTrace |
| irqTrace = IRQTrace() |
| |
| def Main(argv): |
| |
| line_number = 0 |
| |
| usage = "Usage: %prog FILENAME [options]" |
| parser = OptionParser(usage = usage) |
| parser.add_option("-s", "--start", action="store", type="int", dest="start", default=0, |
| help="Start time of analysis in ms") |
| parser.add_option("-e", "--end", action="store", type="int", dest="end", default=1000000000, |
| help="End time of analysis in ms") |
| parser.add_option("-c", "--core", action="store", type="int", dest="num_of_cores", default=0, |
| help="Number of cores, default is 0, i.e. tool automatically tries to " \ |
| "identify num of cores, can fail if 1 core stays in Idle") |
| parser.add_option("", "--norun", action="store_false", dest="running_threads_plot", |
| default=True, |
| help="Disable graph displaying running threads") |
| parser.add_option("", "--nocoreload", action="store_false", dest="load_per_core_plot", |
| default=True, |
| help="Disable graph displaying CPU load per core") |
| parser.add_option("", "--noirq", action="store_false", dest="irq_plot", default=True, |
| help="Disable graph displaying IRQs") |
| parser.add_option("-t", "--timeslice", action="store", type="int", dest="timeslice", |
| default=150, help="Timeslice in ms for CPU load per core plot, default 150") |
| parser.add_option("", "--tsref", action="store", type="str", dest="timestamp_file", default="", |
| help="Use timestamp alignment file") |
| parser.add_option("", "--mhz", action="store_true", dest="cpu_mhz", default=False, |
| help="CPU load per core in MHz") |
| |
| (options, args) = parser.parse_args() |
| |
| if len(args) != 1: |
| print "Usage: type python <program>.py -h" |
| return |
| |
| filterMaster.timestamp_start_b = int(options.start) |
| filterMaster.timestamp_end_b = int(options.end) |
| |
| if str(options.timestamp_file): |
| if timestamp_ref_module: |
| ref_ts.set_file(str(options.timestamp_file)) |
| else: |
| print "\'timestamp_ref\' module not found: \'--tsref\' discarded" |
| |
| filterMaster_ts.timestamp_start_b = int(options.start) |
| filterMaster_ts.timestamp_end_b = int(options.end) |
| filterMaster_ts.timeslice_ms = options.timeslice |
| filterMaster_ts.num_of_cores = options.num_of_cores |
| filterMaster_ts.mhz = options.cpu_mhz |
| |
| irqTrace.timestamp_start_b = int(options.start) |
| irqTrace.timestamp_end_b = int(options.end) |
| |
| # CPU load detailed diagram |
| ########################### |
| |
| file = open(args[0], 'r') |
| string = file.readline() |
| |
| # search for regexp |
| while (string ): |
| line_number += 1 |
| filterMaster.filter_line(string, line_number) |
| string = file.readline() |
| file.close() |
| |
| # CPU load per core |
| ################### |
| |
| if options.load_per_core_plot: |
| file = open(args[0], 'r') |
| line_number = 0 |
| string = file.readline() |
| |
| # search num of cores |
| if (filterMaster_ts.num_of_cores == 0): |
| while (string): |
| filterMaster_ts.filter_line_pre(string, line_number) |
| string = file.readline() |
| |
| file.close() |
| |
| # search for regexp |
| file = open(args[0], 'r') |
| line_number = 0 |
| string = file.readline() |
| |
| while (string): |
| line_number += 1 |
| filterMaster_ts.filter_line(string, line_number) |
| string = file.readline() |
| |
| file.close() |
| |
| # IRQ diagram |
| ############# |
| |
| if options.irq_plot: |
| file = open(args[0], 'r') |
| string = file.readline() |
| |
| # search for regexp |
| while (string ): |
| line_number += 1 |
| irqTrace.filter_line(string, line_number) |
| string = file.readline() |
| file.close() |
| |
| # Display |
| ######### |
| |
| #Update label size for Y axis for all charts |
| matplotlib.rc('ytick', labelsize=10) |
| |
| bottom_margin = 0.05 |
| margin = 0.03 |
| first_graph = None |
| |
| ############################################################# |
| # Window 1: MPU Thread/IRQ execution # |
| ############################################################# |
| win1_num_plot = [] |
| if options.running_threads_plot: |
| win1_num_plot.append(2) |
| if options.irq_plot: |
| win1_num_plot.append(1) |
| |
| current_vert = 1 - margin |
| current_plot = 0 |
| |
| if len(win1_num_plot) > 0: |
| left_margin = 0.2 |
| win1_vert_size = ((1 - bottom_margin - len(win1_num_plot) * margin) / sum(win1_num_plot)) |
| |
| |
| fig1 = P.figure() |
| |
| if options.running_threads_plot: |
| current_vert -= win1_vert_size * win1_num_plot[current_plot] |
| gr = P.axes([left_margin, current_vert, 1-(margin + left_margin), |
| win1_vert_size * win1_num_plot[current_plot]]) |
| current_vert -= margin |
| current_plot += 1 |
| if (first_graph == None): |
| first_graph = gr |
| filterMaster.draw() |
| |
| if options.irq_plot: |
| current_vert -= win1_vert_size * win1_num_plot[current_plot] |
| gr = P.axes([left_margin, current_vert, 1-(margin + left_margin), |
| win1_vert_size * win1_num_plot[current_plot]], sharex = first_graph) |
| current_vert -= margin |
| current_plot += 1 |
| if (first_graph == None): |
| first_graph = gr |
| irqTrace.draw() |
| |
| P.xlabel('time (ms)') |
| |
| root1 = Tk.Tk() |
| root1.title(string="MPU Thread/IRQ execution (" + args[0] + ")") |
| canvas1 = FigureCanvasTkAgg(fig1, master=root1) |
| canvas1.show() |
| canvas1.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) |
| toolbar1 = NavigationToolbar2TkAgg( canvas1, root1 ) |
| toolbar1.update() |
| canvas1._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) |
| |
| |
| ############################################################# |
| # Window 2: MPU load # |
| ############################################################# |
| win2_num_plot = [] |
| cpu_label_margin = 0.05 |
| |
| if options.load_per_core_plot: |
| win2_num_plot.append(1) |
| |
| current_vert = 1 - margin |
| current_plot = 0 |
| |
| |
| if len(win2_num_plot) > 0: |
| left_margin = 0.2 |
| win2_vert_size = ((1 - bottom_margin - len(win2_num_plot) * margin) / sum(win2_num_plot)) |
| fig2 = P.figure() |
| |
| if options.load_per_core_plot: |
| current_vert -= win2_vert_size * win2_num_plot[current_plot] |
| gr = P.axes([left_margin, current_vert, 1-(margin + left_margin), |
| (win2_vert_size - cpu_label_margin) * win2_num_plot[current_plot]], |
| sharex = first_graph) |
| current_vert -= margin |
| current_plot += 1 |
| if (first_graph == None): |
| first_graph = gr |
| filterMaster_ts.draw() |
| |
| P.xlabel('time (ms)') |
| |
| if len(win1_num_plot) > 0: |
| root2 = Tk.Toplevel(root1) |
| else: |
| root2 = Tk.Tk() |
| |
| root2.title(string="MPU load (" + args[0] + ")") |
| canvas2 = FigureCanvasTkAgg(fig2, master=root2) |
| canvas2.show() |
| canvas2.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) |
| toolbar2 = NavigationToolbar2TkAgg( canvas2, root2 ) |
| toolbar2.update() |
| canvas2._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) |
| |
| ############################################################# |
| |
| if len(win1_num_plot) > 0: |
| root = root1 |
| else: |
| root = root2 |
| |
| def _quit(): |
| root.quit() # stops mainloop |
| root.destroy() # this is necessary on Windows to prevent |
| # Fatal Python Error: PyEval_RestoreThread: NULL tstate |
| |
| root.protocol("WM_DELETE_WINDOW", _quit) |
| root.mainloop() |
| |
| |
| if __name__=="__main__": |
| Main(sys.argv[1:]) |
