def _do_process_fired(self):
def stop_process():
progress.update(max_t)
self.is_processing = False
progress.close()
self.is_processing = True
self.init()
max_t = len(self.filenames)
progress = ProgressDialog(title="progress",
message="Processing... ",
max=max_t,
show_time=True,
can_cancel=True)
progress.open()
try:
for i, image in enumerate(self):
(cont, skip) = progress.update(i)
self.process(image, i)
if not cont or skip:
break
except Exception as e:
self.error = error_to_str(e)
raise e
finally:
stop_process()
self.post_process()
def run(self, progressbar=True):
consts_c, vars_c = self.get_constraints()
type_p, consts_p, vars_p = self.get_parameters()
# confirm that we are in good state
avl = self.runcase.avl
avl.sendline()
avl.expect(AVL.patterns['/'])
avl.sendline('oper')
avl.expect(AVL.patterns['/oper'])
# first set the constants once and for all
# constraints
for c, v in consts_c.iteritems():
avl.sendline(c.format(eval(v)))
# paramters
avl.sendline(type_p)
for p, v in consts_p.iteritems():
avl.sendline(p.format(eval(v)))
avl.sendline()
avl.sendline()
avl.expect(AVL.patterns['/'])
outs, modes, matrices = [], [], []
# now run the case and get output while changing the vars each time
if progressbar:
progress = ProgressDialog(title="progress",
message="calculating...",
max=self.runcase_config.x.shape[0],
show_time=True,
can_cancel=True)
try:
progress.open()
except Exception, e:
logger.warning(e)
def task_func(t):
progress = ProgressDialog(title="progress",
message="counting to %d" % t,
max=t,
show_time=True,
can_cancel=True)
progress.open()
for i in range(0, t + 1):
time.sleep(1)
print i
(cont, skip) = progress.update(i)
if not cont or skip:
break
progress.update(t)
def parse_ftrace(filename,callback):
fid = ftrace_open(filename)
progress = ProgressDialog(title="ftrace", message="loading %s..."%(os.path.basename(filename)), max=100, show_time=True, can_cancel=True)
progress.open()
try:
fid.seek(0,2)
except ValueError:
# gzip do not support seek end
# do we uncompress everything. :-/
# parsing is already far slower than uncompressing.
while fid.read(1024):
pass
totsize = fid.tell()
fid.seek(0,0)
last_percent = 0
# the base regular expressions
event_re = re.compile(
r'\s*(.+)-([0-9]+)\s+\[([0-9]+)\][^:]*\s+([0-9.]+): ([^:]*): (.*)')
function_re = re.compile(
r'\s*(.+)-([0-9]+)\s+\[([0-9]+)\][^:]*\s+([0-9.]+): (.*) <-(.*)')
last_timestamp = 0
linenumber = 0
for line in fid:
percent = int(fid.tell()*100./totsize)
if percent != last_percent:
last_percent = percent
(cont, skip) = progress.update(percent)
if not cont or skip:
break
linenumber+=1
line = line.rstrip()
res = event_re.match(line)
if res:
groups = res.groups()
event_name = groups[4]
event = {
'linenumber': linenumber,
'common_comm' : groups[0],
'common_pid' : int(groups[1]),
'common_cpu' : int(groups[2]),
'timestamp' : int(float(groups[3])*1000000),
'event' : event_name,
'event_arg' : groups[5]
}
last_timestamp = event['timestamp']
to_match = event['event_arg']
try:
for name,regex,func in events_re[event_name]:
res = regex.search(to_match)
if res:
func(event,res.groups())
except KeyError:
pass
callback(Event(event))
continue
res = function_re.match(line)
if res:
event = {
'linenumber': linenumber,
'common_comm' : res.group(1),
'common_pid' : int(res.group(2)),
'common_cpu' : int(res.group(3)),
'timestamp' : int(float(res.group(4))*1000000),
'event':'function',
'callee' : res.group(5),
'caller' : res.group(6)
}
callback(Event(event))
continue
fid.close()
def finish_parsing(self):
#put generated data in unresizable numpy format
c_states = []
i = 0
for tc in self.tmp_c_states:
t = tcIdleState(name='cpu%d' % (i))
while len(tc['start_ts']) > len(tc['end_ts']):
tc['end_ts'].append(tc['start_ts'][-1])
t.start_ts = numpy.array(tc['start_ts'])
t.end_ts = numpy.array(tc['end_ts'])
t.types = numpy.array(tc['types'])
c_states.append(t)
i += 1
self.c_states = c_states
i = 0
p_states = []
for tc in self.tmp_p_states:
t = tcFrequencyState(name='cpu%d' % (i))
t.start_ts = numpy.array(tc['start_ts'])
t.end_ts = numpy.array(tc['end_ts'])
t.types = numpy.array(tc['types'])
i += 1
p_states.append(t)
self.wake_events = numpy.array(self.wake_events,
dtype=[('waker', tuple),
('wakee', tuple),
('time', 'uint64')])
self.p_states = p_states
processes = []
last_ts = 0
for pid, comm in self.tmp_process:
tc = self.tmp_process[pid, comm]
if len(tc['end_ts']) > 0 and last_ts < tc['end_ts'][-1]:
last_ts = tc['end_ts'][-1]
if len(self.tmp_process) > 0:
progress = ProgressDialog(title="precomputing data",
message="precomputing overview data...",
max=len(self.tmp_process),
show_time=False,
can_cancel=False)
progress.open()
i = 0
for pid, comm in self.tmp_process:
tc = self.tmp_process[pid, comm]
if self.process_types.has_key(tc['type']):
klass, order = self.process_types[tc['type']]
t = klass(pid=pid, comm=tc['comm'], project=self)
else:
t = tcProcess(pid=pid, comm=comm, project=self)
while len(tc['start_ts']) > len(tc['end_ts']):
tc['end_ts'].append(last_ts)
t.start_ts = numpy.array(tc['start_ts'])
t.end_ts = numpy.array(tc['end_ts'])
t.types = numpy.array(tc['types'])
t.cpus = numpy.array(tc['cpus'])
t.comments = tc['comments'] #numpy.array(tc['comments'])
t.process_type = tc["type"]
# precompute 16 levels of overview cache
t.get_overview_ts(1 << 16)
processes.append(t)
progress.update(i)
i += 1
if len(self.tmp_process) > 0:
progress.close()
self.tmp_process = []
def cmp_process(x, y):
# sort process by type, pid, comm
def type_index(t):
try:
return self.process_types[t][1]
except ValueError:
return len(order) + 1
c = cmp(type_index(x.process_type), type_index(y.process_type))
if c != 0:
return c
c = cmp(x.pid, y.pid)
if c != 0:
return c
c = cmp(x.comm, y.comm)
return c
processes.sort(cmp_process)
self.processes = processes
self.p_states = p_states
self.tmp_c_states = []
self.tmp_p_states = []
self.tmp_process = {}