def conf(self, next_deadline): if next_deadline > self.next_deadline: self.next_deadline = next_deadline self.migrating_task1, self.migrating_task2 = \ self.migrating_task2, self.migrating_task1 if self.migrating_task1: time_a = ceil( (next_deadline - self.sim.now()) * self.migrating_task1[1]) self.timer_a = Timer(self.sim, Modified_EDF.on_end_migrating1, (self, ), time_a, cpu=self.processors[0], in_ms=False) self.timer_a.start() self.migrating_job2 = None if self.migrating_task2: time_b = int((next_deadline - self.sim.now()) * (1 - self.migrating_task2[1])) self.timer_b = Timer(self.sim, Modified_EDF.on_start_migrating2, (self, ), time_b, cpu=self.processors[0], in_ms=False) self.timer_b.start() self.processors[0].resched() if self.migrating_task1: self.migrating_job1 = self.migrating_task1[0].job self.processors[0].resched() else: self.migrating_job1 = None
def schedule(self, cpu): decisions = [] if self.ready_list: # Sort according to the laxity. self.ready_list.sort(key=lambda x: (x.laxity, x.absolute_deadline)) # m : Nombre de processeurs. m = len(self.processors) # Available processors: l = (proc for proc in self.processors if proc.running not in self.ready_list[:m]) if len(self.ready_list) > m: ta = self.ready_list[m - 1] dmin = self.ready_list[m].absolute_deadline * \ self.sim.cycles_per_ms - self.sim.now() if self.timer: self.timer.stop() self.timer = Timer(self.sim, MLLF.update, (self, self.processors[0]), dmin - ta.laxity, one_shot=True, cpu=self.processors[0]) self.timer.start() # The first m jobs should be running: for job in self.ready_list[:m]: if not job.is_running(): proc = next(l) decisions.append((job, proc)) return decisions
def create_timer(self, i): return Timer( self.sim, MLFQ.end_event, (self, self.processors[0]), self.QUANTUM*(2**i), cpu=self.processors[0], in_ms=True)
def schedule(self, cpu): if len(self.ready_list) > 0: # Explication sur la key: # En priorité, on met tous les processeurs libres au début. # Ensuite, on trie tout par ordre décroissant de la deadline. # Et on départage en préférant le processeur "cpu". key = lambda x: (1 if (not x.running) or (not self.pseudo_job[x]) else 0, self.pseudo_job[x].cmp_key() if x.running and self.pseudo_job[x] else None, 1 if x is cpu else 0) cpu_min = max(self.processors, key=key) pjob = min(self.ready_list, key=lambda x: x.cmp_key()) if (cpu_min.running is None or self.pseudo_job[cpu_min] is None or self.pseudo_job[cpu_min].cmp_key() > pjob.cmp_key()): self.ready_list.remove(pjob) if cpu_min.running and self.pseudo_job[cpu_min]: self.ready_list.append(self.pseudo_job[cpu_min]) self.pseudo_job[cpu_min] = pjob timer = Timer(self.sim, EPDF.pseudo_terminate, (self, pjob), pjob.seq * self.quantum - pjob.job.computation_time, cpu=cpu_min, in_ms=True) timer.start() self.timers.append(timer) return (pjob.job, cpu_min) elif self.pseudo_job[cpu] is None: return (None, cpu)
def on_activate(self, job): server = self.cbs_servers[job.task] # If the ready list of the server is empty new runtime and deadline are computed and # the deadline_timer is started if (not server.ready_list): # qi < (di - t)Qi/Ti if not (server.current_runtime < (server.current_deadline - self.sim.now_ms()) * (server.maximum_runtime / server.deadline)): # d = t + D, q = Q self.cbs_servers[job.task].set( self.cbs_servers[job.task].maximum_runtime, self.sim.now_ms() + self.cbs_servers[job.task].deadline, self.sim.now_ms(), Timer(self.sim, SCHED_DEADLINE.deadline_call, (self, self.cbs_servers[job.task]), self.cbs_servers[job.task].deadline, one_shot=True, cpu=self.processors[0], overhead=.000)) # The job is added to the ready_list of the server server.add_job(job) job.cpu.resched()
def schedule(self): """ Schedule this proper sub-system. """ self.to_reschedule = False decision = [] self.virtual = [] jobs = select_jobs(self.root, self.virtual) wakeup_delay = min(self.virtual, key=lambda s: s.budget).budget if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() cpus = [] for cpu in self.processors: if cpu.running in jobs: jobs.remove(cpu.running) else: cpus.append(cpu) for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: decision.append((None, cpu)) return decision
def schedule(self, cpu): """ Schedule main method. """ self.waiting_schedule = False # At the end of the interval: if self.sim.now() >= self.t_f: self.init_interval() # Stop current timers. for job, timer in self.timers.items(): timer.stop() self.timers = {} # Set timers to stop the jobs that will run. for z, proc in enumerate(self.processors): l = self.allocations[z][1] if l and l[0][0] not in self.timers: timer = Timer(self.sim, BF.end_event, (self, z, l[0][0]), l[0][1], cpu=proc, in_ms=False) timer.start() self.timers[l[0][0]] = timer # Schedule the activated tasks on each processor. decisions = [] for z, proc in enumerate(self.processors): l = self.allocations[z][1] if not l[0][0] or l[0][0].is_active(): decisions.append((l[0][0] if l else None, proc)) return decisions
def add_timer(self, wakeup_delay, CPU): if self.dummy_timer: self.dummy_timer.stop() self.dummy_timer = Timer(self.sim, ProperSubsystem.end_dummy, (self, CPU), wakeup_delay, cpu=CPU, in_ms=False) self.dummy_timer.start()
def init(self): self.ready_list = [] self.timer = Timer(self.sim, LLF.update, (self, self.processors[0]), 1, one_shot=False, cpu=self.processors[0], overhead=.001) self.timer.start()
def init(self): self.ready_list = [] self.delay = 2 self.timer = Timer(self.sim, RR.end_event, (self, self.processors[0]), self.delay, cpu=self.processors[0], in_ms=True) self.interupt = False
def add_timer(self, wakeup_delay, CPU): if self.dummy_timer2: self.dummy_timer2.stop() self.dummy_timer2 = Timer(self.sim, ProperSubsystem.dummy_activated, (self, CPU), wakeup_delay, cpu=CPU, in_ms=False) self.dummy_timer2.start()
def init(self): self.ready_list = [] """ However, LSTR scheduling algorithm operates on every basic time unit. Here, we consider the basic time unit of 1 (ms). """ self.timer = Timer(self.sim, LSTR.virtual_event, (self, self.processors[0]), 1, one_shot=False) self.timer.start()
def add_timer(self, wakeup_delay, CPU): #self.sim.logger.log("add_timer to {}".format(wakeup_delay)) if self.dummy_timer: self.dummy_timer.stop() self.dummy_timer = Timer(self.sim, ProperSubsystem.end_dummy, (self, CPU), wakeup_delay, cpu=CPU, in_ms=False) self.dummy_timer.start()
def schedule(self, cpu): """ Take the scheduling decisions. """ self.waiting_schedule = False decisions = [] self.h_c = [(d, t) for d, t in self.h_c if t.job.is_active()] heapify(self.h_c) if self.sim.now() == self.t_f: decisions = self.init_tl_plane() else: for task in self.activations: decisions += self.handle_evt_a(task) if self.evt_bc: decisions += self.handle_evt_bc() self.activations = [] self.evt_bc = False if self.h_b: t_next = self.h_b[0][0] if self.h_c: t_next = min(t_next, self.h_c[0][0]) self.timer = Timer(self.sim, LRE_TL.event_bc, (self, ), t_next - self.sim.now(), cpu=self.processors[0], in_ms=False) else: self.timer = Timer(self.sim, LRE_TL.reschedule, (self, ), self.t_f - self.sim.now(), cpu=self.processors[0], in_ms=False) self.timer.start() return decisions
def accept_migrating_job(self, i, job, budget): self.migrating_job = job job.task.cpu = self.processors[0] # Set timer for end. self.timer = Timer(self.sim, EDF_modified.end_migrating_job, (self, i), budget, cpu=self.processors[0], in_ms=False) self.timer.start() self._resched()
def deadline_call(self, server): # This call is done when a CBS deadline expired # The runtime is refilled, a new deadline-server is computed and # the deadline-time is restarted if server.ready_list: server.set( server.maximum_runtime, self.sim.now_ms() + server.period, self.sim.now_ms(), Timer(self.sim, SCHED_DEADLINE.deadline_call, (self, server), server.deadline, one_shot=True, cpu=self.processors[0], overhead=.000)) server.task.cpu.resched()
def init(self): self.ready_lists = [[] for _ in range(self.NUM_QUEUE)] self.job_timer = None self.timers = [self.create_timer(i) for i in range(self.NUM_QUEUE - 1)] self.prior_table = {} self.boost_timer = Timer( self.sim, MLFQ.boost_event, (self, self.processors[0]), self.BOOST_DELAY, one_shot=False, cpu=self.processors[0], in_ms=True) self.boost_timer.start() self.interupt = False
def init(self): self.ready_list = [] self.timers = [] self.terminate_timers = [] self.waiting_schedule = False self.running_vjobs = [] ER_PD2.quantum = self.sim.cycles_per_ms // 10 # 0.1ms. #ER_PD2.quantum = 1000000 #while not self.is_schedulable() and ER_PD2.quantum > 1000: # ER_PD2.quantum /= 2 self.timer = Timer( self.sim, ER_PD2.reschedule, (self, ), ER_PD2.quantum, cpu=self.processors[0], in_ms=False, one_shot=False) self.timer.start()
def schedule(self, cpu): # update runtime of the running server on cpu if exists if cpu.running: self.cbs_servers[cpu.running.task].update_runtime( self.sim.now_ms()) # List of CBS servers with a ready job which is not currently running ready_servers = [ s for s in self.cbs_servers.values() if s.ready_list and not s.ready_list[0].is_running() and not s.is_throttled ] # Choose the job-server and processor with EDF citeria if ready_servers: # Select a free processor or, if none, # the one with the greatest server-deadline (self in case of equality): key = lambda x: (1 if not x.running else 0, self.cbs_servers[ x.running.task].current_deadline if x.running else 0, 1 if x is cpu else 0) cpu_min = max(self.processors, key=key) # Select the job with the least server-deadline server = min(ready_servers, key=lambda x: x.current_deadline) job = server.ready_list[0] if (cpu_min.running is None or self.cbs_servers[cpu_min.running.task].current_deadline > self.cbs_servers[job.task].current_deadline): print(self.sim.now(), job.name, cpu_min.name) # start runtime timer of the new server selected self.cbs_servers[job.task].timer_runtime = Timer( self.sim, SCHED_DEADLINE.runtime_call, (self, self.cbs_servers[job.task]), self.cbs_servers[job.task].current_runtime, one_shot=True, cpu=self.processors[0], overhead=.000) self.cbs_servers[job.task].timer_runtime.start() self.cbs_servers[job.task].last_update = self.sim.now_ms() # stop runtime timer for the job-server running on the selected processor if (cpu_min.running): self.cbs_servers[cpu_min.running.task].timer_runtime.stop() return (job, cpu_min)
def on_activate(self, job): # First pseudo-activation pseudo_job = EPDF.PseudoJob(job, 1) self.pseudo_activate(pseudo_job) # Set next pseudo activations : while pseudo_job.seq * self.quantum < job.wcet: pseudo_job = EPDF.PseudoJob(job, pseudo_job.seq + 1) timer = Timer(self.sim, EPDF.pseudo_activate, (self, pseudo_job), pseudo_job.release_date * self.quantum - self.sim.now() / self.sim.cycles_per_ms + job.activation_date, cpu=job.cpu, in_ms=True) timer.start() self.timers.append(timer)
def schedule(self, cpu): self.waiting_schedule = False self.update_budget() # Sort the jobs by budgets. sorted_budgets = sorted([(x, ceil(y)) for x, y in self.budget.items()], key=lambda x: (-x[1], x[0].name)) selected = sorted_budgets[:len(self.processors)] not_selected = sorted_budgets[len(self.processors):] # Compute the (relative) date of the next event. next_event = self.date_next_event(selected, not_selected) if next_event > 0: # Set a timer to reschedule the system at that date. self.timer_a = Timer(self.sim, LLREF.reschedule, (self, ), next_event, cpu=cpu, in_ms=False) self.timer_a.start() # Allocate the selected jobs to the processors. # The processors already running selected jobs are not changed. available_procs = [] self.selected_jobs = [s[0] for s in selected if s[1] > 0] remaining_jobs = self.selected_jobs[:] for proc in self.processors: if proc.running in self.selected_jobs: # This processor keeps running the same job. remaining_jobs.remove(proc.running) else: # This processor is not running a selected job. available_procs.append(proc) # The remaining processors are running the remaining jobs or None. padded_remaining_jobs = remaining_jobs + \ [None] * (len(available_procs) - len(remaining_jobs)) # zip create a list of couples (job, proc) using the list of remaining # jobs and the list of available processors. decisions = list(zip(padded_remaining_jobs, available_procs)) return decisions
def schedule(self, cpu): """ Basically a EDF scheduling but using a priority attribute. """ ready_jobs = [j for j in self.ready_list if j.is_active()] if ready_jobs: selected_job = None key = lambda x: (1 if x.running else -1, -x.running.priority if x.running else 0, -1 if x is cpu else 1) cpu_min = min(self.processors, key=key) job = min(ready_jobs, key=lambda x: x.priority) if cpu_min.running is None or \ cpu_min.running.priority > job.priority: self.ready_list.remove(job) if cpu_min.running: self.ready_list.append(cpu_min.running) selected_job = (job, cpu_min) # Recherche du prochain event ZeroLaxity pour configurer le timer. minimum = None for job in self.ready_list: zl_date = job.laxity if (minimum is None or minimum[0] > zl_date) and zl_date > 0: minimum = (zl_date, job) if self.zl_timer: self.zl_timer[1].stop() if minimum: self.zl_timer = (minimum[0], Timer(self.sim, EDZL.zero_laxity, (self, minimum[1]), minimum[0], cpu=cpu, in_ms=False)) self.zl_timer[1].start() return selected_job
def schedule(self, cpu): """ Basically a EDF scheduling but using a priority attribute. """ if self.ready_list: selected_job = None key = lambda x: (1 if x.running else -1, -x.running.priority if x.running else 0, -1 if x is cpu else 1) cpu_min = min(self.processors, key=key) job = min(self.ready_list, key=lambda x: x.priority) if cpu_min.running is None or \ cpu_min.running.priority > job.priority: self.ready_list.remove(job) if cpu_min.running: self.ready_list.append(cpu_min.running) selected_job = (job, cpu_min) minimum = None for job in self.ready_list: zl_date = int((job.absolute_deadline - job.ret) * self.sim.cycles_per_ms - self.sim.now()) if (minimum is None or minimum[0] > zl_date) and zl_date > 0: minimum = (zl_date, job) if self.zl_timer: self.zl_timer[1].stop() if minimum: self.zl_timer = (minimum[0], Timer(self.sim, G_FL_ZL.zero_laxity, (self, minimum[1]), minimum[0], cpu=cpu, in_ms=False)) self.zl_timer[1].start() return selected_job
def schedule(self): """ Schedule this proper sub-system. """ self.to_reschedule = False decision = [] self.virtual = [] active_servers = [ s for s in self.root.children if s.budget > 0 and not s.dummyServer ] selected = select_jobs(self, self.root, self.virtual) idle = [s for s in selected if s.task.name == 'IdleTask'] jobs = [ s.job for s in selected if s.task.name != 'IdleTask' and s.task.name != "wcet" ] min_s = min(self.virtual, key=lambda s: s.budget) wakeup_delay = min_s.budget if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() processors = [] t = self.sim.now() beta = sum([s.budget for s in active_servers]) omega = max(0, self.root.next_deadline - t, beta) if idle: if self.level % 2 == 0: decision.append((None, self.processors[0])) self.processors[0].set_dummy(beta) # primal level else: self.processors[0].set_dummy(omega) processors = self.processors[ 1:] # Refresh available processors list decision.append( (None, self.processors[0])) # Set dummy to first processor else: processors = self.processors self.processors[0].stop_dummy() cpus = [] #first, leave already executing tasks on their current processors; for cpu in processors: if cpu.running in jobs: jobs.remove(cpu.running) # remove job and cpu else: cpus.append(cpu) # second, assign previously idle tasks to their last-used processor, when its available aux_jobs = list(jobs) for job in aux_jobs: if job.task.last_cpu in cpus: decision.append((job, job.task.last_cpu)) jobs.remove(job) cpus.remove(job.task.last_cpu) # third, assign remaining tasks to free processors arbitrarily for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: period = 0 decision.append((None, cpu)) return decision
def schedule(self): """ Schedule this proper sub-system. """ self.to_reschedule = False self.virtual = [] decision = [] processors = [] processors = self.processors self.CSC(self.sim.now()) t = self.sim.now() if t >= self.idleBegin and t < self.idleEnd: self.is_idle = True # add schedule event - end of idle period self.add_timer(self.idleEnd - t, self.processors[0]) else: self.is_idle = False selected = select_jobs(self, self.root, self.virtual) idle = [s for s in selected if s.task.name == 'IdleTask'] jobs = [ s.job for s in selected if s.task.name != 'IdleTask' and s.task.name != "wcet" ] if idle: # CSC dual level if self.level % 2 == 0: # use busyInterval to save energy self.processors[0].set_dummy(self.busyEnd - t) # CSC primal level else: # use idleInterval to save energy self.processors[0].set_dummy(self.idleEnd - t) processors = self.processors[ 1:] # Refresh available processors list decision.append( (None, self.processors[0])) # Set dummy to first processor else: self.processors[0].stop_dummy() wakeup_delay = min([s.budget for s in self.virtual if s.budget > 0]) if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() cpus = [] #first, leave already executing tasks on their current processors; for cpu in processors: if cpu.running in jobs: jobs.remove(cpu.running) # remove job and cpu else: cpus.append(cpu) # second, assign previously idle tasks to their last-used processor, when its available aux_jobs = list(jobs) for job in aux_jobs: if job.task.last_cpu in cpus: decision.append((job, job.task.last_cpu)) jobs.remove(job) cpus.remove(job.task.last_cpu) # third, assign remaining tasks to free processors arbitrarily for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: decision.append((None, cpu)) return decision
def schedule_0(self): """ Schedule this proper sub-system. """ self.to_reschedule = False decision = [] self.virtual = [] active_servers = [s for s in self.root.children if not s.dummyServer and s.budget > 0] if self.is_idle is True and self.keep is False and active_servers: self.sim.logger.log("was idle in t {}".format(self.processors[0].name)) servers = [s for s in self.root.children if not s.dummyServer] # Prolongamento do job dummy liberado em idle_time self.slack = algorithm_1(self, servers, self.sim.now()) # tempo de computação total do job dummy liberado em idle_time delta = self.sim.now() - self.idle_time + self.slack self.sim.logger.log("original slack {} omega {}".format(self.slack, self.sim.now() - self.idle_time)) # período ocioso exato delta self.processors[0].set_idle(delta) # Se houve prolongamento, o nível continua ocioso if self.slack > 0: self.add_timer(self.slack, self.processors[0]) self.keep = True self.is_idle = False self.slack += self.sim.now() # Caso contrário, o nível fica ocupado else: self.is_idle = False self.keep = False elif active_servers and self.sim.now() >= self.slack: self.is_idle = False self.keep = False # Processor level control if not self.busy: self.busy = True self.sim.logger.log("Servidores ativos, BUSY {}, slack {}".format(self.processors[0].name, self.slack)) else: self.sim.logger.log("Sem servidores ativos, IDLE {}, slack {}".format(self.processors[0].name, self.slack)) self.is_idle = True self.idle_time = self.sim.now() # se o tempo acabar antes de aglomerar # Sinaliza início da ociosidade para energy self.processors[0]._power.flag(self.sim.now()) selected = select_jobs(self, self.root, self.virtual) idle = [s for s in selected if s.task.name == 'IdleTask'] jobs = [s.job for s in selected if s.task.name != 'IdleTask' and s.task.name != "wcet"] """if (idle and not self.keep): servers = [s for s in self.root.children if not s.dummyServer] start_slack = min(servers, key=lambda s: s.next_deadline).next_deadline - self.sim.now() if start_slack > 2: self.slack = uni_algorithm_1(self, servers, self.sim.now()+start_slack) self.slack += start_slack #self.sim.logger.log("slack {}, sub {}, start {}".format(self.slack, self.identifier, start_slack)) if int(self.slack) > 0 and self.utilization < 0.985: self.add_timer(self.slack, self.processors[0]) self.keep = True else: self.is_idle = False self.keep = False """ wakeup_delay = min([s.budget for s in self.virtual if s.budget > 0]) """old = self.virtual while wakeup_delay == 0: old.remove(min_s) min_s = min(old, key=lambda s: s.budget) wakeup_delay = min_s.budget""" if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() cpus = [] #first, leave already executing tasks on their current processors; for cpu in self.processors: if cpu.running in jobs: #cpus.append(cpu) jobs.remove(cpu.running) # remove job and cpu else: cpus.append(cpu) # second, assign previously idle tasks to their last-used processor, when its available aux_jobs = list(jobs) for job in aux_jobs: if job.task.last_cpu in cpus: decision.append((job, job.task.last_cpu)) jobs.remove(job) cpus.remove(job.task.last_cpu) # third, assign remaining tasks to free processors arbitrarily for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: period = 0 """if self.keep and self.slack > 0: period = self.slack #self.sim.logger.log("slack {}".format(self.slack)) self.slack = 0 cpu.set_idle(period) elif not self.keep and idle: period = next_activation(idle.pop()) - self.sim.now() #self.sim.logger.log("next_activation {}".format(period)) cpu.set_idle(period) """ decision.append((None, cpu)) return decision
def schedule_1(self): """ Schedule this proper sub-system. """ self.to_reschedule = False self.virtual = [] decision = [] processors = [] processors = self.processors active_servers = [s for s in self.root.children if not s.dummyServer and s.budget > 0] if self.is_idle is True and self.keep is False and active_servers: self.sim.logger.log("was idle in t {}".format(self.processors[0].name)) servers = [s for s in self.root.children if not s.dummyServer] self.slack = algorithm_1(self, servers, self.sim.now()) self.sim.logger.log("slack {}, sub {}".format(self.slack, self.identifier)) if self.slack > 0: self.add_timer(self.slack, self.processors[0]) self.keep = True # calcular o mínimo ocioso apartir do slack d = self.sim.now() + (float(self.slack)/(1-self.dummyTask[0].utilization)) self.lower_bound = d - self.slack - self.sim.now() self.sim.logger.log("lower_bound {}, d {}, u={}".format(self.lower_bound/self.sim.cycles_per_ms, d, self.dummyTask[len(self.dummyTask)-1].utilization)) self.slack += self.sim.now() else: self.is_idle = False self.keep = False elif active_servers and self.sim.now() >= self.slack: self.is_idle = False self.keep = False if self.lower_bound <= 0: self.lower_bound = sum(s.budget for s in active_servers) self.processors[0].set_idle_extend(self.lower_bound) # Processor level control if not self.busy: self.busy = True processors = self.processors[1:] # Refresh avaliable processors list decision.append((None, self.processors[0])) # Set dummy to first processor self.sim.logger.log("Servidores ativos, BUSY {}".format(self.processors[0].name)) else: self.sim.logger.log("Sem servidores ativos, IDLE {}".format(self.processors[0].name)) self.is_idle = True # Processor level control if self.busy: self.processors[0].stop_idle_extend() self.busy = False self.lower_bound = 0 selected = select_jobs(self, self.root, self.virtual) idle = [s for s in selected if s.task.name == 'IdleTask'] jobs = [s.job for s in selected if s.task.name != 'IdleTask' and s.task.name != "wcet"] wakeup_delay = min([s.budget for s in self.virtual if s.budget > 0]) """old = self.virtual while wakeup_delay == 0: old.remove(min_s) min_s = min(old, key=lambda s: s.budget) wakeup_delay = min_s.budget""" if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() cpus = [] #first, leave already executing tasks on their current processors; for cpu in processors: if cpu.running in jobs: #cpus.append(cpu) jobs.remove(cpu.running) # remove job and cpu else: cpus.append(cpu) # second, assign previously idle tasks to their last-used processor, when its available aux_jobs = list(jobs) for job in aux_jobs: if job.task.last_cpu in cpus: #if job.task.last_cpu.is_running(): decision.append((job, job.task.last_cpu)) jobs.remove(job) cpus.remove(job.task.last_cpu) # third, assign remaining tasks to free processors arbitrarily for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: decision.append((None, cpu)) return decision
def schedule(self, cpu): self.toresched = False if self.newly_activated: self.compute_al() self.newly_activated = False else: self.update_al() self.last_event = self.sim.now() next_event = None decisions = [] selected_jobs = {} # Select the jobs: for j, proc in enumerate(self.processors): eligible = [task.job for task in self.task_list if task.job.is_active() and task.job not in selected_jobs and task.job in self.al and self.al[task.job][j] > 0] if not eligible: continue job = min(eligible, key=lambda x: (x.absolute_deadline, x.task.identifier)) if next_event is None or next_event > self.al[job][j]: next_event = self.al[job][j] selected_jobs[job] = j # Set the timer for the next event: if self.timer: self.timer.stop() self.timer = None if next_event is not None: self.timer = Timer(self.sim, U_EDF.reschedule, (self,), next_event, self.processors[0], in_ms=False) self.timer.start() # Bind jobs to processors: jobs = list(selected_jobs.keys()) available_procs = list(self.processors) was_not_running = [] for job in jobs: if job in self.running_jobs: available_procs.remove(job.cpu) else: was_not_running.append(job) remaining_jobs = [] for job in was_not_running: if job.cpu in available_procs: decisions.append((job, job.cpu)) available_procs.remove(job.cpu) else: remaining_jobs.append(job) for p, job in enumerate(remaining_jobs): decisions.append((job, available_procs[p])) self.running_jobs = selected_jobs return decisions
def schedule(self): """ Schedule this proper sub-system. """ self.to_reschedule = False decision = [] self.virtual = [] active_servers = [ s for s in self.root.children if s.budget > 0 and not s.dummyServer ] selected = select_jobs(self, self.root, self.virtual) idle = [s for s in selected if s.task.name == 'IdleTask'] jobs = [ s.job for s in selected if s.task.name != 'IdleTask' and s.task.name != "wcet" ] wcet = [s for s in selected if s.task.name == "wcet"] min_s = min(self.virtual, key=lambda s: s.budget) wakeup_delay = min_s.budget old = self.virtual while wakeup_delay == 0: old.remove(min_s) min_s = min(old, key=lambda s: s.budget) wakeup_delay = min_s.budget if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() processors = [] if idle: processors = self.processors[1:] decision.append((None, self.processors[0])) soma = sum([s.budget for s in active_servers]) self.sim.logger.log("DUMMY TASK Executing on {}".format( self.processors[0].name)) self.processors[0].set_idle_extend(soma) #self.processors[0].set_dummy() else: processors = self.processors #self.sim.logger.log("stop".format()) self.processors[0].stop_idle_extend() #self.processors[0].set_busy() cpus = [] #first, leave already executing tasks on their current processors; for cpu in processors: if cpu.running in jobs: #cpus.append(cpu) jobs.remove(cpu.running) # remove job and cpu else: cpus.append(cpu) # second, assign previously idle tasks to their last-used processor, when its available aux_jobs = list(jobs) for job in aux_jobs: if job.task.last_cpu in cpus: #if job.task.last_cpu.is_running(): decision.append((job, job.task.last_cpu)) jobs.remove(job) cpus.remove(job.task.last_cpu) # third, assign remaining tasks to free processors arbitrarily for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: decision.append((None, cpu)) return decision
def schedule(self): """ Schedule this proper sub-system. """ self.to_reschedule = False decision = [] self.virtual = [] selected = select_jobs(self, self.root, self.virtual) idle = [s for s in selected if s.task.name == 'IdleTask'] jobs = [ s.job for s in selected if s.task.name != 'IdleTask' and s.task.name != "wcet" ] wcet = [s for s in selected if s.task.name == "wcet"] min_s = min(self.virtual, key=lambda s: s.budget) wakeup_delay = min_s.budget old = self.virtual while wakeup_delay == 0: old.remove(min_s) min_s = min(old, key=lambda s: s.budget) wakeup_delay = min_s.budget if wakeup_delay > 0: self.timer = Timer(self.sim, ProperSubsystem.virtual_event, (self, self.processors[0]), wakeup_delay, cpu=self.processors[0], in_ms=False) self.timer.start() cpus = [] #first, leave already executing tasks on their current processors; for cpu in self.processors: if cpu.running in jobs: #cpus.append(cpu) jobs.remove(cpu.running) # remove job and cpu else: cpus.append(cpu) # second, assign previously idle tasks to their last-used processor, when its available aux_jobs = list(jobs) for job in aux_jobs: if job.task.last_cpu in cpus: decision.append((job, job.task.last_cpu)) jobs.remove(job) cpus.remove(job.task.last_cpu) # third, assign remaining tasks to free processors arbitrarily for cpu in cpus: if jobs: decision.append((jobs.pop(), cpu)) else: period = 0 if self.keep and self.slack > 0: period = self.slack #self.sim.logger.log("slack {}".format(self.slack)) self.slack = 0 cpu.set_idle(period) elif not self.keep and idle: period = next_activation(idle.pop()) - self.sim.now() #self.sim.logger.log("next_activation {}".format(period)) cpu.set_idle(period) elif wcet: t = wcet.pop() period = t.task.deadline cpu.set_idle(period) #self.sim.logger.log("WCET NEXT {}".format(period)) decision.append((None, cpu)) return decision