def generate_iot(args): print("generate iot ", args.output) # Constraints and variables with a power-law constraint graph: variables, constraints, domain = generate_powerlaw_var_constraints( args.num, args.domain, args.range ) # Build a dcop and computation graph with no agents, just to be able to # compute the footprint of computations: dcop = DCOP( "graph coloring", "min", domains={"d": domain}, variables=variables, agents={}, constraints=constraints, ) graph_module = import_module("pydcop.computations_graph.factor_graph") cg = graph_module.build_computation_graph(dcop) algo_module = load_algorithm_module("maxsum") footprints = {c.name: algo_module.computation_memory(c) for c in cg.nodes} # Generate an agent for each variable computation and assign the # computation to that agent. agents = {} # type: Dict[str, AgentDef] mapping = defaultdict(lambda: []) # type: Dict[str, List[str]] for comp in cg.nodes: if isinstance(comp, VariableComputationNode): a_name = agt_name(comp.name) agt = AgentDef( a_name, capacity=footprints[comp.name] * 100, default_hosting_cost=10, hosting_costs=agt_hosting_costs(comp, cg), default_route=1, routes=agt_route_costs(comp, cg), ) logger.debug( "Create agent %s for computation %s with capacity %s", agt.name, comp.name, agt.capacity, ) agents[agt.name] = agt mapping[agt.name].append(comp.name) # Now, we have created all the agents and distributed all the variables # let's distribute the factor computations. msg_load = msg_load_func(cg, algo_module.communication_load) factor_mapping = distribute_factors(agents, cg, footprints, mapping, msg_load) for a in mapping: mapping[a].extend(factor_mapping[a]) dcop = DCOP( "graph coloring", "min", domains={"d": domain}, variables=variables, agents=agents, constraints=constraints, ) distribution = Distribution(mapping) if args.output: outputfile = args.output write_in_file(outputfile, dcop_yaml(dcop)) dist = distribution.mapping() cost = ilp_compref.distribution_cost( distribution, cg, dcop.agents.values(), computation_memory=algo_module.computation_memory, communication_load=algo_module.communication_load, ) result = { "inputs": { "dist_algo": "io_problem", "dcop": args.output, "graph": "factor_graph", "algo": "maxsum", }, "distribution": dist, "cost": cost, } outputfile = "dist_" + args.output write_in_file(outputfile, yaml.dump(result)) else: print(dcop_yaml(dcop))
def generate(args): slots, events, resources = generate_problem_definition( args.slots_count, args.resources_count, args.max_resource_value, args.events_count, args.max_length_event, args.max_resources_event, ) penalty = args.max_resource_value * args.slots_count * args.resources_count variables, constraints, agents = peav_model(slots, events, resources, penalty) domains = { variable.domain.name: variable.domain for variable in variables.values() } variables = {variable.name: variable for variable in variables.values()} # agents_defs = {agent.name: agent for agent, _ in agents.values()} # Generate agents hosting and route costs agents_defs = {} if not args.no_agents: for agent, agt_variables in agents.items(): kw = {} kw["hosting_costs"] = {v.name: 0 for v in agt_variables} if args.hosting_default: kw["default_hosting_cost"] = args.hosting_default if args.capacity: kw["capacity"] = args.capacity if args.routes_default: kw["default_route"] = args.routes_default agents_defs[agent] = AgentDef(agent, **kw) dcop = DCOP( "MeetingSceduling", objective="max", domains=domains, variables=variables, constraints=constraints, agents=agents_defs, ) if not args.no_agents: distribution = Distribution({ agent.name: [v.name for v in agents[agent.name]] for agent in agents_defs.values() }) if args.output: output_file = args.output with open(output_file, encoding="utf-8", mode="w") as fo: fo.write(dcop_yaml(dcop)) if not args.no_agents: dist_result = { "inputs": { "dist_algo": "peav", "dcop": output_file, "graph": "constraints_graph", "algo": "NA", }, "distribution": distribution.mapping(), "cost": None, } path, ext = splitext(output_file) dist_output_file = f"{path}_dist{ext}" with open(dist_output_file, encoding="utf-8", mode="w") as fo: fo.write(yaml.dump(dist_result)) else: print(dcop_yaml(dcop)) if not args.no_agents: dist_result = { "inputs": { "dist_algo": "peav", "dcop": "NA", "graph": "constraints_graph", "algo": "NA", }, "distribution": distribution.mapping(), "cost": None, } # FIXME proper serialization of the distribution: print(yaml.dump(dist_result))