def setUp(self):
#Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(2), CPU(1)], 1)
self._PCBProgram1 = PCB(0)
self._PCBProgram1.initialize(self._program1,
self._program1.longitud() // 4)
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [CPU(1), IO(1)], 2)
self._PCBProgram2 = PCB(1)
self._PCBProgram2.initialize(self._program2,
self._program2.longitud() // 4)
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(4), IO(1)], 3)
self._PCBProgram3 = PCB(2)
self._PCBProgram3.initialize(self._program3,
self._program3.longitud() // 4)
# Se crea al schedulerSJF
self._shedulerSJF = SchedulerSJFPreemptive()
# Se agregan el pid, la prioridad(en este caso no se utiliza),
# y el primer burst de los programas 2 y 3
self._shedulerSJF.add(self._PCBProgram2)
self._shedulerSJF.add(self._PCBProgram3)
# Obtiene el primer burst del programa 1
firstBurstProgram1 = self._PCBProgram1.get_firstBurst()
# Setea el primer burst del programa que esta en la CPU
self._shedulerSJF.set_burstPCBInCPU(firstBurstProgram1)
def setUp(self):
self._frame0 = Frame(0)
self._frame1 = Frame(1)
self._frame2 = Frame(2)
self._frame3 = Frame(3)
self._frame4 = Frame(4)
self._frame5 = Frame(5)
self._frame0.setPid(0)
self._frame1.setPid(0)
self._frame2.setPid(1)
self._frame3.setPid(1)
self._frame4.setPid(2)
self._frame5.setPid(2)
self._pcb0 = PCB(0)
self._pcb1 = PCB(1)
self._pcb2 = PCB(2)
self._pageTable0 = PageTable(2)
self._pageTable1 = PageTable(2)
self._pageTable2 = PageTable(2)
self._pcb0.setPages(self._pageTable0)
self._pcb1.setPages(self._pageTable1)
self._pcb2.setPages(self._pageTable2)
self._pcbTable = PCBTable()
self._pcbTable.addPCB(self._pcb0)
self._pcbTable.addPCB(self._pcb1)
self._pcbTable.addPCB(self._pcb2)
self._pageTable0.getPage(0).setBDPhysicalMemory(self._frame0.getBD())
self._pageTable0.getPage(1).setBDPhysicalMemory(self._frame1.getBD())
self._pageTable1.getPage(0).setBDPhysicalMemory(self._frame2.getBD())
self._pageTable1.getPage(1).setBDPhysicalMemory(self._frame3.getBD())
self._pageTable2.getPage(0).setBDPhysicalMemory(self._frame4.getBD())
self._pageTable2.getPage(1).setBDPhysicalMemory(self._frame5.getBD())
self._algorithmClock = ClockPageReplacementAlgorithm()
def setUp(self):
#Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(9)], 2)
self._PCBProgram1 = PCB(0)
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [CPU(12)], 1)
self._PCBProgram2 = PCB(1)
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(8)], 3)
self._PCBProgram3 = PCB(2)
# Se crea el pcb del cuarto programa
self._program4 = Program("word.exe", [CPU(7)], 2)
self._PCBProgram4 = PCB(3)
# Se crea el pcb del cuarto programa
self._program5 = Program("pycharm.exe", [CPU(1)], 2)
self._PCBProgram5 = PCB(4)
# Se inicializa la memoria
self._memory = Memory(64)
# Se inicializa el disco y el Loader
self._memoryManager = MemoryManagerContinuousAssignmentFirstFit(
self._memory, mock.Mock(), mock.Mock(),
1) # El numero indica el moreSpace
def setUp(self):
self._memory = Memory(64)
self._swap = Swap(128)
self._memoryManager = MemoryManagerPaging(
self._memory, 4, mock.Mock(), self._swap,
FirstInFirstOutPageReplacementAlgorithm(
)) # El numero indica el tamanio de un frame
self._mmu = MmuPages(self._memory, self._memoryManager.sizeFrame(),
mock.Mock())
self._loader = LoaderPages(self._memory, self._mmu, disco,
self._memoryManager, self._swap)
self._page = Page()
self._pageTable = PageTable(2)
self._pageTable.getPages()[0].setBDPhysicalMemory(0)
self._pageTable.getPages()[0].setPhysicalMemory(True)
self._pageTable.getPages()[1].setBDPhysicalMemory(8)
self._pageTable.getPages()[1].setPhysicalMemory(True)
pcb = PCB(1)
pcb.setPages(self._pageTable)
self._mmu.setPosition(pcb)
self._loader.loadInPhysicalMemory(p6.instructions(),
self._pageTable.getPages()[0])
self._loader.loadInPhysicalMemory(p7.instructions(),
self._pageTable.getPages()[1])
def setUp(self):
#Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(2), CPU(1)], 2)
self._PCBProgram1 = PCB(0)
self._PCBProgram1.set_priority(self._program1.get_priority())
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [CPU(1), IO(1)], 1)
self._PCBProgram2 = PCB(1)
self._PCBProgram2.set_priority(self._program2.get_priority())
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(4), IO(1)], 3)
self._PCBProgram3 = PCB(2)
self._PCBProgram3.set_priority(self._program3.get_priority())
# Se crea el pcb del tercer programa
self._program4 = Program("word.exe", [CPU(4), IO(1)], 2)
self._PCBProgram4 = PCB(3)
self._PCBProgram4.set_priority(self._program4.get_priority())
# Se inicializa al SchedulerPriorityPreventive con un aging de 3
self._pcbTable = PCBTable()
self._pcbTable.addPCB(self._PCBProgram1)
self._pcbTable.addPCB(self._PCBProgram2)
self._pcbTable.addPCB(self._PCBProgram3)
self._pcbTable.addPCB(self._PCBProgram4)
self._aging = 3
self._shedulerTest = SchedulerPriorityPreemptive(
self._pcbTable, self._aging)
# Se agregan los pid, prioridad y los primeros burst de los tres programas
self._shedulerTest.add(self._PCBProgram1)
self._shedulerTest.add(self._PCBProgram2)
self._shedulerTest.add(self._PCBProgram3)
self._shedulerTest.add(self._PCBProgram4)
def setUp(self):
# Se crea al pcbTable
self._pcbTable = PCBTable()
# Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(10)], 2)
self._PCBProgram1 = PCB(0)
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [IO(1), CPU(9)], 1)
self._PCBProgram2 = PCB(1)
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(10)], 3)
self._PCBProgram3 = PCB(2)
# Se crea el pcb del cuarto programa
self._program4 = Program("word.exe", [CPU(10)], 2)
self._PCBProgram4 = PCB(3)
# Se crea el pcb del quint programa
self._program5 = Program("pycharm.exe", [CPU(10)], 2)
self._PCBProgram5 = PCB(4)
# Se crea el pcb del sexto programa
self._program6 = Program("pharo.exe", [CPU(60)], 2)
self._PCBProgram6 = PCB(5)
self._pcbTable.addPCB(self._PCBProgram1)
self._pcbTable.addPCB(self._PCBProgram2)
self._pcbTable.addPCB(self._PCBProgram3)
self._pcbTable.addPCB(self._PCBProgram4)
self._pcbTable.addPCB(self._PCBProgram5)
self._pcbTable.addPCB(self._PCBProgram6)
# Se inicializa la memoria
self._memory = Memory(100)
# Se cargan los gprogramas al disco
self._disk = Disco()
ls = [
self._program1, self._program2, "so.pdf", self._program3,
self._program4, self._program5, self._program6
]
self._disk.add_files(ls)
# Se inicializa el intManager, memoryManager, y el Loader
self._intmanager = IntManager()
self._memoryManager = MemoryManagerContinuousAssignmentFirstFit(
self._memory, self._pcbTable, self._intmanager, 2)
self._loader = LoaderBlocks(self._memory, Mmu(self._memory),
self._disk, self._memoryManager)
self._intmanager.setInterruptions(self._loader, mock.Mock(),
mock.Mock(), self._pcbTable,
mock.Mock(), self._memoryManager,
mock.Mock())
# Se cargan cinco programas a memoria
self._loader.load(self._PCBProgram1, self._program1.name())
self._loader.load(self._PCBProgram2, self._program2.name())
self._loader.load(self._PCBProgram3, self._program3.name())
self._loader.load(self._PCBProgram4, self._program4.name())
self._loader.load(self._PCBProgram5, self._program5.name())
def execute(self, nameProgram):
pcb = PCB(self._nexPid)
self._loader.load(pcb, nameProgram)
self._pcbTable.addPCB(pcb)
self._nexPid += 1
self.isLoadOrChangeOrToReady(pcb)
#!/usr/bin/env python
# -*- coding: utf-8 -*-s
import unittest
from Prototipo.pcb import PCB
from Prototipo.pcbTable import PCBTable
pcb1 = PCB(1)
pcb2 = PCB(2)
pcbt = PCBTable()
pcbt.addPCB(pcb1)
pcbt.addPCB(pcb2)
class tester(unittest.TestCase):
def test_1(self):
self.assertEqual(pcb1, pcbt.lookUpPCB(1))
self.assertEqual(pcb2, pcbt.lookUpPCB(2))
def test_2(self):
pcbt.removePCB(1)
pcbt.removePCB(2)
self.assertEqual(True, pcbt.pcbTabletIsEmpty())
if __name__ == "__main__":
unittest.main()