def run(self):
''' move task from HD to User memory '''
# get task loaded
if self.used_resources.get_by_class(TaskAtHD) is None:
kernel.ask_for_resource(
kernel_data.RESOURCES.get_by_class(TaskAtHD), self, TaskAtHD)
return
# TODO - interaction with TaskAtHD for asking space
# Enough-space is single resource that when asked checks if there is enough space on user memory
# and reserves it
# get enough space
#if self.used_resources.get_by_class(EnoughSpace) is None:
# kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(EnoughSpace), self, EnoughSpace)
# return
# get channel3
if self.used_resources.get_by_class(Channel3) is None:
kernel.ask_for_resource(
kernel_data.RESOURCES.get_by_class(Channel3), self, Channel3)
return
addresses = channel_device.hd_to_um(
self.used_resources.get_by_class(TaskAtHD).write_info)
if addresses is not None:
kernel.create_resource(TaskLoaded, self, {'addresses': addresses})
kernel.delete_resource(self.used_resources.get_by_class(TaskAtHD))
#kernel.free_resource(self.used_resources.get_by_class(EnoughSpace), self)
#return
kernel.free_resource(self.used_resources.get_by_class(Channel3), self,
True)
return
def run(self):
''' move task from HD to User memory '''
# get task loaded
if self.used_resources.get_by_class(TaskAtHD) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(TaskAtHD), self, TaskAtHD)
return
# TODO - interaction with TaskAtHD for asking space
# Enough-space is single resource that when asked checks if there is enough space on user memory
# and reserves it
# get enough space
#if self.used_resources.get_by_class(EnoughSpace) is None:
# kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(EnoughSpace), self, EnoughSpace)
# return
# get channel3
if self.used_resources.get_by_class(Channel3) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(Channel3), self, Channel3)
return
addresses = channel_device.hd_to_um(self.used_resources.get_by_class(TaskAtHD).write_info)
if addresses is not None:
kernel.create_resource(TaskLoaded, self, {'addresses' : addresses })
kernel.delete_resource(self.used_resources.get_by_class(TaskAtHD))
#kernel.free_resource(self.used_resources.get_by_class(EnoughSpace), self)
#return
kernel.free_resource(self.used_resources.get_by_class(Channel3), self, True)
return
def run(self):
''' move data from kernel memory to HD '''
# get task data
if self.used_resources.get_by_class(TaskDataAtSM) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(TaskDataAtSM), self, TaskDataAtSM)
return
# get external memory
if self.used_resources.get_by_class(ExternalMemory) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(ExternalMemory), self, ExternalMemory)
return
# get channel3
if self.used_resources.get_by_class(Channel3) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(Channel3), self, Channel3)
return
# move data
write_data = real.channel_device.sm_hd(True)
kernel.create_resource(TaskAtHD, self, {'write_info' : write_data})
kernel.delete_resource(self.used_resources.get_by_class(TaskDataAtSM))
kernel.free_resource(self.used_resources.get_by_class(Channel3), self, True)
return
def run(self):
''' move data from kernel memory to HD '''
# get task data
if self.used_resources.get_by_class(TaskDataAtSM) is None:
kernel.ask_for_resource(
kernel_data.RESOURCES.get_by_class(TaskDataAtSM), self,
TaskDataAtSM)
return
# get external memory
if self.used_resources.get_by_class(ExternalMemory) is None:
kernel.ask_for_resource(
kernel_data.RESOURCES.get_by_class(ExternalMemory), self,
ExternalMemory)
return
# get channel3
if self.used_resources.get_by_class(Channel3) is None:
kernel.ask_for_resource(
kernel_data.RESOURCES.get_by_class(Channel3), self, Channel3)
return
# move data
write_data = real.channel_device.sm_hd(True)
kernel.create_resource(TaskAtHD, self, {'write_info': write_data})
kernel.delete_resource(self.used_resources.get_by_class(TaskDataAtSM))
kernel.free_resource(self.used_resources.get_by_class(Channel3), self,
True)
return
def END(self):
''' End task '''
processor.si = 3
kernel.create_resource(InterruptEvent, self, {
'process': self,
'message': 'END event'
})
self.state = configs.BLOCKED_STATE
kernel.schedule()
def get_real_address_from_cs(self, XY):
''' return real address of offset from code segment'''
XY = to_int(XY)
if XY > self.cs_length:
processor.pi = 1
kernel.create_resource(InterruptEvent, self, {'process' : self, 'message' : 'jumping out of program' })
self.state = configs.BLOCKED_STATE
kernel.schedule()
else:
return self.addresses[self.ds_length + 1 + XY]
def get_real_address_of_ds(self, XY):
''' return real address of offset from data segment '''
XY = to_int(XY)
if XY > self.ds_length:
processor.pi = 1
kernel.create_resource(InterruptEvent, self, {'process' : self, 'message' : 'invalid data pointer' })
self.state = configs.BLOCKED_STATE
kernel.schedule()
else:
return self.addresses[XY + 1]
def run(self):
''' execute user task until interrupt is encountered '''
self.update()
command = user_memory.fetch(self.ic)
if command[0:2] == 'LA':
self.LA(command[2:4])
elif command[0:2] == 'LB':
self.LB(command[2:4])
elif command[0:2] == 'MA':
self.MA(command[2:4])
elif command[0:2] == 'MB':
self.MB(command[2:4])
elif command[0:2] == 'WS':
self.WS(command[2:4])
elif command[0:2] == 'LS':
self.LS(command[2:4])
elif command[0:2] == 'JM':
self.JM(command[2:4])
elif command[0:2] == 'JL':
self.JL(command[2:4])
elif command[0:2] == 'JE':
self.JE(command[2:4])
elif command[0:2] == 'PD':
pass
elif command[0:3] == 'ADD':
self.ADD()
elif command[0:3] == 'SUB':
self.SUB()
elif command[0:3] == 'CMP':
self.CMP()
elif command[0:3] == 'END':
self.END()
return
elif command == 'SWAP':
self.SWAP()
elif command == 'AXOR':
self.AXOR()
elif command == 'BXOR':
self.BXOR()
else:
processor.pi = 2
kernel.create_resource(InterruptEvent, self, {'process' : self, 'message' : str(command) })
self.state = configs.BLOCKED_STATE
kernel.schedule()
return
logger.log("COMMAND EVALUATED: " + command)
logger.log("TIME IS : " + str(processor.time))
self.update_time(2)
if self.time_is_over():
processor.ti = 1
kernel.create_resource(InterruptEvent, self, {'process' : self, 'message' : None })
self.state = configs.BLOCKED_STATE
kernel.schedule()
def JM(self, XY):
''' jump to XY '''
#processor.ic = to_hex(to_int(processor.get_real_address(XY)) + BLOCK_SIZE * DS_LENGTH - 1)
#processor.ic = get_real_address_from_cs(XY)
if to_int(XY) > self.cs_length:
processor.pi = 3
kernel.create_resource(InterruptEvent, self, {'process' : self, 'message' : None })
self.state = configs.BLOCKED_STATE
kernel.schedule()
else:
self.num = to_int(XY) + self.ds_length + 1
def get_real_address_from_cs(self, XY):
''' return real address of offset from code segment'''
XY = to_int(XY)
if XY > self.cs_length:
processor.pi = 1
kernel.create_resource(InterruptEvent, self, {
'process': self,
'message': 'jumping out of program'
})
self.state = configs.BLOCKED_STATE
kernel.schedule()
else:
return self.addresses[self.ds_length + 1 + XY]
def get_real_address_of_ds(self, XY):
''' return real address of offset from data segment '''
XY = to_int(XY)
if XY > self.ds_length:
processor.pi = 1
kernel.create_resource(InterruptEvent, self, {
'process': self,
'message': 'invalid data pointer'
})
self.state = configs.BLOCKED_STATE
kernel.schedule()
else:
return self.addresses[XY + 1]
def JM(self, XY):
''' jump to XY '''
#processor.ic = to_hex(to_int(processor.get_real_address(XY)) + BLOCK_SIZE * DS_LENGTH - 1)
#processor.ic = get_real_address_from_cs(XY)
if to_int(XY) > self.cs_length:
processor.pi = 3
kernel.create_resource(InterruptEvent, self, {
'process': self,
'message': None
})
self.state = configs.BLOCKED_STATE
kernel.schedule()
else:
self.num = to_int(XY) + self.ds_length + 1
def run(self):
''' interprets loaded task '''
# get task
if self.used_resources.get_by_class(TaskAtSM) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(TaskAtSM), self, TaskAtSM)
return
if data.SM[-1][:3] != "END" or data.SM[0][:4] != "DATA" or not data.SM.__contains__("CODE"):
kernel.create_resource(LineToPrint, self, {'data' : "PARSING TASK FAILED: task name: " + self.used_resources.get_by_class(TaskAtSM).name + 'at: ' + str(data.SM[0][:3]) + '\n' })
kernel.delete_resource(self.used_resources.get_by_class(TaskAtSM))
return
kernel.create_resource(TaskDataAtSM, self)
kernel.delete_resource(self.used_resources.get_by_class(TaskAtSM))
def run(self):
'''
Reads task from input device to kernel memory and creates
resource task_at_sm
'''
while True:
# get task
if self.used_resources.get_by_class(TaskAtInput) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(TaskAtInput), self, TaskAtInput)
return
# get input device
if self.used_resources.get_by_class(InputDevice) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(InputDevice), self, InputDevice)
return
# get kernel memory
if self.used_resources.get_by_class(KernelMemory) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(KernelMemory), self, KernelMemory)
return
# get channel device
if self.used_resources.get_by_class(Channel1) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(Channel1), self, Channel1)
return
# read data
data.input_file = self.used_resources.get_by_class(TaskAtInput).file_path
channel_device.read_from_in(True)
# create resource at_sm
kernel.create_resource(TaskAtSM, self)
# reverse order because after freeing resource it would be caught again
# delete resource
kernel.delete_resource(self.used_resources.get_by_class(TaskAtInput))
#free resource
kernel.free_resource(self.used_resources.get_by_class(KernelMemory), self, True)
return
kernel.free_resource(self.used_resources.get_by_class(Channel1), self, True)
return
def __init__(self, opts={}):
opts['name'] = 'vm_' + str(kernel_data.PID)
opts['priority'] = configs.LOADER_PRIORITY
Process.__init__(self, opts)
self.cs_length = opts['cs_length']
self.ds_length = opts['ds_length']
self.addresses = opts['addresses']
# state
self.ic = None
self.num = self.ds_length + 1 # skip DATA SEGMENT
# prepare DS
for i in range(1, self.ds_length):
data = user_memory.fetch(self.addresses[i])
if data[0:2] != "DW":
processor.pi = 2
kernel.create_resource(InterruptEvent, self, {'process': self})
else:
user_memory.write(to_hex(to_int(data[2:4])), self.addresses[i])
def __init__(self, opts = {}):
opts['name'] = 'vm_' + str(kernel_data.PID)
opts['priority'] = configs.LOADER_PRIORITY
Process.__init__(self, opts)
self.cs_length = opts['cs_length']
self.ds_length = opts['ds_length']
self.addresses = opts['addresses']
# state
self.ic = None
self.num = self.ds_length + 1 # skip DATA SEGMENT
# prepare DS
for i in range(1, self.ds_length):
data = user_memory.fetch(self.addresses[i])
if data[0:2] != "DW":
processor.pi = 2
kernel.create_resource(InterruptEvent, self, {'process' : self })
else:
user_memory.write(to_hex(to_int(data[2:4])), self.addresses[i])
def __init__(self):
Process.__init__(self, {'parent' : None, 'name' : 'root', 'priority' : configs.ROOT_PRIORITY })
# init kernel
kernel_data.BLOCKED_PROCESSES = ProcessQueue()
kernel_data.READY_PROCESSES = ProcessQueue()
kernel_data.RESOURCES = ResourceList()
kernel_data.ACTIVE_PROCESS = self
# create static resources
for resource in [InputDevice, OutputDevice, UserMemory, ExternalMemory,
Terminate, EnoughSpace, Channel3, Channel1, Channel2, KernelMemory]:
kernel.create_resource(resource, self)
# create dynamic resources
# for that many files in tasks folder create task_at_input resource
counter = 0
for file in os.listdir('tasks'):
kernel.create_resource(TaskAtInput, self, {'file_path' : 'tasks/' + str(file) })
counter += 1
# create child processes
for process in [Interrupt, Print]:
kernel.create_process(process, self)
#create resources if there are tasks to execute
if kernel_data.RESOURCES.is_instance_created(TaskAtInput):
for process in [Read, ParseTask, JobToDisk, JobToMem, Manager]:
kernel.create_process(process, self)
# create tasks_found resource
if counter != 0:
kernel.create_resource(TasksFound, self, {'count' : counter})
def run(self):
''' Waits for InterruptEvent resource, identifies it and deals with it '''
# get interrupt event
if self.used_resources.get_by_class(InterruptEvent) is None:
kernel.ask_for_resource(kernel_data.RESOURCES.get_by_class(InterruptEvent), self, InterruptEvent)
return
interrupt_event = self.used_resources.get_by_class(InterruptEvent)
if processor.pi != 0:
rOpts = {}
'''
Don't forget to change messages into less lame ones.
Also need to think of what to do with the offending processes.
'''
if processor.pi == 1: #Some bad memory thingie
rOpts['data'] = 'Bad memory thingie message: '
elif processor.pi == 2: #Illegal operation
rOpts['data'] = 'Illegal operation: '
elif processor.pi == 3: #Critical system error
rOpts['data'] = 'Critical system error: '
rOpts['data'] += interrupt_event.message
kernel.create_resource(LineToPrint, self, rOpts)
kernel.create_resource(TaskCompleted, self)
kernel.terminate_process(self.used_resources.get_by_class(InterruptEvent).process)
processor.pi = 0
elif processor.si != 0:
if processor.si == 1: #GD
#???
pass
elif processor.si == 2: #PD
#???
pass
elif processor. si == 3: #END statement found
kernel.terminate_process(self.used_resources.get_by_class(InterruptEvent).process)
kernel.create_resource(TaskCompleted, self)
processor.si = 0
# this actually wrong : ioi interrupts don't work this way. See docs
#elif processor.ioi != 0:
# print "IOI"
# rOpts = {}
# rOpts['data'] = '' #find out where to get data
# kernel.create_resource(LineToPrint, self, rOpts)
# processor.ioi = 0
elif processor.ti != 0: #blocks process when time runs out
processor.ti = 0
processor.time = 0
# this is not needed: process was already blocked at this time
#self.used_resources.get_by_class(InterruptEvent).process.make_blocked()
# if VM was terminated, the resource it created will no longer exist
if not self.used_resources.get_by_class(InterruptEvent) is None:
kernel.delete_resource(self.used_resources.get_by_class(InterruptEvent))
def END(self):
''' End task '''
processor.si = 3
kernel.create_resource(InterruptEvent, self, {'process' : self, 'message' : 'END event' })
self.state = configs.BLOCKED_STATE
kernel.schedule()
def run(self):
''' execute user task until interrupt is encountered '''
self.update()
command = user_memory.fetch(self.ic)
if command[0:2] == 'LA':
self.LA(command[2:4])
elif command[0:2] == 'LB':
self.LB(command[2:4])
elif command[0:2] == 'MA':
self.MA(command[2:4])
elif command[0:2] == 'MB':
self.MB(command[2:4])
elif command[0:2] == 'WS':
self.WS(command[2:4])
elif command[0:2] == 'LS':
self.LS(command[2:4])
elif command[0:2] == 'JM':
self.JM(command[2:4])
elif command[0:2] == 'JL':
self.JL(command[2:4])
elif command[0:2] == 'JE':
self.JE(command[2:4])
elif command[0:2] == 'PD':
pass
elif command[0:3] == 'ADD':
self.ADD()
elif command[0:3] == 'SUB':
self.SUB()
elif command[0:3] == 'CMP':
self.CMP()
elif command[0:3] == 'END':
self.END()
return
elif command == 'SWAP':
self.SWAP()
elif command == 'AXOR':
self.AXOR()
elif command == 'BXOR':
self.BXOR()
else:
processor.pi = 2
kernel.create_resource(InterruptEvent, self, {
'process': self,
'message': str(command)
})
self.state = configs.BLOCKED_STATE
kernel.schedule()
return
logger.log("COMMAND EVALUATED: " + command)
logger.log("TIME IS : " + str(processor.time))
self.update_time(2)
if self.time_is_over():
processor.ti = 1
kernel.create_resource(InterruptEvent, self, {
'process': self,
'message': None
})
self.state = configs.BLOCKED_STATE
kernel.schedule()
def run(self):
''' Waits for InterruptEvent resource, identifies it and deals with it '''
# get interrupt event
if self.used_resources.get_by_class(InterruptEvent) is None:
kernel.ask_for_resource(
kernel_data.RESOURCES.get_by_class(InterruptEvent), self,
InterruptEvent)
return
interrupt_event = self.used_resources.get_by_class(InterruptEvent)
if processor.pi != 0:
rOpts = {}
'''
Don't forget to change messages into less lame ones.
Also need to think of what to do with the offending processes.
'''
if processor.pi == 1: #Some bad memory thingie
rOpts['data'] = 'Bad memory thingie message: '
elif processor.pi == 2: #Illegal operation
rOpts['data'] = 'Illegal operation: '
elif processor.pi == 3: #Critical system error
rOpts['data'] = 'Critical system error: '
rOpts['data'] += interrupt_event.message
kernel.create_resource(LineToPrint, self, rOpts)
kernel.create_resource(TaskCompleted, self)
kernel.terminate_process(
self.used_resources.get_by_class(InterruptEvent).process)
processor.pi = 0
elif processor.si != 0:
if processor.si == 1: #GD
#???
pass
elif processor.si == 2: #PD
#???
pass
elif processor.si == 3: #END statement found
kernel.terminate_process(
self.used_resources.get_by_class(InterruptEvent).process)
kernel.create_resource(TaskCompleted, self)
processor.si = 0
# this actually wrong : ioi interrupts don't work this way. See docs
#elif processor.ioi != 0:
# print "IOI"
# rOpts = {}
# rOpts['data'] = '' #find out where to get data
# kernel.create_resource(LineToPrint, self, rOpts)
# processor.ioi = 0
elif processor.ti != 0: #blocks process when time runs out
processor.ti = 0
processor.time = 0
# this is not needed: process was already blocked at this time
#self.used_resources.get_by_class(InterruptEvent).process.make_blocked()
# if VM was terminated, the resource it created will no longer exist
if not self.used_resources.get_by_class(InterruptEvent) is None:
kernel.delete_resource(
self.used_resources.get_by_class(InterruptEvent))
