/* initialize network */ bool setup_network(void) { now = time(NULL); init_events(); init_connections(); init_subnets(); init_nodes(); init_edges(); init_requests(); if(get_config_int(lookup_config(config_tree, "PingInterval"), &pinginterval)) { if(pinginterval < 1) { pinginterval = 86400; } } else pinginterval = 60; if(!get_config_int(lookup_config(config_tree, "PingTimeout"), &pingtimeout)) pingtimeout = 5; if(pingtimeout < 1 || pingtimeout > pinginterval) pingtimeout = pinginterval; if(!get_config_int(lookup_config(config_tree, "MaxOutputBufferSize"), &maxoutbufsize)) maxoutbufsize = 10 * MTU; if(!setup_myself()) return false; return true; }
void ir_init(void) { firm_init_flags(); init_ident(); init_edges(); init_tarval_1(); /* Builds a basic program representation, so modes can be added. */ init_irprog_1(); init_mode(); init_tarval_2(); firm_init_op(); firm_init_reassociation(); firm_init_funccalls(); firm_init_inline(); firm_init_scalar_replace(); /* Builds a construct allowing to access all information to be constructed later. */ init_irprog_2(); firm_init_memory_disambiguator(); firm_init_loop_opt(); arch_dep_set_opts(arch_dep_none); init_execfreq(); firm_be_init(); #ifdef DEBUG_libfirm firm_init_debugger(); #endif }
void initialize_data_structures(int source) { init_edges(); /* We assume 3 is the source */ init_heap(source, heap, len_heap); /* Also initialize final array */ init_weight_array(source, weights, len_heap); }
void ir_init(void) { /* for historical reasons be_init must be run first */ firm_be_init(); /* initialize firm flags */ firm_init_flags(); /* initialize all ident stuff */ init_ident(); /* Edges need hooks. */ init_edges(); /* create the type kinds. */ init_tpop(); /* create an obstack and put all tarvals in a pdeq */ init_tarval_1(0l, /* support_quad_precision */0); /* Builds a basic program representation, so modes can be added. */ init_irprog_1(); /* initialize all modes an ir node can consist of */ init_mode(); /* initialize tarvals, and floating point arithmetic */ init_tarval_2(); /* initialize node opcodes */ firm_init_op(); /* init graph construction */ firm_init_irgraph(); /* kind of obstack initialization */ firm_init_mangle(); /* initialize reassociation */ firm_init_reassociation(); /* initialize function call optimization */ firm_init_funccalls(); /* initialize function inlining */ firm_init_inline(); /* initialize scalar replacement */ firm_init_scalar_replace(); /* Builds a construct allowing to access all information to be constructed later. */ init_irprog_2(); /* memory disambiguation */ firm_init_memory_disambiguator(); firm_init_loop_opt(); /* Init architecture dependent optimizations. */ arch_dep_set_opts(arch_dep_none); init_execfreq(); init_stat(); #ifdef DEBUG_libfirm /* integrated debugger extension */ firm_init_debugger(); #endif }
void ntPolyline::init() { stroke = 0.5; //INITIALIZE POLYLINE VERTEX DATA STRUCTURES vS = vecs[0]; vE = vecs[vecs.size()]; ntVertex vert = ntVertex(vS); verts.push_back(&vert); for (int i = 1; i < vecs.size(); i++) { if ((i != vecs.size() - 1) && (isClosed == true)) { vert = ntVertex(vecs[i]); verts.push_back(&vert); } } init_edges(); }
/* initialize network */ bool setup_network(meshlink_handle_t *mesh) { init_connections(mesh); init_nodes(mesh); init_edges(mesh); init_requests(mesh); mesh->pinginterval = 60; mesh->pingtimeout = 5; maxoutbufsize = 10 * MTU; if(!setup_myself(mesh)) return false; return true; }
void generate_random_subgraph(typename graph_traits<Graph>::size_type desired_verts, typename graph_traits<Graph>::size_type desired_edges, Graph& g, subgraph_adapter<Graph>& subg) { typedef typename graph_traits<Graph>::size_type size_type; typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator; typedef typename graph_traits<Graph>::edge_iterator edge_iterator; size_type order = num_vertices(g); size_type size = num_edges(g); vertex_iterator verts = vertices(g); edge_iterator edgs = edges(g); // The bitmap indicating which vertices are in the subgraph. vertex_property_map<Graph, bool> subgraph_verts(g); for (size_type i = 0; i < size; ++i) subgraph_verts[verts[i]] = false; // The bitmap indicating which edges are in the subgraph. edge_property_map<Graph, bool> subgraph_edges(g); for (size_type i = 0; i < size; ++i) subgraph_edges[edgs[i]] = false; // These are counters that are shared by all the copies of the visitors. size_type created_verts = 0; size_type created_edges = 0; detail::generate_random_subgraph_visitor<Graph> gen_sg_vis(desired_verts, desired_edges, subgraph_verts, subgraph_edges, g, created_verts, created_edges); psearch_high_low<Graph, detail::generate_random_subgraph_visitor<Graph>, AND_FILTER, DIRECTED> psrch(g, gen_sg_vis, 1); psrch.run(); init_edges(subgraph_edges, subg); delete [] subgraph_verts; }
void filter_graph_by_edges(graph_adapter& g, graph_adapter_trg& target, filter_comparator& filter_compare, subgraph_adapter<graph_adapter>& filteredG) { typedef typename graph_traits<graph_adapter>::edge_descriptor edge_descriptor; typedef typename graph_traits<graph_adapter>::size_type size_type; typedef typename graph_traits<graph_adapter>::edge_iterator edge_iterator; size_type n_edges = num_edges(g); // The bitmap indicating which edges to keep. int* possible_edges = (int*) calloc(n_edges, sizeof(int)); detail::iso_edge_filter<graph_adapter, filter_comparator, graph_adapter_trg> edgeTypeFilter(g, target, filter_compare, possible_edges); // Do a psearch_high_low<NO_FILTER, DIRECTED> with a visitor that doesn't // define a visit_test(). The default visit_test() always returns false. // Thus, each vertex will be visited once, and each out edge of every // vertex will be visited. For directed and bidirectional graphs, each // edge will be visited once. For undirected graphs, each edge will be // visited twice where each endpoint gets a chance to be the "source". psearch_high_low<graph_adapter, detail::iso_edge_filter<graph_adapter, filter_comparator, graph_adapter_trg>, NO_FILTER, DIRECTED> psrch(g, edgeTypeFilter, 100); psrch.run(); // Count the number of possible edges. size_type edge_count = 0; for (size_type i = 0; i < n_edges; ++i) { edge_count += possible_edges[i] > 0; } int* possible_edges2 = (int*) malloc(n_edges * sizeof(int)); // Change possible edges where each entry is the sum of all the previous // entries. possible_edges2[0] = possible_edges[0]; for (size_type i = 1; i < n_edges; ++i) { possible_edges2[i] = possible_edges2[i - 1] + possible_edges[i]; } // This sets the entries in possible_edges to be either -1 (representing // an edge that isn't possible) or 0..edge_count-1 (representing the new // edge id of a possible edge). possible_edges[0] = possible_edges2[0] == 1 ? 0 : -1; for (size_type i = 1; i < n_edges; ++i) { possible_edges[i] = possible_edges2[i] == possible_edges2[i - 1] ? -1 : possible_edges2[i] - 1; } free(possible_edges2); // Create an array of the possible edges then create a subgraph out of the // possible edges. edge_descriptor* filtered_edges = (edge_descriptor*) malloc(edge_count * sizeof(edge_descriptor)); edge_iterator edgs = edges(g); #pragma mta assert nodep for (size_type i = 0; i < n_edges; ++i) { if (possible_edges[i] >= 0) { filtered_edges[possible_edges[i]] = edgs[i]; } } init_edges(filtered_edges, edge_count, filteredG); free(filtered_edges); free(possible_edges); }
Triangle::Triangle(Point *center) { this->center = center; init_edges(); }