Пример #1
0
    def __init__(self, state_n, nodes, run_times, tree, data):
        self.n = len(run_times)  # tasks amount
        self.m = len(nodes)  # nodes amount
        self.state_n = state_n
        self.actions = [[i, j] for i in range(self.state_n)
                        for j in range(self.m)]

        # требуемые для внутренний логики
        self.nodes = nodes  # массив с колличеством ядер на узлах
        # self.bandwidth = 0.1  # скорость передачи данных в MB = 50MB
        self.bandwidth = 10.0  # скорость передачи данных в MB = 50MB
        self.run_times = run_times  # время выполнения задач на узлах
        self.comp_times = estimate_comp_times(self.run_times, self.nodes)
        self.tree = tree  # матрица инцидентности
        self.data_map = data  # матрица зависимостей по данным (как инцидентности, только с объёмом данных в значениях)
        self.endtime_map = np.ones(
            (self.n, self.m)
        ) * -1  # матрица с кортежами (время старта; время финиша) для каждой задачи на нодах -1, если нет
        self.scheduled = []  # индексы уже запланированных задач
        self.schedule = self.init_schedule()

        # доп статы и метрики
        # static
        self.worst_time = self.wf_worst_schedule_time()
        self.lvls, self.task_lvls, self.height, self.widths = self.levels()
        self.max_width = max(self.widths)
        self.avg_width = sum(self.widths) / len(self.widths)
        self.width_eq_one = len(np.where(np.array(self.widths) == 1))
        self.tasks_on_lvl = np.array(
            [self.widths[self.task_lvls[t]] for t in range(self.n)])
        self.lvl_runtime = self.levels_runtimes()
        self.t_parents = [self.parents(t) for t in range(self.n)]
        self.t_children = [self.children(t) for t in range(self.n)]
        self.t_parents_avg = np.mean([len(par) for par in self.t_parents])
        self.t_children_avg = np.mean([len(ch) for ch in self.t_children])
        self.t_parents_max = np.max([len(par) for par in self.t_parents])
        self.t_children_max = np.max([len(ch) for ch in self.t_children])
        self.runtime_sum = self.run_times.sum()
        self.input_sum = self.data_map[np.where(self.data_map > 0)].sum()
        self.runtime_med = np.median(self.run_times)
        self.input_avg = 0.0
        if self.data_map.max() > 0:
            self.input_avg = np.mean(
                self.data_map[np.where(self.data_map > 0)])
        self.t_input = self.tasks_input()
        self.lvl_input = self.levels_input()

        # dynamic
        self.completed = False
        self.load = np.zeros(self.m)
        self.tasks_ready = np.zeros(self.n, dtype=np.int)
        self.scheduled_tasks = np.zeros(self.n, dtype=np.int)
        self.p_on_node = np.zeros((self.n, self.m), dtype=np.int)
        self.input_on_node = np.zeros((self.n, self.m))

        self.state = []
        self.update_state()
Пример #2
0
    def _reset(self):
        self.actions = [[i, j] for i in range(self.state_n)
                        for j in range(self.m)]

        # требуемые для внутренний логики
        # self.bandwidth = 0.1  # скорость передачи данных в MB = 50MB
        self.bandwidth = 10.0  # скорость передачи данных в MB = 50MB
        self.comp_times = estimate_comp_times(self.run_times, self.nodes)
        self.endtime_map = np.ones((self.n, self.m)) * -1
        # матрица с кортежами (время старта; время финиша) для каждой задачи на нодах -1, если нет
        self.scheduled = []  # индексы уже запланированных задач
        self.schedule = self.init_schedule()

        # доп статы и метрики
        # static
        self.worst_time = self.wf_worst_schedule_time()
        self.lvls, self.task_lvls, self.height, self.widths = self.levels()
        self.max_width = max(self.widths)
        self.avg_width = sum(self.widths) / len(self.widths)
        self.width_eq_one = len(np.where(np.array(self.widths) == 1))
        self.tasks_on_lvl = np.array(
            [self.widths[self.task_lvls[t]] for t in range(self.n)])
        self.lvl_runtime = self.levels_runtimes()
        self.t_parents = [self.parents(t) for t in range(self.n)]
        self.t_children = [self.children(t) for t in range(self.n)]
        self.t_parents_avg = np.mean([len(par) for par in self.t_parents])
        self.t_children_avg = np.mean([len(ch) for ch in self.t_children])
        self.t_parents_max = np.max([len(par) for par in self.t_parents])
        self.t_children_max = np.max([len(ch) for ch in self.t_children])
        self.runtime_sum = self.run_times.sum()
        self.input_sum = self.data_map[np.where(self.data_map > 0)].sum()
        self.runtime_med = np.median(self.run_times)
        self.input_avg = 0.0
        if self.data_map.max() > 0:
            self.input_avg = np.mean(
                self.data_map[np.where(self.data_map > 0)])
        self.t_input = self.tasks_input()
        self.lvl_input = self.levels_input()

        # dynamic
        self._episode_ended = False
        self.load = np.zeros(self.m)
        self.tasks_ready = np.zeros(self.n, dtype=np.int)
        self.scheduled_tasks = np.zeros(self.n, dtype=np.int)
        self.p_on_node = np.zeros((self.n, self.m), dtype=np.int)
        self.input_on_node = np.zeros((self.n, self.m))

        self.state = []
        self.update_state()
        return ts.restart(self.state)