void sat_bruteforce(sat_t *sat) { state_t *state_best = state_init(sat->vars_cnt, STATE_ALL_0); state_t *state = state_init(sat->vars_cnt, STATE_ALL_0); sat_bruteforce_inner(sat, state, state_best, sat->vars_cnt); fprintf(stderr, "bf= %u ", cost_main(sat, state_best)); state_free(state); state_free(state_best); }
/* The real main loop of the Eruta engine. Most of the work happens in state.c, * and the main.rb script, though. */ int real_main(void) { Image * border = NULL; Image * sheet = NULL; Tileset * tileset = NULL; Tile * tile = NULL; State * state = NULL; Camera * camera = NULL; Tilepane * tilepane = NULL; Tilemap * map = NULL; Thing * actor = NULL; Tracker * tracker = NULL; Tracker * maptracker = NULL; Sprite * sprite = NULL; SpriteState * spritestate = NULL; AlpsShower shower; int actor_id = -1; int sprite_id = -1; int npc1_id = -1; int npc2_id = -1; React react; ALLEGRO_COLOR myblack = {0.0, 0.0, 0.0, 1.0}; state = state_alloc(); state_set(state); if((!(state)) || (!state_init(state, FALSE))) { perror(state_errmsg(state)); return 1; } alpsshower_init(&shower, state_camera(state), 100, 1.0, bevec(10.0, 10000.0)); /* Initializes the reactor, the game state is it's data. */ react_initempty(&react, state); react.keyboard_key_up = main_react_key_up; react.keyboard_key_down = main_react_key_down; puts_standard_path(ALLEGRO_EXENAME_PATH, "ALLEGRO_EXENAME_PATH:"); camera = state_camera(state); /* Finally initialize ruby and call the ruby startup function. */ rh_load_main(); callrb_on_start(); /* Main game loop, controlled by the State object. */ while(state_busy(state)) { Point spritenow = bevec(100, 120); react_poll(&react, state); alpsshower_update(&shower, state_frametime(state)); state_update(state); state_draw(state); /* alpsshower_draw(&shower, camera); */ state_flip_display(state); } state_done(state); state_free(state); return 0; }
/* Parse the given disk state and set a newly allocated state. On success, * return that state else NULL. */ static sr_state_t * disk_state_parse(const sr_disk_state_t *new_disk_state) { sr_state_t *new_state = state_new(default_fname, time(NULL)); tor_assert(new_disk_state); new_state->version = new_disk_state->Version; new_state->valid_until = new_disk_state->ValidUntil; new_state->valid_after = new_disk_state->ValidAfter; /* Set our current phase according to the valid-after time in our disk * state. The disk state we are parsing contains everything for the phase * starting at valid_after so make sure our phase reflects that. */ new_state->phase = get_sr_protocol_phase(new_state->valid_after); /* Parse the shared random values. */ if (disk_state_parse_sr_values(new_state, new_disk_state) < 0) { goto error; } /* Parse the commits. */ if (disk_state_parse_commits(new_state, new_disk_state) < 0) { goto error; } /* Great! This new state contains everything we had on disk. */ return new_state; error: state_free(new_state); return NULL; }
static void state_allocate(struct State * state, struct Query * query, struct Target * target) { int i; state->height = query->len; state->width = target->n_bits; state->n_bytes = target->n_bytes; state->res_counter = 0; if(state->max_length < query->len * target->n_bytes){ if(state->max_length != 0){ printf("state->free called max_length : %d\n", state->max_length); state_free(state); } state->mat = (long *)talloc((query->len + 2) *// Depth target->n_bytes * // Width state->height * // Height sizeof(long)); // sizeof(long) state->res_max_len = (query->len + 2) *// Depth target->n_bytes * // Width state->height * // Height sizeof(long) * 100; state->res = (long *)talloc(state->res_max_len); // sizeof(long) state->max_length = query->len * target->n_bytes; } state->length = query->len * target->n_bytes; state->depth = -1; for(i = 0 ; i < state->length ; i++){ state->mat[i] = 0;} }
static VALUE mol_by_mol(VALUE self, VALUE q_mol, VALUE t_mol) { struct Query query; struct Target target; struct State state; VALUE result; target.max_length = 0; state.max_length = 0; query_setup( q_mol, & query ); target_setup( t_mol, & target ); state_allocate(& state, & query, & target); if(rb_block_given_p() == Qtrue){ state_setup_block(& state); } else{ state_setup(& state, & query, & target); } search_by_ullmann(& state, & query, & target); result = state_get_result(& state); query_free(& query); target_free(& target); state_free(& state); return result; }
/* Set our global state pointer with the one given. */ static void state_set(sr_state_t *state) { tor_assert(state); if (sr_state != NULL) { state_free(sr_state); } sr_state = state; }
/* Cleanup and free our disk and memory state. */ void sr_state_free_all(void) { state_free(sr_state); disk_state_free(sr_disk_state); /* Nullify our global state. */ sr_state = NULL; sr_disk_state = NULL; }
int main( int argc, char **argv ) { struct state *s = parse( argv[1] ); #ifdef DEBUG state_print( s ); #endif state_free( s ); return 0; }
void run_code_event(struct state *state, struct event *event, const char *text) { DEBUGP("%d: run code event\n", event->line_number); char *error = NULL, *script_path = NULL; /* Wait for the right time before firing off this event. */ wait_for_event(state); if (state->socket_under_test == NULL) { asprintf(&error, "no socket to use for code"); goto error_out; } int fd = state->socket_under_test->live.fd; struct code_state *code = state->code; void *data = NULL; int data_len = 0; if (code->data_type == DATA_NONE) { /* First time: try various getsockopt calls until one works. */ #if HAVE_TCP_INFO if (data == NULL) { code->data_type = DATA_TCP_INFO; data = get_data(fd, code->data_type, &data_len); } #endif /* HAVE_TCP_INFO */ if (data == NULL) { asprintf(&error, "can't find getsockopt to get TCP info"); goto error_out; } } else { /* Run the getsockopt we already picked above. */ data = get_data(fd, code->data_type, &data_len); if (!data) { asprintf(&error, "can't get info for socket"); goto error_out; } } assert(code->data_type != DATA_NONE); assert(data != NULL); append_data(code, code->data_type, data, data_len); append_text(code, state->config->script_path, event->line_number, strdup(text)); return; error_out: script_path = strdup(state->config->script_path); state_free(state); die("%s:%d: runtime error in code: %s\n", script_path, event->line_number, error); free(script_path); free(error); }
Profile * tracker_create_profile (tracker_t *tracker) { uint8_t *end = tracker->events + tracker->n_event_bytes; StackStash *resolved_stash; Profile *profile; state_t *state; uint8_t *event; state = state_new (); resolved_stash = stack_stash_new (g_free); event = tracker->events; while (event < end) { event_type_t type = GET_TYPE (*(uint32_t *)event); switch (type) { case NEW_PROCESS: create_process (state, (new_process_t *)event); event += sizeof (new_process_t); break; case NEW_MAP: create_map (state, (new_map_t *)event); event += sizeof (new_map_t); break; case FORK: process_fork (state, (fork_t *)event); event += sizeof (fork_t); break; case EXIT: process_exit (state, (exit_t *)event); event += sizeof (exit_t); break; case SAMPLE: process_sample (state, resolved_stash, (sample_t *)event); event += sizeof (sample_t); break; } } profile = profile_new (resolved_stash); state_free (state); stack_stash_unref (resolved_stash); return profile; }
/** forward declare machine */ static void state_on_ops_off(struct state *state, struct machine *fsm) { struct state_off *off; _MY_TRACE_STR("state_on::off()\n"); off = malloc(sizeof(*off)); state_off_init(off); machine_set_state(fsm, &off->state); state_free(state); }
/* Run the given packet event; print warnings/errors, and exit on error. */ static void run_local_packet_event(struct state *state, struct event *event, struct packet *packet) { char *error = NULL; int result = STATUS_OK; result = run_packet_event(state, event, packet, &error); if (result == STATUS_WARN) { fprintf(stderr, "%s", error); free(error); } else if (result == STATUS_ERR) { state_free(state); die("%s\n", error); } }
static void db_load(struct CompoundDB * db, struct Query * query){ int new_n_bits; int new_n_bytes; int mat_ptr; struct Target target; struct State state; struct Record record; int i, j; target.n_bits = 0; target.n_bytes = 0; target.max_length = 0; state.max_length = 0; for(;;){ if(feof(db->idx) || feof(db->mat) || feof(db->mat)){ printf("Database broken!\n"); return; } fread(& record, sizeof(struct Record), 1, db->idx); if(record.n_bits == -1){ return; } target_setup_db(& target, & record); if(record.information != -1){ fread(target.mat, sizeof(long), target.n_bits * target.n_bytes, db->mat); fread(target.typ, sizeof(long), target.n_bits, db->typ); state_allocate(& state, query, & target); state_setup(& state, query, & target); //show(state.mat, query->len, target.n_bits); search_by_ullmann(& state, query, & target); }else{ fread(target.typ, sizeof(long), target.n_bytes, db->typ); printf("atom_number : %d\n", target.typ[0]); } } target_free_db(& target); state_free(& state); }
/* * A spatial file manager. Treat directories as independent resources with * fixed positions. Useful for navigating your filesystem with a predictable * GUI. */ int main(int argc, char *argv[]) { struct geometry *geometry; GtkWidget *window; WnckWindow *w; struct state *d; char *dir, ch; if ((d = state_new(argv[0])) == NULL) err(1, "could not build the callback data"); gtk_init(&argc, &argv); while ((ch = getopt(argc, argv, "")) != -1) switch (ch) { default: usage(); /* NOTREACHED */ } argc -= optind; argv += optind; dir = getdir(argc, argv); if (((w = window_by_title(dir)) != NULL) && window_activate(w) != -1) goto done; if (state_add_dir(d, dir) < 0) err(1, "state_add_dir"); if ((geometry = malloc(sizeof(struct geometry))) == NULL) err(1, "malloc"); getgeometry(dir, geometry); window = prepare_window(dir, geometry, d); free(geometry); gtk_widget_show(window); gtk_main(); done: state_free(d); return 0; }
/* * A desktop file manager. This opens files and directories the same way that * argonaut(1) does. */ int main(int argc, char *argv[]) { GtkBuilder *builder; GtkWidget *root, *icons; struct state *d; char *dir; if ((dir = get_dir()) == NULL) err(1, "get_dir"); if ((d = state_new(BINDIR"/argonaut")) == NULL) err(1, "could not build the callback data"); if (state_add_dir(d, dir) < 0) err(1, "state_add_dir"); gtk_init(&argc, &argv); builder = gtk_builder_new_from_file(INTERFACE_PATH); icons = GTK_WIDGET(gtk_builder_get_object(builder, "desktop-icons")); d->icon_view = GTK_ICON_VIEW(icons); root = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name(root, "argonaut-desktop"); set_window_geometry(GTK_WINDOW(root), GTK_WIDGET(icons)); desktopize(root); skip_pager(root); populate_model(dir, d->icon_view); set_up_icon_view(icons, d); gtk_container_add(GTK_CONTAINER(root), icons); gtk_widget_show(icons); gtk_widget_show(root); gtk_main(); state_free(d); free(dir); return 0; }
void run_command_event( struct state *state, struct event *event, struct command_spec *command) { char *script_path = NULL; DEBUGP("%d: command: `%s`\n", event->line_number, command->command_line); /* Wait for the right time before firing off this event. */ wait_for_event(state); char *error = NULL; if (safe_system(command->command_line, &error)) goto error_out; return; error_out: script_path = strdup(state->config->script_path); state_free(state); die("%s:%d: error executing `%s` command: %s\n", script_path, event->line_number, command->command_line, error); free(script_path); free(error); }
void run_script(struct config *config, struct script *script) { char *error = NULL; struct state *state = NULL; struct netdev *netdev = NULL; struct event *event = NULL; DEBUGP("run_script: running script\n"); set_scheduling_priority(); lock_memory(); /* This interpreter loop runs for local mode or wire client mode. */ assert(!config->is_wire_server); /* How we use the network is of course a little different in * each of the two cases.... */ if (config->is_wire_client) netdev = wire_client_netdev_new(config); else netdev = local_netdev_new(config); state = state_new(config, script, netdev); if (config->is_wire_client) { state->wire_client = wire_client_new(); wire_client_init(state->wire_client, config, script, state); } if (script->init_command != NULL) { if (safe_system(script->init_command->command_line, &error)) { die("%s: error executing init command: %s\n", config->script_path, error); } } signal(SIGPIPE, SIG_IGN); /* ignore EPIPE */ state->live_start_time_usecs = schedule_start_time_usecs(); DEBUGP("live_start_time_usecs is %lld\n", state->live_start_time_usecs); if (state->wire_client != NULL) wire_client_send_client_starting(state->wire_client); while (1) { if (get_next_event(state, &error)) die("%s", error); event = state->event; if (event == NULL) break; if (state->wire_client != NULL) wire_client_next_event(state->wire_client, event); /* In wire mode, we adjust relative times after * getting notification that previous packet events * have completed, if any. */ adjust_relative_event_times(state, event); switch (event->type) { case PACKET_EVENT: /* For wire clients, the server handles packets. */ if (!config->is_wire_client) { run_local_packet_event(state, event, event->event.packet); } break; case SYSCALL_EVENT: run_system_call_event(state, event, event->event.syscall); break; case COMMAND_EVENT: run_command_event(state, event, event->event.command); break; case CODE_EVENT: run_code_event(state, event, event->event.code->text); break; case INVALID_EVENT: case NUM_EVENT_TYPES: assert(!"bogus type"); break; /* We omit default case so compiler catches missing values. */ } } /* Wait for any outstanding packet events we requested on the server. */ if (state->wire_client != NULL) wire_client_next_event(state->wire_client, NULL); if (code_execute(state->code, &error)) { die("%s: error executing code: %s\n", state->config->script_path, error); free(error); } state_free(state); DEBUGP("run_script: done running\n"); }
void astar(t_env *env) { t_state_tree state_tree; t_state_list *opened = NULL; t_state *best_state; t_state_list *expend; t_state_list *tmp; t_state *tmp_state; int in_closed; int complexity_time = 0; int complexity_size = 0; int success = 0; int size_tmp; int opened_size = 0; int closed_size = 0; int tmpg; int is_closed = 0; memset(&state_tree, 0, sizeof(state_tree)); if (!(state_tree.childs = malloc(sizeof(*state_tree.childs) * env->size * env->size))) { ft_putendl_fd("nuzzle: malloc failed", 2); exit(EXIT_FAILURE); } memset(state_tree.childs, 0, sizeof(*state_tree.childs) * env->size * env->size); state_list_push(&opened, env->start); state_tree_push(env, &state_tree, env->start, 1); if ((size_tmp = opened_size + closed_size) > complexity_size) { complexity_size = size_tmp; } while (opened) { best_state = opened->state; complexity_time++; if (best_state->h == 0) { success = 1; break; } tmp = opened; opened = opened->next; free(tmp); opened_size--; closed_size++; state_tree_set(env, &state_tree, best_state, 0); expend = state_expend(env, best_state); if ((size_tmp = opened_size + closed_size + state_list_size(expend)) > complexity_size) { complexity_size = size_tmp; } while (expend) { tmp_state = state_tree_get(env, &state_tree, expend->state, &is_closed); in_closed = tmp_state != NULL && is_closed; if (in_closed) { tmp = expend; expend = expend->next; state_free(env, tmp->state); free(tmp); continue; } tmpg = best_state->g + 1; if (!tmp_state) { expend->state->pred = best_state; expend->state->g = tmpg; expend->state->f = 0; if (!env->greedy) expend->state->f += expend->state->g; if (!env->uniform) expend->state->f += expend->state->h; state_list_push(&opened, expend->state); state_tree_push(env, &state_tree, expend->state, 1); opened_size++; tmp = expend; expend = expend->next; free(tmp); continue; } else if (tmpg >= tmp_state->g) { tmp = expend; expend = expend->next; state_free(env,tmp->state); free(tmp); continue; } tmp_state->pred = best_state; tmp_state->g = tmpg; tmp_state->f = 0; if (!env->greedy) tmp_state->f += tmp_state->g; if (!env->uniform) tmp_state->f += tmp_state->h; tmp = expend; expend = expend->next; state_free(env, tmp->state); free(tmp); } } if (success) { t_state *kek = best_state; int i = 0; while (kek) { ++i; kek = kek->pred; } setvbuf(stdout, NULL, _IOFBF, BUFSIZ); printf("solution: \n"); print_solution(env, best_state); printf("time complexity: %d\nsize complexity: %d\nnumber of moves: %d\n", complexity_time, complexity_size, i); fflush(stdout); setvbuf(stdout, NULL, _IOLBF, BUFSIZ); } else { ft_putendl("This puzzle is not solvable"); } state_tree_free(env, &state_tree); state_list_free(opened); }
void history_free(history_t* past) { state_free(dict_lookup(past->states, "x")); state_free(dict_lookup(past->states, "y")); state_free(dict_lookup(past->states, "scalex")); state_free(dict_lookup(past->states, "scaley")); state_free(dict_lookup(past->states, "cxform.r0")); state_free(dict_lookup(past->states, "cxform.g0")); state_free(dict_lookup(past->states, "cxform.b0")); state_free(dict_lookup(past->states, "cxform.a0")); state_free(dict_lookup(past->states, "cxform.r1")); state_free(dict_lookup(past->states, "cxform.g1")); state_free(dict_lookup(past->states, "cxform.b1")); state_free(dict_lookup(past->states, "cxform.a1")); state_free(dict_lookup(past->states, "rotate")); state_free(dict_lookup(past->states, "shear")); state_free(dict_lookup(past->states, "pivot.x")); state_free(dict_lookup(past->states, "pivot.y")); state_free(dict_lookup(past->states, "pin.x")); state_free(dict_lookup(past->states, "pin.y")); state_free(dict_lookup(past->states, "blendmode")); state_free(dict_lookup(past->states, "flags")); filterState_free(dict_lookup(past->states, "filter")); dict_destroy(past->states); free(past); }
/* * eq: equlibirium factor * ti: temperature initial * te: temperature end * cf: cooling factor (0 < cf < 1) */ uint32_t simulated_annealing(sat_t *sat, double te, double steps) { state_t *state = state_init(sat->vars_cnt, STATE_RANDOMIZE); state_t *state_next = state_init(sat->vars_cnt, STATE_ALL_0); uint32_t ret = 0; uint32_t real_cost = 0; uint32_t eq; /* equlibrium */ double cf; /* cooling factor */ double ti; /* temperature initial */ ti = sat->vars_cnt * sat->weight_max * 10; cf = pow(te / ti, 1 / (steps - 1)); // cf = 1 - ((ti - te) / steps); static bool print_once = false; //true; uint32_t it = 0; // printf("ti=%lf te=%lf cf=%lf, eq=%d\n", ti, te, cf, eq); // for (double t = ti; te < t; t *= cf) { // for (int i = 0; i < eq; i++) { // state_gen_next(state, state_next); // double d = ((double) cost(sat, state)) // - ((double) cost(sat, state_next)); // // if (d < 0 || randd() < pow(M_E, -d / t)) { // state_swap(&state, &state_next); // continue; // } // // //printf("it= %4u best= %4u bits= ", it++, cost(sat, state)); // // state_print(state); // } // } //http://www.cs.ubc.ca/~hoos/SATLIB/benchm.html eq = (uint32_t) (sat->vars_cnt / (double) 2.0); uint32_t *p = calloc(sat->vars_cnt, sizeof(uint32_t)); for (double t = ti; te < t; t *= cf) { permutation(p, sat->vars_cnt); it++; // printf("t=%lf\n", t); for (uint32_t i = 0; i < eq; i++) { double c = cost(sat, state); uint32_t ind = p[i]; state->ch[ind] = (state->ch[ind] + 1) % 2; double d = (c - (double) cost(sat, state)); if (d < 0 || randd() < pow(M_E, -d / t)) { continue; } state->ch[ind] = (state->ch[ind] + 1) % 2; } real_cost = cost_main(sat, state); if (g_print_progress) { printf("%u %u %lf\n", it, real_cost, cost(sat, state)); } ret = max(ret, real_cost); } if (print_once) { fprintf(stderr, "ti=%lf cf=%lf it=%u eq=%u\n", ti, cf, it, eq); assert(0 < cf && cf < 1); print_once = false; state_print(state); } free(p); state_free(state); state_free(state_next); return (ret); }
void mcmc(tree *tr, analdef *adef) { int i=0; tr->startLH = tr->likelihood; printBothOpen("start minimalistic search with LH %f\n", tr->likelihood); printBothOpen("tr LH %f, startLH %f\n", tr->likelihood, tr->startLH); int insert_id; int j; int maxradius = 30; int accepted_spr = 0, accepted_nni = 0, accepted_bl = 0, accepted_model = 0, accepted_gamma = 0, inserts = 0; int rejected_spr = 0, rejected_nni = 0, rejected_bl = 0, rejected_model = 0, rejected_gamma = 0; int num_moves = 10000; boolean proposalAccepted; boolean proposalSuccess; prop which_proposal; double testr; double acceptance; srand (440); double totalTime = 0.0, proposalTime = 0.0, blTime = 0.0, printTime = 0.0; double t_start = gettime(); double t; //allocate states double bl_prior_exp_lambda = 0.1; double bl_sliding_window_w = 0.005; double gm_sliding_window_w = 0.75; double rt_sliding_window_w = 0.5; state *curstate = state_init(tr, adef, maxradius, bl_sliding_window_w, rt_sliding_window_w, gm_sliding_window_w, bl_prior_exp_lambda); printStateFileHeader(curstate); set_start_bl(curstate); printf("start bl_prior: %f\n",curstate->bl_prior); set_start_prior(curstate); curstate->hastings = 1;//needs to be set by the proposal when necessary /* Set the starting LH with a full traversal */ evaluateGeneric(tr, tr->start, TRUE); tr->startLH = tr->likelihood; printBothOpen("Starting with tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); /* Set reasonable model parameters */ evaluateGeneric(curstate->tr, curstate->tr->start, FALSE); // just for validation printBothOpen("tr LH before modOpt %f\n",curstate->tr->likelihood); printSubsRates(curstate->tr, curstate->model, curstate->numSubsRates); /* optimize the model with Brents method for reasonable starting points */ modOpt(curstate->tr, curstate->adef, 5.0); /* not by proposal, just using std raxml machinery... */ evaluateGeneric(curstate->tr, curstate->tr->start, FALSE); // just for validation printBothOpen("tr LH after modOpt %f\n",curstate->tr->likelihood); printSubsRates(curstate->tr, curstate->model, curstate->numSubsRates); recordSubsRates(curstate->tr, curstate->model, curstate->numSubsRates, curstate->curSubsRates); int first = 1; /* beginning of the MCMC chain */ for(j=0; j<num_moves; j++) { //printBothOpen("iter %d, tr LH %f, startLH %f\n",j, tr->likelihood, tr->startLH); //printRecomTree(tr, TRUE, "startiter"); proposalAccepted = FALSE; t = gettime(); /* evaluateGeneric(tr, tr->start); // just for validation printBothOpen("before proposal, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); */ which_proposal = proposal(curstate); if (first == 1) { first = 0; curstate->curprior = curstate->newprior; } //printBothOpen("proposal done, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); assert(which_proposal == SPR || which_proposal == stNNI || which_proposal == UPDATE_ALL_BL || which_proposal == UPDATE_MODEL || which_proposal == UPDATE_GAMMA); proposalTime += gettime() - t; /* decide upon acceptance */ testr = (double)rand()/(double)RAND_MAX; //should look something like acceptance = fmin(1,(curstate->hastings) * (exp(curstate->newprior-curstate->curprior)) * (exp(curstate->tr->likelihood-curstate->tr->startLH))); /* //printRecomTree(tr, FALSE, "after proposal"); printBothOpen("after proposal, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); */ if(testr < acceptance) { proposalAccepted = TRUE; switch(which_proposal) { case SPR: //printRecomTree(tr, TRUE, "after accepted"); // printBothOpen("SPR new topology , iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_spr++; break; case stNNI: printBothOpen("NNI new topology , iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_nni++; break; case UPDATE_ALL_BL: // printBothOpen("BL new , iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_bl++; break; case UPDATE_MODEL: // printBothOpen("Model new, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_model++; break; case UPDATE_GAMMA: // printBothOpen("Gamma new, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_gamma++; break; default: assert(0); } curstate->tr->startLH = curstate->tr->likelihood; //new LH curstate->curprior = curstate->newprior; } else { //printBothOpen("rejected , iter %d tr LH %f, startLH %f, %i \n", j, tr->likelihood, tr->startLH, which_proposal); resetState(which_proposal,curstate); switch(which_proposal) { case SPR: rejected_spr++; break; case stNNI: rejected_nni++; break; case UPDATE_ALL_BL: rejected_bl++; break; case UPDATE_MODEL: rejected_model++; break; case UPDATE_GAMMA: rejected_gamma++; break; default: assert(0); } evaluateGeneric(tr, tr->start, FALSE); // just for validation if(fabs(curstate->tr->startLH - tr->likelihood) > 1.0E-10) { printBothOpen("WARNING: LH diff %.10f\n", curstate->tr->startLH - tr->likelihood); } //printRecomTree(tr, TRUE, "after reset"); //printBothOpen("after reset, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); assert(fabs(curstate->tr->startLH - tr->likelihood) < 1.0E-10); } inserts++; /* need to print status */ if (j % 50 == 0) { t = gettime(); printBothOpen("sampled at iter %d, tr LH %f, startLH %f, prior %f, incr %f\n",j, tr->likelihood, tr->startLH, curstate->curprior, tr->likelihood - tr->startLH); boolean printBranchLengths = TRUE; /*printSimpleTree(tr, printBranchLengths, adef);*/ //TODO: print some parameters to a file printStateFile(j,curstate); printTime += gettime() - t; } } t = gettime(); treeEvaluate(tr, 1); blTime += gettime() - t; printBothOpen("accepted SPR %d, accepted stNNI %d, accepted BL %d, accepted model %d, accepted gamma %d, num moves tried %d, SPRs with max radius %d\n", accepted_spr, accepted_nni, accepted_bl, accepted_model, accepted_gamma, num_moves, maxradius); printBothOpen("rejected SPR %d, rejected stNNI %d, rejected BL %d, rejected model %d, rejected gamma %d\n", rejected_spr, rejected_nni, rejected_bl, rejected_model, rejected_gamma); printBothOpen("ratio SPR %f, ratio stNNI %f, ratio BL %f, ratio model %f, ratio gamma %f\n", accepted_spr/(double)(rejected_spr+accepted_spr), accepted_nni/(double)(rejected_nni+accepted_nni), accepted_bl/(double)(rejected_bl+accepted_bl), accepted_model/(double)(rejected_model+accepted_model), accepted_gamma/(double)(rejected_gamma+accepted_gamma)); printBothOpen("total %f, BL %f, printing %f, proposal %f\n", gettime()- t_start, blTime, printTime, proposalTime); assert(inserts == num_moves); state_free(curstate); }
/* Handle a wire connection from a client. */ static void *wire_server_thread(void *arg) { struct wire_server *wire_server = (struct wire_server *)arg; struct netdev *netdev = NULL; char *error = NULL; DEBUGP("wire_server_thread\n"); set_default_config(&wire_server->config); if (wire_server_receive_args(wire_server)) goto error_done; if (wire_server_receive_script_path(wire_server)) goto error_done; if (wire_server_receive_script(wire_server)) goto error_done; if (wire_server_receive_hw_address(wire_server)) goto error_done; if (parse_script_and_set_config(wire_server->argc, wire_server->argv, &wire_server->config, &wire_server->script, wire_server->script_path, wire_server->script_buffer)) goto error_done; set_scheduling_priority(); lock_memory(); netdev = wire_server_netdev_new(&wire_server->config, wire_server->wire_server_device, &wire_server->client_ether_addr, &wire_server->server_ether_addr); wire_server->state = state_new(&wire_server->config, &wire_server->script, netdev); if (wire_server_send_server_ready(wire_server)) goto error_done; if (wire_server_receive_client_starting(wire_server)) goto error_done; if (wire_server_run_script(wire_server, &error)) goto error_done; DEBUGP("wire_server_thread: finished test successfully\n"); error_done: if (error != NULL) fprintf(stderr, "%s\n", error); if (wire_server->state != NULL) state_free(wire_server->state, 0); DEBUGP("wire_server_thread: connection is done\n"); wire_server_free(wire_server); return NULL; }
void state_free(state_t* state) { if (state->next) state_free(state->next); free(state); }