void destroy_list(LinkedList *list) { // Emancipates a Linked List from its memory-bound slavery. if(list != NULL) { destroy_nodes(list->root); free(list); } }
/** * This routine frees all memory consumed by a temporary * configuration. * * @param Config config to be freed * * @note Globals: none * @note Exceptions: none * @note History: Thu Mar 14 13:34:23 1991, DSJ, Created. */ void FreeTempConfig(TEMP_CONFIG Config) { assert (Config != NULL); destroy_nodes (Config->ContextsSeen, memfree); FreeBitVector (Config->Protos); free_struct (Config, sizeof (TEMP_CONFIG_STRUCT), "TEMP_CONFIG_STRUCT"); } /* FreeTempConfig */
void destroy_nodes(Node *node) { // Recursively frees all the Nodes. if(node != NULL) { if(node->next == NULL) destroy_node(node); else { destroy_nodes(node->next); destroy_node(node); } } }
/* append contents to file and reset count to 0 */ int flush_to_disk(char *file, Parts db) { int rc = 0; if ((rc = write_db(file, db, "ab")) == 0) { destroy_nodes(db); db->head = NULL; db->count = 0; } return rc; }
static void destroy_nodes(struct node *n) { if (n == NULL) { // do nothing } else { for (int i = 0; i < 26; i++) { destroy_nodes(n->children[i]); } free(n); } }
/*---------------------------------------------------------------------------*/ void FreeMicroFeatures(MICROFEATURES MicroFeatures) { /* ** Parameters: ** MicroFeatures list of micro-features to be freed ** Globals: none ** Operation: ** This routine deallocates all of the memory consumed by ** a list of micro-features. ** Return: none ** Exceptions: none ** History: 7/27/89, DSJ, Created. */ destroy_nodes(MicroFeatures, Efree); } /* FreeMicroFeatures */
/*-------------------------------------------------------------------------*/ void free_adapted_class(ADAPT_CLASS adapt_class) { int i; for (i = 0; i < MAX_NUM_CONFIGS; i++) { if (ConfigIsPermanent (adapt_class, i) && PermConfigFor (adapt_class, i) != NULL) FreePermConfig (PermConfigFor (adapt_class, i)); else if (!ConfigIsPermanent (adapt_class, i) && TempConfigFor (adapt_class, i) != NULL) FreeTempConfig (TempConfigFor (adapt_class, i)); } FreeBitVector (adapt_class->PermProtos); FreeBitVector (adapt_class->PermConfigs); destroy_nodes (adapt_class->TempProtos, FreeTempProto); Efree(adapt_class); }
/*---------------------------------------------------------------------------*/ void FreeTempConfig(TEMP_CONFIG Config) { /* ** Parameters: ** Config config to be freed ** Globals: none ** Operation: This routine frees all memory consumed by a temporary ** configuration. ** Return: none ** Exceptions: none ** History: Thu Mar 14 13:34:23 1991, DSJ, Created. */ assert (Config != NULL); destroy_nodes (Config->ContextsSeen, memfree); FreeBitVector (Config->Protos); c_free_struct (Config, sizeof (TEMP_CONFIG_STRUCT), "TEMP_CONFIG_STRUCT"); } /* FreeTempConfig */
void destroy_tree(struct prefix_tree *t) { destroy_nodes(t->root); }
int main(int argc, char **argv) { int op, ret; while ((op = getopt(argc, argv, "s:b:c:C:S:t:p:")) != -1) { switch (op) { case 's': dst_addr = optarg; break; case 'b': src_addr = optarg; break; case 'c': connections = atoi(optarg); break; case 'C': message_count = atoi(optarg); break; case 'S': message_size = atoi(optarg); break; case 't': set_tos = 1; tos = (uint8_t) atoi(optarg); break; case 'p': port_space = strtol(optarg, NULL, 0); break; default: printf("usage: %s\n", argv[0]); printf("\t[-s server_address]\n"); printf("\t[-b bind_address]\n"); printf("\t[-c connections]\n"); printf("\t[-C message_count]\n"); printf("\t[-S message_size]\n"); printf("\t[-t type_of_service]\n"); printf("\t[-p port_space - %#x for UDP (default), " "%#x for IPOIB]\n", RDMA_PS_UDP, RDMA_PS_IPOIB); exit(1); } } test.dst_addr = (struct sockaddr *) &test.dst_in; test.src_addr = (struct sockaddr *) &test.src_in; test.connects_left = connections; test.channel = rdma_create_event_channel(); if (!test.channel) { perror("failed to create event channel"); exit(1); } if (alloc_nodes()) exit(1); if (dst_addr) ret = run_client(); else ret = run_server(); printf("test complete\n"); destroy_nodes(); rdma_destroy_event_channel(test.channel); printf("return status %d\n", ret); return ret; }
int main(int argc, char **argv) { int op, ret; hints.ai_port_space = RDMA_PS_TCP; while ((op = getopt(argc, argv, "s:b:f:P:c:C:S:t:p:m")) != -1) { switch (op) { case 's': dst_addr = optarg; break; case 'b': src_addr = optarg; break; case 'f': if (!strncasecmp("ip", optarg, 2)) { hints.ai_flags = RAI_NUMERICHOST; } else if (!strncasecmp("gid", optarg, 3)) { hints.ai_flags = RAI_NUMERICHOST | RAI_FAMILY; hints.ai_family = AF_IB; } else if (strncasecmp("name", optarg, 4)) { fprintf(stderr, "Warning: unknown address format\n"); } break; case 'P': if (!strncasecmp("ib", optarg, 2)) { hints.ai_port_space = RDMA_PS_IB; } else if (strncasecmp("tcp", optarg, 3)) { fprintf(stderr, "Warning: unknown port space format\n"); } break; case 'c': connections = atoi(optarg); break; case 'C': message_count = atoi(optarg); break; case 'S': message_size = atoi(optarg); break; case 't': set_tos = 1; tos = (uint8_t) strtoul(optarg, NULL, 0); break; case 'p': port = optarg; break; case 'm': migrate = 1; break; default: printf("usage: %s\n", argv[0]); printf("\t[-s server_address]\n"); printf("\t[-b bind_address]\n"); printf("\t[-f address_format]\n"); printf("\t name, ip, ipv6, or gid\n"); printf("\t[-P port_space]\n"); printf("\t tcp or ib\n"); printf("\t[-c connections]\n"); printf("\t[-C message_count]\n"); printf("\t[-S message_size]\n"); printf("\t[-t type_of_service]\n"); printf("\t[-p port_number]\n"); printf("\t[-m(igrate)]\n"); exit(1); } } test.connects_left = connections; test.channel = create_first_event_channel(); if (!test.channel) { exit(1); } if (alloc_nodes()) exit(1); if (dst_addr) { ret = run_client(); } else { hints.ai_flags |= RAI_PASSIVE; ret = run_server(); } printf("test complete\n"); destroy_nodes(); rdma_destroy_event_channel(test.channel); if (test.rai) rdma_freeaddrinfo(test.rai); printf("return status %d\n", ret); return ret; }
int main(int argc, char *argv[]) { exit_if_false(argc == 2,"exactly one input argument required"); timer_start(); //-------------------------------------------------------------------// // counters int i, n; // file paths char *input_file_path, *geometry_file_path, *case_file_path, *data_file_path, *data_numbered_file_path, *display_file_path, *display_numbered_file_path; exit_if_false(geometry_file_path = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating geometry file path"); exit_if_false(case_file_path = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating case file path"); exit_if_false(data_file_path = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating data file path"); exit_if_false(data_numbered_file_path = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating data numbered file path"); exit_if_false(display_file_path = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating display file path"); exit_if_false(display_numbered_file_path = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating display numbered file path"); // print string char *print; exit_if_false(print = (char *)malloc(MAX_STRING_LENGTH * sizeof(char)),"allocating the print string"); // mesh structures int n_nodes, n_faces, n_elements, n_boundaries_old = 0, n_boundaries, n_terms; struct NODE *node; struct FACE *face; struct ELEMENT *element; struct BOUNDARY *boundary_old = NULL, *boundary; struct TERM *term; EXPRESSION *initial = NULL; // solution vectors int n_u_old = 0, n_u; double *u_old = NULL, *u; // files FILE *input_file, *case_file, *data_file, *geometry_file, *display_file; //-------------------------------------------------------------------// // opening the input file print_info("opening the input file %s",argv[1]); input_file_path = argv[1]; input_file = fopen(input_file_path,"r"); exit_if_false(input_file != NULL,"opening %s",input_file_path); // reading the case file path print_info("reading the case file path"); exit_if_false(fetch_value(input_file,"case_file_path",'s',case_file_path) == FETCH_SUCCESS,"reading case_file_path from %s",input_file_path); print_continue(case_file_path); // reading the number of variables, variable names and orders print_info("reading the variables"); int n_variables_old = 0, n_variables; exit_if_false(fetch_value(input_file,"number_of_variables",'i',&n_variables) == FETCH_SUCCESS,"reading number_of_variables from %s",input_file_path); int *variable_order_old = NULL, *variable_order = (int *)malloc(n_variables * sizeof(int)); exit_if_false(variable_order != NULL,"allocating orders"); exit_if_false(fetch_vector(input_file, "variable_order", 'i', n_variables, variable_order) == FETCH_SUCCESS,"reading variable_order from %s",input_file_path); char **variable_name = allocate_character_matrix(NULL,n_variables,MAX_STRING_LENGTH); exit_if_false(variable_name != NULL,"allocating variable names"); warn_if_false(fetch_vector(input_file,"variable_name",'s',n_variables,variable_name) == FETCH_SUCCESS,"reading variable_name from %s",input_file_path); for(i = 0; i < n_variables; i ++) print_continue("%s order %i",variable_name[i],variable_order[i]); // reading the number of inner and outer iterations to perform print_info("reading the numbers of iterations"); int outer_iteration = 0, inner_iteration; int n_outer_iterations, n_inner_iterations, data_n_outer_iterations, display_n_outer_iterations; exit_if_false(fetch_value(input_file,"number_of_inner_iterations",'i',&n_inner_iterations) == FETCH_SUCCESS,"reading number_of_inner_iterations from %s",input_file_path); exit_if_false(fetch_value(input_file,"number_of_outer_iterations",'i',&n_outer_iterations) == FETCH_SUCCESS,"reading number_of_outer_iterations from %s",input_file_path); print_continue("%i outer of %i inner iterations to be done",n_outer_iterations,n_inner_iterations); // read existing case and data case_file = fopen(case_file_path,"r"); if(case_file != NULL) { print_info("reading existing case file %s",case_file_path); read_case(case_file, &n_variables_old, &variable_order_old, &n_nodes, &node, &n_faces, &face, &n_elements, &element, &n_boundaries_old, &boundary_old); fclose(case_file); n = 0; for(i = 0; i < n_variables; i ++) n += n_elements*ORDER_TO_N_BASIS(variable_order[i]); if(fetch_value(input_file,"initial_data_file_path",'s',data_file_path) == FETCH_SUCCESS) { print_info("reading existing data file %s",data_file_path); exit_if_false(data_file = fopen(data_file_path,"r"),"opening %s",data_file_path); read_data(data_file, &n_u_old, &u_old, &outer_iteration); fclose(data_file); exit_if_false(n_u_old == n,"case and initial data does not match"); } } // construct new case else { print_info("reading the geometry file path"); exit_if_false(fetch_value(input_file,"geometry_file_path",'s',geometry_file_path) == FETCH_SUCCESS,"reading geometry_file_path from %s",input_file_path); print_continue(geometry_file_path); print_info("reading the geometry file %s",geometry_file_path); exit_if_false(geometry_file = fopen(geometry_file_path,"r"),"opening %s",geometry_file_path); read_geometry(geometry_file, &n_nodes, &node, &n_faces, &face, &n_elements, &element); fclose(geometry_file); print_continue("%i nodes, %i faces and %i elements",n_nodes,n_faces,n_elements); print_info("generating additional connectivity and geometry"); process_geometry(n_nodes, node, n_faces, face, n_elements, element); } // read the data file path and output frequency print_info("reading the data file path and output frequency"); exit_if_false(fetch_value(input_file,"data_file_path",'s',data_file_path) == FETCH_SUCCESS,"reading data_file_path from %s",input_file_path); if(fetch_value(input_file,"data_number_of_outer_iterations",'i',&data_n_outer_iterations) != FETCH_SUCCESS) data_n_outer_iterations = n_outer_iterations + outer_iteration; print_continue("data to be written to %s every %i outer iterations",data_file_path,data_n_outer_iterations); // read boundaries print_info("reading boundaries"); boundaries_input(input_file, n_faces, face, &n_boundaries, &boundary); print_continue("%i boundaries",n_boundaries); // read terms print_info("reading PDE terms"); terms_input(input_file, &n_terms, &term); print_continue("%i terms",n_terms); // update unknown indices and values print_info("updating the numbering of the degrees of freedom"); update_element_unknowns(n_variables_old, n_variables, variable_order_old, variable_order, n_elements, element, n_u_old, &n_u, u_old, &u); print_continue("%i degrees of freedom",n_u); // update face boundaries print_info("updating the face boundary associations"); update_face_boundaries(n_variables, n_faces, face, n_boundaries, boundary); // update integration print_info("updating integration"); i = update_face_integration(n_variables_old, n_variables, variable_order_old, variable_order, n_faces, face); if(i) print_continue("updated %i face quadratures",i); i = update_element_integration(n_variables_old, n_variables, variable_order_old, variable_order, n_elements, element); if(i) print_continue("updated %i element quadratures",i); // update numerics print_info("updating numerics"); i = update_face_numerics(n_variables_old, n_variables, variable_order_old, variable_order, n_faces, face, n_boundaries_old, boundary_old); if(i) print_continue("updated %i face interpolations",i); i = update_element_numerics(n_variables_old, n_variables, variable_order_old, variable_order, n_elements, element); if(i) print_continue("updated %i element interpolations",i); // write case file print_info("writing case file %s",case_file_path); exit_if_false(case_file = fopen(case_file_path,"w"),"opening %s",case_file_path); write_case(case_file, n_variables, variable_order, n_nodes, node, n_faces, face, n_elements, element, n_boundaries, boundary); fclose(case_file); // read the display file path and output frequency print_info("reading the display file path and output frequency"); if( fetch_value(input_file,"display_file_path",'s',display_file_path) == FETCH_SUCCESS && fetch_value(input_file,"display_number_of_outer_iterations",'i',&display_n_outer_iterations) == FETCH_SUCCESS ) print_continue("display to be written to %s every %i outer iterations",display_file_path,display_n_outer_iterations); else { display_n_outer_iterations = 0; warn_if_false(0,"display files will not be written"); } // initialise if(initial_input(input_file, n_variables, &initial)) { print_info("initialising the degrees of freedom"); initialise_values(n_variables, variable_order, n_elements, element, initial, u); } //-------------------------------------------------------------------// // allocate and initialise the system print_info("allocating and initialising the system"); SPARSE system = NULL; initialise_system(n_variables, variable_order, n_elements, element, n_u, &system); double *residual, *max_residual, *du, *max_du; exit_if_false(residual = (double *)malloc(n_u * sizeof(double)),"allocating the residuals"); exit_if_false(max_residual = (double *)malloc(n_variables * sizeof(double)),"allocating the maximum residuals"); exit_if_false(du = (double *)malloc(n_u * sizeof(double)),"allocating du"); exit_if_false(max_du = (double *)malloc(n_variables * sizeof(double)),"allocating the maximum changes"); exit_if_false(u_old = (double *)realloc(u_old, n_u * sizeof(double)),"re-allocating u_old"); timer_reset(); // iterate print_info("iterating"); n_outer_iterations += outer_iteration; for(; outer_iteration < n_outer_iterations; outer_iteration ++) { print_output("iteration %i", outer_iteration); for(i = 0; i < n_u; i ++) u_old[i] = u[i]; for(inner_iteration = 0; inner_iteration < n_inner_iterations; inner_iteration ++) { calculate_system(n_variables, variable_order, n_faces, face, n_elements, element, n_terms, term, n_u, u_old, u, system, residual); exit_if_false(sparse_solve(system, du, residual) == SPARSE_SUCCESS,"solving system"); for(i = 0; i < n_u; i ++) u[i] -= du[i]; calculate_maximum_changes_and_residuals(n_variables, variable_order, n_elements, element, du, max_du, residual, max_residual); for(i = 0; i < n_variables; i ++) sprintf(&print[26*i],"%.6e|%.6e ",max_du[i],max_residual[i]); print_continue("%s",print); } slope_limit(n_variables, variable_order, n_nodes, node, n_elements, element, n_boundaries, boundary, u); if(data_n_outer_iterations && outer_iteration % data_n_outer_iterations == 0) { generate_numbered_file_path(data_numbered_file_path, data_file_path, outer_iteration); print_info("writing data to %s",data_numbered_file_path); exit_if_false(data_file = fopen(data_numbered_file_path,"w"),"opening %s",data_numbered_file_path); write_data(data_file, n_u, u, outer_iteration); fclose(data_file); } if(display_n_outer_iterations && outer_iteration % display_n_outer_iterations == 0) { generate_numbered_file_path(display_numbered_file_path, display_file_path, outer_iteration); print_info("writing display to %s",data_numbered_file_path); exit_if_false(display_file = fopen(display_numbered_file_path,"w"),"opening %s",display_numbered_file_path); write_display(display_file, n_variables, variable_name, variable_order, n_elements, element, n_u, u); fclose(display_file); } timer_print(); } //-------------------------------------------------------------------// print_info("freeing all memory"); fclose(input_file); free(geometry_file_path); free(case_file_path); free(data_file_path); free(data_numbered_file_path); free(display_file_path); free(display_numbered_file_path); free(print); destroy_nodes(n_nodes,node); destroy_faces(n_faces,face,n_variables); destroy_elements(n_elements,element,n_variables); destroy_boundaries(n_boundaries_old,boundary_old); destroy_boundaries(n_boundaries,boundary); destroy_terms(n_terms,term); destroy_initial(n_variables,initial); free(variable_order_old); free(variable_order); destroy_matrix((void *)variable_name); free(u_old); free(u); sparse_destroy(system); free(residual); free(max_residual); free(du); free(max_du); return 0; }
int main(int argc, char **argv) { char *node, *service; uint64_t flags = 0; struct fi_eq_attr eq_attr; int op, ret; opts = INIT_OPTS; hints = fi_allocinfo(); if (!hints) exit(1); hints->caps = FI_MSG; hints->ep_attr->type = FI_EP_MSG; hints->mode = FI_LOCAL_MR; hints->tx_attr->mode = hints->mode; hints->rx_attr->mode = hints->mode; hints->ep_attr->max_msg_size = 100; hints->tx_attr->size = 10; hints->rx_attr->size = 10; while ((op = getopt(argc, argv, "c:C:S:h" ADDR_OPTS INFO_OPTS)) != -1) { switch (op) { case 'c': connections = atoi(optarg); break; case 'C': hints->tx_attr->size = atoi(optarg); hints->rx_attr->size = hints->tx_attr->size; break; case 'S': hints->ep_attr->max_msg_size = atoi(optarg); break; default: ft_parse_addr_opts(op, optarg, &opts); ft_parseinfo(op, optarg, hints); break; case '?': case 'h': usage(argv[0]); } } if (optind < argc) opts.dst_addr = argv[optind]; connects_left = connections; ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts); if (ret) return ret; ret = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &info); if (ret) { FT_PRINTERR("fi_getinfo", ret); goto exit0; } printf("using provider: %s\n", info->fabric_attr->prov_name); ret = fi_fabric(info->fabric_attr, &fabric, NULL); if (ret) { FT_PRINTERR("fi_fabric", ret); goto exit1; } memset(&eq_attr, 0, sizeof eq_attr); eq_attr.wait_obj = FI_WAIT_UNSPEC; ret = fi_eq_open(fabric, &eq_attr, &eq, NULL); if (ret) { FT_PRINTERR("fi_eq_open", ret); goto exit2; } if (alloc_nodes()) goto exit3; ret = opts.dst_addr ? run_client() : run_server(); printf("test complete\n"); destroy_nodes(); exit3: fi_close(&eq->fid); exit2: fi_close(&fabric->fid); exit1: fi_freeinfo(info); exit0: fi_freeinfo(hints); return -ret; }
int main(int argc, char **argv) { int op, ret; hints.ai_port_space = RDMA_PS_UDP; while ((op = getopt(argc, argv, "s:b:c:C:S:t:p:P:f:")) != -1) { switch (op) { case 's': dst_addr = optarg; break; case 'b': src_addr = optarg; break; case 'c': connections = atoi(optarg); break; case 'C': message_count = atoi(optarg); break; case 'S': message_size = atoi(optarg); break; case 't': set_tos = 1; tos = (uint8_t) strtoul(optarg, NULL, 0); break; case 'p': /* for backwards compatibility - use -P */ hints.ai_port_space = strtol(optarg, NULL, 0); break; case 'f': if (!strncasecmp("ip", optarg, 2)) { hints.ai_flags = RAI_NUMERICHOST; } else if (!strncasecmp("gid", optarg, 3)) { hints.ai_flags = RAI_NUMERICHOST | RAI_FAMILY; hints.ai_family = AF_IB; } else if (strncasecmp("name", optarg, 4)) { fprintf(stderr, "Warning: unknown address format\n"); } break; case 'P': if (!strncasecmp("ipoib", optarg, 5)) { hints.ai_port_space = RDMA_PS_IPOIB; } else if (strncasecmp("udp", optarg, 3)) { fprintf(stderr, "Warning: unknown port space format\n"); } break; default: printf("usage: %s\n", argv[0]); printf("\t[-s server_address]\n"); printf("\t[-b bind_address]\n"); printf("\t[-f address_format]\n"); printf("\t name, ip, ipv6, or gid\n"); printf("\t[-P port_space]\n"); printf("\t udp or ipoib\n"); printf("\t[-c connections]\n"); printf("\t[-C message_count]\n"); printf("\t[-S message_size]\n"); printf("\t[-t type_of_service]\n"); printf("\t[-p port_space - %#x for UDP (default), " "%#x for IPOIB]\n", RDMA_PS_UDP, RDMA_PS_IPOIB); exit(1); } } test.connects_left = connections; test.channel = rdma_create_event_channel(); if (!test.channel) { perror("failed to create event channel"); exit(1); } if (alloc_nodes()) exit(1); if (dst_addr) { ret = run_client(); } else { hints.ai_flags |= RAI_PASSIVE; ret = run_server(); } printf("test complete\n"); destroy_nodes(); rdma_destroy_event_channel(test.channel); if (test.rai) rdma_freeaddrinfo(test.rai); printf("return status %d\n", ret); return ret; }
void destroy_db(Parts db) { destroy_nodes(db); free(db); }
int main(int argc, char **argv) { int op, ret; while ((op = getopt(argc, argv, "s:b:c:C:S:t:p:mT")) != -1) { switch (op) { case 's': dst_addr = optarg; break; case 'b': src_addr = optarg; break; case 'c': connections = atoi(optarg); break; case 'C': message_count = atoi(optarg); break; case 'S': message_size = atoi(optarg); break; case 't': set_tos = 1; tos = (uint8_t) strtoul(optarg, NULL, 0); break; case 'p': port = optarg; break; case 'm': migrate = 1; break; case 'T': set_ts = 1; break; default: printf("usage: %s\n", argv[0]); printf("\t[-s server_address]\n"); printf("\t[-b bind_address]\n"); printf("\t[-c connections]\n"); printf("\t[-C message_count]\n"); printf("\t[-S message_size]\n"); printf("\t[-t type_of_service]\n"); printf("\t[-p port_number]\n"); printf("\t[-m(igrate)]\n"); printf("\t[-T(imestamping)]\n"); exit(1); } } test.connects_left = connections; test.channel = rdma_create_event_channel(); if (!test.channel) { printf("failed to create event channel\n"); exit(1); } if (alloc_nodes()) exit(1); if (dst_addr) ret = run_client(); else ret = run_server(); printf("test complete\n"); destroy_nodes(); rdma_destroy_event_channel(test.channel); if (test.rai) rdma_freeaddrinfo(test.rai); printf("return status %d\n", ret); return ret; }
int main(int argc, char **argv) { int op, ret; while ((op = getopt(argc, argv, "m:M:sb:c:C:S:p:")) != -1) { switch (op) { case 'm': dst_addr = optarg; break; case 'M': unmapped_addr = 1; dst_addr = optarg; break; case 's': is_sender = 1; break; case 'b': src_addr = optarg; test.src_addr = (struct sockaddr *) &test.src_in; break; case 'c': connections = atoi(optarg); break; case 'C': message_count = atoi(optarg); break; case 'S': message_size = atoi(optarg); break; case 'p': port_space = strtol(optarg, NULL, 0); break; default: printf("usage: %s\n", argv[0]); printf("\t-m multicast_address\n"); printf("\t[-M unmapped_multicast_address]\n" "\t replaces -m and requires -b\n"); printf("\t[-s(ender)]\n"); printf("\t[-b bind_address]\n"); printf("\t[-c connections]\n"); printf("\t[-C message_count]\n"); printf("\t[-S message_size]\n"); printf("\t[-p port_space - %#x for UDP (default), " "%#x for IPOIB]\n", RDMA_PS_UDP, RDMA_PS_IPOIB); exit(1); } } if (unmapped_addr && !src_addr) { printf("unmapped multicast address requires binding " "to source address\n"); exit(1); } test.dst_addr = (struct sockaddr *) &test.dst_in; test.connects_left = connections; test.channel = rdma_create_event_channel(); if (!test.channel) { perror("failed to create event channel"); exit(1); } if (alloc_nodes()) exit(1); ret = run(); printf("test complete\n"); destroy_nodes(); rdma_destroy_event_channel(test.channel); printf("return status %d\n", ret); return ret; }
int main(int argc, char **argv) { char *node, *service; uint64_t flags = 0; int op, ret; opts = INIT_OPTS; hints = fi_allocinfo(); if (!hints) exit(1); hints->caps = FI_MSG; hints->ep_attr->type = FI_EP_MSG; hints->mode = FI_LOCAL_MR; hints->tx_attr->mode = hints->mode; hints->rx_attr->mode = hints->mode; hints->ep_attr->max_msg_size = 100; hints->tx_attr->size = 10; hints->rx_attr->size = 10; while ((op = getopt(argc, argv, "c:C:S:h" ADDR_OPTS INFO_OPTS)) != -1) { switch (op) { case 'c': connections = atoi(optarg); break; case 'C': hints->tx_attr->size = atoi(optarg); hints->rx_attr->size = hints->tx_attr->size; break; case 'S': hints->ep_attr->max_msg_size = atoi(optarg); break; default: ft_parse_addr_opts(op, optarg, &opts); ft_parseinfo(op, optarg, hints); break; case '?': case 'h': usage(argv[0]); } } if (optind < argc) opts.dst_addr = argv[optind]; connects_left = connections; ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts); if (ret) goto out; ret = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &fi); if (ret) { FT_PRINTERR("fi_getinfo", ret); goto out; } printf("using provider: %s\n", fi->fabric_attr->prov_name); ret = ft_open_fabric_res(); if (ret) goto out; if (alloc_nodes()) goto out; ret = opts.dst_addr ? run_client() : run_server(); printf("test complete\n"); destroy_nodes(); out: ft_free_res(); return -ret; }
/** * Release all memory consumed by the specified list * of outlines. * @param Outlines list of mf-outlines to be freed * @return none * @note Exceptions: none * @note History: Thu Dec 13 16:14:50 1990, DSJ, Created. */ void FreeOutlines(LIST Outlines) { destroy_nodes(Outlines, FreeMFOutline); } /* FreeOutlines */
void free_variables() { destroy_nodes(variable_list, free); variable_list = NIL; }