/** * Run the event loop until we've got a response for all of our spooled * commands. You should not call this function from within your callbacks. * * @param instance the instance to run the event loop for. * * @author Trond Norbye */ LIBCOUCHBASE_API lcb_error_t lcb_wait(lcb_t instance) { if (instance->wait != 0) { return instance->last_error; } if (instance->connection.state != LCB_CONNSTATE_CONNECTED && !lcb_flushing_buffers(instance) && (instance->compat.type == LCB_CACHED_CONFIG || instance->compat.type == LCB_MEMCACHED_CLUSTER) && instance->vbucket_config != NULL) { return LCB_SUCCESS; } /* * The API is designed for you to run your own event loop, * but should also work if you don't do that.. In order to be * able to know when to break out of the event loop, we're setting * the wait flag to 1 */ instance->last_error = LCB_SUCCESS; instance->wait = 1; if (instance->connection.state != LCB_CONNSTATE_CONNECTED || lcb_flushing_buffers(instance) || hashset_num_items(instance->timers) > 0 || hashset_num_items(instance->durability_polls) > 0) { lcb_size_t ii; for (ii = 0; ii < instance->nservers; ii++) { lcb_server_t *c = instance->servers + ii; if (lcb_server_has_pending(c)) { lcb_connection_delay_timer(&c->connection); } } instance->io->v.v0.run_event_loop(instance->io); } else { instance->wait = 0; } if (instance->vbucket_config) { return LCB_SUCCESS; } return instance->last_error; }
void lcb_maybe_breakout(lcb_t instance) { /** * So we're done with normal operations. See if we need a refresh */ if (instance->wait) { if (!lcb_flushing_buffers(instance) && hashset_num_items(instance->timers) == 0 && hashset_num_items(instance->durability_polls) == 0) { instance->wait = 0; instance->io->v.v0.stop_event_loop(instance->io); } } }
static void trivial(void) { char *missing = "missing"; char *items[] = {"zero", "one", "two", "three", NULL}; char *foo = "foo"; size_t ii, nitems = 4; hashset_t set = hashset_create(); if (set == NULL) { fprintf(stderr, "failed to create hashset instance\n"); abort(); } for (ii = 0; ii < nitems; ++ii) { hashset_add(set, items[ii]); } for (ii = 0; ii < nitems; ++ii) { assert(hashset_is_member(set, items[ii])); } assert(hashset_is_member(set, missing) == 0); assert(hashset_remove(set, items[1]) == 1); assert(hashset_num_items(set) == 3); assert(hashset_remove(set, items[1]) == 0); assert(hashset_add(set, foo) == 1); assert(hashset_add(set, foo) == 0); hashset_destroy(set); }
void libcouchbase_maybe_breakout(libcouchbase_t instance) { if (instance->wait) { if (!libcouchbase_has_data_in_buffers(instance) && hashset_num_items(instance->timers) == 0) { instance->wait = 0; instance->io->stop_event_loop(instance->io); } } }
int libcouchbase_has_data_in_buffers(libcouchbase_t instance) { libcouchbase_size_t ii; for (ii = 0; ii < instance->nservers; ++ii) { libcouchbase_server_t *c = instance->servers + ii; if (c->cmd_log.nbytes || c->output.nbytes || c->input.nbytes || c->pending.nbytes || hashset_num_items(c->http_requests)) { return 1; } } return 0; }
int lcb_flushing_buffers(lcb_t instance) { lcb_size_t ii; if (hashset_num_items(instance->http_requests)) { return 1; } for (ii = 0; ii < instance->nservers; ++ii) { if (lcb_server_has_pending(instance->servers + ii)) { return 1; } } return 0; }
int lcb_flushing_buffers(lcb_t instance) { lcb_size_t ii; if (hashset_num_items(instance->http_requests)) { return 1; } for (ii = 0; ii < instance->nservers; ++ii) { if (lcb_server_has_pending(instance->servers + ii)) { return 1; } } if (instance->bootstrap.type == LCB_CONFIG_TRANSPORT_CCCP && lcb_server_has_pending(&instance->bootstrap.via.cccp.server)) { return 1; } return 0; }
/** * Run the event loop until we've got a response for all of our spooled * commands. You should not call this function from within your callbacks. * * @param instance the instance to run the event loop for. * * @author Trond Norbye */ LIBCOUCHBASE_API void libcouchbase_wait(libcouchbase_t instance) { if (instance->wait != 0) { return; } /* * The API is designed for you to run your own event loop, * but should also work if you don't do that.. In order to be * able to know when to break out of the event loop, we're setting * the wait flag to 1 */ instance->wait = 1; if (instance->vbucket_config == NULL) { /* Initial configuration. Set a timer */ instance->vbucket_state_listener_last = instance->vbucket_state_listener; instance->vbucket_state_listener = breakout_vbucket_state_listener; /* Initial connection timeout */ instance->io->update_timer(instance->io, instance->timeout.event, instance->timeout.usec, instance, initial_connect_timeout_handler); } if (instance->vbucket_config == NULL || libcouchbase_has_data_in_buffers(instance) || hashset_num_items(instance->timers) > 0) { instance->io->run_event_loop(instance->io); } else { instance->wait = 0; } /* * something else will call libcouchbase_maybe_breakout with a corresponding * stop_event_loop() */ }
/** * Run the event loop until we've got a response for all of our spooled * commands. You should not call this function from within your callbacks. * * @param instance the instance to run the event loop for. * * @author Trond Norbye */ LIBCOUCHBASE_API lcb_error_t lcb_wait(lcb_t instance) { if (instance->wait != 0) { return instance->last_error; } if (!instance->connected && !lcb_has_data_in_buffers(instance) && instance->compat.type == LCB_CACHED_CONFIG && instance->vbucket_config != NULL) { return LCB_SUCCESS; } /* * The API is designed for you to run your own event loop, * but should also work if you don't do that.. In order to be * able to know when to break out of the event loop, we're setting * the wait flag to 1 */ instance->last_error = LCB_SUCCESS; instance->wait = 1; if (!instance->connected || lcb_has_data_in_buffers(instance) || hashset_num_items(instance->timers) > 0) { lcb_size_t idx; /* update timers on all servers */ for (idx = 0; idx < instance->nservers; ++idx) { lcb_update_server_timer(instance->servers + idx); } instance->io->v.v0.run_event_loop(instance->io); } else { instance->wait = 0; } return instance->last_error; }
LIBCOUCHBASE_API void lcb_destroy(lcb_t instance) { lcb_size_t ii; lcb_settings *settings = &instance->settings; if (instance->cur_configinfo) { lcb_clconfig_decref(instance->cur_configinfo); instance->cur_configinfo = NULL; } instance->vbucket_config = NULL; lcb_bootstrap_destroy(instance); lcb_confmon_destroy(instance->confmon); hostlist_destroy(instance->usernodes); if (instance->timers != NULL) { for (ii = 0; ii < instance->timers->capacity; ++ii) { if (instance->timers->items[ii] > 1) { lcb_timer_destroy(instance, (lcb_timer_t)instance->timers->items[ii]); } } hashset_destroy(instance->timers); } if (instance->durability_polls) { struct lcb_durability_set_st **dset_list; lcb_size_t nitems = hashset_num_items(instance->durability_polls); dset_list = (struct lcb_durability_set_st **) hashset_get_items(instance->durability_polls, NULL); if (dset_list) { for (ii = 0; ii < nitems; ii++) { lcb_durability_dset_destroy(dset_list[ii]); } free(dset_list); } hashset_destroy(instance->durability_polls); } for (ii = 0; ii < instance->nservers; ++ii) { lcb_server_destroy(instance->servers + ii); } if (instance->http_requests) { for (ii = 0; ii < instance->http_requests->capacity; ++ii) { if (instance->http_requests->items[ii] > 1) { lcb_http_request_t htreq = (lcb_http_request_t)instance->http_requests->items[ii]; /** * We don't want to invoke callbacks *or* remove it from our * hash table */ htreq->status |= LCB_HTREQ_S_CBINVOKED | LCB_HTREQ_S_HTREMOVED; /* we should figure out a better error code for this.. */ lcb_http_request_finish(instance, htreq, LCB_ERROR); } } } hashset_destroy(instance->http_requests); free(instance->servers); connmgr_destroy(instance->memd_sockpool); if (settings->io && settings->io->v.v0.need_cleanup) { lcb_destroy_io_ops(settings->io); } ringbuffer_destruct(&instance->purged_buf); ringbuffer_destruct(&instance->purged_cookies); free(instance->histogram); free(instance->scratch); free(settings->username); free(settings->password); free(settings->bucket); free(settings->sasl_mech_force); if (instance->cmdht) { genhash_free(instance->cmdht); instance->cmdht = NULL; } memset(instance, 0xff, sizeof(*instance)); free(instance); }
double genHOMFitness(char* srcDir,char*target,char*makeDir,Config *user_config,char*original_source,MResult *mResult,HOMutant *hom){ char **args_combineFOM = malloc(sizeof(char*)*(hom->FOMutants_count+4)); args_combineFOM[0]="bash"; args_combineFOM[1]="combineFOM.sh"; args_combineFOM[2]=original_source; args_combineFOM[hom->FOMutants_count+2]=NULL; //Merge all the FOM source files to generate the HOM int i; for (i=0;i<hom->FOMutants_count;i++){ args_combineFOM[i+3]=hom->FOMutants[i].mutant_source_file; } startprogram(args_combineFOM,NULL,0); free(args_combineFOM); char hom_dir[strlen(srcDir)+strlen("hom_dir.log")+2]; sprintf(hom_dir,"%s/%s", srcDir, "hom_dir.log"); char hom_dir_loc[strlen(srcDir)+20]; char hom_file_name[strlen(srcDir)+20]; FILE* hom_dir_file =fopen(hom_dir,"r"); if(hom_dir_file==NULL){ return -1; } fscanf (hom_dir_file, "%s %s",hom_file_name , hom_dir_loc); fclose(hom_dir_file); copy_file(hom_dir_loc, target); //Evaluate mutant //Run make on the mutated project in order to build it printf("--> Evaluating HOM: %s\n",hom_file_name); //Open log file for recording mutation results mutation_results = fopen(mutation_results_path,"a+"); fprintf(mutation_results, "\n**** Mutant: %s ****\n",hom_file_name); fflush(mutation_results); fclose(mutation_results); mResult->homResult->total_mutants++; //Get mutants killed by tests before new evaluation int prev_killed_by_tests=get_non_trivial_FOM_stats()[0]; if(runMake(makeDir,hom_file_name,user_config->makeTestTarget)==2){ mResult->homResult->mutant_kill_count++; } //Get mutants killed by tests after evaluation int *stats = get_non_trivial_FOM_stats(); if(stats[0]-prev_killed_by_tests==1){ mResult->homResult->mutant_kill_count++; } hom->fragility=((double)stats[1]/(double)stats[2]); //Generate the fragility for all the set of FOMs that makeup this HOM hashset_t test_killed_set = hashset_create(); if (test_killed_set == NULL) { fprintf(stderr, "failed to create hashset instance\n"); abort(); } int mut,c; for(mut=0;mut<hom->FOMutants_count;mut++){ Mutant mutant = hom->FOMutants[mut]; for(c=0;c<mutant.killed_by_tests_count;c++){ hashset_add(test_killed_set, &mutant.killed_by_tests[c]); } } hom->fitness=hom->fragility/(((double)hashset_num_items(test_killed_set)/(double)stats[2])); hashset_destroy(test_killed_set); return hom->fitness; }