def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(10)])
self.program1 = Program("p.exe", [CPUInstruction(5)])
self.program2 = Program("x.exe", [
IOInstruction(1),
CPUInstruction(2),
])
self.hardware = Hardware(memorySize=64)
self.kernel = Kernel(
self.hardware, FCFS(),
Pagination(self.hardware.memory(),
self.hardware.mmu(),
frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.scheduler = self.kernel.scheduler()
self.pcbTable = self.kernel.pcbTable()
self.cpu = self.kernel.hardware().cpu()
self.waitingQueue = self.kernel.hardware().IOdevice().getWaitingQueue()
class Priority_Test(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(9)])
self.program1 = Program("p.exe", [CPUInstruction(2)])
self.program2 = Program("x.exe", [CPUInstruction(5)])
self.program3 = Program("e.exe", [CPUInstruction(10)])
self.hardware = Hardware(memorySize=64)
self.kernel = Kernel(
self.hardware, Priority(5),
Pagination(self.hardware.memory(),
self.hardware.mmu(),
frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.fileSystem.save("home/nicolas/program3", self.program3)
def prioridad_Test(self):
self.kernel.execute("home/nicolas/program2",
3) # 1 porque cpu esta ociosa
self.kernel.execute("home/nicolas/program1", 2) # 4
self.kernel.execute("home/nicolas/program0", 1) # 3
self.kernel.execute("home/nicolas/program3", 0) # 2
self.kernel.start_running()
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(9)])
self.program2 = Program("s.exe", [CPUInstruction(5), IOInstruction(1)])
self.hardware = Hardware(memorySize = 32)
self.kernel = Kernel(self.hardware, FCFS(), Pagination(self.hardware.memory(), self.hardware.mmu(), frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program2", self.program2)
def setUp(self):
self.pcb1 = PCB(5, 20, 4)
self.pcb2 = PCB(4, 21, 3)
self.a_kernel = Kernel(None)
self.scheduler = Scheduler(None)
self.a_kernel.set_scheduler(self.scheduler)
self.cpu = Cpu(self.a_kernel)
def setUp(self):
self.memory = Memory(50)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.a_kernel = Kernel(None)
self.pcb_table = PCBTable()
self.a_kernel.set_pcb_table(self.pcb_table)
interruption_manager = InterruptionHandler(self.a_kernel.cpu)
self.a_kernel.set_interruption_handler(interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(self, interruption_manager)
class TestSchedulerInteractions(unittest.TestCase):
'''
Testing Scheduler and CPU interactions...
'''
def setUp(self):
self.pcb1 = PCB(5, 20, 4)
self.pcb2 = PCB(4, 21, 3)
self.a_kernel = Kernel(None)
self.scheduler = Scheduler(None)
self.a_kernel.set_scheduler(self.scheduler)
self.cpu = Cpu(self.a_kernel)
def test_when_given_scheduler_with_priority_and_cpu_then_scheduler_sends_next_process_to_cpu(self):
queue = PriorityQueue()
scheduler_priority = Scheduler(None, ready_queue=queue)
self.a_kernel.set_scheduler(scheduler_priority)
scheduler_priority.set_cpu(self.cpu)
scheduler_priority.set_as_priority()
self.pcb1.set_priority(1)
scheduler_priority.push_to_queue(self.pcb1)
self.pcb2.set_priority(2)
scheduler_priority.push_to_queue(self.pcb2)
expected_pcb = scheduler_priority.next_process()
scheduler_priority.send_next_to_cpu()
self.assertEqual(self.pcb2, self.cpu.get_actual_pcb())
def test_when_given_scheduler_with_round_robin_and_a_cpu_then_scheduler_sends_next_process_to_cpu(self):
self.scheduler.set_cpu(self.cpu)
quantum = 1
self.scheduler.set_as_round_robin(quantum)
self.scheduler.push_to_queue(self.pcb1)
self.scheduler.send_next_to_cpu()
self.assertEqual(self.pcb1, self.cpu.get_actual_pcb())
def test_when_given_scheduler_with_fifo_and_a_cpu_then_scheduler_sends_next_process_to_cpu(self):
self.scheduler.set_cpu(self.cpu)
self.scheduler.set_as_fifo()
self.scheduler.push_to_queue(self.pcb1)
self.scheduler.send_next_to_cpu()
self.assertEqual(self.pcb1, self.cpu.get_actual_pcb())
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(3)])
self.program1 = Program("p.exe", [CPUInstruction(5)])
self.program2 = Program("e.exe", [CPUInstruction(10)])
self.hardware = Hardware(memorySize=32)
self.kernel = Kernel(
self.hardware, Priority(5),
Pagination(self.hardware.memory(),
self.hardware.mmu(),
frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.scheduler = self.kernel.scheduler()
self.pcbTable = self.kernel.pcbTable()
self.cpu = self.kernel.hardware().cpu()
def setUp(self):
self.kernel = Kernel(None)
self.kernel.to_user_mode()
self.kernel.scheduler = Scheduler(None)
self.kernel.scheduler.set_as_fifo()
self.interruption_manager = InterruptionHandler(self.kernel.cpu)
self.kernel.set_interruption_handler(self.interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(self, self.interruption_manager)
self.memory = ToyMemory()
self.memory_manager = ToyMemoryAdmin(self.memory)
self.kernel.set_memory_manager(self.memory_manager)
class TestKernel(unittest.TestCase):
def setUp(self):
self.memory = Memory(50)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.a_kernel = Kernel(None)
self.pcb_table = PCBTable()
self.a_kernel.set_pcb_table(self.pcb_table)
interruption_manager = InterruptionHandler(self.a_kernel.cpu)
self.a_kernel.set_interruption_handler(interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(self, interruption_manager)
def write_program(self,program,memory):
pos = 0
for instruction in program.obtain_instructions():
memory.put(pos,instruction)
def load_a_instruction_in_a_program(self):
program = Program("SIN-IO")
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,2)
def load_a_io_instruction_in_a_program(self):
program = Program("IO")
self.a_kernel.set_scheduler(self.scheduler)
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.pcb_table.add(pcb)
self.scheduler.policy.add_pcb(pcb)
memory_admin = ToyMemoryAdmin(self.memory)
self.a_kernel.cpu.set_actual_pcb(pcb)
self.a_kernel.cpu.set_memory_manager(memory_admin)
def test_given_pcb_when_cpu_complete_instruction_cycle_then_increments_pc(self):
'''
Compare the initial state of PCB's PC with final state
'''
self.load_a_instruction_in_a_program()
self.assertEqual(0, self.a_kernel.cpu.actual_pcb.get_pc())
self.a_kernel.cpu.complete_instruction_cycle()
self.assertEqual(1, self.a_kernel.cpu.actual_pcb.get_pc())
def test_given_pcb_when_cpu_complete_instruction_cycle_then_IO_Manager_captures_interruption_and_increments_pc(self):
self.load_a_io_instruction_in_a_program()
self.assertEqual(0, self.a_kernel.cpu.actual_pcb.get_pc())
self.a_kernel.cpu.complete_instruction_cycle()
self.assertEqual(1, self.a_kernel.cpu.actual_pcb.get_pc())
class TestIOInterruption(unittest.TestCase):
def setUp(self):
self.kernel = Kernel(None)
self.kernel.to_user_mode()
self.kernel.scheduler = Scheduler(None)
self.kernel.scheduler.set_as_fifo()
self.interruption_manager = InterruptionHandler(self.kernel.cpu)
self.kernel.set_interruption_handler(self.interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(self, self.interruption_manager)
self.memory = ToyMemory()
self.memory_manager = ToyMemoryAdmin(self.memory)
self.kernel.set_memory_manager(self.memory_manager)
def two_programs_in_ready_queue(self):
instruction_io = InstructionIO()
instruction = Instruction("text")
hold1 = [1,2,3,4]
hold2 = [5,6,7,8]
self.block_holder1 = BlockHolder(self.a_program_with_instruction(instruction_io))
self.block_holder1.set_representation(hold1)
self.pcb1 = PCB(1, 1, self.block_holder1)
self.block_holder2 = BlockHolder(self.a_program_with_instruction(instruction))
self.block_holder2.set_representation(hold2)
self.pcb2 = PCB(1, 2, self.block_holder2)
self.kernel.scheduler.push_to_queue(self.pcb1)
self.kernel.scheduler.push_to_queue(self.pcb2)
def a_program_with_instruction(self,instruction_io):
a_program = Program("P")
for i in range(0,5):
a_program.addInstruction(instruction_io)
self.memory.write_program(a_program)
return a_program
def test_when_a_process_is_io_then_goes_to_the_waiting_queue(self):
self.two_programs_in_ready_queue()
io_pcb = self.kernel.get_ready_queue._get()
self.kernel.cpu.set_actual_pcb(io_pcb)
without_io_pcb = self.kernel.get_ready_queue._get()
self.assertEqual(io_pcb.get_pid,self.kernel.cpu.actual_pcb.get_pid)
self.kernel.cpu.complete_instruction_cycle()
self.assertEqual(ProcessState.ProcessState.waiting, io_pcb.get_state)
self.kernel.cpu.set_actual_pcb(without_io_pcb)
self.assertEqual(without_io_pcb.get_pid,self.kernel.cpu.actual_pcb.get_pid)
without_io_pcb.set_state(ProcessState.ProcessState.running)
self.assertEqual(ProcessState.ProcessState.running, without_io_pcb.get_state)
class FCFS_Test(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(9)])
self.program1 = Program("p.exe", [CPUInstruction(5)])
self.program2 = Program("f.exe", [CPUInstruction(5), IOInstruction(1)])
self.hardware = Hardware(memorySize = 32)
self.kernel = Kernel(self.hardware, FCFS(), Pagination(self.hardware.memory(), self.hardware.mmu(), frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
def FCFS_Test(self):
self.kernel.execute("home/nicolas/program0")
self.kernel.execute("home/nicolas/program1")
self.kernel.start_running()
def FCFS_IO_Test(self):
self.kernel.execute("home/nicolas/program0")
self.kernel.execute("home/nicolas/program2")
self.kernel.execute("home/nicolas/program1")
self.kernel.start_running()
class FCFS_Test(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(10)])
self.program1 = Program("p.exe", [CPUInstruction(5)])
self.program2 = Program("x.exe", [
IOInstruction(1),
CPUInstruction(2),
])
self.hardware = Hardware(memorySize=64)
self.kernel = Kernel(
self.hardware, FCFS(),
Pagination(self.hardware.memory(),
self.hardware.mmu(),
frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.scheduler = self.kernel.scheduler()
self.pcbTable = self.kernel.pcbTable()
self.cpu = self.kernel.hardware().cpu()
self.waitingQueue = self.kernel.hardware().IOdevice().getWaitingQueue()
def FCFS_Test(self):
self.kernel.execute("home/nicolas/program0")
self.kernel.execute("home/nicolas/program1")
self.kernel.start_running(2) # Ejecuto 2 ticks
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
1) # La cola de listos tiene el pcb de program1
self.assertEqual(self.pcbTable.runningPcb().getPid(),
0) # el pid de program0
self.assertEqual(self.cpu.getPCB().getPid(), 0)
self.kernel.start_running(
9) # debe cambiar de contexto a program1, program0 termino
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
0) # Program1 termino, program0 esta en Cpu
self.assertEqual(self.pcbTable.runningPcb().getPid(),
1) # el pid de program1
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.kernel.start_running(3) # ejecuto tres instrucciones de program1
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 0)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.kernel.start_running(
3) # ejecuto las instrucciones que quedan de program1
self.assertEqual(
self.cpu.getPC(),
-1) # Cpu esta ociosa [en realidad deberia ser pc = -1]
print(self.kernel.hardware().memory())
def FCFS_IO_Test(self):
self.kernel.execute("home/nicolas/program2")
self.kernel.execute("home/nicolas/program0")
self.kernel.start_running(
1) # ejecuto un tick, program 2 tira una interrupcion de IO
self.assertEqual(
self.scheduler.getReadyQueue().qsize(),
0) # vacia, program2 esta haciendo IO, program0 en Cpu
self.assertEqual(self.pcbTable.runningPcb().getPid(),
1) # el pid de program0
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.assertEqual(self.waitingQueue.qsize(), 1) # el pcb de program2
self.kernel.start_running(6) # program2 termina IO y pasa a readyQueue
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
1) # program0 sigue ejecutando
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.kernel.start_running(5) # program0 termina
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
0) # program2 esta en Cpu
self.assertEqual(self.pcbTable.runningPcb().getPid(),
0) # el pid de program2
self.assertEqual(self.cpu.getPCB().getPid(), 0)
self.kernel.start_running(3) # termina program2
print(self.kernel.hardware().memory())
class Priority_Test(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(3)])
self.program1 = Program("p.exe", [CPUInstruction(5)])
self.program2 = Program("e.exe", [CPUInstruction(10)])
self.hardware = Hardware(memorySize=32)
self.kernel = Kernel(
self.hardware, Priority(5),
Pagination(self.hardware.memory(),
self.hardware.mmu(),
frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.scheduler = self.kernel.scheduler()
self.pcbTable = self.kernel.pcbTable()
self.cpu = self.kernel.hardware().cpu()
def priority_Test(self):
self.kernel.execute(
"home/nicolas/program0",
3) # CPU esta ociosa y llega program0 primero, se ejecuta primero
self.kernel.execute("home/nicolas/program1",
2) # Llega program1 1 pero se ejecuta ultimo
self.kernel.execute("home/nicolas/program2",
1) # Llega program2 y se ejecuta segundo
self.kernel.start_running(2) # Ejecuto 2 ticks
self.assertTrue(len(self.scheduler.getReadyQueue()),
2) # La cola de listos tiene 2 pcbs, de program1 y 2
self.assertEqual(self.pcbTable.runningPcb().getPid(),
0) # verifico que tiene el pid para program0
self.assertEqual(self.cpu.getPCB().getPid(), 0)
self.kernel.start_running(
2) # Ejecuta los ticks necesarios para terminar program0
self.assertTrue(
len(self.scheduler.getReadyQueue()),
1) # La cola de listos tiene solo un pcb, el de program1
self.assertEqual(self.pcbTable.runningPcb().getPid(),
2) # el pid de program2, que tiene mayor prioridad
self.assertEqual(self.cpu.getPCB().getPid(), 2)
self.kernel.start_running(
11) # Ejecuta los ticks necesarios para terminar program2
self.assertTrue(len(self.scheduler.getReadyQueue()),
0) # La cola de listos ya no tiene pcbs
self.assertEqual(self.pcbTable.runningPcb().getPid(),
1) # el pid de program1
self.assertEqual(self.cpu.getPCB().getPid(), 1)
print(self.kernel.hardware().memory())
class Mem_Test(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(9)])
self.program2 = Program("s.exe", [CPUInstruction(5), IOInstruction(1)])
self.hardware = Hardware(memorySize = 32)
self.kernel = Kernel(self.hardware, FCFS(), Pagination(self.hardware.memory(), self.hardware.mmu(), frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program2", self.program2)
# frameSize = 2
# GetFramesForProgram0 --> frames[15,14,13,12,11]
# pag = pc = 0 / frameSize (2)
# offset = pc = 0 % frameSize
# DirFisic = frame * FrameSize (2) + offset
# Dirs Fisicas --> # PAg0 --> 30, 31 # PAg1 --> 28, 29 # PAg2 --> 26, 27 # etc
def load_a_Program_Test(self):
self.kernel.execute("home/nicolas/program0")
self.kernel.start_running(11)
print(self.kernel.hardware().memory())
def load_two_programs_Test(self):
self.kernel.execute("home/nicolas/program0")
self.kernel.execute("home/nicolas/program2")
self.kernel.start_running(25)
print(self.kernel.hardware().memory())
class PaginationTest(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(10)])
self.program2 = Program("x.exe", [IOInstruction(1),
CPUInstruction(60),
])
self.program3 = Program("f.exe", [CPUInstruction(65)]) # Programa demasiado grande para la memoria disponible
self.hardware = Hardware(memorySize=64)
self.kernel = Kernel(self.hardware, FCFS(), Pagination(self.hardware.memory(), self.hardware.mmu(), frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.fileSystem.save("home/nicolas/program3", self.program3)
self.scheduler = self.kernel.scheduler()
self.pcbTable = self.kernel.pcbTable()
self.cpu = self.kernel.hardware().cpu()
self.waitingQueue = self.kernel.hardware().IOdevice().getWaitingQueue()
def load_program_Test(self):
self.assertEqual(self.fileSystem.get("home/nicolas/program0"), self.program0)
program0 = self.fileSystem.get("home/nicolas/program0")
self.assertEqual(self.kernel.memoryManager().freeFramesLength(), 32)
self.assertEqual(self.kernel.memoryManager().cantPages(program0), 6)
self.assertEqual(self.kernel.memoryManager().freeFrames(), [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
21,22,23,24,25,26,27,28,29,30,31])
self.assertEqual(self.kernel.memoryManager().generatePageTable([26,27,28,29,30,31], program0).getFrames(), [26,27,28,
29,30,31])
self.kernel.execute("home/nicolas/program0")
self.kernel.start_running(1) # Ejecuto 1 tick
self.assertEqual(self.kernel.memoryManager().freeFramesLength(), 26)
self.assertEqual(self.kernel.memoryManager().freeFrames(),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
self.assertEqual(self.pcbTable.runningPcb().pageTable().getFrames(), [31,30,29,28,27,26])
def pagination_memory_Test(self):
self.kernel.execute("home/nicolas/program0") # El programa tiene 11 instrucciones, 10 de Cpu y una de Exit
self.assertEqual(type(self.kernel.hardware().memory().get(62)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(63)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(60)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(61)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(58)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(59)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(56)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(57)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(54)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(55)).__name__, type(CPUInstruction(0)).__name__)
self.assertEqual(type(self.kernel.hardware().memory().get(52)).__name__, type(EXITInstruction(0)).__name__)
for x in range(0, 52): # 52 no incluye
self.assertEqual(self.kernel.hardware().memory().get(x), 'trash')
self.assertEqual(self.kernel.hardware().memory().get(53), 'trash')
def no_enough_memory_Test(self):
with self.assertRaises(NotEnoughSpaceInMemoryException):
self.kernel.execute("home/nicolas/program3")
def no_program_available_Test(self):
with self.assertRaises(ProgramNotAvailableException):
self.kernel.execute("home/nicolas/programNoHay")
def put_one_program_try_put_another_but_there_is_no_memory_Test(self):
self.kernel.execute("home/nicolas/program0") # program0 tiene 11 instrucciones
self.kernel.start_running(3) # ejecuto 3 ticks, program0 no libero su memoria
with self.assertRaises(NotEnoughSpaceInMemoryException): # Llega un programa de 62 instrucciones
self.kernel.execute("home/nicolas/program2") # como la memoria disp es 64 pero ambos progs ocupan 62 + 11 inst, no hay mem suficiente
# Ahora pongo los mismos progs. que antes pero como program0 termina libera su memoria y program3 tiene suficiente para ejecutarse
def put_one_program_try_put_another_Test(self):
self.kernel.execute("home/nicolas/program0") # program0 tiene 11 instrucciones
self.kernel.start_running(11) # ejecuto 11 ticks, program0 termina, libera su mem y puede cargarse program3
self.kernel.execute("home/nicolas/program2") # Llega un programa de 62 instrucciones como program0 termino libero 11 lugares en mem
class RoundRobin_Test(unittest.TestCase):
def setUp(self):
self.program0 = Program("t.exe", [CPUInstruction(10)])
self.program1 = Program("p.exe", [CPUInstruction(5)])
self.program2 = Program("t.exe", [
IOInstruction(1),
CPUInstruction(2),
])
self.hardware = Hardware(memorySize=32)
self.kernel = Kernel(
self.hardware,
RoundRobin(3, self.hardware.clock(), self.hardware.irqVector()),
Pagination(self.hardware.memory(),
self.hardware.mmu(),
frameSize=2))
self.fileSystem = self.kernel.fileSystem()
# Load programs
self.fileSystem.save("home/nicolas/program0", self.program0)
self.fileSystem.save("home/nicolas/program1", self.program1)
self.fileSystem.save("home/nicolas/program2", self.program2)
self.scheduler = self.kernel.scheduler()
self.pcbTable = self.kernel.pcbTable()
self.cpu = self.kernel.hardware().cpu()
self.waitingQueue = self.kernel.hardware().IOdevice().getWaitingQueue()
def RR_Test(self):
self.kernel.execute("home/nicolas/program0")
self.kernel.execute("home/nicolas/program1")
self.kernel.start_running(3) # Ejecuto 3 ticks, el quantum
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
1) # La cola de listos tiene el pcb de program1
self.assertEqual(self.pcbTable.runningPcb().getPid(),
0) # el pid de program0
self.assertEqual(self.cpu.getPCB().getPid(), 0)
self.kernel.start_running(
3) # cambia de proceso, debe ejecutar program1
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
1) # La cola de listos tiene el pcb de program0
self.assertEqual(self.pcbTable.runningPcb().getPid(),
1) # el pid de program1
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.kernel.start_running(3)
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 1)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 0)
self.assertEqual(self.cpu.getPCB().getPid(), 0)
self.kernel.start_running(2) # los ticks que le quedan a program 1
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 1)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.kernel.start_running(1)
self.assertEqual(self.scheduler.getReadyQueue().qsize(),
0) # ya no esta program1
self.assertEqual(self.pcbTable.runningPcb().getPid(), 0)
self.assertEqual(self.cpu.getPCB().getPid(), 0)
print(self.kernel.hardware().memory())
def RR_IO_Test(self):
self.kernel.execute("home/nicolas/program2")
self.kernel.execute("home/nicolas/program0")
self.kernel.start_running(1)
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 0)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.assertEqual(self.waitingQueue.qsize(), 1)
self.kernel.start_running(2)
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 0)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.assertEqual(self.waitingQueue.qsize(), 0)
self.kernel.start_running(3)
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 0)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
self.kernel.start_running(3)
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 1)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 0)
self.assertEqual(self.cpu.getPCB().getPid(), 0)
self.kernel.start_running(3)
self.assertEqual(self.scheduler.getReadyQueue().qsize(), 0)
self.assertEqual(self.pcbTable.runningPcb().getPid(), 1)
self.assertEqual(self.cpu.getPCB().getPid(), 1)
print(self.kernel.hardware().memory())
