Method fuzz_loop

src/fuzzer.rs:191–252

(&mut self)

    }

    pub fn fuzz_loop(&mut self) -> Result<()> {
        let mut logger = ProgramLogger::default();
        let initial_combination = rand_choose_combination(rand_comb_len());
        let mut prompt = if let Some(prompt) = load_prompt(&self.deopt) {
            prompt
        } else {
            Prompt::from_combination(initial_combination)
        };
        let mut loop_cnt = 0;
        let mut has_checked = false;

        self.sync_from_previous_state(&mut logger)?;

        loop {
            if self.is_converge() {
                break;
            }
            let programs = self.generate_until_n_success(&mut prompt, &mut logger)?;
            let is_stuck = self.is_stuck(programs.len());
            let mut has_new = false;
            for mut program in programs {
                self.deopt.save_succ_program(&program)?;
                let coverage = self.deopt.get_seed_coverage(program.id)?;
                let unique_branches = self.observer.has_unique_branch(&coverage);
                has_new = !unique_branches.is_empty();
                program.update_quality(unique_branches, &self.deopt)?;
                self.deopt.update_seed_queue(program, &coverage, has_new)?;
                self.observer.merge_coverage(&coverage);
            }
            if !get_config().disable_power_schedule {
                self.mutate_prompt(&mut prompt)?;
            } else {
                let new_comb = rand_choose_combination(config::DEFAULT_COMB_LEN);
                prompt = Prompt::from_combination(new_comb);
            }

            if has_new {
                self.quiet_round = 0;
            } else if !is_stuck {
                self.quiet_round += 1;
            }
            // As the corpus is also evolved, we recheck the seeds on the evolved corpus to eliminate the error programs that was not catched before.
            if self.should_recheck() && !has_checked {
                self.executor.recheck_seed(&mut self.deopt)?;
                self.observer.recompute_global_coverage()?;
                self.deopt.load_programs_from_seeds()?;
                has_checked = true;
                self.quiet_round = 0;
                crate::mutation::prompt_shuffle(&mut prompt);
            }
            loop_cnt += 1;
            logger.reset_round();
            log::info!(
                "[Mutate Loop]: loop: {loop_cnt}, quiet_round: {}, {}",
                self.quiet_round,
                self.observer.dump_global_states()
            );
        }