static bool determine_max_movement (tree stmt, bool must_preserve_exec) { basic_block bb = bb_for_stmt (stmt); struct loop *loop = bb->loop_father; struct loop *level; struct lim_aux_data *lim_data = LIM_DATA (stmt); tree val; ssa_op_iter iter; if (must_preserve_exec) level = ALWAYS_EXECUTED_IN (bb); else level = superloop_at_depth (loop, 1); lim_data->max_loop = level; FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_USE) if (!add_dependency (val, lim_data, loop, true)) return false; FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_VIRTUAL_USES) if (!add_dependency (val, lim_data, loop, false)) return false; lim_data->cost += stmt_cost (stmt); return true; }
/* * Read the dependencies of 'n'. */ static int read_depends(FILE * f, struct trie *nodes, struct node *n, unsigned int *nnodesp) { int err, len, newline, escaped = 0; int nnodes = 0; char token[LINE_MAX + 1]; do { len = next_token(f, token, LINE_MAX + 1, &newline); if (len > 0 && strcmp(token, "\\") == 0) escaped = 1; else if (len > 0) { struct node *d; escaped = 0; d = get_node(nodes, token, nnodesp); if (!d) return -1; err = add_dependency(n, d); if (err) return -1; } } while (len != EOF && (!newline || escaped)); return nnodes; }
void ACE_Config_Scheduler::add_dependency (RtecScheduler::handle_t handle, RtecScheduler::handle_t dependency, CORBA::Long number_of_calls, RtecScheduler::Dependency_Type_t dependency_type) { RtecScheduler::RT_Info* rt_info = 0; switch (impl->lookup_rt_info (handle, rt_info)) { case BaseSchedImplType::SUCCEEDED: { RtecScheduler::Dependency_Info dep; dep.rt_info = dependency; dep.number_of_calls = number_of_calls; dep.dependency_type = dependency_type; #if defined (TAO_USES_STRATEGY_SCHEDULER) impl->add_dependency (rt_info, dep); #else BaseSchedImplType::add_dependency (rt_info, dep); #endif /* defined (TAO_USES_STRATEGY_SCHEDULER) */ } break; case BaseSchedImplType::FAILED: case BaseSchedImplType::ST_UNKNOWN_TASK: default: ORBSVCS_ERROR ((LM_ERROR, "cannot find %d to add dependency", handle)); // TODO: throw something. break; } }
void DepTree::add_dependency( const PackageSpec &spec, DepTree::SpecTree::iterator where ) { try { string depstr = Info::instance().get_dependencystring( spec ); vector<PackageSpec> v; Info::instance().list_dependencies( depstr, v ); for( vector<PackageSpec>::iterator i = v.begin(); i != v.end(); ++i ) { i->verify(); where = tree.insert( where, *i ); add_dependency( *i, where.first_child() ); } } catch( PackageError &e ) { std::cerr << format(_("Error while building dependency graph: \"%1%\"\n"))%e.what(); } }
void form_dependency_graph (command_stream_t c_stream) { // If there is only one command, the graph is done if(c_stream == NULL || c_stream->stream_size == 1) return; int i, j; command_t independent = NULL; command_t dependent = NULL; // We offset the beginning of our loop by 1 as the first command is always independent for(i = 1; i < c_stream->stream_size; i++) { dependent = c_stream->commands[i]; for(j = 0; j < i; j++) { independent = c_stream->commands[j]; if(check_dependence (independent, dependent)) add_dependency (dependent, independent); } } }
void DepTree::doreload() { add_dependency( *spec, tree.begin() ); }
/* Parses a single module dependency line */ int parse_dep_line(char *line,select_menu *parent) { char *mod_name,*mod_dep,*mod_desc,*p; int name_len,desc_len,dep_len; select_item *item; mod_name = line+1; int len = strlen(line)-1; p = memchr(line,'=',len); if (!p) { fprintf(output,"Malformed dep line\n"); return -1; } name_len = p - mod_name; mod_name[name_len]=0; /* Is this still the previous module ? */ if (name_len == prev_module_len && memcmp(prev_module,mod_name,name_len) == 0) { /* Previously found module with multiple deps. * Just add the new dependency */ fprintf(output,"found prev module %s with extra deps\n",mod_name); mod_dep = p+1; dep_len = (line+len) - mod_dep; mod_dep[dep_len]=0; if (add_dependency(prev_item,mod_dep) < 0) { fprintf(output,"Failed to add dependency\n"); return -1; } } else { fprintf(output,"found new module %s\n",mod_name); /* nope, new module, get description */ mod_desc=p+1; p = memchr(mod_desc,'|',line+len-mod_desc); if (!p) { fprintf(output,"Malformed desc line\n"); return -1; } desc_len = p-mod_desc; mod_desc[desc_len]=0; item = create_item(mod_name,mod_desc); if (item == NULL) { fprintf(output,"Failed to create item\n"); return -1; } mod_dep = p+1; dep_len = (line+len) - mod_dep; mod_dep[dep_len]=0; /* Add the dependency */ if (add_dependency(item,mod_dep) < 0) { fprintf(output,"Failed to add dependency\n"); return -1; } /* And link it */ link_item(parent,item); prev_item = item; strcpy(prev_module,mod_name); prev_module_len = name_len; } return 0; }
void node::add_dependency(const node & dest) { add_dependency(dest.token); }
ddl::defn_node ffnn_ev_controller_defn::get_defn(ddl::specifier& spc) { auto available_input_names_fn = ddl::enum_defn_node::enum_values_str_fn_t{ [this](ddl::navigator nav) { // auto sys_defn = sys_defn_fn_(nav); // Get a list of agents using this evolved controller // TODO: !!! this. process will be similar to below in generate() where we find num_outputs //auto attached_agents = get_attached_agents(); // Get list of available state values // TODO: For now assuming just 1 agent, but ideally want to use the intersection of state values // for each attached agent. // TODO: Should be using get_agent_sensor_names(), or some agent-relative call // auto available_inputs = sys_defn->get_system_state_values(nav); // todo: deps //auto num_available_inputs = available_inputs.size(); auto available_inputs = sv_fn_(nav); ddl::enum_defn_node::enum_str_set_t enum_values; for(auto const& ip : available_inputs) { enum_values.insert(std::end(enum_values), ip.to_string()); } return enum_values; } }; available_input_names_fn.add_dependency(sv_fn_);// sys_defn_fn_); ddl::defn_node inputs = spc.enumeration("inputs") (ddl::spc_range < size_t > { 1, boost::none }) (ddl::define_enum_func{ available_input_names_fn }) ; ddl::defn_node hl_neuron_count = spc.integer("hl_neuron_count") (ddl::spc_min < ddl::integer_defn_node::value_t > { 1 }) (ddl::spc_default < ddl::integer_defn_node::value_t > { 1 }) // todo: dependent upon current sel count of inputs? ; ddl::defn_node hidden_layer = spc.composite("hidden_layer")(ddl::define_children{} ("num_neurons", hl_neuron_count) // todo: ); ddl::defn_node hidden_layer_list = spc.list("hidden_layer_list") (ddl::spc_item{ hidden_layer }) ; auto af_vals = ddl::define_enum_fixed{}; for(size_t fn = 0; fn < (size_t)nnet::ActivationFnType::Count; ++fn) { af_vals = af_vals(std::string{ nnet::ActivationFnNames2[fn] }); } ddl::defn_node act_fn = spc.enumeration("act_fn") (ddl::spc_range < size_t > { 1, 1 }) (ddl::spc_default < ddl::enum_defn_node::str_value_t > { { nnet::ActivationFnNames2[(int)nnet::ActivationFnType::SigmoidSymmetric] } }) (af_vals) ; ddl::defn_node steepness = spc.realnum("steepness") (ddl::spc_min < ddl::realnum_defn_node::value_t > { 0.0 }) (ddl::spc_default < ddl::realnum_defn_node::value_t > { 0.5 }) ; //////////TODO other location in param tree ddl::defn_node temp_mutation = gene_mutation_defn_.get_defn(spc); return spc.composite("ffnn_ev_controller")(ddl::define_children{} ("inputs", inputs) ("hidden_layer_list", hidden_layer_list) ("hidden_act_fn", act_fn) ("hidden_steepness", steepness) ("output_act_fn", act_fn) ("output_steepness", steepness) ("temp_mutation", temp_mutation) ); }