class Main(Thread):
def __init__(self):
Thread.__init__(self)
self.memory = Memory(50)
self.a_kernel = Kernel(None)
self.cpu = Cpu(self.a_kernel)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.clock = Clock(self.cpu)
self.a_kernel.clock = self.clock
self.pcb_table = PCBTable()
def load_a_instruction_in_a_program(self):
program = Program("SIN-IO")
self.a_kernel.set_scheduler(self.scheduler)
self.a_kernel.set_pcb_table(self.pcb_table)
interruption_manager = InterruptionHandler(self.cpu)
self.a_kernel.set_interruption_handler(interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(interruption_manager)
instruction = Instruction("Texto")
program.addInstruction(instruction)
program.addInstruction(instruction)
self.write_program(program,self.memory)
self.setup_load_of_a_program_in_memory(2, program, 1)
def write_program(self,program,memory):
pos = 0
for instruction in program.obtain_instructions():
memory.put(pos,instruction)
def load_a_io_instruction_in_a_program(self):
program = Program("IO")
self.a_kernel.set_scheduler(self.scheduler)
interruption_manager = InterruptionHandler(self.cpu)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(interruption_manager)
self.a_kernel.set_interruption_handler(interruption_manager)
instruction = InstructionIO()
program.addInstruction(instruction)
program.addInstruction(instruction)
self.write_program(program,self.memory)
self.setup_load_of_a_program_in_memory(2, program, 2)
def setup_load_of_a_program_in_memory(self, amount_instructions, program, pcb_id):
block_holder = BlockHolder(program)
block_holder.set_representation([0,1])
pcb = PCB(amount_instructions, pcb_id, block_holder)
self.scheduler.policy.add_pcb(pcb)
memory_admin = ToyMemoryAdmin(self.memory)
self.cpu.set_actual_pcb(pcb)
self.pcb_table.add(self.cpu.get_actual_pcb())
self.cpu.set_memory_manager(memory_admin)
def run(self):
self.load_a_instruction_in_a_program()
self.clock.start()
class Helper:
def __init__(self):
self.memory = Memory(50)
self.hdd = HDD(5)
self.cpu = Cpu(None)
self.scheduler = Scheduler()
self.fifo = FifoPolicy(self.scheduler)
self.pcb_table = PCBTable()
self.memory_manager = MemoryManager()
self.a_kernel = Kernel(self.cpu, self.memory_manager)
self.a_kernel.set_scheduler(self.scheduler)
self.a_kernel.set_pcb_table(self.pcb_table)
self.a_kernel.set_hdd(self.hdd)
self.a_kernel.hdd.generate_file_system()
self.instruction = Instruction("Texto")
self.instruction_io = InstructionIO("IO")
def load_a_instruction_in_a_program(self):
program = Program("SIN-IO")
manager = Manager(self.scheduler, self.pcb_table, self.memory_manager)
interruption_handler = InterruptionHandler(manager)
self.a_kernel.set_interruption_handler(interruption_handler)
self.cpu.kernel = self.a_kernel
program.addInstruction(self.instruction)
program.addInstruction(self.instruction)
self.write_program(program,self.memory)
self.setup_load_of_a_program_in_memory(2, program, 1)
def load_a_io_instruction_in_a_program(self):
program = Program("IO")
manager = Manager(self.scheduler, self.pcb_table, self.memory_manager)
interruption_handler = InterruptionHandler(manager)
self.a_kernel.set_interruption_handler(interruption_handler)
self.cpu.kernel = self.a_kernel
program.addInstruction(self.instruction_io)
program.addInstruction(self.instruction_io)
self.write_program(program,self.memory)
self.setup_load_of_a_program_in_memory(2, program, 2)
def write_program(self,program,memory):
pos = 0
for instruction in program.get_instructions():
memory.put(pos,instruction)
def setup_load_of_a_program_in_memory(self, amount_instructions, program, pcb_id):
page_holder = PageHolder(program)
pcb = PCB(amount_instructions, pcb_id, page_holder)
self.pcb_table.add(pcb)
self.fifo.add_pcb(pcb)
self.cpu.set_actual_pcb(pcb)
class TestInterruption(unittest.TestCase):
def setUp(self):
self.cpu = Cpu(None)
self.kernel = Kernel(None, self.cpu)
self.cpu.kernel = self.kernel
self.pcb_table = self.kernel.pcb_table
self.memory_manager = self.kernel.memory_manager
self.fifo = FifoPolicy(self.kernel.scheduler)
self.program = Program("Pepe")
self.instruction = Instruction("first instruction")
self.program.addInstruction(self.instruction)
self.info_unit = [1, 2, 3, 4]
self.block_holder = BlockHolder(self.program)
self.block_holder.set_representation(self.info_unit)
self.pcb = PCB(1, 4, self.block_holder)
self.pcb_table.add(self.pcb)
self.cpu.set_actual_pcb(self.pcb)
self.manager = Manager(self.kernel.scheduler, self.pcb_table, self.memory_manager)
self.interruption_handler = InterruptionHandler(self.manager)
self.kernel.set_interruption_handler(self.interruption_handler)
def test_when_a_process_is_killed_then_it_is_removed_from_the_pcb_table(self):
self.cpu.execute_single_instruction(self.program.get_instructions().pop())
self.assertEquals(self.pcb_table.size(), 0)