def solve(ca):
n, k = map(int, raw_input().split())
problem = pulp.LpProblem('pname', pulp.LpMinimize)
sumi = map(int, raw_input().split())
xi = [pulp.LpVariable('x%d' % i, -MAX, MAX, 'Integer') for i in range(n)]
#linex = [pulp.LpVariable('li%d'%i, 0, 1, 'Binary') for i in range(n)]
maxx = pulp.LpVariable('maxx', -MAX, MAX, 'Integer')
minx = pulp.LpVariable('minx', -MAX, MAX, 'Integer')
problem += pulp.lpSum([xi[i] for i in range(k)]) == sumi[0]
for i in range(n - k):
problem += sumi[i] + xi[i + k] == sumi[i + 1] + xi[i]
for i in range(n):
problem += xi[i] <= maxx
problem += xi[i] >= minx
problem += maxx - minx
#print problem
#status = problem.solve(pulp.GLPK())
#status = problem.solve(pulp.COIN(msg = True))
status = problem.solve(pulp.COIN())
#status = problem.solve()
ans = maxx.value() - minx.value()
# for i in linex:
# print i, i.value(),
# print
print "Case #%d: %.0f" % (ca, ans)
def perform_experiment_phase_II(infrastructure_file,
workload_file,
year,
phase_I_solution,
output_file,
frac_gap=None,
max_seconds=10*60):
solution_I = lloovia.SolutionI.load(phase_I_solution)
if solution_I.solving_stats.status == "aborted":
# There is no solution of Phase I, so Phase II cannot
# be performed
print("Case '%s' has no solution for Phase I. Skipping" %
(phase_I_solution))
# Save empty dataframe as solution
pd.DataFrame().to_pickle(output_file)
return
problem = lloovia.Problem(load_infrastructure(infrastructure_file),
load_workload(workload_file, year))
solver = pulp.COIN(threads=2, fracGap=frac_gap,
maxSeconds=max_seconds, msg=1)
phaseII = lloovia.PhaseII(problem, solution_I, solver=solver)
phaseII.solve_period()
phaseII.solution.save(output_file)
def perform_experiment_multiregion_phase_II(
azure_infrastructure_file,
amazon_infrastructure_file,
workload_file,
year,
providers_to_use,
phase_I_solution,
output_file,
frac_gap=None,
max_seconds=10*60):
infrastructure = get_infrastructure_for_providers(
providers_to_use,
azure_infrastructure_file,
amazon_infrastructure_file
)
solution_I = lloovia.SolutionI.load(phase_I_solution)
if solution_I.solving_stats.status == "aborted":
print("Case '%s' has no solution for Phase I. Skipping" %
(phase_I_solution))
# Save empty dataframe as solution
pd.DataFrame().to_pickle(output_file)
return
problem = lloovia.Problem(infrastructure,
load_workload(workload_file, year))
solver = pulp.COIN(threads=2, fracGap=frac_gap,
maxSeconds=max_seconds, msg=1)
phaseII = lloovia.PhaseII(problem, solution_I, solver=solver)
phaseII.solve_period()
phaseII.solution.save(output_file)
def test_cbc(self, ilp):
"""Test method for CBC."""
try:
ilp.solve(pulp.COIN())
assert round(pulp.value(ilp.objective), 0) == 5
except pulp.solvers.PulpSolverError:
pytest.fail(f"Solver not installed")
def solve(self,msg=0,**kwarg):
# kind = 'CBC'
if 'kind' in kwarg:
kind = kwarg['kind']
time_limit = None
if 'time_limit' in kwarg:
time_limit = float(kwarg['time_limit'])
random_seed = None
if 'random_seed' in kwarg:
random_seed = kwarg['random_seed']
ratio_gap = None
if 'ratio_gap' in kwarg:
ratio_gap = float(kwarg['ratio_gap'])
start_time = time.time()
# select solver for pl
if kind == 'CPLEX':
if time_limit is not None:
# pulp does currently not support a timelimit in 1.5.9
self.mip.solve(pl.CPLEX_CMD(msg=msg, timelimit=time_limit))
else:
self.mip.solve(pl.CPLEX_CMD(msg=msg))
elif kind == 'GLPK':
self.mip.solve(pl.GLPK_CMD(msg=msg))
elif kind == 'SCIP':
self.mip.solve(SCIP_CMD(msg=msg,time_limit=time_limit,ratio_gap=ratio_gap))
elif kind == 'CBC' or kind == 'COIN':
options = []
if time_limit is not None:
options.extend(['sec', str(time_limit)])
if random_seed is not None:
options.extend(['randomSeed', str(random_seed)])
options.extend(['randomCbcSeed', str(random_seed)])
if ratio_gap is not None:
options.extend(['ratio', str(ratio_gap)])
if kind == 'CBC':
self.mip.solve(pl.PULP_CBC_CMD(msg=msg, options=options))
elif kind == 'COIN':
self.mip.solve(pl.COIN(msg=msg, options=options))
elif kind == 'GUROBI':
# GUROBI_CMD does not support a timelimit or epgap
# GUROBI cannot dispatch parameters from options correctly
options=[]
if time_limit is not None:
if ratio_gap is not None:
self.mip.solve(pl.GUROBI(msg=msg,timeLimit=time_limit,epgap=ratio_gap))
elif time_limit is not None:
self.mip.solve(pl.GUROBI(msg=msg, timeLimit=time_limit))
elif ratio_gap is not None:
self.mip.solve(pl.GUROBI(msg=msg, epgap=ratio_gap))
else:
self.mip.solve(pl.GUROBI_CMD(msg=msg))
else:
raise Exception('ERROR: solver ' + kind + ' not known')
if msg:
print('INFO: execution time for solving mip (sec) = ' + str(time.time() - start_time))
if self.mip.status == 1 and msg:
print('INFO: objective = ' + str(pl.value(self.mip.objective)))
def perform_experiment_phase_I(infrastructure_file,
workload_file,
year,
max_bins,
output_file,
frac_gap=0.01,
max_seconds=10*60):
problem = lloovia.Problem(load_infrastructure(infrastructure_file),
load_workload(workload_file, year))
phaseI = lloovia.PhaseI(problem)
solver = pulp.COIN(threads=2, fracGap=frac_gap,
maxSeconds=max_seconds, msg=1)
phaseI.solve(max_bins=max_bins, solver=solver)
phaseI.solution.save(output_file)
def _get_solver(solver_name, timelimit):
if solver_name == "cplex":
return pulp.CPLEX_PY(msg=0, timeLimit=timelimit)
elif solver_name == "gurobi":
return pulp.GUROBI(msg=0, timeLimit=timelimit)
elif solver_name == "glpk":
return pulp.GLPK(msg=0, options=["--tmlim", str(timelimit)])
elif solver_name == "cbc":
return pulp.COIN(msg=0, maxSeconds=timelimit)
elif solver_name == "scip":
return pulp.SCIP(msg=0,
options=["-c", f"set limits time {timelimit}"])
raise ValueError("Invalid Solver Name")
def perform_experiment_multiregion_phase_I(
azure_infrastructure_file,
amazon_infrastructure_file,
workload_file,
year,
max_bins,
providers_to_use,
output_file,
frac_gap=None,
max_seconds=60*60):
infrastructure = get_infrastructure_for_providers(
providers_to_use,
azure_infrastructure_file,
amazon_infrastructure_file
)
problem = lloovia.Problem(infrastructure,
load_workload(workload_file, year))
phaseI = lloovia.PhaseI(problem)
solver = pulp.COIN(threads=2, fracGap=frac_gap,
maxSeconds=max_seconds, msg=1)
phaseI.solve(max_bins=max_bins, solver=solver)
phaseI.solution.save(output_file)
def perform_experiment_phase_II_od_only(infrastructure_file,
workload_file,
year,
output_file,
frac_gap=None,
max_seconds=10*60):
infrastructure = load_infrastructure(infrastructure_file)
only_ondemand = [vm for vm in infrastructure if not vm.reserved]
only_reserved = [vm for vm in infrastructure if vm.reserved]
problem = lloovia.Problem(only_ondemand,
load_workload(workload_file, year))
# Create a fake solution from phase I in which all reserved
# instances are deactivated
trivial_stats = lloovia.SolvingStatsI(
max_bins=None,
workload=lloovia.LlooviaHistogram({0: 0}),
frac_gap=None,
max_seconds=None,
creation_time=0.0,
solving_time=0.0,
status="optimal",
lower_bound=None,
optimal_cost=0.0
)
# Solution: Zero reserved VMs of each type
sol = dict((vm, 0) for vm in only_reserved)
trivial_allocation = pd.DataFrame([sol])[only_reserved]
trivial_solution = lloovia.Solution(problem, trivial_stats,
allocation=trivial_allocation)
solver = pulp.COIN(threads=2, fracGap=frac_gap,
maxSeconds=max_seconds, msg=1)
phaseII = lloovia.PhaseII(problem, trivial_solution, solver=solver)
phaseII.solve_period()
phaseII.solution.save(output_file)
import pulp as solver
from pulp import *
import time
import gc
z = 0
solvers = [
solver.CPLEX(timeLimit=30),
solver.GLPK(),
solver.GUROBI(),
solver.PULP_CBC_CMD(),
solver.COIN()
]
solverUsado = 3
def solver_exact(g, init, final, is_first, is_last, name):
var = [(i + ',' + str(t)) for i in g.edge for t in range(1, g.z)]
var2 = [(str(i) + ',' + str(t)) for i in g.vertices for t in range(1, g.z)]
X = solver.LpVariable.dicts("X", var, cat=solver.LpBinary)
Y = solver.LpVariable.dicts("Y", var2, cat=solver.LpBinary)
problem = solver.LpProblem("The_best_Cut", solver.LpMinimize)
if is_first:
problem += (solver.lpSum(
X.get(
str(i.split(',')[0]) + ',' + str(i.split(',')[1]) + ',' +
str(t)) * g.mis[i.split(',')[0]][i.split(',')[1]]
for i in g.edge for t in range(1, g.z)) + solver.lpSum(
((g.pis[k.split(',')[0]][k.split(',')[1]])) -
((g.mis[k.split(',')[0]][k.split(',')[1]]))
for k in g.edgeCuts) / 2) + solver.lpSum(
def solve_problem(perf_factor,
instance_names,
n_apps,
first_app,
quant_factor,
exp_n,
max_priv_new,
priv_prev_n,
priv_prev_ecus,
priv_new_ecus,
priv_new_cost,
region_names=None,
verbose=False,
workload_dir="hours"):
amazon_s3_data = cloud_providers.read_amazon_s3_data('amazon_s3_data.csv')
amazon_ec2_data = cloud_providers.read_amazon_ec2_data(
'amazon_ec2_data.csv')
# This data is also filtered later, but it is done per instance, so if we
# remove it here, the computation is faster
amazon_ec2_data = remove_unneded_instances_ec2(amazon_ec2_data)
ics, _ = create_ics(amazon_ec2_data, amazon_s3_data, instance_names,
region_names)
# Add instance classes for the private cloud
ics.append(
malloovia.InstanceClass(id=f'priv',
name='priv',
limiting_sets=(),
price=priv_new_cost,
max_vms=max_priv_new,
is_reserved=True,
is_private=True,
time_unit="h",
cores=2))
# Previously bought private instances
if priv_prev_n > 0:
ics.append(
malloovia.InstanceClass(
id=f'priv_prev',
name='priv_prev',
limiting_sets=(),
price=0.000001, # Insignificant
max_vms=priv_prev_n,
is_reserved=True,
is_private=True,
time_unit="h",
cores=2))
# Apps
apps = [malloovia.App(f'a{i}', name=f'{i}') for i in range(n_apps)]
# This is used for having more apps than the available workloads
factor_repeat = math.ceil(n_apps / N_AVAILABLE_WLS)
# Performances
perfs_per_ecu = [1000, 500, 2000, 300
] * factor_repeat # Performance for a machine with 1 ECU
perfs_per_ecu = reordered_list(perfs_per_ecu, first_app)
perfs = get_perfs(amazon_ec2_data, ics, apps, perf_factor, perfs_per_ecu,
priv_prev_ecus, priv_new_ecus)
perf_list = []
for a in apps:
l = list(perfs.values[i, a] for i in ics)
perf_list.append(l)
quanta = get_quanta(perf_list, quant_factor)
# Workloads
wls = []
for i in range(N_AVAILABLE_WLS):
with open(f'{workload_dir}/wl{i}.csv') as f:
reader = csv.reader(f)
for row in reader:
wls.append(tuple(int(x) for x in row))
wls[i] = wls[i][:WL_LEN]
wls = reordered_list(wls, first_app)
wls = wls * factor_repeat
wls = wls[:n_apps]
if quant_factor != 0:
wls = discretize_levels(wls, quanta)
wls = wls.tolist() * factor_repeat
else:
wls = wls * factor_repeat
ltwp = []
for app, wl in zip(apps, wls):
ltwp.append(
malloovia.Workload(
"ltwp_{}".format(app.id),
description="rph for {}".format(app.name),
app=app,
time_unit="h",
values=wl,
))
problem = malloovia.Problem(
id="Hybrid cloud",
name="Hybrid cloud",
workloads=ltwp,
instance_classes=ics,
performances=perfs,
)
print('Solving', datetime.now().strftime("%H:%M:%S"))
phase_i = malloovia.PhaseI(problem)
solver = pulp.COIN(maxSeconds=2200 * 60, msg=1, fracGap=0, threads=8)
phase_i_solution = phase_i.solve(solver=solver)
filename = f'sols/{exp_n:03}_sol.p'
pickle.dump(phase_i_solution, open(filename, 'wb'))
status = phase_i_solution.solving_stats.algorithm.status
if status != malloovia.Status.optimal:
print(f"No optimal solution. Status: {status.name} ({status})")
print('Time', datetime.now().strftime("%H:%M:%S"))
raise Exception()
comp_cost_malloovia = phase_i_solution.solving_stats.optimal_cost
creation_time_malloovia = phase_i_solution.solving_stats.creation_time
solving_time_malloovia = phase_i_solution.solving_stats.solving_time
if verbose:
print("=" * 80)
print(f"Computation cost = {comp_cost_malloovia}")
print("=" * 80)
return ExpResult(comp_cost_malloovia, creation_time_malloovia,
solving_time_malloovia)
def find_closest_positions(
funds: float,
composition: Composition,
prices: dict[SimpleContract, float],
) -> dict[SimpleContract, int]:
"""
Constructs the most closely-matching concrete, integral-share Portfolio
matching this Allocation.
It is guaranteed that portfolio.gpv <= allocation.
Using a MILP solver might be overkill for this, but we do, ever-so-rarely,
round the other way from the target (fractional) allocation. This lets us do
that correctly without guesswork. Can't be too careful with money.
:param funds: total amount of money available to spend on the portfolio.
:param composition: the target composition to approximate
:param prices: the assumed _unsafe_prices of the securities.
:return: a mapping from contacts to allocated share counts.
"""
# will raise if a price is missing
comp_arr, price_arr = np.array(
[[composition[c], prices[c]] for c in composition.contracts]
).T
assert np.isclose(comp_arr.sum(), 1.0)
assert len(composition) == len(prices)
target_alloc = funds * comp_arr / price_arr
prob = pulp.LpProblem()
alloc = lparray.create_anon(
"Alloc", shape=comp_arr.shape, cat=pulp.LpInteger
)
# to avoid zero division later
(alloc >= 1).constrain(prob, "PositivePositions")
cost = (alloc @ price_arr).sum()
(cost <= funds).constrain(prob, "DoNotExceedFunds")
# TODO bigM here should be the maximum possible value of
# alloc - target_alloc
# while 100k should be enough for reasonable uses, we can figure master_eq a
# proper max
loss = (alloc - target_alloc).abs(prob, "Loss", bigM=1_000_000).sumit()
prob += loss
try:
pulp.COIN(msg=False).solve(prob)
except Exception as e:
raise PortfolioSolverError(e)
status = prob.status
if status == LpStatusInfeasible:
raise ProgrammingError(f"Solver returned infeasible: {prob}.")
# this means the solver was interrupted -- we propagate that up
elif status == "Not Solved":
raise KeyboardInterrupt()
normed_misalloc = loss.value() / funds
Policy.MISALLOCATION.validate(normed_misalloc)
return {c: int(v) for c, v in zip(composition.contracts, alloc.values)}
def solve_problem(perf_factor, verbose=False):
ics = [ # Only one
InstanceClass(id='ic',
name='ic',
limiting_sets=(),
price=0.01,
max_vms=3,
is_reserved=False,
time_unit="h")
]
n_apps = 1
# Apps
apps = tuple(App(f'a{i}', name=f'{i}') for i in range(n_apps))
# Performances
perfs_per_ecu = [RPH, RPH]
perfs = get_perfs(ics=tuple(ics),
apps=apps,
perf_factor=perf_factor,
perfs_per_ecu=perfs_per_ecu)
# Workloads
wls = ([3 * RPH, RPH] * (WL_LEN // 2), )
ltwp = []
for app, wl in zip(apps, wls):
ltwp.append(
Workload(
"ltwp_{}".format(app.id),
description="rph for {}".format(app.name),
app=app,
time_unit="h",
values=tuple(wl),
))
problem = Problem(
id="Hybrid cloud",
name="Hybrid cloud",
workloads=tuple(ltwp),
instance_classes=tuple(ics),
performances=perfs,
)
print('Solving', datetime.now().strftime("%H:%M:%S"))
phase_i = PhaseI(problem)
solver = pulp.COIN(maxSeconds=2200 * 60, msg=1, fracGap=0.05, threads=8)
phase_i_solution = phase_i.solve(solver=solver)
filename = 'sols/3vm.p'
pickle.dump(phase_i_solution, open(filename, 'wb'))
yaml = solutions_to_yaml([phase_i_solution])
with open('sols/3vm.yaml', 'w') as f:
f.write(yaml)
status = phase_i_solution.solving_stats.algorithm.status
if status != Status.optimal:
print(f"No optimal solution. Status: {status.name} ({status})")
print('Time', datetime.now().strftime("%H:%M:%S"))
raise Exception()
comp_cost_malloovia = phase_i_solution.solving_stats.optimal_cost
if verbose:
print("=" * 80)
print(f"Computation cost = {comp_cost_malloovia}")
print("=" * 80)