def solve_problem(problem, solver, **kwargs):
sname= solver.__name__
logger.info('STATUS: start to solve with %s/%s' % (sname, kwargs))
start_time = time.time()
solution = solver(problem, **kwargs)
solved_time = time.time() - start_time
logger.info('STATUS: start to evaluate')
score = solution.evaluate_for(problem)
logger.info('RESULT: solver=%s time=%.3f score=%.6f' %
(sname, solved_time, score))
utils = solution.evaluate_utilization(problem)
utils_msg = ",".join(map(lambda x: "%.2f%%" % (x * 100), utils))
logger.info('RESULT: solver=%s util=%s' % (sname, utils_msg))
filepath = solution.dump(sname, str(int(start_time)))
logger.info('STATUS: solution dumped to %s' % filepath)
def solve(self):
iter_count = 0
while True:
# step 1: pick a user
picked_user = self._pick_user()
if picked_user == -1:
break
# step 2: pick a host
picked_host = self._pick_host(picked_user)
if picked_host == -1:
self._mark_user_unallocatable(picked_user)
continue
# step 3: update allocation
self._allocate(picked_user, picked_host)
# step 4: update lambdas
self._update_lambdas()
iter_count += 1
logger.info('ANALYSIS: random_solve iterated %d' % iter_count)
return Solution(self._x_mat)
def main():
logger.info('STATUS: bench-%d started' % os.getpid())
# parse delta sys.argv
delta = 0.01
if len(sys.argv) > 1:
try:
delta = float(sys.argv[1])
except ValueError:
pass
logger.info('STATUS: delta = %.3f' % delta)
# load problem
logger.info('STATUS: load problem')
data_file = os.path.join(os.path.dirname(__file__), 'vm_small.txt')
problem = load_problem(data_file)
# solve problem
solve_problem(problem, drfh.solver.bf_solve)
solve_problem(problem, drfh.solver.random_solve, delta=delta)
solve_problem(problem, drfh.solver.ph_solve, delta=delta)
def ph_solve(problem, delta=0.01):
# init
user_num = problem.user_num
resource_num = problem.resource_num
host_num = problem.host_num
resource_matrix = problem.resource_matrix
demand_matrix = problem.demand_matrix
dominant_vector = problem.dominant_vector
x_matrix = drfh.common.new_matrix(user_num, host_num, defval=0)
lambda_matrix = drfh.common.new_matrix(host_num, resource_num, defval=0)
remainning_matrix = copy.deepcopy(resource_matrix)
share_vector = drfh.common.new_vector(user_num, defval=0)
user_vector = drfh.common.new_vector(user_num, defval=True)
# delta = 0.01
# step 0: calculate the user
kappa = problem.kappa
iter_count = 0
while True:
# step 1: pick a user
picked_user, least_share = -1, 999999999999
for idx, shr in enumerate(share_vector):
if user_vector[idx] and shr < least_share:
picked_user, least_share = idx, shr
if picked_user == -1:
# no user pickable at the moment, break the allocation process
break
# logger.debug("picked user %d", picked_user)
# step 2: pick a host
picked_host, least_cost = -1, 999999999999
for host in range(host_num):
# remainning resource of this host must statisfy the picked_user
if not drfh.common.vector_ngt(demand_matrix[picked_user], remainning_matrix[host]):
continue
# calculate the cost
cost = sum([demand_matrix[picked_user][res] * lambda_matrix[host][res] for res in range(resource_num)])
# choose the least cost
if cost < least_cost:
picked_host, least_cost = host, cost
if picked_host == -1:
# no host pickable at the moment, continue for another user
user_vector[picked_user] = False
# logger.debug("no pickable host for user %d", picked_user)
continue
# logger.debug("picked host %d", picked_host)
# step 3: update allocation
x_matrix[picked_user][picked_host] += 1
share_vector[picked_user] += dominant_vector[picked_user]
for m in range(resource_num):
remainning_matrix[picked_host][m] -= demand_matrix[picked_user][m]
# logger.debug("allocation matrix %s", x_matrix)
# logger.debug("remainning matrix %s", remainning_matrix)
# step 4: update lambda_matrix
for n, m in itertools.product(range(host_num), range(resource_num)):
val = lambda_matrix[n][m] - delta * (
resource_matrix[n][m] / kappa - sum([demand_matrix[j][m] * x_matrix[j][n] for j in range(user_num)])
)
lambda_matrix[n][m] = max(0, val)
iter_count += 1
logger.info("ANALYSIS: ph_solve iterated %d" % iter_count)
return drfh.solution.Solution(x_matrix)
