Пример #1
0
class TestCPU(unittest.TestCase):

    def setUp(self):
        self.kernel = Mock()
        self.cpu = Cpu(self.kernel)
        self.kernel.return_value = Kernel()
        self.kernel.return_value.cpu = self.cpu
        self.memory_manager = Mock()
        self.kernel.return_value.memory_manager = self.memory_manager
        self.program = Mock()
        self.hdd = Mock()
        self.scheduler = Mock()
        self.fifo = Mock()
        self.pcb_table = Mock()

    def test_a_cpu_fetch_a_instruction_allocated_in_memory(self):
        self.helper.load_a_instruction_in_a_program()
        instruction = self.cpu.fetch_single_instruction()
        self.assertEquals(self.helper.instruction, instruction)

    def test_given_pcb_when_cpu_complete_instruction_cycle_then_the_Manager_captures_interruption(self):
        '''
        Compare the initial state of PCB's PC with final state
        '''
        self.helper.load_a_instruction_in_a_program()
        self.cpu.complete_instruction_cycle()
        self.assertEqual(1, self.cpu.actual_pcb.get_pc())

    def test_given_pcb_when_cpu_complete_instruction_cycle_then_has_IO_Interruption(self):
        self.helper.load_a_io_instruction_in_a_program()
        self.cpu.complete_instruction_cycle()
        self.assertEqual(1, self.cpu.actual_pcb.get_pc())
Пример #2
0
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()
Пример #3
0
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)
Пример #4
0
 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()
Пример #5
0
 def setUp(self):
     self.kernel = Mock()
     self.cpu = Cpu(self.kernel)
     self.kernel.return_value = Kernel()
     self.kernel.return_value.cpu = self.cpu
     self.memory_manager = Mock()
     self.kernel.return_value.memory_manager = self.memory_manager
     self.program = Mock()
     self.hdd = Mock()
     self.scheduler = Mock()
     self.fifo = Mock()
     self.pcb_table = Mock()
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)
Пример #7
0
 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 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)