def replay(self):
lines = open(self.replay_file).read().strip().split('\n')
succ_cnt = 0
replay_cnt = 0
for i in xrange(self.retry_count):
logger.info("=== try No. %d ===" % i)
log.clear()
self.replay_lines(lines)
replay_cnt += 1
if self.target:
target_buginfo = self.get_target_info()
logger.info("target bug to replay: " + buglib.get_bug_info(target_buginfo))
if self.check_target(target_buginfo):
logger.info("successfully replayed the bug at retry %d" % i)
succ_cnt += 1
if not self.cont_after_succ:
break
else:
logger.info("failed to replay the bug")
else:
logger.info("no replay target specified. maybe succeeded")
break
logger.info("=== succ count / replay count / retry count: %d/%d/%d" % (succ_cnt, replay_cnt, self.retry_count))
def check_target(self, target):
if not log.get_log_file():
return False
bugs = buglib.collect([log.get_log_file()])
for bug in bugs:
logger.debug("bug found: " + buglib.get_bug_info(bug))
if buglib.same_bug(bug, target):
return True
return False
def simplify(self, simplify_result):
lines = open(self.replay_file).read().strip().split('\n')
target_buginfo = self.get_target_info()
if not target_buginfo:
logger.error("please specify target when doing simplification")
return
logger.info("target bug: " + buglib.get_bug_info(target_buginfo))
# split lines into "events"
events = self.lines_to_events(lines)
orig_events = len(events)
logger.info("== initial events: ==")
self.dump_events(events)
acts = set()
for event in events:
event.realize()
acts = event.parse_act_info(acts)
events = self.adv_simp(events, target_buginfo, True)
events = self.adv_simp(events, target_buginfo, False)
# first, try to remove single elements
i = 0
while i < len(events):
if not events[i].may_remove:
i += 1
continue
if events[i].need_fake():
events[i].set_fake(True)
removed = events[i]
else:
removed = events.pop(i)
logger.info("trying to remove event %d/%d: %s" % (i, len(events), removed.get_desc()))
succ = self.try_to_replay(events, target_buginfo)
if succ:
# yes! we can remove it!
logger.info("successfully removed it")
self.save_simplify_result(events, simplify_result)
if removed.need_fake():
i += 1
else:
# no... keep it
logger.info("keep it")
if removed.need_fake():
events[i].set_fake(False)
else:
events.insert(i, removed)
i += 1
# second: try to remove loop in the state graph
logger.info("== events after first step: ==")
self.dump_events(events)
self.save_simplify_result(events, simplify_result)
logger.info("== get states for loop detection/removal ==")
states = self.get_states(events)
logger.info("== loop detection/removal ==")
self.sel_events = []
self.sel_states = []
i = 0
while i < len(events):
logger.debug("= trying to check event %d =" % i)
state = states[i]
state_poses = self.find_state(state)
dont_add = False
if events[i].may_remove and state_poses and not events[i].is_fake():
logger.debug("= state duplication at: %r =" % state_poses)
# state repeated
for state_pos in state_poses:
tmp_event_ids = self.sel_events[:state_pos + 1] + range(i+1, len(events))
tmp_events = self.pickup_events(events, tmp_event_ids)
succ = self.try_to_replay(tmp_events, target_buginfo)
if succ:
# yes! let's remove it!
logger.debug("= after event %d, selected state %d duplicated. =" % (i, state_pos))
logger.debug("= remove loop from %d to %d =" % (state_pos + 1, len(self.sel_states) - 1))
for j in xrange(state_pos + 1, len(self.sel_states)):
self.remove_state(self.sel_states[j], j)
self.sel_states = self.sel_states[:state_pos + 1]
self.sel_events = self.sel_events[:state_pos + 1]
dont_add = True
break
else:
# we should not remove it
pass
if not dont_add and not events[i].is_fake():
# record new state & event
self.record_state(state, len(self.sel_states))
self.sel_states += [state]
self.sel_events += [i]
i += 1
events = self.pickup_events(events, self.sel_events)
logger.info("== events after second step: ==")
self.dump_events(events)
logger.info("simplification finished!")
logger.info("before / after simplification: %d / %d" % (orig_events, self.get_nofake_len(events)))
self.save_simplify_result(events, simplify_result)
