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)