// moved this to aftermove so xinertia on treads is already applied // when we calculate the main object position. void XBoss::RunAftermove() { Object *o = mainobject; int i; if (!mainobject || mainobject->state == 0 || !X.initilized) return; // main object pulled along as treads move int tread_center = (treads[UL]->x + treads[UR]->x + \ treads[LL]->x + treads[LR]->x) / 4; o->x += (tread_center - o->x) / 16; run_internals(); for(i=0;i<4;i++) { run_body(i); run_target(i); } for(i=0;i<2;i++) { run_door(i); } }
int main(int argc, char** argv) { pid_t child_pid; if (argc < 2) { fprintf(stderr, "Expected a program name as argument\n"); return -1; } child_pid = fork(); if (child_pid == 0) run_target(argv[1]); else if (child_pid > 0) run_debugger(child_pid); else { perror("fork"); return -1; } return 0; }
int main(int argc, char**argv) { pid_t child_pid; if(argc < 2){ fprintf(stderr, "Expected a program address\n"); return -1; } child_pid = fork(); if(child_pid == 0) { run_target(argv[1]); } else if (child_pid > 0) { run_debugger(child_pid); } else { perror("fork error\n"); return -1; } return 0; }
int main(int argc, char** argv) { /* Equation eq; eq.theta0 = -1; eq.theta[0] = 2; Equation eq1; eq.roundoff(eq1); std::cout << eq << std::endl; std::cout << eq1 << std::endl; return 0; */ if (argc < 1) { std::cout << "Arguments less than 2.\n"; exit(-1); } if (argc >= 3) { minv = atoi(argv[1]); maxv = atoi(argv[2]); } Solution inputs; init_gsets(); srand(time(NULL)); // initialize seed for rand() function int rnd; bool b_similar_last_time = false; bool b_converged = false; bool b_svm_i = false; Equation* p = NULL; int pre_positive_size = 0, pre_negative_size = 0; // , pre_question_size = 0; //int cur_positive_size = 0, cur_negative_size = 0; // , cur_question_size = 0; //Start SVM training SVM* svm = new SVM(print_null); //svm->problem.x = (svm_node**)(training_set); //svm->problem.y = training_label; for (rnd = 1; rnd <= max_iter; rnd++) { svm->main_equation = NULL; init_svm: std::cout << "[" << rnd << "]SVM-----------------------------------------------" << "-------------------------------------------------------------" << std::endl; if (rnd == 1) { /* * The first round is very special, so we put this round apart with its following rounds. * 1> We used random values as inputs for program executions in the first round. * 2> We need to make sure there are at last two classes of generated traces. "positive" and "negative" */ std::cout << "\t(1) execute programs... [" << init_exes + random_exes << "] {"; for (int i = 0; i < init_exes + random_exes; i++) { Equation::linearSolver(NULL, inputs); std::cout << inputs; if (i < init_exes + random_exes - 1) std::cout << "|"; run_target(inputs); } std::cout << "}" << std::endl; if (gsets[POSITIVE].traces_num() == 0 || gsets[NEGATIVE].traces_num() == 0) { if (gsets[POSITIVE].traces_num() == 0) std::cout << "[0] Positive trace, execute program again." << std::endl; if (gsets[NEGATIVE].traces_num() == 0) std::cout << "[0] Negative trace, execute program again." << std::endl; goto init_svm; } } else { std::cout << "\t(1) execute programs...[" << after_exes + random_exes << "] {"; for (int i = 0; i < random_exes; i++) { Equation::linearSolver(NULL, inputs); std::cout << inputs; std::cout << " | "; run_target(inputs); } for (int i = 0; i < after_exes; i++) { Equation::linearSolver(p, inputs); std::cout << " | " << inputs; run_target(inputs); } std::cout << "}" << std::endl; } std::cout << "\t(2) prepare training data... "; svm->prepare_training_data(gsets, pre_positive_size, pre_negative_size); std::cout << std::endl; std::cout << "\t(3) start training... "; svm->train(); std::cout << "|-->> "; set_console_color(std::cout); std::cout << *svm << std::endl; unset_console_color(std::cout); /* * check on its own training data. * There should be no prediction errors. */ std::cout << "\t(4) checking training traces."; double passRat = svm->predict_on_training_set(); std::cout << " [" << passRat * 100 << "%]"; if (passRat < 1) { std::cout << " [FAIL] \n The problem is not linear separable.. Trying to solve is by SVM-I algo" << std::endl; if (p != NULL) { Equation* tmp = svm->main_equation; svm->main_equation = p; double passRat = svm->predict_on_training_set(); std::cout << " last divide: " << *p << " accuracy[" << passRat * 100 << "%]\n"; svm->main_equation = tmp; } std::cerr << "*******************************USING SVM_I NOW******************************" << std::endl; b_svm_i = true; break; } std::cout << " [PASS]" << std::endl; /* * Check on Question traces. * There should not exists one traces, in which a negative state is behind a positive state. */ std::cout << "\t(5) checking question traces."; set_console_color(std::cout, RED); if (svm->check_question_set(gsets[QUESTION]) != 0) { std::cout << std::endl << "check on question set return error." << std::endl; unset_console_color(std::cout); return -1; } unset_console_color(std::cout); std::cout << std::endl; /* * b_similar_last_time is used to store the convergence check return value for the last time. * We only admit convergence if the three consecutive round are converged. * This is to prevent in some round the points are too right to adjust the classifier. */ std::cout << "\t(6) check convergence: "; if (svm->main_equation->is_similar(p) == 0) { if (b_similar_last_time == true) { std::cout << "[TT] [SUCCESS] rounding off" << std::endl; b_converged = true; break; } std::cout << "[FT]"; b_similar_last_time = true; } else { std::cout << ((b_similar_last_time == true) ? "[T" : "[F") << "F] "; b_similar_last_time = false; } std::cout << " [FAIL] neXt round " << std::endl; if (p != NULL) { delete p; } p = svm->main_equation; } // end of SVM training procedure if ((b_converged) || (rnd >= max_iter)) { std::cout << "-------------------------------------------------------" << "-------------------------------------------------------------" << std::endl; std::cout << "finish running svm for " << rnd << " times." << std::endl; int equation_num = -1; Equation* equs = svm->roundoff(equation_num); assert(equation_num == 1); set_console_color(std::cout); if (b_converged) std::cout << " Hypothesis Invairant(Converged): {\n"; else std::cout << " Hypothesis Invairant(Reaching Maximium Iteration): {\n"; std::cout << "\t\t" << equs[0] << std::endl; std::cout << " }" << std::endl; unset_console_color(std::cout); delete[]equs; delete p; delete svm->main_equation; delete svm; return 0; } if (p == NULL) { // get out svm in the first round, p has not been set yet p = svm->main_equation; } delete svm; b_similar_last_time = false; int pre_equation_num = 1; //start SVM_I training assert(b_svm_i == true); SVM_I* svm_i = new SVM_I(print_null, p); int svm_i_start = rnd; for (; rnd <= max_iter; rnd++) { // init_svm_i: std::cout << "[" << rnd << "]SVM-I---------------------------------------------" << "-------------------------------------------------------------" << std::endl; if (rnd != svm_i_start) { int exes_each_equation = (after_exes + pre_equation_num - 1) / pre_equation_num; std::cout << "\t(1) execute programs...[" << exes_each_equation * pre_equation_num + random_exes << "] {"; for (int i = 0; i < random_exes; i++) { Equation::linearSolver(NULL, inputs); std::cout << inputs << " | "; run_target(inputs); } p = svm_i->main_equation; for (int j = 0; j < exes_each_equation; j++) { Equation::linearSolver(p, inputs); std::cout << " | " << inputs; run_target(inputs); } for (int i = 0; i < svm_i->equ_num; i++) { p = &(svm_i->equations[i]); for (int j = 0; j < exes_each_equation; j++) { Equation::linearSolver(p, inputs); std::cout << " | " << inputs; run_target(inputs); } } std::cout << "}" << std::endl; } else { pre_positive_size = 0; pre_negative_size = 0; } std::cout << "\t(2) prepare training data... "; svm_i->prepare_training_data(gsets, pre_positive_size, pre_negative_size); std::cout << std::endl; std::cout << "\t(3) start training... "; int ret = svm_i->train(); if (ret == -1) return -1; std::cout << svm_i->equ_num; std::cout << "|-->> "; set_console_color(std::cout); std::cout << *svm_i << std::endl; unset_console_color(std::cout); /* * check on its own training data. * There should be no prediction errors. */ std::cout << "\t(4) checking training traces."; double passRat = svm_i->predict_on_training_set(); std::cout << " [" << passRat * 100 << "%]"; if (passRat < 1) { set_console_color(std::cout, RED); std::cerr << "[FAIL] ..... Can not dividey by SVM_I." << std::endl; //std::cerr << "[FAIL] ..... Reaching maximium num of equation supported by SVM_I." << std::endl; //std::cerr << "You can increase the limit by modifying [classname::methodname]=SVM-I::SVM-I(..., int equ = **) " << std::endl; unset_console_color(std::cout); return -1; // b_svm_i = true; // break; } else { std::cout << " [PASS]" << std::endl; } /* * Check on Question traces. * There should not exists one traces, in which a negative state is behind a positive state. */ std::cout << "\t(5) checking question traces."; if (svm_i->check_question_set(gsets[QUESTION]) != 0) { std::cout << std::endl << "check on question set return error." << std::endl; return -1; } std::cout << std::endl; /* * b_similar_last_time is used to store the convergence check return value for the last time. * We only admit convergence if the three consecutive round are converged. * This is to prevent in some round the points are too right to adjust the classifier. */ std::cout << "\t(6) check convergence: "; if (pre_equation_num == svm_i->equ_num + 1) { if (b_similar_last_time == true) { std::cout << "[TT] [SUCCESS] rounding off" << std::endl; b_converged = true; break; } std::cout << "[FT]"; b_similar_last_time = true; } else { std::cout << ((b_similar_last_time == true) ? "[T" : "[F") << "F] "; b_similar_last_time = false; } std::cout << " [FAIL] neXt round " << std::endl; pre_equation_num = svm_i->equ_num + 1; std::cout << std::endl; } // end of SVM-I training procedure std::cout << "-------------------------------------------------------" << "-------------------------------------------------------------" << std::endl; std::cout << "finish running svm-I for " << rnd - svm_i_start << " times." << std::endl; int equation_num = -1; Equation* equs = svm_i->roundoff(equation_num); set_console_color(std::cout); std::cout << "Hypothesis Invairant: {\n"; std::cout << "\t " << equs[0] << std::endl; for (int i = 1; i < equation_num; i++) std::cout << "\t /\\ " << equs[i] << std::endl; std::cout << "}" << std::endl; unset_console_color(std::cout); delete[]equs; delete svm_i->main_equation; delete svm_i; return 0; }
int main(int argc, char** argv) { s32 opt; u8 mem_limit_given = 0, timeout_given = 0, qemu_mode = 0; u32 tcnt; char** use_argv; doc_path = access(DOC_PATH, F_OK) ? "docs" : DOC_PATH; while ((opt = getopt(argc,argv,"+o:m:t:A:eqZQ")) > 0) switch (opt) { case 'o': if (out_file) FATAL("Multiple -o options not supported"); out_file = optarg; break; case 'm': { u8 suffix = 'M'; if (mem_limit_given) FATAL("Multiple -m options not supported"); mem_limit_given = 1; if (!strcmp(optarg, "none")) { mem_limit = 0; break; } if (sscanf(optarg, "%llu%c", &mem_limit, &suffix) < 1 || optarg[0] == '-') FATAL("Bad syntax used for -m"); switch (suffix) { case 'T': mem_limit *= 1024 * 1024; break; case 'G': mem_limit *= 1024; break; case 'k': mem_limit /= 1024; break; case 'M': break; default: FATAL("Unsupported suffix or bad syntax for -m"); } if (mem_limit < 5) FATAL("Dangerously low value of -m"); if (sizeof(rlim_t) == 4 && mem_limit > 2000) FATAL("Value of -m out of range on 32-bit systems"); } break; case 't': if (timeout_given) FATAL("Multiple -t options not supported"); timeout_given = 1; if (strcmp(optarg, "none")) { exec_tmout = atoi(optarg); if (exec_tmout < 20 || optarg[0] == '-') FATAL("Dangerously low value of -t"); } break; case 'e': if (edges_only) FATAL("Multiple -e options not supported"); edges_only = 1; break; case 'q': if (quiet_mode) FATAL("Multiple -q options not supported"); quiet_mode = 1; break; case 'Z': /* This is an undocumented option to write data in the syntax expected by afl-cmin. Nobody else should have any use for this. */ cmin_mode = 1; quiet_mode = 1; break; case 'A': /* Another afl-cmin specific feature. */ at_file = optarg; break; case 'Q': if (qemu_mode) FATAL("Multiple -Q options not supported"); if (!mem_limit_given) mem_limit = MEM_LIMIT_QEMU; qemu_mode = 1; break; default: usage(argv[0]); } if (optind == argc || !out_file) usage(argv[0]); setup_shm(); setup_signal_handlers(); set_up_environment(); find_binary(argv[optind]); if (!quiet_mode) { show_banner(); ACTF("Executing '%s'...\n", target_path); } detect_file_args(argv + optind); if (qemu_mode) use_argv = get_qemu_argv(argv[0], argv + optind, argc - optind); else use_argv = argv + optind; run_target(use_argv); tcnt = write_results(); if (!quiet_mode) { if (!tcnt) FATAL("No instrumentation detected" cRST); OKF("Captured %u tuples in '%s'." cRST, tcnt, out_file); } exit(child_crashed * 2 + child_timed_out); }
int DifferentialEvolution::recombination(RunManagerAbstract &run_manager) { ostream &os = file_manager.rec_ofstream(); int best_run_idx = 0; ModelRun run_target(obj_func_ptr); ModelRun run_canidate(obj_func_ptr); Parameters tmp_pars_targ; Observations tmp_obs_targ; Parameters tmp_pars_can; Observations tmp_obs_can; best_phi = std::numeric_limits<double>::max(); int d = gen_1.get_nruns(); int n_good_runs_targ = gen_1.get_num_good_runs(); int n_good_runs_can = run_manager.get_num_good_runs(); double phi_sum_targ = 0.0; double phi_sum_can = 0.0; double phi_sum_new = 0.0; double phi_max_targ = 0.0; double phi_max_can = 0.0; double phi_max_new = 0.0; double phi_min_targ = std::numeric_limits<double>::max(); double phi_min_can = std::numeric_limits<double>::max(); double phi_min_new = std::numeric_limits<double>::max(); os << " population phi values:" << endl; os << " parent canidate" << endl; os << " id phi phi" << endl; os << " ---- --------- ---------" << endl; for (int i_run = 0; i_run < d; ++i_run) { double new_phi = std::numeric_limits<double>::max(); bool run_target_ok = gen_1.get_run(i_run, tmp_pars_targ, tmp_obs_targ); bool run_canidate_ok = run_manager.get_run(i_run, tmp_pars_can, tmp_obs_can); if (!run_canidate_ok && !run_target_ok) { //keep current target new_phi = std::numeric_limits<double>::max(); ++failed_runs_old; ++failed_runs_new; os << " " << left << setw(10) << i_run << setw(15) << "N/A" << setw(15) << "N/A"; os << endl; } else if (!run_canidate_ok) { //keep current target ++failed_runs_new; par_transform.model2ctl_ip(tmp_pars_targ); // compute phi run_target.update_ctl(tmp_pars_targ, tmp_obs_targ); double phi_target = run_target.get_phi(DynamicRegularization::get_unit_reg_instance()); phi_sum_targ += phi_target; phi_sum_new += phi_target; phi_min_targ = min(phi_min_targ, phi_target); phi_max_targ = max(phi_max_targ, phi_target); os << " " << left << setw(10) << i_run << setw(15) << phi_target << setw(15) << "N/A"; os << endl; } else if (!run_target_ok) { gen_1.update_run(i_run, tmp_pars_can, tmp_obs_can); // compute phi par_transform.model2ctl_ip(tmp_pars_can); run_canidate.update_ctl(tmp_pars_can, tmp_obs_can); new_phi = run_canidate.get_phi(DynamicRegularization::get_unit_reg_instance()); ++failed_runs_old; phi_sum_can += new_phi; phi_sum_new += new_phi; phi_min_can = min(phi_min_targ, new_phi); phi_max_can = max(phi_max_targ, new_phi); os << " " << left << setw(10) << i_run << setw(15) << "N/A" << setw(15) << new_phi; os << endl; } else { // process target parameters and observations par_transform.model2ctl_ip(tmp_pars_targ); run_target.update_ctl(tmp_pars_targ, tmp_obs_targ); double phi_target = run_target.get_phi(DynamicRegularization::get_unit_reg_instance()); //process canidate parameters and observations par_transform.model2ctl_ip(tmp_pars_can); run_canidate.update_ctl(tmp_pars_can, tmp_obs_can); double phi_canidate = run_canidate.get_phi(DynamicRegularization::get_unit_reg_instance()); new_phi = min(phi_target, phi_canidate); os << " " << left << setw(10) << i_run; os << setw(15) << phi_target; os << setw(15) << phi_canidate; os << endl; if (phi_canidate < phi_target) { gen_1.update_run(i_run, tmp_pars_can, tmp_obs_can); } phi_sum_targ += phi_target; phi_sum_can += phi_canidate; phi_sum_new += new_phi; phi_min_can = min(phi_min_can, phi_canidate); phi_max_can = max(phi_max_can, phi_canidate); phi_min_targ = min(phi_min_targ, phi_target); phi_max_targ = max(phi_max_targ, phi_target); } phi_min_new = min(phi_min_new, new_phi); phi_max_new = max(phi_max_new, new_phi); if (new_phi < best_phi) { best_phi = new_phi; best_run_idx = i_run; } } double phi_avg_targ = std::numeric_limits<double>::max(); double phi_avg_can = std::numeric_limits<double>::max(); double phi_avg_new = std::numeric_limits<double>::max(); int n_good_runs_new = gen_1.get_num_good_runs(); if (n_good_runs_targ > 0) { phi_avg_targ = phi_sum_targ / n_good_runs_targ; } if (n_good_runs_can > 0) { phi_avg_can = phi_sum_can / n_good_runs_can; } if (n_good_runs_new > 0) { phi_avg_new = phi_sum_new / n_good_runs_new; } write_run_summary(cout, n_good_runs_targ, phi_avg_targ, phi_min_targ, phi_max_targ, n_good_runs_can, phi_avg_can, phi_min_can, phi_max_can, n_good_runs_new, phi_avg_new, phi_min_new, phi_max_new); cout << endl; os << endl; write_run_summary(os, n_good_runs_targ, phi_avg_targ, phi_min_targ, phi_max_targ, n_good_runs_can, phi_avg_can, phi_min_can, phi_max_can, n_good_runs_new, phi_avg_new, phi_min_new, phi_max_new); os << endl; return best_run_idx; }