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._programTestOne = Program("so.exe", [CPU(2), CPU(1)], 1)
self._programTestTwo = Program(
"pc.exe",
[CPU(2), CPU(2), IO(1),
CPU(2), IO(3), CPU(1)], 2)
self._burstTestOne = Bursts(self._programTestOne)
self._burstTestTwo = Bursts(self._programTestTwo)
class MyTestCase(unittest.TestCase):
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 testSchedulerPriorityPreventive(self):
# Se comprueba que se desencola primero el pid del programa 2, porque es el de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram2.get_pid())
# Se comprueba que se desencola el pid del programa 1, porque es siguiente de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram1.get_pid())
# y la prioridad del programa 1 sigue siendo de 2
self.assertEqual(self._PCBProgram1.get_priority(), 2)
# Se comprueba que se desencola el pid del programa 4, porque es siguiente de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram4.get_pid())
# el aging llego a 3
# y la prioridad del programa 1 ahora es de 2 por el aging del scheduler
self.assertEqual(self._PCBProgram4.get_priority(), 1)
# Se comprueba que se desencola el pid del programa 3, porque es siguiente de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram3.get_pid())
# y la prioridad del programa 1 ahora es de 2 por el aging del scheduler
self.assertEqual(self._PCBProgram3.get_priority(), 2)
class MyTestCase(unittest.TestCase):
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 testSchedulerSJF(self):
# Obtiene el primer burst del programa 2
firstBurstProgram2 = self._PCBProgram2.get_firstBurst()
# Se comprueba que el burst del programa 2 es menor que el programa que esta en CPU
self.assertTrue(
self._shedulerSJF.isChange(self._PCBProgram3, self._PCBProgram2))
# El scheduler desencola un programa
pid = self._shedulerSJF.pop()
# Se comprueba que desencolo al pid del programa con menor burst
self.assertEqual(pid, self._PCBProgram2.get_pid())
# Setea el busrt del programa que ahora esta en CPU
self._shedulerSJF.set_burstPCBInCPU(firstBurstProgram2)
# Se comprueba que el burst del programa 3 es menor que el programa que esta en CPU
self.assertFalse(
self._shedulerSJF.isChange(self._PCBProgram2, self._PCBProgram3))
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):
#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)
from Prototipo.pcb import PCB
from Prototipo.swap import Swap
from Prototipo.disco import *
from Prototipo.instructions import *
from Prototipo.intManager import IntManager
from Prototipo.loader import *
from Prototipo.memory import *
########### Programas a cargar en disco ###############
from Prototipo.memoryManagerPaging import MemoryManagerPaging, FirstInFirstOutPageReplacementAlgorithm
from Prototipo.frame import Frame
from Prototipo.mmu import MmuPages
from Prototipo.pcbTable import PCBTable
from Prototipo.program import Program
p0 = Program("SO.exe", [CPU(2)], 2)
p1 = Program("Word.exe", [CPU(4)], 1)
p2 = Program("PC.exe", [CPU(3)], 3)
p3 = Program("Text.exe", [CPU(5)], 1)
p4 = Program("paint.exe", [CPU(1)], 2)
p5 = Program("vlc.exe", [CPU(10), IO_2(3), CPU(2)], 2)
p6 = Program("sdasd", [CPU(2), IO_1(1)], 1)
p7 = Program("sdasd", [CPU(1), IO_1(2)], 1)
######################################################
disco = Disco()
ls = [p0, p1, p2, "so.pdf", p3, p4, p5]
disco.add_files(ls)
#!/usr/bin/env python
# -*- coding: utf-8 -*-s
from Prototipo.disco import Disco
from Prototipo.instructions import *
from Prototipo.kernel import *
from Prototipo.program import Program
from Prototipo.print import Print
if __name__ == '__main__':
log = Print()
################# Programs ############################
p0 = Program("SO.exe", [CPU(3)], 5)
p1 = Program("Word.exe", [CPU(2)], 2)
p2 = Program("PC.exe", [CPU(2)], 3)
p3 = Program("Text.exe", [CPU(1)], 1)
p4 = Program("Paint.exe", [CPU(4)], 4)
#######################################################
disco = Disco()
ls = [p0, p1, p2, "historiaSO.pdf", p3, p4]
disco.add_files(ls)
programs = [(0, "SO.exe"), (1, "Word.exe"), (3, "PC.exe"), (4, "Text.exe"),
(7, "Paint.exe")]
kernelFactory = KernelFactoty(disco)
kernel = kernelFactory.initialize()
class MyTestCase(unittest.TestCase):
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 testMemory(self):
# Se cargan cuatro programas a memoria
self._memoryManager.addProgram(self._PCBProgram1.get_pid(),
self._program1.longitud())
self._memoryManager.addProgram(self._PCBProgram2.get_pid(),
self._program2.longitud())
self._memoryManager.addProgram(self._PCBProgram3.get_pid(),
self._program3.longitud())
self._memoryManager.addProgram(self._PCBProgram4.get_pid(),
self._program4.longitud())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(4, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(1, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram1.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(3, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram3.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(2, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(3, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram2.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(1, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se carga un quinto programa a memoria
self._memoryManager.addProgram(self._PCBProgram5.get_pid(),
self._program5.longitud())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(2, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram4.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(1, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram5.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(0, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(1, len(self._memoryManager.getFreeBlocks()))
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())
class MyTestCase(unittest.TestCase):
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 testCompactacion(self):
self.assertEqual(1, len(self._memoryManager.getFreeBlocks()))
self.assertEqual(5, len(self._memoryManager.getUsedBlocks()))
self._loader.freeMemory(self._PCBProgram1)
self._loader.freeMemory(self._PCBProgram4)
self.assertEqual(3, len(self._memoryManager.getFreeBlocks()))
self.assertEqual(3, len(self._memoryManager.getUsedBlocks()))
self.assertFalse(self._memoryManager.thereIsBlockForProgram(60))
self.assertFalse(self._memory.get(0).isIO())
self.assertEqual(67, self._memoryManager.getFree())
# compacta
self._loader.load(self._PCBProgram6, self._program6.name())
self.assertTrue(self._memory.get(0).isIO())
self.assertEqual(1, len(self._memoryManager.getFreeBlocks()))
self.assertEqual(4, len(self._memoryManager.getUsedBlocks()))
self.assertEqual(6, self._memoryManager.getFree())
def testCompactacion2(self):
self.assertEqual(5,
len(self._loader.getMemoryManager().getUsedBlocks()))
self.assertEquals(1,
len(self._loader.getMemoryManager().getFreeBlocks()))
self._loader.freeMemory(self._PCBProgram1)
self._loader.freeMemory(self._PCBProgram4)
sizeAntesCompac = self._memoryManager.getFree()
self.assertEqual(3, len(self._memoryManager.getFreeBlocks()))
self.assertEqual(3, len(self._memoryManager.getUsedBlocks()))
self._memoryManager.toCompact()
self.assertEqual(1, len(self._memoryManager.getFreeBlocks()))
self.assertEqual(3, len(self._memoryManager.getUsedBlocks()))
sizeDepuesCompac = self._memoryManager.getFree()
self.assertTrue(self._memory.get(0).isIO())
self.assertEqual(sizeAntesCompac, sizeDepuesCompac)