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)