def __init__(self, strategy):
assert isinstance(strategy, Strategy)
self.howToSchedule = strategy
# timer listeners
self.cpu = CPU() # that's what we want to manage
self.processManager = ProcessManager() # is responsible for managing processes
self.ea_queues = [EAQueue()] * 1
self.ready_queue = list() # hold only processes waiting for the cpu
self.init_process = None # you have to initialize the scheduler first
self._loop_counter = 0 # count how many time the run-method was called
# every process needs the same quantum at beginning of the run
try:
self.quantum = strategy.__getattribute__("quantum")
except AttributeError:
self.quantum = 4
self.processManager.setQuantumForEveryProcess(
self.quantum) # TODO:move to run-method / assuming here: processes are created before scheduler instantiates
try:
self.timeslice = strategy.__getattribute__("timeslice") # make timeslice public
except AttributeError:
self.timeslice = 10
SystemTimer().timeunit = self.timeslice
SystemTimer().register(self) # register at system clock
class Scheduler(TimerListener):
def __init__(self, strategy):
assert isinstance(strategy, Strategy)
self.howToSchedule = strategy
# timer listeners
self.cpu = CPU() # that's what we want to manage
self.processManager = ProcessManager() # is responsible for managing processes
self.ea_queues = [EAQueue()] * 1
self.ready_queue = list() # hold only processes waiting for the cpu
self.init_process = None # you have to initialize the scheduler first
self._loop_counter = 0 # count how many time the run-method was called
# every process needs the same quantum at beginning of the run
try:
self.quantum = strategy.__getattribute__("quantum")
except AttributeError:
self.quantum = 4
self.processManager.setQuantumForEveryProcess(
self.quantum) # TODO:move to run-method / assuming here: processes are created before scheduler instantiates
try:
self.timeslice = strategy.__getattribute__("timeslice") # make timeslice public
except AttributeError:
self.timeslice = 10
SystemTimer().timeunit = self.timeslice
SystemTimer().register(self) # register at system clock
def popFromReadyQueue(self):
"""
get the next process from the ready queue. The state belongs in state ready. I
:return: PCB
"""
try:
return self.ready_queue.pop(0)
except IndexError:
raise IndexError("the schedulers ready queue is empty")
def addToEAQueue(self, pcb, i=0):
print "add process to EAQueue%i %s" % (i, pcb)
self.ea_queues[i].append(pcb)
def notify(self, timestamp):
"""an event occurred. On every event, we have to decide if we dispatch the running process or not"""
print "Scheduler notified after a step of", timestamp
if self.schedule():
# there is still something to do
SystemTimer().tick()
else:
print "FINISHED"
def initialize(self, start_pcb_str):
"""
initialize the scheduler by defining the first process to run.
:param start_pcb_str: name of the initial process
"""
self.init_process = self.processManager.getProcessByName(start_pcb_str)
def run(self):
"""
start the scheduler
begin with initialisation of the ready queue
:return:
"""
if self.init_process is None:
raise RuntimeError("No init process found! please initialise first")
else:
# on the first run, the initial process is pushed to the ready queue
self.addToMatchingQueue(self.init_process) # init fill the ready queue
self.schedule()
# init process is now in CPU, time is 0
SystemTimer().tick() # do the first tick
def addToMatchingQueue(self, pcb):
"""
append pcb to right queue
there are two types of queue: ready queues and waiting queues (aka. EAQueues)
:param pcb: pcb to push to queue
:return:
:raise IndexError: if pcb's Workplan is empty
"""
if isinstance(pcb.process.workplan.head(), Wait):
# waiting section means ea queue:
self.addToEAQueue(pcb)
elif isinstance(pcb.process.workplan.head(), Work):
self.addToReadyQueue(pcb)
elif isinstance(pcb.process.workplan.head(), Launch):
# interesting! now we have a launch. We push the Included process to the queue!
print "trying to launch", pcb.process.workplan.head().action
self.addToMatchingQueue(pcb.process.workplan.head().action) # the process to launch is stored in the action
else:
# these sections are not made for queues
pass
def schedule(self):
# check the ea queues if there are finished processes. if so, append them to the queues
finished_waiting_processes = self.__check_ea_queues()
for p in finished_waiting_processes:
self.addToMatchingQueue(p)
# active = self.processManager.getActiveProcess()
active = self.cpu.running_process
try:
next_section = active.process.workplan.head()
except:
pass
else:
if isinstance(next_section, Wait):
# process will enter wait section: dispatch
try:
next_from_ready_queue = self.ready_queue.pop()
except IndexError:
# ready queue empyt
next_from_ready_queue = None
waiting_pcb = self.cpu.dispatch(next_from_ready_queue)
self.addToMatchingQueue(waiting_pcb)
active = self.cpu.running_process # notwendig, da dispatch ausgefuehrt wurde
if isinstance(next_section, Launch):
# process will launch another process
self.addToMatchingQueue(active)
# collect information about resources
sum_waiting_pcbs = sum(map(lambda x: len(x), self.ea_queues)) # Sum of all PCBs in EAQueues
readyq_empty = True if len(self.ready_queue) == 0 else False # ready queue empty?
if not active and readyq_empty:
# cpu leer, runq leer
if sum_waiting_pcbs > 0:
# but there are still waiting processes
next_run = True
else:
next_run = False # and no more processes in ea_queue
elif not active and not readyq_empty:
# cpu leer, runq voll: dispatchen und nochmal laufen
ready = self.ready_queue.pop()
ready.refill_quantum() # refill quantum for next process in cpu
self.cpu.dispatch(ready)
# update system timer
work_duration = ready.process.workplan.head().duration
SystemTimer().next_tick_in(work_duration)
next_run = True
elif active and readyq_empty:
# cpu voll, runq leer
# there is no readyq_empty process...
# reschedule: process in cpu belongs in cpu
print 'reschedule process'
if self.cpu.running_process.quantum == 0:
# quantum gets refilled, if process is allowed to run again and the quantum was already consumed
self.cpu.running_process.refill_quantum()
next_run = True
elif active and not readyq_empty:
# cpu voll, runq voll
next_run = True
if SystemTimer().next_temp_timeunit != 0:
# we need this distinction because this happens in 2 steps...
strategy_result = self.howToSchedule.schedule(self)
if strategy_result is not active:
# neuer process
old = self.cpu.dispatch(strategy_result)
active = strategy_result # the new active process is the strategy result
self.addToMatchingQueue(old)
else:
# unefined state
raise RuntimeError("undefined scheduling state")
self._loop_counter += 1 # count the scheduling-steps
return next_run
def __check_ea_queues(self):
"""
check if there are finished processes in the queue
:return list: list of all ready pcbs
"""
finished_waiting_processes = []
for ea_q in self.ea_queues:
p = ea_q.pickup_ready_processes()
finished_waiting_processes.extend(p)
return finished_waiting_processes
def addToReadyQueue(self, pcb):
"""
add process to ready queue
:param pcb: pcb to be added
"""
pcb.setReady()
self.__maintain_process_history(pcb)
print "add process to ready queue:", pcb
# if rescheduled because of time quantum, add at the end, if it's because of preemption, add to the beginning
self.howToSchedule.addToReadyQueue(scheduler=self, pcb=pcb)
return True
def __maintain_process_history(self, pcb):
"""
usually, the history is maintained in the doWork()-Method in the Process-Class.
However the Ready-Section must be maintained here.
The Ready-Section is not part of the regular workplan.
"""
# if len(pcb.process.history.plan) == 0:
# ready_time = 0
# else:
# ready_time = SystemTimer().next_temp_timeunit
# @TODO: fix this ugly method...
ready_time = 0
new_history_section = Ready(ready_time)
new_history_section.starting_at = SystemTimer().timecounter
new_history_section.ending_at = SystemTimer().timecounter + ready_time
pcb.process.history.insert(new_history_section, i=len(pcb.process.history.plan))