static void *on_empty(struct attach *att,void *d) { struct directed *dir = (struct directed *) d; dir->is_empty = 1; on_empty_attach(dir->attach,NULL,NULL); check_done(dir); return OOP_CONTINUE; }
void task_set::wait(bool block) { DASSERT(submitter() == std::this_thread::get_id()); const std::chrono::milliseconds wait_time(0); if (m_pool->is_worker(m_submitter_thread)) block = true; // don't get into recursive work stealing if (block == false) { int tries = 0; while (1) { bool all_finished = true; int nfutures = 0, finished = 0; for (auto&& f : m_futures) { // Asking future.wait_for for 0 time just checks the status. ++nfutures; auto status = f.wait_for(wait_time); if (status != std::future_status::ready) all_finished = false; else ++finished; } if (all_finished) // All futures are ready? We're done. break; // We're still waiting on some tasks to complete. What next? if (++tries < 4) { // First few times, pause(4); // just busy-wait, check status again continue; } // Since we're waiting, try to run a task ourselves to help // with the load. If none is available, just yield schedule. if (!m_pool->run_one_task(m_submitter_thread)) { // We tried to do a task ourselves, but there weren't any // left, so just wait for the rest to finish. #if 1 yield(); #else // FIXME -- as currently written, if we see an empty queue // but we're still waiting for the tasks in our set to end, // we will keep looping and potentially ourselves do work // that was part of another task set. If there a benefit to, // once we see an empty queue, only waiting for the existing // tasks to finish and not altruistically executing any more // tasks? This is how we would take the exit now: for (auto&& f : m_futures) f.wait(); break; #endif } } } else { // If block is true, just block on completion of all the tasks // and don't try to do any of the work with the calling thread. for (auto&& f : m_futures) f.wait(); } #ifndef NDEBUG check_done(); #endif }
static gboolean on_fd(gint fd, GIOCondition cond, gpointer data) { did_fd = true; SOL_DBG("did fd=%d, cond=%#x", fd, cond); check_done(); return false; }
static gboolean on_timeout(gpointer data) { did_timeout = true; SOL_DBG("did timeout"); check_done(); return false; }
static gboolean on_idle(gpointer data) { did_idle = true; SOL_DBG("did idle"); check_done(); return false; }
static pfunc scan(struct jv_parser* p, char ch, jv* out) { p->column++; if (ch == '\n') { p->line++; p->column = 0; } presult answer = 0; if (p->st == JV_PARSER_NORMAL) { chclass cls = classify(ch); if (cls != LITERAL) { TRY(check_literal(p)); if (check_done(p, out)) answer = OK; } switch (cls) { case LITERAL: tokenadd(p, ch); break; case WHITESPACE: break; case QUOTE: p->st = JV_PARSER_STRING; break; case STRUCTURE: TRY(token(p, ch)); break; case INVALID: return "Invalid character"; } if (check_done(p, out)) answer = OK; } else { if (ch == '"' && p->st == JV_PARSER_STRING) { TRY(found_string(p)); p->st = JV_PARSER_NORMAL; if (check_done(p, out)) answer = OK; } else { tokenadd(p, ch); if (ch == '\\' && p->st == JV_PARSER_STRING) { p->st = JV_PARSER_STRING_ESCAPE; } else { p->st = JV_PARSER_STRING; } } } return answer; }
void res_graph(t_info *s, t_graph *g, t_nodes *list) { t_nodes *elem; g->a = 1; elem = s->elem_ext; while (my_strcmp(elem->name, s->elem_ent->name) == 0) { if (check_done(g, get_count(elem->name, list, s->nb_nodes))) { g->done[g->count_done++] = get_count(elem->name, list, s->nb_nodes); g->done[g->count_done] = -1; } if (shock_wave(s, g, list, elem)) elem = s->elem_ent; else elem = res_graph_suit(g, list, elem); } s->elem_ent->free = g->a + 1; s->elem_ext->free = 0; find_path(s, g, list); }
int shock_wave(t_info *s, t_graph *g, t_nodes *list, t_nodes *elem) { t_nodes *elem_tmp; int a; int b; a = get_count(elem->name, list, s->nb_nodes); b = 0; while (b != s->nb_nodes) { elem_tmp = get_node(list, b); if (elem_tmp->status == 1 && g->links[a][b] > 0) return (1); else if (g->links[a][b] > 0 && check_done(g, b) && check_to_do(g, b)) g->to_do[g->count_to_do++] = b; b += 1; } if (my_strcmp(elem->name, s->elem_ext->name)) g->to_do[g->count_to_do++] = -2; g->to_do[g->count_to_do] = -1; return (0); }
void check_cover(ldns_rr_list *list, ldns_rdf *qname) { ldns_status status; size_t i; if(check_done(qname)) return; for(i=0; i<ldns_rr_list_rr_count(list); ++i) { ldns_rr* nsec3 = ldns_rr_list_rr(list, i); if(ldns_rr_get_type(nsec3) != LDNS_RR_TYPE_NSEC3) { /* skip non nsec3 */ continue; } ldns_rdf* hashed = ldns_nsec3_hash_name_frm_nsec3( nsec3, qname); status = ldns_dname_cat(hashed, ldns_dname_left_chop( ldns_rr_owner(nsec3))); if(status != LDNS_STATUS_OK) abort_ldns_error("ldns_dname_cat", status); if(ldns_dname_compare(hashed, ldns_rr_owner(nsec3)) == 0) { ldns_rdf_print(stdout, ldns_rr_owner(nsec3)); printf(" proves "); ldns_rdf_print(stdout, qname); printf(" exists.\n"); } else if(ldns_nsec_covers_name(nsec3, hashed)) { ldns_rdf_print(stdout, ldns_rr_owner(nsec3)); printf(" proves "); ldns_rdf_print(stdout, qname); printf(" does not exist.\n"); } ldns_rdf_free(hashed); } }
static void *on_timeout(oop_source *src,struct timeval tv,void *d) { struct directed *dir = (struct directed *) d; dir->is_old = 1; check_done(dir); return OOP_CONTINUE; }
int main() { //set up random number generator srand(time(NULL)); //set up possible room names char names[10][10] = {"Amir", "Suri", "Dave", "Tess", "Dane", "Sara", "Evan", "Ruth", "Thor", "Anne"}; /************************************************** This section creates the randomized map for each game. **************************************************/ //select room names int chosen_nums[7] = {11,11,11,11,11,11,11}; int sevNames; for (sevNames = 0; sevNames < 7; sevNames++) { while (1) { int name_select = rand() % 10; if (checkChosen(chosen_nums, name_select)) { chosen_nums[sevNames] = name_select; break; } } } //create room matrix int rooms[7][8] = { {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0}, }; //make rooms unconnectable to themselves int index; for (index = 0; index < 7; index++) { rooms[index][index] = 8; } //create random room connections //draw a number for a row that is not full do { int rowAdd = rand() % 7; //check that row isn't already full if (rooms[rowAdd][7] != 6) { //draw a column that isnt already chosen while (1) { //draw column number int colAdd = rand() % 7; //check that it is not the same as the row or already chosen if (colAdd != rowAdd && rooms[rowAdd][colAdd] != 9) { //mark connections with 9 and incrament counters rooms[rowAdd][colAdd] = 9; rooms[colAdd][rowAdd] = 9; rooms[rowAdd][7]++; rooms[colAdd][7]++; break; } } } } while(!check_done(rooms)); //choose start and end int startRoom = rand() % 7; int endRoom = 8; do { endRoom = rand() % 7; } while (endRoom == startRoom && endRoom < 7); /************************************************** This section write the created map to the files they will be read from. It also creates the directory they are in and a temporary file for storing the path history. **************************************************/ //get process id int pid = getpid(); //create directory pointer char *dirName = malloc(20); //create dirname from parts snprintf(dirName, 20, "breinhoh.rooms.%d", pid); struct stat st = {0}; //create directory if (stat(dirName, &st) == -1) { mkdir(dirName, 0755); } //open file in directory int fileCount; for (fileCount = 0; fileCount < 7; fileCount++) { //create file char filepath[30]; strcpy(filepath, dirName); strcat(filepath, "/"); strcat(filepath, names[chosen_nums[fileCount]]); FILE* f = fopen(filepath, "w"); if (f < 0) { perror("CLIENT:\n"); exit(1); } //write data to file //write name to file fprintf(f, "ROOM NAME: %s\n", names[chosen_nums[fileCount]]); //write connections to file int conCount2 = 1; int conCount; for (conCount = 0; conCount < 7; conCount++) { if (rooms[fileCount][conCount] == 9) { fprintf(f, "CONNECTION %d: %s\n", conCount2, names[chosen_nums[conCount]]); conCount2++; } } //write start, end, or mid if (fileCount == startRoom) { fprintf(f, "ROOM TYPE: START_ROOM"); } else if (fileCount == endRoom) { fprintf(f, "ROOM TYPE: END_ROOM"); } else { fprintf(f, "ROOM TYPE: MID_ROOM"); } //close file fclose(f); } //create history file char hfilepath[30]; strcpy(hfilepath, dirName); strcat(hfilepath, "/history"); FILE* hf = fopen(hfilepath, "w+"); if (hf < 0) { perror("CLIENT:\n"); exit(1); } /************************************************** This section is the actual game. It locates the start file and reads it. Then it outputs the right info to the screen. Then it takes user input and if it checks out it records the right data finds the new file and starts over. If the user data does not it reprints the current files data and ask again. **************************************************/ //get start file name char currRoom[5]; strcpy(currRoom, names[chosen_nums[startRoom]]); int stepCount = 0; int destNotReached = 1; //This loop is the game itself each room is read here while (destNotReached) { int roomNum = 0; //open file char roomfile[30]; strcpy(roomfile, dirName); strcat(roomfile, "/"); strcat(roomfile, currRoom); int file_descriptor; ssize_t nread; char buffer[512]; file_descriptor = open(roomfile, O_RDONLY); if (file_descriptor == -1) { exit(1); } //save name and connections to array char data[8][10] = {"", "", "", "", "", "", "", ""}; nread = read(file_descriptor, buffer, 512); char fileText[512]; strcpy(fileText, buffer); memset(buffer, 0, 512); char * token = strtok(fileText, ":"); token = strtok(NULL, " \n"); strcpy(data[roomNum], token); roomNum++; token = strtok(NULL, " \n"); while (token[0] == 'C') { token = strtok(NULL, " \n"); token = strtok(NULL, " \n"); strcpy(data[roomNum], token); roomNum++; token = strtok(NULL, "\r R"); } token = strtok(NULL, ":"); token = strtok(NULL, " \n"); strcpy(data[7], token); close(file_descriptor); int verified = 1; //this loop is to verify the user input while (verified) { //check if file is end file if (!strcmp(data[7], "END_ROOM")) { destNotReached = 0; break; } //print info printf("CURRENT LOCATION: %s\nPOSSIBLE CONNECTIONS: ", data[0]); int conns; for (conns = 1; conns < 7; conns++) { if (strlen(data[conns]) == 0) { printf(".\nWHERE TO? >"); break; } else { printf("%s", data[conns]); if (conns != 6) { if (strlen(data[conns + 1]) != 0) { printf(", "); } } else { printf(".\nWHERE TO? >"); } } } //take user input char go2room[100]; fgets(go2room, 100, stdin); go2room[strlen(go2room) - 1] = '\0'; printf("\n"); //check if user input is valid int roomCheck; for (roomCheck = 1; roomCheck < 7; roomCheck++) { if (!strcmp(go2room, data[roomCheck])) { verified = 0; strcpy(currRoom, go2room); stepCount++; //read new room to hostory file fprintf(hf, go2room); fprintf(hf, "\n"); } } //find new file or print an error response if (!verified) { break; } else { printf("HUH? I DON’T UNDERSTAND THAT ROOM. TRY AGAIN.\n\n"); } } } //the game is over print the game data and delete the temp file. printf("YOU HAVE FOUND THE END ROOM. CONGRATULATIONS!\nYOU TOOK %d STEPS. YOUR PATH TO VICTORY WAS:\n", stepCount); rewind(hf); char let[512]; while(fscanf(hf,"%[^\n]\n",let)!=EOF) { printf("%s\n", let); } // file close fclose(hf); remove(hfilepath); return 0; }