/*
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();
}
