void queue_test() { int i; int item; int length = 128; Queue *queue = make_queue(length); assert(queue_empty(queue)); for (i=0; i<length-1; i++) { queue_push(queue, i); } assert(queue_full(queue)); for (i=0; i<10; i++) { item = queue_pop(queue); assert(i == item); } assert(!queue_empty(queue)); assert(!queue_full(queue)); for (i=0; i<10; i++) { queue_push(queue, i); } assert(queue_full(queue)); for (i=0; i<10; i++) { item = queue_pop(queue); } assert(item == 19); }
int main(void) { int buf[MAX_BUF] = {0,}; if( !input("input.txt", buf) ) { fprintf(stderr, "ERROR: file open error or buffer overflow\n"); delete_all_memory(); exit(EXIT_FAILURE); } if(!make_stack(buf)) { fprintf(stderr, "ERROR: memory allocation failed\n"); delete_all_memory(); exit(EXIT_FAILURE); } if(!make_queue(buf)) { fprintf(stderr, "ERROR: memory allocation failed\n"); delete_all_memory(); exit(EXIT_FAILURE); } if(!make_circle(buf)) { fprintf(stderr, "ERROR: memory allocation failed or Queue size overflow\n"); delete_all_memory(); exit(EXIT_FAILURE); } output(); exit(EXIT_SUCCESS); }
Level_Order_Tree_Iterator_Impl<T>::Level_Order_Tree_Iterator_Impl (Tree<T> &tree) // You fill in here. :queue_(make_queue(Options::instance()->queue_type())), rvalue() { // You fill in here. if(!tree.is_null()) { queue_->enqueue(tree); rvalue = queue_->front(); } }
int main(int argc,char ** argv) { if(argc!=3) { printf("ERROR in call one of the client\n"); exit(-1); } cln_num=atoi(argv[2]); num_cl=atoi(argv[1]); make_queue(); return 0; }
static void number_connected_verts(struct mds* m, mds_id v, struct mds_tag* tag, mds_id* label) { struct queue q; struct mds_set adj[2]; int i; adj[0].n = adj[1].n = 0; if (!visit(m, tag, label, v)) return; make_queue(&q, m->n[MDS_VERTEX]); push_queue(&q, v); while ( ! queue_empty(&q)) { v = pop_queue(&q); mds_get_adjacent(m, v, 1, &adj[1]); adj[0].n = adj[1].n; for (i = 0; i < adj[1].n; ++i) adj[0].e[i] = other_vert(m, adj[1].e[i], v); for (i = 0; i < adj[0].n; ++i) if (visit(m, tag, label, adj[0].e[i])) push_queue(&q, adj[0].e[i]); } free_queue(&q); }
void carmen_conventional_dynamic_program(int goal_x, int goal_y) { double *utility_ptr; int index; double max_val, min_val; int num_expanded; int done; struct timeval start_time, end_time; int delta_sec, delta_usec; static double last_time, cur_time, last_print; queue state_queue; state_ptr current_state; if (costs == NULL) return; gettimeofday(&start_time, NULL); cur_time = carmen_get_time(); if ((int)(cur_time - last_print) > 10) { carmen_verbose("Time since last DP: %d secs, %d usecs\n", (int)(cur_time - last_time), ((int)((cur_time-last_time)*1e6)) % 1000000); last_print = cur_time; } last_time = cur_time; if (utility == NULL) { utility = (double *)calloc(x_size*y_size, sizeof(double)); carmen_test_alloc(utility); } utility_ptr = utility; for (index = 0; index < x_size * y_size; index++) *(utility_ptr++) = -1; if (is_out_of_map(goal_x, goal_y)) return; max_val = -MAXDOUBLE; min_val = MAXDOUBLE; done = 0; state_queue = make_queue(); current_state = carmen_conventional_create_state(goal_x, goal_y, 0); max_val = MAX_UTILITY; *(utility_value(goal_x, goal_y)) = max_val; add_neighbours_to_queue(goal_x, goal_y, state_queue); num_expanded = 1; while ((current_state = pop_queue(state_queue)) != NULL) { num_expanded++; if (current_state->cost <= *(utility_value(current_state->x, current_state->y))) add_neighbours_to_queue(current_state->x, current_state->y, state_queue); if (current_state->cost < min_val) min_val = current_state->cost; free(current_state); } delete_queue(&state_queue); gettimeofday(&end_time, NULL); delta_usec = end_time.tv_usec - start_time.tv_usec; delta_sec = end_time.tv_sec - start_time.tv_sec; if (delta_usec < 0) { delta_sec--; delta_usec += 1000000; } // carmen_warn("Elasped time for dp: %d secs, %d usecs\n", delta_sec, delta_usec); }
/*** * share_add() * Add a share: NET SHARE netname[=resource[;resource...]] * * Args: * name - netname=resource string * pass - password * type - 0: unknown, STYPE_PRINTQ: printQ, STYPE_DEVICE: comm * * Returns: * nothing - success * exit(2) - command failed */ VOID share_add(TCHAR * name, TCHAR * pass, int type) { USHORT err; /* API return status */ TCHAR * resource; TCHAR FAR * ptr; struct share_info_2 FAR * share_entry; ULONG setType; TCHAR disk_dev_buf[4]; // // The redir doesn't have to be running on NT for the server to work // start_autostart(txt_SERVICE_FILE_SRV); share_entry = (struct share_info_2 FAR *) MGetBuffer(BIG_BUFFER_SIZE); /* * If name isn't IPC$ and we're on a peer server, then set the * mac_uses to MAX_PEER_USERS */ if (stricmpf(name,IPC_DOLLAR) && (QueryServerType() == PEER_BASE_VER)) share_entry->shi2_max_uses = MAX_PEER_USERS; else share_entry->shi2_max_uses = (DWORD) SHI_USES_UNLIMITED; share_entry->shi2_permissions = ACCESS_ALL & (~ACCESS_PERM); /* default */ share_entry->shi2_remark = 0L; /* Find netname and resource. We determine a value for resource rather */ /* strangely due to problems caused by _tcschr() returning a FAR char * */ /* and resource needing to be a NEAR char *. */ if (ptr = _tcschr(name, '=')) { *ptr = NULLC; resource = name + _tcslen(name) + 1; /* if use specified path for IPC$ or ADMIN$, barf! */ if (!stricmpf(name, ADMIN_DOLLAR) || !stricmpf(name, IPC_DOLLAR)) ErrorExit(APE_CannotShareSpecial) ; } else resource = NULL; /* Check here for 8.3 FAT name compliance. If the name is not FAT 8.3, */ /* warn the admin and query as to whether he wants to continue. */ /* (fix for bug 818) */ { ULONG Type; if (I_MNetPathType(NULL, name, &Type, INPT_FLAGS_OLDPATHS)) if ( !YorN(APE2_SHARE_MSG_NONFAT, TRUE) ) return; } COPYTOARRAY(share_entry->shi2_netname, name); #ifndef NTENV if (type == STYPE_PRINTQ) { share_entry->shi2_path = name; share_entry->shi2_type = STYPE_PRINTQ; make_queue(share_entry->shi2_netname, resource); share_entry->shi2_permissions = ACCESS_CREATE; /* default */ } else #endif if (type == STYPE_DEVICE) { share_entry->shi2_type = STYPE_DEVICE; share_entry->shi2_path = resource; share_entry->shi2_permissions = ACCESS_CREATE | ACCESS_WRITE | ACCESS_READ; } else if (resource == NULL) { /* Here must have IPC$ or ADMIN$. Assume the parser got it right */ if (! stricmpf(share_entry->shi2_netname, ADMIN_DOLLAR)) { share_entry->shi2_type = STYPE_DISKTREE; share_entry->shi2_path = NULL; } else { share_entry->shi2_type = STYPE_IPC; share_entry->shi2_path = NULL; } } else { /* Disk or Spooled thing? */ if (I_MNetPathType(NULL, resource, &setType, 0L)) /* resource has already been typed successfully * by the call to I_NetListCanon, so this error * must mean that we have a LIST. */ setType = ITYPE_DEVICE_LPT; if (setType == ITYPE_DEVICE_DISK) { strncpyf(disk_dev_buf,resource,3); _tcscpy(disk_dev_buf+2, TEXT("\\")); share_entry->shi2_path = (TCHAR FAR *)disk_dev_buf; share_entry->shi2_type = STYPE_DISKTREE; } else #ifndef NTENV if (setType == ITYPE_PATH_ABSD) #endif { share_entry->shi2_type = STYPE_DISKTREE; share_entry->shi2_path = resource; } #ifndef NTENV else { /* assume it is a list of print devices */ make_queue(share_entry->shi2_netname, resource); share_entry->shi2_type = STYPE_PRINTQ; share_entry->shi2_path = name; share_entry->shi2_permissions = ACCESS_CREATE; /* default */ } #endif } COPYTOARRAY(share_entry->shi2_passwd, TEXT("")); share_munge(share_entry); if ((share_entry->shi2_type == STYPE_DISKTREE) && resource) { TCHAR dev[DEVLEN+1] ; dev[0] = *resource ; dev[1] = TEXT(':') ; dev[2] = TEXT('\\') ; dev[3] = 0 ; if (GetDriveType(dev) == DRIVE_REMOTE) ErrorExit(APE_BadResource) ; } if (err = MNetShareAdd(NULL, 2, (LPBYTE)share_entry, LITTLE_BUFFER_SIZE)) ErrorExit(err); InfoPrintInsTxt(APE_ShareSuccess, share_entry->shi2_netname); NetApiBufferFree((TCHAR FAR *) share_entry); }
Level_Order_Tree_Iterator_Impl<T>::Level_Order_Tree_Iterator_Impl() // You fill in here. :queue_(make_queue(Options::instance()->queue_type())), rvalue(0, false) { }
static void search(carmen_roadmap_vertex_t *start_node, carmen_roadmap_t *roadmap) { int num_expanded; state_ptr current_state; int i, j; double *fwd_utilities, *open_list; int *parent_ptrs; carmen_roadmap_vertex_t *node_list; carmen_roadmap_edge_t *edges; double min_neighbour_utility; int min_neighbour, neighbour_id; int min_edge; double best_utility, utility; int best_neighbour; queue the_state_queue = NULL; the_state_queue = make_queue(); node_list = (carmen_roadmap_vertex_t *)(roadmap->nodes->list); fwd_utilities = (double *)calloc(roadmap->nodes->length, sizeof(double)); carmen_test_alloc(fwd_utilities); for (i = 0; i < roadmap->nodes->length; i++) fwd_utilities[i] = FLT_MAX; open_list = (double *)calloc(roadmap->nodes->length, sizeof(double)); carmen_test_alloc(open_list); for (i = 0; i < roadmap->nodes->length; i++) open_list[i] = -1; parent_ptrs = (int *)calloc(roadmap->nodes->length, sizeof(int)); carmen_test_alloc(parent_ptrs); for (i = 0; i < roadmap->nodes->length; i++) parent_ptrs[i] = -1; push_state(start_node->id, start_node->id, 0, 0, the_state_queue); fwd_utilities[start_node->id] = 0; node_list[roadmap->goal_id].utility = 0; num_expanded = 0; while ((current_state = pop_queue(the_state_queue)) != NULL) { num_expanded++; if (0) carmen_warn("Popped %d\n", current_state->id); fwd_utilities[current_state->id] = fwd_utilities[current_state->parent_id] + current_state->cost; parent_ptrs[current_state->id] = current_state->parent_id; open_list[current_state->id] = -2; assert (fwd_utilities[current_state->id] < 1e5); if (current_state->id == roadmap->goal_id) { if (node_list[roadmap->goal_id].edges->length == 0) construct_edges(roadmap, roadmap->goal_id); empty_queue(the_state_queue); } else { add_neighbours_to_queue(roadmap, current_state->id, roadmap->goal_id, fwd_utilities, open_list, the_state_queue); } free(current_state); } carmen_warn("Num Expanded %d\n", num_expanded); if (fwd_utilities[roadmap->goal_id] > FLT_MAX/2) carmen_warn("PROBLEM\n"); else if (0) { node_list[roadmap->goal_id].utility = 0; i = roadmap->goal_id; while (i != start_node->id) { edges = (carmen_roadmap_edge_t *)(node_list[i].edges->list); assert (node_list[i].edges->length > 0); min_neighbour_utility = FLT_MAX; min_neighbour = -1; min_edge = -1; for (j = 0; j < node_list[i].edges->length; j++) { if (edges[j].cost > 1e5 || edges[j].blocked) continue; neighbour_id = edges[j].id; assert (fwd_utilities[neighbour_id] >= 0); if (fwd_utilities[neighbour_id] < min_neighbour_utility) { min_neighbour_utility = fwd_utilities[neighbour_id]; min_neighbour = neighbour_id; min_edge = j; } } assert (min_neighbour >= 0); assert (min_neighbour_utility < fwd_utilities[i]); assert(node_list[min_neighbour].utility > FLT_MAX/2 || node_list[min_neighbour].utility == node_list[i].utility + edges[min_edge].cost); if (node_list[min_neighbour].utility > FLT_MAX/2) { node_list[min_neighbour].utility = node_list[i].utility + edges[min_edge].cost; assert(node_list[i].utility < FLT_MAX/2); assert(fwd_utilities[i] < FLT_MAX/2); assert(fwd_utilities[min_neighbour] < FLT_MAX/2); assert(node_list[min_neighbour].utility < 1e5); } assert (node_list[i].utility < node_list[min_neighbour].utility); // carmen_warn("%d %d %f %f\n", node_list[i].x, node_list[i].y, node_list[i].utility, FLT_MAX/2); i = min_neighbour; assert(node_list[i].utility < FLT_MAX/2); } } else { node_list[roadmap->goal_id].utility = 0; i = roadmap->goal_id; while (i != start_node->id) { min_neighbour = parent_ptrs[i]; assert (min_neighbour >= 0); min_neighbour_utility = fwd_utilities[min_neighbour]; assert (min_neighbour_utility < fwd_utilities[i]); edges = (carmen_roadmap_edge_t *)(node_list[i].edges->list); assert (node_list[i].edges->length > 0); for (min_edge = 0; min_edge < node_list[i].edges->length; min_edge++) { if (edges[min_edge].id == min_neighbour) break; } assert (min_edge < node_list[i].edges->length); assert(node_list[min_neighbour].utility > FLT_MAX/2 || fabs(node_list[min_neighbour].utility - (node_list[i].utility + edges[min_edge].cost)) < 1e6); if (node_list[min_neighbour].utility > FLT_MAX/2) { carmen_roadmap_edge_t *edges2; edges2 = (carmen_roadmap_edge_t *)node_list[min_neighbour].edges->list; node_list[min_neighbour].utility = node_list[i].utility + edges[min_edge].cost; best_neighbour = -1; best_utility = FLT_MAX; for (j = 0; j < node_list[min_neighbour].edges->length; j++) { if (edges2[j].cost > 1e5 || edges2[j].blocked) continue; if (node_list[edges2[j].id].utility > FLT_MAX/2) continue; utility = node_list[edges2[j].id].utility; if (utility < best_utility) { best_utility = utility; best_neighbour = edges2[j].id; } } if (best_neighbour < 0) continue; assert (best_utility < FLT_MAX/2); assert (node_list[best_neighbour].utility < node_list[min_neighbour].utility); assert(node_list[i].utility < FLT_MAX/2); assert(fwd_utilities[i] < FLT_MAX/2); assert(fwd_utilities[min_neighbour] < FLT_MAX/2); assert(node_list[min_neighbour].utility < 1e5); } assert (node_list[i].utility < node_list[min_neighbour].utility); // carmen_warn("%d %d %f %f\n", node_list[i].x, node_list[i].y, node_list[i].utility, FLT_MAX/2); i = min_neighbour; assert(node_list[i].utility < FLT_MAX/2); } } /* Check to make sure that no node is a local minimum. The only node that's allowed to be a local minimum is the goal. */ for (i = 0; i < roadmap->nodes->length; i++) { if (i == roadmap->goal_id) continue; edges = (carmen_roadmap_edge_t *)(node_list[i].edges->list); if (node_list[i].utility > FLT_MAX/2) continue; best_neighbour = -1; best_utility = FLT_MAX; for (j = 0; j < node_list[i].edges->length; j++) { if (edges[j].cost > 1e5 || edges[j].blocked) continue; if (node_list[edges[j].id].utility > FLT_MAX/2) continue; utility = node_list[edges[j].id].utility; if (utility < best_utility) { best_utility = utility; best_neighbour = edges[j].id; } } if (best_neighbour < 0) continue; assert (best_utility < FLT_MAX/2); assert (node_list[best_neighbour].utility < node_list[i].utility); } free(fwd_utilities); delete_queue(&the_state_queue); }
Shared *make_shared() { Shared *shared = check_malloc(sizeof(Shared)); shared->queue = make_queue(128); return shared; }