def distribute(
computation_graph: ComputationsFactorGraph,
agentsdef: Iterable[AgentDef],
hints=None,
computation_memory: Callable[[ComputationNode], float] = None,
communication_load: Callable[[ComputationNode, str], float] = None,
timeout=600, # Max 10 min
) -> Distribution:
if computation_memory is None or communication_load is None:
raise ImpossibleDistributionException(
"oilp_secp_fgdp distribution requires "
"computation_memory and link_communication functions"
)
mapping = defaultdict(lambda: [])
agents_capa = {a.name: a.capacity for a in agentsdef}
variable_computations, factor_computations = [], []
for comp in computation_graph.nodes:
if isinstance(comp, VariableComputationNode):
variable_computations.append(comp.name)
elif isinstance(comp, FactorComputationNode):
factor_computations.append(comp.name)
else:
raise ImpossibleDistributionException(
f"Error: {comp} is neither a factor nor a variable computation"
)
# actuators variables and cost factor on the corresponding agent:
for variable in variable_computations[:]:
for agent in agentsdef:
if agent.hosting_cost(variable) == 0:
# Found an actuator variable, host it on the agent
mapping[agent.name].append(variable)
variable_computations.remove(variable)
agents_capa[agent.name] -= computation_memory(
computation_graph.computation(variable)
)
# search for the cost factor, if any, and host it on the same agent.
for factor in factor_computations[:]:
if f"c_{variable}" == factor:
mapping[agent.name].append(factor)
factor_computations.remove(factor)
agents_capa[agent.name] -= computation_memory(
computation_graph.computation(factor)
)
if agents_capa[agent.name] < 0:
raise ImpossibleDistributionException(
f"Not enough capacity on {agent} to hosts actuator {variable}: {agents_capa[agent.name]}"
)
break
logger.info(f"Actuator variables - agents: {dict(mapping)}")
logger.info(f"Remaining capacity: {dict(agents_capa)}")
return fg_secp_ilp(
computation_graph,
agentsdef,
Distribution(mapping),
computation_memory,
communication_load,
)
def distribute(
computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory: Callable[[ComputationNode], float] = None,
communication_load: Callable[[ComputationNode, str], float] = None,
timeout=None, # not used
) -> Distribution:
if computation_memory is None:
raise ImpossibleDistributionException("adhoc distribution requires "
"computation_memory functions")
mapping = defaultdict(lambda: [])
agents_capa = {a.name: a.capacity for a in agentsdef}
computations = computation_graph.node_names()
# as we're dealing with a secp modelled as a constraint graph,
# we only have actuator and pysical model variables.
# First, put each actuator variable on its agent
for agent in agentsdef:
for comp in computation_graph.node_names():
if agent.hosting_cost(comp) == 0:
mapping[agent.name].append(comp)
computations.remove(comp)
agents_capa[agent.name] -= computation_memory(
computation_graph.computation(comp))
if agents_capa[agent.name] < 0:
raise ImpossibleDistributionException(
f"Not enough capacity on {agent} to hosts actuator {comp}: {agents_capa[agent.name]}"
)
break
logger.info(f"Actuator variables on agents: {dict(mapping)}")
# We must now place physical model variable on an agent that host
# a variable it depends on.
# As physical models always depends on actuator variable,
# there must always be a computation it depends on that is already hosted.
for comp in computations:
footprint = computation_memory(computation_graph.computation(comp))
neighbors = computation_graph.neighbors(comp)
candidates = find_candidates(agents_capa, comp, footprint, mapping,
neighbors)
# Host the computation on the first agent and decrease its remaining capacity
selected = candidates[0][2]
mapping[selected].append(comp)
agents_capa[selected] -= footprint
return Distribution({a: list(mapping[a]) for a in mapping})
def distribute(computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory=None,
communication_load=None):
"""
Generate a distribution for the dcop.
This method uses a simple heuristic for distribution, with no guaranty of
optimality.
Even if a feasible distribution exists, this method is not warranted to
find it.
When using a dcop that represents an secp, given the correct
DistributionHint the same distribution should be generated that with the
adhoc secp distribution method.
"""
if computation_memory is None:
raise ImpossibleDistributionException('adhoc distribution requires '
'computation_memory functions')
agents = list(agentsdef)
hints = DistributionHints() if hints is None else hints
return _distribute_try(computation_graph, agents, hints,
computation_memory, computation_graph)
def find_candidates(agents_capa: Dict[str, int], comp: str, footprint: float,
mapping: Dict, neighbors: Iterable[str]):
# Candidate : agents with enough capacity, that host at least
# one neighbor computation
candidates = []
for agent, capa in agents_capa.items():
hosted_neighbors = len(set(mapping[agent]).intersection(neighbors))
# logger.debug(
# f"agent: {agent} {hosted_neighbors} {set(mapping[agent])} - {neighbors}")
hosted_neighbors = len(set(mapping[agent]).intersection(neighbors))
if hosted_neighbors > 0 and capa >= footprint:
candidates.append((hosted_neighbors, capa, agent))
if not candidates:
logger.error(
f"Cannot host {comp} with footprint {footprint} - no valid candidate"
)
logger.error(f"Already hosted: {dict(mapping)}")
logger.error(f"Remaining agents capacity: {agents_capa} - {footprint}")
raise ImpossibleDistributionException(
f"No neighbor or not enough capacity to host {comp}")
# Now, sort candidate agent by the number of neighbor computation they host
# and remaining capacity
candidates.sort(reverse=True)
return candidates
def distribute(computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints=None,
computation_memory=None,
communication_load=None):
"""
Generate a distribution for the dcop.
:param computation_graph: a ComputationGraph
:param agentsdef: the agents definitions
:param hints: a DistributionHints
:param computation_memory: a function that takes a computation node as an
argument and return the memory footprint for this
:param link_communication: a function that takes a Link as an argument
and return the communication cost of this edge
"""
if computation_memory is None or communication_load is None:
raise ImpossibleDistributionException('LinearProg distribution requires '
'computation_memory and link_communication functions')
agents = list(agentsdef)
hints = DistributionHints() if hints is None else hints
return factor_graph_lp_model(computation_graph, agents, hints,
computation_memory, communication_load)
def distribute(computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory=None,
communication_load=None):
"""
Generate a distribution for the dcop.
:param computation_graph: a ComputationGraph
:param agentsdef: the agents definitions
:param hints: a DistributionHints
:param computation_memory: a function that takes a computation node as an
argument and return the memory footprint for this
:param link_communication: a function that takes a Link as an argument
and return the communication cost of this edge
"""
if computation_memory is None or communication_load is None:
raise ImpossibleDistributionException(
'LinearProg distribution requires '
'computation_memory and link_communication functions')
agents = list(agentsdef)
# In order to remove (latter on) distribution hints, we interpret
# hosting costs of 0 as a "must host" relationship
must_host = defaultdict(lambda: [])
for agent in agentsdef:
for comp in computation_graph.node_names():
if agent.hosting_cost(comp) == 0:
must_host[agent.name].append(comp)
logger.debug(f"Must host: {must_host}")
return factor_graph_lp_model(computation_graph, agents, must_host,
computation_memory, communication_load)
def distribute(computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory=None,
communication_load=None) -> Distribution:
"""
Simplistic distribution method: each computation is hosted on agent
agent and each agent host a single computation.
Agent capacity is not considered.
Raises an ImpossibleDistributionException
:param computation_graph:
:param agentsdef: AgntsDef object containing the list of agent, there must
be at least as many agents as computations
:param hints DistributionHints
:return: a distribution a dict {agent_name: [ var_name, ...]}
"""
agents = list(agentsdef)
if len(agents) < len(computation_graph.nodes):
raise ImpossibleDistributionException(
'Not enough agents for one agent for each computation : {} < {}'.
format(len(agents), len(computation_graph.nodes)))
agent_names = [a.name for a in agents]
distribution = defaultdict(lambda: list())
for n, a in zip(computation_graph.nodes, agent_names):
distribution[a].append(n.name)
return Distribution(distribution)
def distribute(
computation_graph: ComputationConstraintsHyperGraph,
agentsdef: Iterable[AgentDef],
hints=None,
computation_memory: Callable[[ComputationNode], float] = None,
communication_load: Callable[[ComputationNode, str], float] = None,
timeout=600, # Max 10 min
) -> Distribution:
if computation_memory is None or communication_load is None:
raise ImpossibleDistributionException(
"oilp_secp_cgdp distribution requires "
"computation_memory and link_communication functions")
mapping = defaultdict(lambda: [])
agents_capa = {a.name: a.capacity for a in agentsdef}
computations = computation_graph.node_names()
# as we're dealing with a secp modelled as a constraint graph,
# we only have actuator and pysical model variables.
# First, put each actuator variable on its agent
for agent in agentsdef:
for comp in computation_graph.node_names():
if agent.hosting_cost(comp) == 0:
mapping[agent.name].append(comp)
computations.remove(comp)
agents_capa[agent.name] -= computation_memory(
computation_graph.computation(comp))
if agents_capa[agent.name] < 0:
raise ImpossibleDistributionException(
f"Not enough capacity on {agent} to hosts actuator {comp}: {agents_capa[agent.name]}"
)
logger.info(f"Actuator variables on agents: {dict(mapping)}")
logger.info(f"Remaining capacity: {dict(agents_capa)}")
return cg_secp_ilp(
computation_graph,
agentsdef,
Distribution(mapping),
computation_memory,
communication_load,
)
def distribute(computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory=None,
communication_load=None,
timeout=None) -> Distribution:
"""
Simplistic distribution method: each computation is hosted on agent
agent and each agent host a single computation.
Agent capacity is not considered.
Raises an ImpossibleDistributionException
Parameters
----------
computation_graph: a ComputationGraph
the computation graph containing the computation that must be
distributed
agentsdef: iterable of AgentDef objects
The definition of the agents the computation will be assigned to.
There **must** be at least as many agents as computations.
hints:
Not used by the ``oneagent`` distribution method.
computation_memory:
Not used by the ``oneagent`` distribution method.
computation_memory:
Not used by the ``oneagent`` distribution method.
Returns
-------
distribution: Distribution
A Distribution object containing the mapping form agents to
computations.
"""
agents = list(agentsdef)
if len(agents) < len(computation_graph.nodes):
raise ImpossibleDistributionException(
'Not enough agents for one agent for each computation : {} < {}'.
format(len(agents), len(computation_graph.nodes)))
agent_names = [a.name for a in agents]
distribution = defaultdict(lambda: list())
for n, a in zip(computation_graph.nodes, agent_names):
distribution[a].append(n.name)
return Distribution(distribution)
def distribute(
computation_graph: ComputationsFactorGraph,
agentsdef: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory: Callable[[ComputationNode], float] = None,
communication_load: Callable[[ComputationNode, str], float] = None,
timeout=None, # not used
) -> Distribution:
if computation_memory is None:
raise ImpossibleDistributionException("adhoc distribution requires "
"computation_memory functions")
# as we're dealing with a secp modelled as a factor graph, we have computations for
# actuator and physical model variables, rules and physical model factors.
mapping = defaultdict(lambda: [])
agents_capa = {a.name: a.capacity for a in agentsdef}
variable_computations = []
factor_computations = []
for comp in computation_graph.nodes:
if isinstance(comp, VariableComputationNode):
variable_computations.append(comp.name)
elif isinstance(comp, FactorComputationNode):
factor_computations.append(comp.name)
else:
raise ImpossibleDistributionException(
f"Error: {comp} is neither a factor nor a variable computation"
)
# First, put each actuator variable and cost factor on its agent
for variable in variable_computations[:]:
for agent in agentsdef:
if agent.hosting_cost(variable) == 0:
# Found an actuator variable, host it on the agent
mapping[agent.name].append(variable)
variable_computations.remove(variable)
agents_capa[agent.name] -= computation_memory(
computation_graph.computation(variable))
# search for the cost factor, if any, and host it on the same agent.
for factor in factor_computations[:]:
if f"c_{variable}" == factor:
mapping[agent.name].append(factor)
factor_computations.remove(factor)
agents_capa[agent.name] -= computation_memory(
computation_graph.computation(factor))
if agents_capa[agent.name] < 0:
raise ImpossibleDistributionException(
f"Not enough capacity on {agent} to hosts actuator {variable}: {agents_capa[agent.name]}"
)
break
logger.info(f"Actuator computations - agents: {dict(mapping)}")
logger.info(f"Remaining capacity: {dict(agents_capa)}")
# now find computations for physical models and variables variables.
# * all remaining variables are model variables
# * physical model factor computation names contain the name of the variable
model_variables = variable_computations
models = []
for model_var in model_variables:
for fact in factor_computations:
if f"c_{model_var}" == fact:
models.append((model_var, fact))
factor_computations.remove(fact)
# All remaining factor ar rule factors
rule_factors = factor_computations
logger.debug(f"Physical models: {models}")
logger.debug(f"Rules: {rule_factors}")
# Now place models
for model_var, model_fac in models:
footprint = computation_memory(
computation_graph.computation(model_fac)) + computation_memory(
computation_graph.computation(model_var))
neighbors = computation_graph.neighbors(model_fac)
candidates = find_candidates(agents_capa, model_fac, footprint,
mapping, neighbors)
# Host the model on the first agent and decrease its remaining capacity
selected = candidates[0][2]
mapping[selected].append(model_var)
mapping[selected].append(model_fac)
agents_capa[selected] -= footprint
logger.debug(f"All models hosted: {dict(mapping)}")
logger.debug(f"Remaining capacity: {agents_capa}")
# And rules at last:
for rule_fac in rule_factors:
footprint = computation_memory(computation_graph.computation(rule_fac))
neighbors = computation_graph.neighbors(rule_fac)
candidates = find_candidates(agents_capa, rule_fac, footprint, mapping,
neighbors)
# Host the computation on the first agent and decrease its remaining capacity
selected = candidates[0][2]
mapping[selected].append(rule_fac)
agents_capa[selected] -= footprint
return Distribution({a: list(mapping[a]) for a in mapping})
def distribute(
computation_graph: ComputationGraph,
agentsdef: Iterable[AgentDef],
hints=None,
computation_memory: Callable[[ComputationNode], float] = None,
communication_load: Callable[[ComputationNode, str], float] = None,
) -> Distribution:
"""
gh-cgdp distribution method.
Heuristic distribution baed on communication and hosting costs, while respecting
agent's capacities
Parameters
----------
computation_graph
agentsdef
hints
computation_memory
communication_load
Returns
-------
Distribution:
The distribution for the computation graph.
"""
# Place computations with hosting costs == 0
# For SECP, this assign actuators var and factor to the right device.
fixed_mapping = {}
for comp in computation_graph.node_names():
for agent in agentsdef:
if agent.hosting_cost(comp) == 0:
fixed_mapping[comp] = (
agent.name,
computation_memory(computation_graph.computation(comp)),
)
break
# Sort computation by footprint, but add a random element to avoid sorting on names
computations = [(computation_memory(n), n, None, random.random())
for n in computation_graph.nodes
if n.name not in fixed_mapping]
computations = sorted(computations,
key=lambda o: (o[0], o[3]),
reverse=True)
computations = [t[:-1] for t in computations]
logger.info("placing computations %s",
[(f, c.name) for f, c, _ in computations])
current_mapping = {} # Type: Dict[str, str]
i = 0
while len(current_mapping) != len(computations):
footprint, computation, candidates = computations[i]
logger.debug(
"Trying to place computation %s with footprint %s",
computation.name,
footprint,
)
# look for cancidiate agents for computation c
# TODO: keep a list of remaining capacities for agents ?
if candidates is None:
candidates = candidate_hosts(
computation,
footprint,
computations,
agentsdef,
communication_load,
current_mapping,
fixed_mapping,
)
computations[i] = footprint, computation, candidates
logger.debug("Candidates for computation %s : %s", computation.name,
candidates)
if not candidates:
if i == 0:
logger.error(
f"Cannot find a distribution, no candidate for computation {computation}\n"
f" current mapping: {current_mapping}")
raise ImpossibleDistributionException(
f"Impossible Distribution, no candidate for {computation}")
# no candidate : backtrack !
i -= 1
logger.info(
"No candidate for %s, backtrack placement "
"of computation %s (was on %s",
computation.name,
computations[i][1].name,
current_mapping[computations[i][1].name],
)
current_mapping.pop(computations[i][1].name)
# FIXME : eliminate selected agent for previous computation
else:
_, selected = candidates.pop()
current_mapping[computation.name] = selected.name
computations[i] = footprint, computation, candidates
logger.debug("Place computation %s on agent %s", computation.name,
selected.name)
i += 1
# Build the distribution for the mapping
agt_mapping = defaultdict(lambda: [])
for c, a in current_mapping.items():
agt_mapping[a].append(c)
for c, (a, _) in fixed_mapping.items():
agt_mapping[a].append(c)
dist = Distribution(agt_mapping)
return dist
def ilp_cgdp(
cg: ComputationGraph,
agentsdef: Iterable[AgentDef],
footprint: Callable[[str], float],
capacity: Callable[[str], float],
route: Callable[[str, str], float],
msg_load: Callable[[str, str], float],
hosting_cost: Callable[[str, str], float],
):
agt_names = [a.name for a in agentsdef]
pb = LpProblem("oilp_cgdp", LpMinimize)
# One binary variable xij for each (variable, agent) couple
xs = LpVariable.dict("x", (cg.node_names(), agt_names), cat=LpBinary)
# TODO: Do not create var for computation that are already assigned to an agent with hosting = 0 ?
# Force computation with hosting cost of 0 to be hosted on that agent.
# This makes the work much easier for glpk !
x_fixed_to_0 = []
x_fixed_to_1 = []
for agent in agentsdef:
for comp in cg.node_names():
assigned_agent = None
if agent.hosting_cost(comp) == 0:
pb += xs[(comp, agent.name)] == 1
x_fixed_to_1.append((comp, agent.name))
assigned_agent = agent.name
for other_agent in agentsdef:
if other_agent.name == assigned_agent:
continue
pb += xs[(comp, other_agent.name)] == 0
x_fixed_to_0.append((comp, other_agent.name))
logger.debug(
f"Setting binary varaibles to fixed computation {comp}")
# One binary variable for computations c1 and c2, and agent a1 and a2
betas = {}
count = 0
for a1, a2 in combinations(agt_names, 2):
# Only create variables for couple c1, c2 if there is an edge in the
# graph between these two computations.
for l in cg.links:
# As we support hypergraph, we may have more than 2 ends to a link
for c1, c2 in combinations(l.nodes, 2):
if (c1, a1, c2, a2) in betas:
continue
count += 2
b = LpVariable("b_{}_{}_{}_{}".format(c1, a1, c2, a2),
cat=LpBinary)
betas[(c1, a1, c2, a2)] = b
# Linearization constraints :
# a_ijmn <= x_im
# a_ijmn <= x_jn
if (c1, a1) in x_fixed_to_0 or (c2, a2) in x_fixed_to_0:
pb += b == 0
elif (c1, a1) in x_fixed_to_1:
pb += b == xs[(c2, a2)]
elif (c2, a2) in x_fixed_to_1:
pb += b == xs[(c1, a1)]
else:
pb += b <= xs[(c1, a1)]
pb += b <= xs[(c2, a2)]
pb += b >= xs[(c2, a2)] + xs[(c1, a1)] - 1
b = LpVariable("b_{}_{}_{}_{}".format(c1, a2, c2, a1),
cat=LpBinary)
if (c1, a2) in x_fixed_to_0 or (c2, a1) in x_fixed_to_0:
pb += b == 0
elif (c1, a2) in x_fixed_to_1:
pb += b == xs[(c2, a1)]
elif (c2, a1) in x_fixed_to_1:
pb += b == xs[(c1, a2)]
else:
betas[(c1, a2, c2, a1)] = b
pb += b <= xs[(c2, a1)]
pb += b <= xs[(c1, a2)]
pb += b >= xs[(c1, a2)] + xs[(c2, a1)] - 1
# Set objective: communication + hosting_cost
pb += (
_objective(xs, betas, route, msg_load, hosting_cost),
"Communication costs and prefs",
)
# Adding constraints:
# Constraints: Memory capacity for all agents.
for a in agt_names:
pb += (
lpSum([footprint(i) * xs[i, a]
for i in cg.node_names()]) <= capacity(a),
"Agent {} capacity".format(a),
)
# Constraints: all computations must be hosted.
for c in cg.node_names():
pb += (
lpSum([xs[c, a] for a in agt_names]) == 1,
"Computation {} hosted".format(c),
)
# solve using GLPK
status = pb.solve(
solver=GLPK_CMD(keepFiles=1, msg=False, options=["--pcost"]))
if status != LpStatusOptimal:
raise ImpossibleDistributionException("No possible optimal"
" distribution ")
logger.debug("GLPK cost : %s", pulp.value(pb.objective))
mapping = {}
for k in agt_names:
agt_computations = [
i for i, ka in xs if ka == k and pulp.value(xs[(i, ka)]) == 1
]
# print(k, ' -> ', agt_computations)
mapping[k] = agt_computations
return mapping
def distribute_factors(
agents: Dict[str, AgentDef],
cg: ComputationGraph,
footprints: Dict[str, float],
mapping: Dict[str, List[str]],
msg_load: Callable[[str, str], float],
) -> Dict[str, List[str]]:
"""
Optimal distribution of factors on agents.
Parameters
----------
cg: computations graph
agents: dict
a dict {agent_name : AgentDef} containing all available agents
Returns
-------
a dict { agent_name: list of factor names}
"""
pb = LpProblem("ilp_factors", LpMinimize)
# build the inverse mapping var -> agt
inverse_mapping = {} # type: Dict[str, str]
for a in mapping:
inverse_mapping[mapping[a][0]] = a
# One binary variable xij for each (variable, agent) couple
factor_names = [n.name for n in cg.nodes if isinstance(n, FactorComputationNode)]
xs = LpVariable.dict("x", (factor_names, agents), cat=LpBinary)
logger.debug("Binary variables for factor distribution : %s", xs)
# Hard constraints: respect agent's capacity
for a in agents:
# Footprint of the variable this agent is already hosting:
v_footprint = footprints[mapping[a][0]]
pb += (
lpSum([footprints[fn] * xs[fn, a] for fn in factor_names])
<= (agents[a].capacity - v_footprint),
"Agent {} capacity".format(a),
)
# Hard constraints: all computations must be hosted.
for c in factor_names:
pb += lpSum([xs[c, a] for a in agents]) == 1, "Factor {} hosted".format(c)
# 1st objective : minimize communication costs:
comm = LpAffineExpression()
for (fn, an_f) in xs:
for vn in cg.neighbors(fn):
an_v = inverse_mapping[vn] # agt hosting neighbor var vn
comm += agents[an_f].route(an_v) * msg_load(vn, fn) * xs[(fn, an_f)]
# 2st objective : minimize hosting costs
hosting = lpSum([agents[a].hosting_cost(c) * xs[(c, a)] for c, a in xs])
# agregate the two objectives using RATIO_HOST_COMM
pb += lpSum([RATIO_HOST_COMM * comm, (1 - RATIO_HOST_COMM) * hosting])
# solve using GLPK and convert to mapping { agt_name : [factors names]}
status = pb.solve(solver=GLPK_CMD(keepFiles=1, msg=False, options=["--pcost"]))
if status != LpStatusOptimal:
raise ImpossibleDistributionException(
"No possible optimal distribution for factors"
)
logger.debug("GLPK cost : %s", value(pb.objective))
mapping = {} # type: Dict[str, List[str]]
for k in agents:
agt_computations = [i for i, ka in xs if ka == k and value(xs[(i, ka)]) == 1]
# print(k, ' -> ', agt_computations)
mapping[k] = agt_computations
logger.debug("Factors distribution : %s ", mapping)
return mapping
def cg_secp_ilp(
cg: ComputationConstraintsHyperGraph,
agents: List[AgentDef],
already_assigned: Distribution,
computation_memory: Callable[[ComputationNode], float],
communication_load: Callable[[ComputationNode, str], float],
timeout=600, # Max 10 min
) -> Distribution:
start_t = time.time()
agents = list(agents)
agents_names = [a.name for a in agents]
# Only keep computations for which we actually need to find an agent.
comps_to_host = [
c for c in cg.node_names() if not already_assigned.has_computation(c)
]
# x_i^k : binary variable indicating if var x_i is hosted on agent a_k.
xs = _build_cs_binvar(comps_to_host, agents_names)
# alpha_ijk : binary variable indicating if x_i and f_j are both on a_k.
alphas = _build_alphaijk_binvars(cg, agents_names)
logger.debug(f"alpha_ijk {alphas}")
# LP problem with objective function (total communication cost).
pb = LpProblem("distribution", LpMinimize)
pb += (
_objective_function(cg, communication_load, alphas, agents_names),
"Communication costs",
)
# Constraints.
# All variable computations must be hosted:
for i in comps_to_host:
pb += (
lpSum([xs[(i, k)] for k in agents_names]) == 1,
"var {} is hosted".format(i),
)
# Each agent must host at least one computation:
# We only need this constraints for agents that do not already host a
# computation:
empty_agents = [
a for a in agents_names if not already_assigned.computations_hosted(a)
]
for k in empty_agents:
pb += (
lpSum([xs[(i, k)] for i in comps_to_host]) >= 1,
"atleastone {}".format(k),
)
# Memory capacity constraint for agents
for a in agents:
# Decrease capacity for already hosted computations
capacity = a.capacity - sum([
secp_computation_memory_in_cg(c, cg, computation_memory)
for c in already_assigned.computations_hosted(a.name)
])
pb += (
lpSum([
secp_computation_memory_in_cg(i, cg, computation_memory) *
xs[(i, a.name)] for i in comps_to_host
]) <= capacity,
"memory {}".format(a.name),
)
# Linearization constraints for alpha_ijk.
for (i, j), k in alphas:
if i in comps_to_host and j in comps_to_host:
pb += alphas[((i, j), k)] <= xs[(i, k)], "lin1 {}{}{}".format(
i, j, k)
pb += alphas[((i, j), k)] <= xs[(j, k)], "lin2 {}{}{}".format(
i, j, k)
pb += (
alphas[((i, j), k)] >= xs[(i, k)] + xs[(j, k)] - 1,
"lin3 {}{}{}".format(i, j, k),
)
elif i in comps_to_host and j not in comps_to_host:
# Var is free, factor is already hosted
if already_assigned.agent_for(j) == k:
pb += alphas[((i, j), k)] == xs[(i, k)]
else:
pb += alphas[((i, j), k)] == 0
elif i not in comps_to_host and j in comps_to_host:
# if i is not in vars_vars_to_host, it means that it's a
# computation that is already hosted (from hints)
if already_assigned.agent_for(i) == k:
pb += alphas[((i, j), k)] == xs[(j, k)]
else:
pb += alphas[((i, j), k)] == 0
else:
# i and j are both alredy hosted
if (already_assigned.agent_for(i) == k
and already_assigned.agent_for(j) == k):
pb += alphas[((i, j), k)] == 1
else:
pb += alphas[((i, j), k)] == 0
# the timeout for the solver must be monierd by the time spent to build the pb:
remaining_time = round(timeout - (time.time() - start_t)) - 2
# Now solve our LP
status = pb.solve(
GLPK_CMD(keepFiles=0,
msg=False,
options=["--pcost", "--tmlim",
str(remaining_time)]))
if status != LpStatusOptimal:
raise ImpossibleDistributionException("No possible optimal"
" distribution ")
else:
logger.debug("GLPK cost : %s", pulp.value(pb.objective))
comp_dist = already_assigned
for k in agents_names:
agt_vars = [
i for i, ka in xs if ka == k and pulp.value(xs[(i, ka)]) == 1
]
comp_dist.host_on_agent(k, agt_vars)
return comp_dist
def factor_graph_lp_model(cg: ComputationsFactorGraph,
agents: List[AgentDef],
must_host: Dict[str, List],
computation_memory=None,
communication_load=None):
"""
To distribute we need:
* com : the communication cost of an edge between a var and a fact
* mem_var : the memory footprint of a variable computation
* mem_fac : the memory footprint of a factor computation
These function depends on the algorithm.
Here
* mem_var and mem_fac are given by the computation_memory method.
* com is given by computation_memory
:return:
"""
variables = [n for n in cg.nodes if n.type == 'VariableComputation']
factors = [n for n in cg.nodes if n.type == 'FactorComputation']
agents = list(agents)
agents_names = [a.name for a in agents]
fixed_dist = Distribution(must_host)
# Only keep computations for which we actually need to find an agent.
vars_to_host = [
v.name for v in variables if not fixed_dist.has_computation(v.name)
]
facs_to_host = [
f.name for f in factors if not fixed_dist.has_computation(f.name)
]
# x_i^k : binary variable indicating if var x_i is hosted on agent a_k.
xs = _build_xs_binvar(vars_to_host, agents_names)
# f_j^k : binary variable indicating if factor f_j is hosted on agent a_k.
fs = _build_fs_binvar(facs_to_host, agents_names)
# alpha_ijk : binary variable indicating if x_i and f_j are both on a_k.
alphas = _build_alphaijk_binvars(cg, agents_names)
# LP problem with objective function (total communication cost).
pb = LpProblem('distribution', LpMinimize)
pb += _objective_function(cg, communication_load, alphas,
agents_names), 'Communication costs'
# Constraints.
# All variable computations must be hosted:
for i in vars_to_host:
pb += lpSum([xs[(i, k)] for k in agents_names]) == 1, \
'var {} is hosted'.format(i)
# All factor computations must be hosted:
for j in facs_to_host:
pb += lpSum([fs[(j, k)] for k in agents_names]) == 1, \
'factor {} is hosted'.format(j)
# Each agent must host at least one computation:
# We only need this constraints for agents that do not already host a
# computation:
empty_agents = [a for a in agents_names if not must_host[a]]
for k in empty_agents:
pb += lpSum([xs[(i, k)] for i in vars_to_host]) + \
lpSum([fs[(j, k)] for j in facs_to_host]) >= 1, \
'atleastone {}'.format(k)
# Memory capacity constraint for agents
for a in agents:
# Decrease capacity for already hosted computations
capacity = a.capacity - \
sum([_computation_memory_in_cg(c, cg, computation_memory)
for c in must_host[a.name]])
pb += lpSum([_computation_memory_in_cg(i, cg, computation_memory) *
xs[(i, a.name)] for i in vars_to_host]) \
+ lpSum([_computation_memory_in_cg(j, cg, computation_memory) *
fs[(j, a.name)] for j in facs_to_host]) <= capacity, \
'memory {}'.format(a.name)
# Linearization constraints for alpha_ijk.
for link in cg.links:
i, j = link.variable_node, link.factor_node
for k in agents_names:
if i in vars_to_host and j in facs_to_host:
pb += alphas[((i, j), k)] <= xs[(i, k)], \
'lin1 {}{}{}'.format(i, j, k)
pb += alphas[((i, j), k)] <= fs[(j, k)], \
'lin2 {}{}{}'.format(i, j, k)
pb += alphas[((i, j), k)] >= xs[(i, k)] + fs[(j, k)] - 1, \
'lin3 {}{}{}'.format(i, j, k)
elif i in vars_to_host and j not in facs_to_host:
# Var is free, factor is already hosted
if fixed_dist.agent_for(j) == k:
pb += alphas[((i, j), k)] == xs[(i, k)]
else:
pb += alphas[((i, j), k)] == 0
elif i not in vars_to_host and j in facs_to_host:
# if i is not in vars_vars_to_host, it means that it's a
# computation that is already hosted (from hints)
if fixed_dist.agent_for(i) == k:
pb += alphas[((i, j), k)] == fs[(j, k)]
else:
pb += alphas[((i, j), k)] == 0
else:
# i and j are both alredy hosted
if fixed_dist.agent_for(i) == k and fixed_dist.agent_for(j) \
== k:
pb += alphas[((i, j), k)] == 1
else:
pb += alphas[((i, j), k)] == 0
# Now solve our LP
# status = pb.solve(GLPK_CMD())
# status = pb.solve(GLPK_CMD(mip=1))
# status = pb.solve(GLPK_CMD(mip=0, keepFiles=1,
# options=['--simplex', '--interior']))
status = pb.solve(GLPK_CMD(keepFiles=0, msg=False, options=['--pcost']))
if status != LpStatusOptimal:
raise ImpossibleDistributionException("No possible optimal"
" distribution ")
else:
logger.debug('GLPK cost : %s', value(pb.objective))
comp_dist = fixed_dist
for k in agents_names:
agt_vars = [
i for i, ka in xs if ka == k and value(xs[(i, ka)]) == 1
]
comp_dist.host_on_agent(k, agt_vars)
agt_rels = [
j for j, ka in fs if ka == k and value(fs[(j, ka)]) == 1
]
comp_dist.host_on_agent(k, agt_rels)
return comp_dist
def _distribute_try(computation_graph: ComputationGraph,
agents: Iterable[AgentDef],
hints: DistributionHints = None,
computation_memory=None,
communication_load=None,
attempt=0):
agents_capa = {a.name: a.capacity for a in agents}
# The distribution methods depends on the order used to process the node,
# we shuffle them to test a new configuration when retry a distribution
# after a failure
nodes = list(computation_graph.nodes)
shuffle(nodes)
mapping = defaultdict(set)
var_hosted = {}
# Distribute owned computation variable on the corresponding agent.
# For dcop build from an secp, this is the same thing as deploying the
# light variable on the light devices, as we were doing before.
for a in agents_capa:
for c in hints.must_host(a):
mapping[a].add(c)
var_hosted.update({c: a})
agents_capa[a] -= computation_memory(
computation_graph.computation(c))
# First mimic original secp adhoc behavior
for n in nodes:
if n.name in var_hosted:
continue
hostwith = hints.host_with(n.name)
# secp models have a constraint that should be hosted on the same
# agent than the variable of the model
if len(hostwith) == 1 and n.type == 'FactorComputation' and \
computation_graph.computation(hostwith[0]).type \
== 'VariableComputation':
dependent_var = [v.name for v in n.factor.dimensions]
candidates = [
a for a in agents_capa
if len(set(mapping[a]).intersection(dependent_var)) > 0
]
candidates.sort(key=lambda x: len(mapping[a]))
if candidates:
selected = candidates[0]
else:
selected = choice(list(agents_capa.keys()))
mapping[selected].update({n.name, hostwith[0]})
var_hosted[n.name] = selected
var_hosted[hostwith[0]] = selected
agents_capa[selected] -= computation_memory(n)
for n in nodes:
if n.name in var_hosted:
continue
footprint = computation_memory(n)
# Candidates : hints only with enough capacity
candidates = [(agents_capa[a], a) for a in hints.host_with(n.name)
if agents_capa[a] > footprint]
# If no hinted agents has enough capacity, fall back to all agents
if not candidates:
candidates = [(c, a) for a, c in agents_capa.items()
if c > footprint]
# Select the candidate that is already hosting the highest
# number of computations sharing a link with this one.
scores = []
for capacity, a in candidates:
count = 0
for l in computation_graph.links_for_node(n.name):
count += len([None for l_n in l.nodes if l_n in mapping[a]])
# The tuple is in this order so that we sort by score first,
# and then by available capacity.
scores.append((count, capacity, a))
scores.sort(reverse=True)
if scores:
selected = scores[0][2]
agents_capa[selected] -= footprint
else:
# Retry 3 times in case of failure, the nodes will be shuffled
# every time, increasing the probability to find a feasible
# distribution.
if attempt > 2:
raise ImpossibleDistributionException(
'Could not find feasible distribution after {} '
'attempts'.format(attempt))
else:
_distribute_try(computation_graph, agents, hints,
computation_memory, computation_graph,
attempt + 1)
mapping[selected].update({n.name})
var_hosted[n.name] = selected
return Distribution({a: list(mapping[a]) for a in mapping})
def fg_secp_ilp(
cg: ComputationsFactorGraph,
agents: List[AgentDef],
already_assigned: Distribution,
computation_memory: Callable[[ComputationNode], float],
communication_load: Callable[[ComputationNode, str], float],
) -> Distribution:
variables = [n for n in cg.nodes if n.type == "VariableComputation"]
factors = [n for n in cg.nodes if n.type == "FactorComputation"]
agents = list(agents)
agents_names = [a.name for a in agents]
# Only keep computations for which we actually need to find an agent.
vars_to_host = [
v.name for v in variables
if not already_assigned.has_computation(v.name)
]
facs_to_host = [
f.name for f in factors if not already_assigned.has_computation(f.name)
]
# x_i^k : binary variable indicating if var x_i is hosted on agent a_k.
xs = _build_xs_binvar(vars_to_host, agents_names)
# f_j^k : binary variable indicating if factor f_j is hosted on agent a_k.
fs = _build_fs_binvar(facs_to_host, agents_names)
# alpha_ijk : binary variable indicating if x_i and f_j are both on a_k.
alphas = _build_alphaijk_binvars(cg, agents_names)
logger.debug(f"alpha_ijk {alphas}")
# LP problem with objective function (total communication cost).
pb = LpProblem("distribution", LpMinimize)
pb += (
secp_dist_objective_function(cg, communication_load, alphas,
agents_names),
"Communication costs",
)
# Constraints.
# All variable computations must be hosted:
for i in vars_to_host:
pb += (
lpSum([xs[(i, k)] for k in agents_names]) == 1,
"var {} is hosted".format(i),
)
# All factor computations must be hosted:
for j in facs_to_host:
pb += (
lpSum([fs[(j, k)] for k in agents_names]) == 1,
"factor {} is hosted".format(j),
)
# Each agent must host at least one computation:
# We only need this constraints for agents that do not already host a
# computation:
empty_agents = [
a for a in agents_names if not already_assigned.computations_hosted(a)
]
for k in empty_agents:
pb += (
lpSum([xs[(i, k)] for i in vars_to_host]) +
lpSum([fs[(j, k)] for j in facs_to_host]) >= 1,
"atleastone {}".format(k),
)
# Memory capacity constraint for agents
for a in agents:
# Decrease capacity for already hosted computations
capacity = a.capacity - sum([
secp_computation_memory_in_cg(c, cg, computation_memory)
for c in already_assigned.computations_hosted(a.name)
])
pb += (
lpSum([
secp_computation_memory_in_cg(i, cg, computation_memory) * xs[
(i, a.name)] for i in vars_to_host
]) + lpSum([
secp_computation_memory_in_cg(j, cg, computation_memory) * fs[
(j, a.name)] for j in facs_to_host
]) <= capacity,
"memory {}".format(a.name),
)
# Linearization constraints for alpha_ijk.
for link in cg.links:
i, j = link.variable_node, link.factor_node
for k in agents_names:
if i in vars_to_host and j in facs_to_host:
pb += alphas[((i, j), k)] <= xs[(i, k)], "lin1 {}{}{}".format(
i, j, k)
pb += alphas[((i, j), k)] <= fs[(j, k)], "lin2 {}{}{}".format(
i, j, k)
pb += (
alphas[((i, j), k)] >= xs[(i, k)] + fs[(j, k)] - 1,
"lin3 {}{}{}".format(i, j, k),
)
elif i in vars_to_host and j not in facs_to_host:
# Var is free, factor is already hosted
if already_assigned.agent_for(j) == k:
pb += alphas[((i, j), k)] == xs[(i, k)]
else:
pb += alphas[((i, j), k)] == 0
elif i not in vars_to_host and j in facs_to_host:
# if i is not in vars_vars_to_host, it means that it's a
# computation that is already hosted (from hints)
if already_assigned.agent_for(i) == k:
pb += alphas[((i, j), k)] == fs[(j, k)]
else:
pb += alphas[((i, j), k)] == 0
else:
# i and j are both alredy hosted
if (already_assigned.agent_for(i) == k
and already_assigned.agent_for(j) == k):
pb += alphas[((i, j), k)] == 1
else:
pb += alphas[((i, j), k)] == 0
# Now solve our LP
# status = pb.solve(GLPK_CMD())
# status = pb.solve(GLPK_CMD(mip=1))
# status = pb.solve(GLPK_CMD(mip=0, keepFiles=1,
# options=['--simplex', '--interior']))
status = pb.solve(GLPK_CMD(keepFiles=0, msg=False, options=["--pcost"]))
if status != LpStatusOptimal:
raise ImpossibleDistributionException("No possible optimal"
" distribution ")
else:
logger.debug("GLPK cost : %s", pulp.value(pb.objective))
comp_dist = already_assigned
for k in agents_names:
agt_vars = [
i for i, ka in xs if ka == k and pulp.value(xs[(i, ka)]) == 1
]
comp_dist.host_on_agent(k, agt_vars)
agt_rels = [
j for j, ka in fs if ka == k and pulp.value(fs[(j, ka)]) == 1
]
comp_dist.host_on_agent(k, agt_rels)
return comp_dist
def lp_model(cg: ComputationGraph,
agentsdef: Iterable[AgentDef],
footprint: Callable[[str], float],
capacity: Callable[[str], float],
route: Callable[[str, str], float],
msg_load: Callable[[str, str], float],
hosting_cost: Callable[[str, str], float]):
comp_names = [n.name for n in cg.nodes]
agt_names = [a.name for a in agentsdef]
pb = LpProblem('ilp_compref', LpMinimize)
# One binary variable xij for each (variable, agent) couple
xs = LpVariable.dict('x', (comp_names, agt_names), cat=LpBinary)
# One binary variable for computations c1 and c2, and agent a1 and a2
betas = {}
count = 0
for a1, a2 in combinations(agt_names, 2):
# Only create variables for couple c1, c2 if there is an edge in the
# graph between these two computations.
for l in cg.links:
# As we support hypergraph, we may have more than 2 ends to a link
for c1, c2 in combinations(l.nodes, 2):
count += 2
b = LpVariable('b_{}_{}_{}_{}'.format(c1, a1, c2, a2),
cat=LpBinary)
betas[(c1, a1, c2, a2)] = b
pb += b <= xs[(c1, a1)]
pb += b <= xs[(c2, a2)]
pb += b >= xs[(c2, a2)] + xs[(c1, a1)] - 1
b = LpVariable('b_{}_{}_{}_{}'.format(c1, a2, c2, a1),
cat=LpBinary)
betas[(c1, a2, c2, a1)] = b
pb += b <= xs[(c2, a1)]
pb += b <= xs[(c1, a2)]
pb += b >= xs[(c1, a2)] + xs[(c2, a1)] - 1
# Set objective: communication + hosting_cost
pb += _objective(xs, betas, route, msg_load, hosting_cost), \
'Communication costs and prefs'
# Adding constraints:
# Constraints: Memory capacity for all agents.
for a in agt_names:
pb += lpSum([footprint(i) * xs[i, a] for i in comp_names])\
<= capacity(a), \
'Agent {} capacity'.format(a)
# Constraints: all computations must be hosted.
for c in comp_names:
pb += lpSum([xs[c, a] for a in agt_names]) == 1, \
'Computation {} hosted'.format(c)
# solve using GLPK
status = pb.solve(solver=GLPK_CMD(keepFiles=1, msg=False,
options=['--pcost']))
if status != LpStatusOptimal:
raise ImpossibleDistributionException("No possible optimal"
" distribution ")
logger.debug('GLPK cost : %s', value(pb.objective))
# print('BETAS:')
# for c1, a1, c2, a2 in betas:
# print(' ', c1, a1, c2, a2, value(betas[(c1, a1, c2, a2)]))
#
# print('XS:')
# for c, a in xs:
# print(' ', c, a, value(xs[(c, a)]))
mapping = {}
for k in agt_names:
agt_computations = [i for i, ka in xs
if ka == k and value(xs[(i, ka)]) == 1]
# print(k, ' -> ', agt_computations)
mapping[k] = agt_computations
return mapping