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
