def __init__(self, workflow, resource_manager, estimator, flops=20): self.counter = 0 self.workflow = workflow self.flops = flops ##interface Estimator self.estimator = estimator self.resource_manager = resource_manager nodes = list(HeftHelper.to_nodes(resource_manager.get_resources())) ranking = HeftHelper.build_ranking_func(nodes, lambda job, agent: estimator.estimate_runtime(job, agent), lambda ni, nj, A, B: estimator.estimate_transfer_time(A, B, ni, nj)) sorted_tasks = ranking(self.workflow) self.nodes = nodes self.sorted_tasks = sorted_tasks self.workflow_size = len(sorted_tasks) self.task_map = {task.id: task for task in sorted_tasks} self.node_map = {node.name: node for node in nodes} self.initializing_alg = SimpleRandomizedHeuristic(self.workflow, self.nodes, self.estimator) self.initial_chromosome = None##GAFunctions.schedule_to_chromosome(initial_schedule) pass
def make_ranking(self, wf, nodes): ##resources = self.resource_manager.get_resources() ##print("common nodes count:" + str(len(toNodes(resources)))) ##nodes = HeftHelper.to_nodes(resources) ranking_func = HeftHelper.build_ranking_func(nodes, self.compcost, self.commcost) wf_jobs = ranking_func(wf) return wf_jobs
def run(self, current_cleaned_schedule): ## current_cleaned_schedule - this schedule contains only ## finished and executed tasks, all unfinished and failed have been removed already ## current_cleaned_schedule also have down nodes and new added ## ALGORITHM DOESN'T CHECK ADDING OF NEW NODES BY ITSELF ## nodes contain only available now ## 1. get all unscheduled tasks ## 2. sort them by rank ## 3. map on the existed nodes according to current_cleaned_schedule nodes = self.get_nodes() for_planning = HeftHelper.get_tasks_for_planning( self.workflow, current_cleaned_schedule) ## TODO: check if it sorted properly for_planning = set([task.id for task in for_planning]) sorted_tasks = [ task for task in self.wf_jobs if task.id in for_planning ] # print("P: " + str(sorted_tasks)) new_sched = self.mapping([(self.workflow, sorted_tasks)], current_cleaned_schedule.mapping, nodes, self.commcost, self.compcost) return new_sched
def schedule(self): """ create inter-priority """ def byPriority(wf): return 0 if wf.priority is None else wf.priority ##simple inter priority sorting sorted_wfs = sorted(self.workflows, key=byPriority) wf_jobs = {wf: [] for wf in sorted_wfs} resources = self.resource_manager.get_resources() ##print("common nodes count:" + str(len(toNodes(resources)))) nodes = HeftHelper.to_nodes(resources) wf_jobs = {wf: self.make_ranking(wf, nodes) for wf in sorted_wfs} ##new_schedule = self.get_unchanged_schedule(self.old_schedule, time) new_schedule = Schedule({node: [] for node in nodes}) new_plan = new_schedule.mapping for (wf, jobs) in wf_jobs.items(): new_schedule = self.mapping([(wf, jobs)], new_plan, nodes, self.commcost, self.compcost) new_plan = new_schedule.mapping return new_schedule
def __init__(self, workflow, resource_manager, estimator): self.counter = 0 self.workflow = workflow ##interface Estimator self.estimator = estimator self.resource_manager = resource_manager nodes = resource_manager.get_nodes( ) #list(HeftHelper.to_nodes(resource_manager.get_resources())) ranking = HeftHelper.build_ranking_func( nodes, lambda job, agent: estimator.estimate_runtime(job, agent), lambda ni, nj, A, B: estimator.estimate_transfer_time( A, B, ni, nj)) sorted_tasks = ranking(self.workflow) self.nodes = nodes self.sorted_tasks = sorted_tasks self.workflow_size = len(sorted_tasks) self.task_map = {task.id: task for task in sorted_tasks} self.node_map = {node.name: node for node in nodes} self.initializing_alg = SimpleRandomizedHeuristic( self.workflow, self.nodes, self.estimator) self.initial_chromosome = None ##GAFunctions.schedule_to_chromosome(initial_schedule) pass
def default_fixed_schedule_part(resource_manager): fix_schedule_part = Schedule({ node: [] for node in HeftHelper.to_nodes( resource_manager.get_resources()) }) return fix_schedule_part
def get_infrastructure(bundle, reliability, with_ga_initial, nodes_conf=None): if nodes_conf is not None: resources = ResourceGenerator.r(nodes_conf) else: resources = bundle.dedicated_resources nodes = HeftHelper.to_nodes(resources) realibility_map = {node.name: reliability for node in nodes} initial_schedule = None if with_ga_initial is True: initial_schedule = bundle.ga_schedule #initial_ga_makespan = Utility.get_the_last_time(initial_schedule ) #print("Initial GA makespan: " + str(initial_ga_makespan)) ## TODO: end ##====================== ## create heft_executor ##====================== estimator = ExperimentEstimator(bundle.transfer_mx, bundle.ideal_flops, realibility_map) resource_manager = ExperimentResourceManager(resources) return (estimator, resource_manager, initial_schedule)
def test_fixed_ordering(self): _wf = wf("Montage_25") rm = ExperimentResourceManager(rg.r([10, 15, 25, 30])) estimator = SimpleTimeCostEstimator(comp_time_cost=0, transf_time_cost=0, transferMx=None, ideal_flops=20, transfer_time=100) sorted_tasks = HeftHelper.heft_rank(_wf, rm, estimator) heft_schedule = run_heft(_wf, rm, estimator) heft_mapping = schedule_to_position(heft_schedule) heft_gen = lambda: heft_mapping if random.random( ) > 0.95 else generate(_wf, rm, estimator) toolbox = Toolbox() # toolbox.register("generate", generate, _wf, rm, estimator) toolbox.register("generate", heft_gen) toolbox.register("fitness", fitness, _wf, rm, estimator, sorted_tasks) toolbox.register("force_vector_matrix", force_vector_matrix, rm) toolbox.register("velocity_and_position", velocity_and_position, _wf, rm, estimator) toolbox.register("G", G) toolbox.register("kbest", Kbest) statistics = Statistics() statistics.register( "min", lambda pop: numpy.min([p.fitness.mofit for p in pop])) statistics.register( "avr", lambda pop: numpy.average([p.fitness.mofit for p in pop])) statistics.register( "max", lambda pop: numpy.max([p.fitness.mofit for p in pop])) statistics.register( "std", lambda pop: numpy.std([p.fitness.mofit for p in pop])) logbook = Logbook() logbook.header = ("gen", "G", "kbest", "min", "avr", "max", "std") pop_size = 100 iter_number = 100 kbest = pop_size ginit = 5 final_pop = run_gsa(toolbox, statistics, logbook, pop_size, iter_number, kbest, ginit) best = min(final_pop, key=lambda x: toolbox.fitness(x).mofit) solution = { MAPPING_SPECIE: list(zip(sorted_tasks, best)), ORDERING_SPECIE: sorted_tasks } schedule = build_schedule(_wf, estimator, rm, solution) Utility.validate_static_schedule(_wf, schedule) makespan = Utility.makespan(schedule) print("Final makespan: {0}".format(makespan)) pass
def ordering_default_initialize(ctx, size): env = ctx['env'] sorted_tasks = HeftHelper.heft_rank(env.wf, env.rm, env.estimator) assert _check_precedence(env.wf, sorted_tasks), "Check precedence failed" result = [ListBasedIndividual(ordering_default_mutate(ctx, deepcopy(sorted_tasks))) for i in range(size)] return result
def init(self): if self.initial_schedule is None: self.current_schedule = Schedule({node:[] for node in self.heft_planner.get_nodes()}) self.current_schedule = self.heft_planner.run(self.current_schedule) else: id_to_task = {tsk.id: tsk for tsk in HeftHelper.get_all_tasks(self.heft_planner.workflow)} mapping = {node: [ScheduleItem(id_to_task[item.job.id], item.start_time, item.end_time) for item in items] for (node, items) in self.initial_schedule.mapping.items()} self.current_schedule = Schedule(mapping) self._post_new_events()
def checkDown(self, node_name, is_down): nodes = HeftHelper.to_nodes(self.public_resources) for nd in nodes: if nd.name == node_name: if is_down: nd.state = Node.Down else: nd.state = Node.Unknown pass
def mapping(self, sorted_jobs, existing_plan, nodes, commcost, compcost): """def allocate(job, orders, jobson, prec, compcost, commcost):""" """ Allocate job to the machine with earliest finish time Operates in place """ ## TODO: add finished tasks jobson = dict() for (node, items) in existing_plan.items(): for item in items: if item.state == ScheduleItem.FINISHED or item.state == ScheduleItem.EXECUTING: jobson[item.job] = node new_plan = existing_plan def ft(machine): #cost = st(machine) runtime = compcost(task, machine) cost = st(machine, runtime) + runtime ##print("machine: %s job:%s cost: %s" % (machine.name, task.id, cost)) ##print("machine: " + str(machine.name) + " cost: " + str(cost)) return cost for wf, tasks in sorted_jobs: ##wf_dag = self.convert_to_parent_children_map(wf) wf_dag = HeftHelper.convert_to_parent_children_map(wf) prec = reverse_dict(wf_dag) for task in tasks: st = partial(self.start_time, wf, task, new_plan, jobson, prec, commcost) # ress = [(key, ft(key)) for key in new_plan.keys()] # agent_pair = min(ress, key=lambda x: x[1][0]) # agent = agent_pair[0] # start = agent_pair[1][0] # end = agent_pair[1][1] agent = min(new_plan.keys(), key=ft) runtime = compcost(task, agent) start = st(agent, runtime) end = ft(agent) # new_plan[agent].append(ScheduleItem(task, start, end)) Schedule.insert_item(new_plan, agent, ScheduleItem(task, start, end)) jobson[task] = agent new_sched = Schedule(new_plan) return new_sched
def ordering_default_initialize(ctx, size): env = ctx['env'] sorted_tasks = HeftHelper.heft_rank(env.wf, env.rm, env.estimator) assert check_precedence(env.wf, sorted_tasks), "Check precedence failed" result = [ ListBasedIndividual( ordering_default_mutate(ctx, deepcopy(sorted_tasks))) for i in range(size) ] return result
def _run_heft(): dynamic_planner = DynamicHeft(wf, resource_manager, estimator) nodes = HeftHelper.to_nodes(resource_manager.resources) current_cleaned_schedule = Schedule({node: [] for node in nodes}) schedule_dynamic_heft = dynamic_planner.run(current_cleaned_schedule) self._validate(wf, estimator, schedule_dynamic_heft) if is_visualized: viz.visualize_task_node_mapping(wf, schedule_dynamic_heft) # Utility.create_jedule_visualization(schedule_dynamic_heft, wf_name+'_heft') pass return schedule_dynamic_heft
def __init__(self, workflow, nodes, estimator): self.workflow = workflow self.nodes = nodes self.workflow_size = workflow.get_task_count() self.estimator = estimator self.task_map = {task.id: task for task in HeftHelper.get_all_tasks(self.workflow)} self.node_map = {node.name: node for node in nodes} self.initial_chromosome = None pass
def __init__(self, workflow, nodes, estimator): self.workflow = workflow self.nodes = nodes self.workflow_size = workflow.get_task_count() self.estimator = estimator self.task_map = { task.id: task for task in HeftHelper.get_all_tasks(self.workflow) } self.node_map = {node.name: node for node in nodes} self.initial_chromosome = None pass
def _run_heft(): dynamic_planner = DynamicHeft(wf, resource_manager, estimator) nodes = HeftHelper.to_nodes(resource_manager.resources) current_cleaned_schedule = Schedule({node: [] for node in nodes}) schedule_dynamic_heft = dynamic_planner.run( current_cleaned_schedule) self._validate(wf, estimator, schedule_dynamic_heft) if is_visualized: viz.visualize_task_node_mapping(wf, schedule_dynamic_heft) # Utility.create_jedule_visualization(schedule_dynamic_heft, wf_name+'_heft') pass return schedule_dynamic_heft
def test_fixed_ordering(self): _wf = wf("Montage_25") rm = ExperimentResourceManager(rg.r([10, 15, 25, 30])) estimator = SimpleTimeCostEstimator(comp_time_cost=0, transf_time_cost=0, transferMx=None, ideal_flops=20, transfer_time=100) sorted_tasks = HeftHelper.heft_rank(_wf, rm, estimator) heft_schedule = run_heft(_wf, rm, estimator) heft_mapping = schedule_to_position(heft_schedule) heft_gen = lambda: heft_mapping if random.random() > 0.95 else generate(_wf, rm, estimator) toolbox = Toolbox() # toolbox.register("generate", generate, _wf, rm, estimator) toolbox.register("generate", heft_gen) toolbox.register("fitness", fitness, _wf, rm, estimator, sorted_tasks) toolbox.register("force_vector_matrix", force_vector_matrix, rm) toolbox.register("velocity_and_position", velocity_and_position, _wf, rm, estimator) toolbox.register("G", G) toolbox.register("kbest", Kbest) statistics = Statistics() statistics.register("min", lambda pop: numpy.min([p.fitness.mofit for p in pop])) statistics.register("avr", lambda pop: numpy.average([p.fitness.mofit for p in pop])) statistics.register("max", lambda pop: numpy.max([p.fitness.mofit for p in pop])) statistics.register("std", lambda pop: numpy.std([p.fitness.mofit for p in pop])) logbook = Logbook() logbook.header = ("gen", "G", "kbest", "min", "avr", "max", "std") pop_size = 100 iter_number = 100 kbest = pop_size ginit = 5 final_pop = run_gsa(toolbox, statistics, logbook, pop_size, iter_number, kbest, ginit) best = min(final_pop, key=lambda x: toolbox.fitness(x).mofit) solution = {MAPPING_SPECIE: list(zip(sorted_tasks, best)), ORDERING_SPECIE: sorted_tasks} schedule = build_schedule(_wf, estimator, rm, solution) Utility.validate_static_schedule(_wf, schedule) makespan = Utility.makespan(schedule) print("Final makespan: {0}".format(makespan)) pass
def init(self): if self.initial_schedule is None: self.current_schedule = Schedule( {node: [] for node in self.heft_planner.get_nodes()}) self.current_schedule = self.heft_planner.run( self.current_schedule) else: id_to_task = { tsk.id: tsk for tsk in HeftHelper.get_all_tasks(self.heft_planner.workflow) } mapping = { node: [ ScheduleItem(id_to_task[item.job.id], item.start_time, item.end_time) for item in items ] for (node, items) in self.initial_schedule.mapping.items() } self.current_schedule = Schedule(mapping) self._post_new_events()
def __init__(self, workflow, resource_manager, estimator, task_map, node_map, # fixed part of schedule. It need to be accounted when new schedule is built, but it's not possible to cahnge something inside it fixed_schedule_part): self.workflow = workflow self.nodes = HeftHelper.to_nodes(resource_manager.get_resources()) self.estimator = estimator ##TODO: Build it self.task_map = task_map ##TODO: Build it self.node_map = node_map self.fixed_schedule_part = fixed_schedule_part # construct initial mapping # eliminate all already scheduled tasks pass
def __init__( self, workflow, resource_manager, estimator, task_map, node_map, # fixed part of schedule. It need to be accounted when new schedule is built, but it's not possible to cahnge something inside it fixed_schedule_part): self.workflow = workflow self.nodes = HeftHelper.to_nodes(resource_manager.get_resources()) self.estimator = estimator ##TODO: Build it self.task_map = task_map ##TODO: Build it self.node_map = node_map self.fixed_schedule_part = fixed_schedule_part # construct initial mapping # eliminate all already scheduled tasks pass
def run(self, current_cleaned_schedule): ## current_cleaned_schedule - this schedule contains only ## finished and executed tasks, all unfinished and failed have been removed already ## current_cleaned_schedule also have down nodes and new added ## ALGORITHM DOESN'T CHECK ADDING OF NEW NODES BY ITSELF ## nodes contain only available now ## 1. get all unscheduled tasks ## 2. sort them by rank ## 3. map on the existed nodes according to current_cleaned_schedule nodes = self.get_nodes() for_planning = HeftHelper.get_tasks_for_planning(self.workflow, current_cleaned_schedule) ## TODO: check if it sorted properly for_planning = set([task.id for task in for_planning]) sorted_tasks = [task for task in self.wf_jobs if task.id in for_planning] # print("P: " + str(sorted_tasks)) new_sched = self.mapping([(self.workflow, sorted_tasks)], current_cleaned_schedule.mapping, nodes, self.commcost, self.compcost) return new_sched
def get_infrastructure(bundle, reliability, with_ga_initial, nodes_conf=None): if nodes_conf is not None: resources = ResourceGenerator.r(nodes_conf) else: resources = bundle.dedicated_resources nodes = HeftHelper.to_nodes(resources) realibility_map = {node.name: reliability for node in nodes} initial_schedule = None if with_ga_initial is True: initial_schedule = bundle.ga_schedule #initial_ga_makespan = Utility.get_the_last_time(initial_schedule ) #print("Initial GA makespan: " + str(initial_ga_makespan)) ## TODO: end ##====================== ## create heft_executor ##====================== estimator = ExperimentEstimator(bundle.transfer_mx, bundle.ideal_flops, realibility_map) resource_manager = ExperimentResourceManager(resources) return (estimator, resource_manager, initial_schedule)
def get_by_softreq(self, soft_reqs): nodes = HeftHelper.to_nodes(self.public_resources) def check_reqs(node): return (soft_reqs in node.soft) or (SoftItem.ANY_SOFT in node.soft) gotcha = [node for node in nodes if node.state != Node.Down and check_reqs(node)] return gotcha
def generate_public_resources(self): ## TODO: remake it later #(public_resources, generate_reliability, generate_probability_law_for_(task,node)_pair) = generate public_resource resCount = 3 resources = list() for i in range(0, resCount): res = Resource("public_res_" + str(i)) resources.append(res) nodeCount = None if i == 0: nodeCount = 15 elif i == 1: nodeCount = 12 elif i == 2: nodeCount = 9 for j in range(0, nodeCount): node = Node(res.name + "_node_" + str(j), res, [SoftItem.ANY_SOFT]) # if j == 0: # node.flops = 10 + 5 # if j == 1: # node.flops = 15 + 10#10*3 # if j == 2: # node.flops = 25 + 10#25*3 # if j == 3: # node.flops = 25 + 10#25*3 # if j == 4: # node.flops = 30 + 10#30*3 # if j == 5: # node.flops = 10 + 5 # if j == 6: # node.flops = 15 + 10#10*3 # if j == 7: # node.flops = 25 + 10#25*3 # if j == 8: # node.flops = 25 + 10#25*3 # if j == 9: # node.flops = 30 + 10#30*3 # if j == 10: # node.flops = 10 + 5 # if j == 11: # node.flops = 15 + 10#10*3 # if j == 12: # node.flops = 25 + 10#25*3 # if j == 13: # node.flops = 25 + 10#25*3 # if j == 14: # node.flops = 30 + 10#30*3 if j == 0: node.flops = 10 if j == 1: node.flops = 15#10*3 if j == 2: node.flops = 25#25*3 if j == 3: node.flops = 25#25*3 if j == 4: node.flops = 30#30*3 if j == 5: node.flops = 10 if j == 6: node.flops = 15#10*3 if j == 7: node.flops = 25#25*3 if j == 8: node.flops = 25#25*3 if j == 9: node.flops = 30#30*3 if j == 10: node.flops = 10 if j == 11: node.flops = 15#10*3 if j == 12: node.flops = 25#25*3 if j == 13: node.flops = 25#25*3 if j == 14: node.flops = 30#30*3 res.nodes.add(node) nodes = HeftHelper.to_nodes(resources) reliability_map = {node.name: 0.9 for node in nodes} def probability_estimator(dt, comp_estimation, transfer_estimation): M = comp_estimation + transfer_estimation sigma = 0.1 * M result = 0.5 *(1 + math.erf((dt - M)/sigma)) return result return (resources, reliability_map, probability_estimator)
from heft.algs.pso.gapso import run_gapso from heft.algs.pso.sdpso import run_pso, update, schedule_to_position, construct_solution, MappingParticle, \ Velocity, Position from heft.core.CommonComponents.ExperimentalManagers import ExperimentResourceManager from heft.core.environment.Utility import Utility, wf from heft.algs.common.mapordschedule import build_schedule, MAPPING_SPECIE, ORDERING_SPECIE, ordering_from_schedule, \ mapping_from_schedule from heft.experiments.cga.mobjective.utility import SimpleTimeCostEstimator from heft.core.environment.ResourceGenerator import ResourceGenerator as rg from heft.algs.common.mapordschedule import fitness as basefitness _wf = wf("Montage_50") rm = ExperimentResourceManager(rg.r([10, 15, 25, 30])) estimator = SimpleTimeCostEstimator(comp_time_cost=0, transf_time_cost=0, transferMx=None, ideal_flops=20, transfer_time=100) sorted_tasks = HeftHelper.heft_rank(_wf, rm, estimator) heft_schedule = run_heft(_wf, rm, estimator) print(Utility.makespan(heft_schedule)) stats = tools.Statistics(lambda ind: ind.fitness.values[0]) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) logbook = tools.Logbook()
def isCloudNode(self, node): result = node.name in [nd.name for nd in HeftHelper.to_nodes(self.public_resources)] return result
from heft.core.CommonComponents.ExperimentalManagers import ExperimentResourceManager from heft.core.environment.Utility import Utility, wf from heft.algs.common.mapordschedule import build_schedule, MAPPING_SPECIE, ORDERING_SPECIE from heft.experiments.aggregate_utilities import interval_statistics, interval_stat_string from heft.experiments.cga.mobjective.utility import SimpleTimeCostEstimator from heft.core.environment.ResourceGenerator import ResourceGenerator as rg from heft.experiments.cga.utilities.common import repeat _wf = wf("Montage_75") rm = ExperimentResourceManager(rg.r([10, 15, 25, 30])) estimator = SimpleTimeCostEstimator(comp_time_cost=0, transf_time_cost=0, transferMx=None, ideal_flops=20, transfer_time=100) sorted_tasks = HeftHelper.heft_rank(_wf, rm, estimator) heft_schedule = run_heft(_wf, rm, estimator) heft_mapping = schedule_to_position(heft_schedule) heft_mapping.velocity = MappingParticle.Velocity({}) heft_gen = lambda n: [ deepcopy(heft_mapping) if random.random() > 1.0 else generate(_wf, rm, estimator, 1)[0] for _ in range(n) ] W, C1, C2 = 0.1, 0.6, 0.2 GEN, N = 300, 50
def default_fixed_schedule_part(resource_manager): fix_schedule_part = Schedule({node: [] for node in HeftHelper.to_nodes(resource_manager.get_resources())}) return fix_schedule_part
def generate_public_resources(self): ## TODO: remake it later #(public_resources, generate_reliability, generate_probability_law_for_(task,node)_pair) = generate public_resource resCount = 3 resources = list() for i in range(0, resCount): res = Resource("public_res_" + str(i)) resources.append(res) nodeCount = None if i == 0: nodeCount = 15 elif i == 1: nodeCount = 12 elif i == 2: nodeCount = 9 for j in range(0, nodeCount): node = Node(res.name + "_node_" + str(j), res, [SoftItem.ANY_SOFT]) # if j == 0: # node.flops = 10 + 5 # if j == 1: # node.flops = 15 + 10#10*3 # if j == 2: # node.flops = 25 + 10#25*3 # if j == 3: # node.flops = 25 + 10#25*3 # if j == 4: # node.flops = 30 + 10#30*3 # if j == 5: # node.flops = 10 + 5 # if j == 6: # node.flops = 15 + 10#10*3 # if j == 7: # node.flops = 25 + 10#25*3 # if j == 8: # node.flops = 25 + 10#25*3 # if j == 9: # node.flops = 30 + 10#30*3 # if j == 10: # node.flops = 10 + 5 # if j == 11: # node.flops = 15 + 10#10*3 # if j == 12: # node.flops = 25 + 10#25*3 # if j == 13: # node.flops = 25 + 10#25*3 # if j == 14: # node.flops = 30 + 10#30*3 if j == 0: node.flops = 10 if j == 1: node.flops = 15 #10*3 if j == 2: node.flops = 25 #25*3 if j == 3: node.flops = 25 #25*3 if j == 4: node.flops = 30 #30*3 if j == 5: node.flops = 10 if j == 6: node.flops = 15 #10*3 if j == 7: node.flops = 25 #25*3 if j == 8: node.flops = 25 #25*3 if j == 9: node.flops = 30 #30*3 if j == 10: node.flops = 10 if j == 11: node.flops = 15 #10*3 if j == 12: node.flops = 25 #25*3 if j == 13: node.flops = 25 #25*3 if j == 14: node.flops = 30 #30*3 res.nodes.add(node) nodes = HeftHelper.to_nodes(resources) reliability_map = {node.name: 0.9 for node in nodes} def probability_estimator(dt, comp_estimation, transfer_estimation): M = comp_estimation + transfer_estimation sigma = 0.1 * M result = 0.5 * (1 + math.erf((dt - M) / sigma)) return result return (resources, reliability_map, probability_estimator)
def get_nodes(self): resources = self.resource_manager.get_resources() nodes = HeftHelper.to_nodes(resources) return nodes
def get_nodes(self): resources = self.resource_manager.get_resources() nodes = HeftHelper.to_nodes(resources) return nodes