int main(int argc, char *argv[]) { struct dict_radix *dict = new_dict_radix(); allocate_nodes(dict, 200000, 100000, 10000); read_dict(dict, NULL); print_sizes(dict); print_stats(dict); return 0; }
/* ---------------------------------------------------------------------- */ static mxArray * allocate_grid(struct processed_grid *grid, const char *func) /* ---------------------------------------------------------------------- */ { size_t nflds, nhf; const char *fields[] = { "nodes", "faces", "cells", "type", "cartDims", "griddim" }; mxArray *G, *nodes, *faces, *cells; mxArray *type, *typestr, *cartDims, *griddim; nflds = sizeof(fields) / sizeof(fields[0]); nhf = count_halffaces(grid->number_of_faces, grid->face_neighbors); G = mxCreateStructMatrix(1, 1, nflds, fields); nodes = allocate_nodes(grid->number_of_nodes); faces = allocate_faces(grid->number_of_faces, grid->face_ptr[ grid->number_of_faces ]); cells = allocate_cells(grid->number_of_cells, nhf); type = mxCreateCellMatrix(1, 1); typestr = mxCreateString(func); cartDims = mxCreateDoubleMatrix(1, 3, mxREAL); griddim = mxCreateDoubleScalar(3); if ((G != NULL) && (nodes != NULL) && (faces != NULL) && (cells != NULL) && (type != NULL) && (typestr != NULL) && (cartDims != NULL) && (griddim != NULL)) { mxSetCell(type, 0, typestr); mxSetField(G, 0, "nodes" , nodes ); mxSetField(G, 0, "faces" , faces ); mxSetField(G, 0, "cells" , cells ); mxSetField(G, 0, "type" , type ); mxSetField(G, 0, "cartDims", cartDims); mxSetField(G, 0, "griddim" , griddim ); } else { if (griddim != NULL) { mxDestroyArray(griddim); } if (cartDims != NULL) { mxDestroyArray(cartDims); } if (typestr != NULL) { mxDestroyArray(typestr); } if (type != NULL) { mxDestroyArray(type); } if (cells != NULL) { mxDestroyArray(cells); } if (faces != NULL) { mxDestroyArray(faces); } if (nodes != NULL) { mxDestroyArray(nodes); } if (G != NULL) { mxDestroyArray(G); } G = NULL; } return G; }
int read_poly_file(const char *filename, triangulateio * input) { int error_value = 0; FILE *polyfile; int markers; int firstnode; polyfile = fopen(filename, "r"); if (polyfile == (FILE *) NULL) { printf(" Error: Cannot access file %s.\n", filename); return FILE_ERR; } error_value = read_nodes_header(polyfile, input, &markers); if (error_value != SUCCESS) return error_value; allocate_nodes(input); error_value = read_nodes(polyfile, input, &markers, &firstnode); if (error_value != SUCCESS) return error_value; error_value = read_segments_header(polyfile, input, &markers); if (error_value != SUCCESS) return error_value; allocate_segments(input); error_value = read_segments(polyfile, input, markers, firstnode); if (error_value != SUCCESS) return error_value; error_value = read_holes_header(polyfile, input); if (error_value != SUCCESS) return error_value; allocate_holes(input); error_value = read_holes(polyfile, input); if (error_value != SUCCESS) return error_value; report(input, 1, 0, 0, 1, 0, 0); return SUCCESS; }
void PDQ_Init(char *name) { extern char model[]; extern char s1[]; extern char tUnit[]; extern char wUnit[]; extern int demand_ext; extern int method; extern double tolerance; // These 3 globals are reset = 0 at the end of this proc extern int nodes; extern int streams; extern int demands; // set = 1 by SetDemand() extern int prev_init; extern NODE_TYPE *node; extern JOB_TYPE *job; extern TERMINAL_TYPE *tm; extern BATCH_TYPE *bt; extern TRANSACTION_TYPE *tx; extern SYSTAT_TYPE *sys; extern int PDQ_DEBUG; extern void allocate_nodes(); extern void allocate_jobs(); char *p = "PDQ_Init()"; if (PDQ_DEBUG) debug(p, "Entering"); if (strlen(name) > MAXCHARS) { resets(s1); sprintf(s1, "Model name > %d characters", MAXCHARS); errmsg(p, s1); } // There may be multiple Inits in the same model if (prev_init) { for (c = 0; c < MAXSTREAMS; c++) { if (job[c].term) { if (job[c].term->sys) { PDQ_FREE(job[c].term->sys); job[c].term->sys = NULL; job[c].batch->sys = NULL; job[c].trans->sys = NULL; } PDQ_FREE(job[c].term); job[c].term = NULL; } if (job[c].batch) { if (job[c].batch->sys) { PDQ_FREE(job[c].batch->sys); job[c].term->sys = NULL; job[c].batch->sys = NULL; job[c].trans->sys = NULL; } PDQ_FREE(job[c].batch); job[c].batch = NULL; } if (job[c].trans) { if (job[c].trans->sys) { PDQ_FREE(job[c].trans->sys); job[c].term->sys = NULL; job[c].batch->sys = NULL; job[c].trans->sys = NULL; } PDQ_FREE(job[c].trans); job[c].trans = NULL; } } // over c loop if (job) { PDQ_FREE(job); job = NULL; } if (node) { PDQ_FREE(node); node = NULL; } resets(model); resets(wUnit); resets(tUnit); } // Copy user-supplied name string into PDQ global model[] strcpy(model, name); Comment[0] = '\0'; // NULL string demand_ext = VOID; method = VOID; tolerance = TOL; allocate_nodes(MAXNODES+1); allocate_jobs(MAXSTREAMS+1); /********************************************************************************** On 12/6/06 John Strunk (Carnegie Mellon Univ.) sent the following comment: "My code analyzes a large number of models within a single invocation, so I call PDQ::Init to re-init the state before each model is analyzed. Unfortunately, a large portion of execution time (of my whole program) is spent in PDQ_Init, and I've tracked it down to the nested loop at PDQ_Build.c:130. Perhaps it would be possible to remove this set of loops entirely since calloc in allocate_*() right above that inits the memory to zero. These changes can provide a 6x speedup in my application." for (cc = 0; cc < MAXSTREAMS; cc++) { for (kk = 0; kk < MAXNODES; kk++) { node[kk].devtype = VOID; node[kk].sched = VOID; node[kk].demand[cc] = 0.0; node[kk].resit[cc] = 0.0; node[kk].qsize[cc] = 0.0; } job[cc].should_be_class = VOID; job[cc].network = VOID; } NJG on Tue, Apr 3, 2007 Since the speedup would be nearly an order of magnitude, it's worth a try. I was probably being overly defensive when I originally zeroed out every array element. After commenting out the above loops, a simple PDQ test (no re-Init calls), does not reveal any integrity problems. The VOID constant in PDQ_Lib.h also set to zero instead of -1. **********************************************************************************/ // reset circuit counters nodes = streams = demands = 0; c = k = 0; prev_init = TRUE; if (PDQ_DEBUG) { debug(p, "Exiting"); } } /* PDQ_Init */
/*this fucntion is already serialized in the function that calls this so from here on out there is no worry about locking*/ gasnete_coll_local_tree_geom_t *gasnete_coll_tree_geom_create_local(gasnete_coll_tree_type_t in_type, int rootrank, gasnete_coll_team_t team, gasnete_coll_tree_geom_t *base_geom) { gasnete_coll_local_tree_geom_t *geom; int i; gasnete_coll_tree_type_t intype_copy; tree_node_t *allnodes = (tree_node_t*) team->tree_construction_scratch; tree_node_t rootnode,mynode; gasneti_assert(rootrank<team->total_ranks && rootrank >=0); gasneti_assert_always(in_type); intype_copy = in_type; geom = (gasnete_coll_local_tree_geom_t*)gasneti_malloc(sizeof(gasnete_coll_local_tree_geom_t)); gasneti_assert_always(in_type==intype_copy); switch (in_type->tree_class) { #if 1 case GASNETE_COLL_NARY_TREE: gasneti_assert(in_type->num_params ==1); allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank); rootnode = make_nary_tree(allnodes, team->total_ranks, in_type->params[0]); geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1); geom->num_rotations = 1; geom->rotation_points[0] = rootrank; break; case GASNETE_COLL_KNOMIAL_TREE: gasneti_assert(in_type->num_params ==1); allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank); rootnode = make_knomial_tree(allnodes, team->total_ranks, in_type->params[0]); geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1); geom->num_rotations = 1; geom->rotation_points[0] = rootrank; break; case GASNETE_COLL_FLAT_TREE: allocate_nodes((tree_node_t**) &team->tree_construction_scratch , team, rootrank); rootnode = make_flat_tree(team->tree_construction_scratch, team->total_ranks); geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1); geom->num_rotations = 1; geom->rotation_points[0] = rootrank; break; case GASNETE_COLL_RECURSIVE_TREE: gasneti_assert(in_type->num_params ==1); allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank); rootnode = make_recursive_tree(allnodes, team->total_ranks, in_type->params[0]); geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1); geom->num_rotations = 1; geom->rotation_points[0] = rootrank; break; case GASNETE_COLL_FORK_TREE: allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank); rootnode = make_fork_tree(allnodes, team->total_ranks, in_type->params, in_type->num_params); geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1); geom->num_rotations = 1; geom->rotation_points[0] = rootrank; break; case GASNETE_COLL_HIERARCHICAL_TREE: #if 0 allnodes = team->tree_construction_scratch = allocate_nodes(allnodes, team, 0); rootnode = make_hiearchical_tree(in_type, allnodes, team->total_ranks); /* XXX ADD CODE TO GET ROTATION POINTS*/ break; #else gasneti_fatalerror("HIERARCHICAL_TREE not yet fully supported"); #endif #endif default: gasneti_fatalerror("unknown tree type"); break; } rootnode = setparents(rootnode); mynode = find_node(rootnode, team->myrank); geom->root = rootrank; geom->tree_type = in_type; geom->total_size = team->total_ranks; geom->parent = GET_PARENT_ID(mynode); geom->child_count = GET_NUM_CHILDREN(mynode); geom->mysubtree_size = treesize(mynode); geom->parent_subtree_size = treesize(mynode->parent); geom->children_reversed = mynode->children_reversed; if(rootrank != team->myrank) { geom->num_siblings = GET_NUM_CHILDREN(mynode->parent); geom->sibling_id = -1; geom->sibling_offset = 0; for(i=0; i<geom->num_siblings; i++) { int tmp_id; if(mynode->parent->children_reversed==1) { tmp_id = geom->num_siblings-1-i; } else { tmp_id =i; } if(GET_NODE_ID(GET_CHILD_IDX(mynode->parent, tmp_id))==team->myrank) { geom->sibling_id = tmp_id; break; } else { geom->sibling_offset += treesize(GET_CHILD_IDX(mynode->parent, tmp_id)); } } } else { geom->num_siblings = 0; geom->sibling_id = 0; geom->sibling_offset = 0; /***** THIS NEEDS TO BE TAKEN OUT The DFS ordering that we impose on the trees will mean that this no longer needs to be kept around but it's in here for now for backward compatability sake until we make the neccessary changes to all the other collective algorithms ****/ geom->dfs_order = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*team->total_ranks); for(i=0; i<team->total_ranks; i++) { geom->dfs_order[i] = (i+rootrank)%team->total_ranks; } } geom->seq_dfs_order = 1; geom->child_list = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count); geom->subtree_sizes = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count); geom->child_offset = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count); geom->grand_children = (gasnet_node_t*)gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count); geom->num_non_leaf_children=0; geom->num_leaf_children=0; geom->child_contains_wrap = 0; for(i=0; i<geom->child_count; i++) { geom->child_list[i] = GET_NODE_ID(GET_CHILD_IDX(mynode,i)); geom->subtree_sizes[i] = treesize(GET_CHILD_IDX(mynode,i)); geom->grand_children[i] = GET_NUM_CHILDREN(GET_CHILD_IDX(mynode, i)); if(geom->subtree_sizes[i] > 1) { geom->num_non_leaf_children++; } else { geom->num_leaf_children++; } if(geom->child_list[i]+geom->subtree_sizes[i] > geom->total_size) { geom->child_contains_wrap = 1; } } gasneti_assert((geom->num_leaf_children+geom->num_non_leaf_children) == geom->child_count); if(mynode->children_reversed==1) { size_t temp_offset = 0; for(i=geom->child_count-1; i>=0; i--) { geom->child_offset[i] = temp_offset; temp_offset+=geom->subtree_sizes[i]; } } else { size_t temp_offset = 0; for(i=0; i<geom->child_count; i++) { geom->child_offset[i] = temp_offset; temp_offset+=geom->subtree_sizes[i]; } } #if 0 /* Not using the reference counts for now */ gasneti_weakatomic_set(&(geom->ref_count), 0, 0); geom->base_geom = base_geom; #endif #if 0 gasnete_coll_print_tree(geom, gasneti_mynode); #endif return geom; }