def setUp(self):
self.memory = RAM(65535)
self.mmu = MMU(1, self.memory)
self.scheduler = Mock()
self.hdd = Mock()
self.queue = Mock()
self.interruptor2 = Mock()
self.interruptor = Mock()
self.logger = Mock()
self.semaphore = RLock()
self.cpu = CPU(self.memory, self.interruptor, self.semaphore, self.mmu)
self.cpu.setLogger(self.logger)
self.clock = Clock(self.cpu)
self.mov = InstCPU("Matar a Flanders")
self.Instruction2 = InstCPU("Y Tambien A Selma")
self.instructionIO = InstIO("Soy de IO", 0)
self.memory.putDir(0, self.mov)
self.memory.putDir(1, self.Instruction2)
self.memory.putDir(2, self.instructionIO)
page0 = Page(0)
page1 = Page(1)
page2 = Page(2)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
page2.changeMemoryFlag()
self.aPcb = PCB(0, [page0, page1, page2], 3, 4, 1, [Page(123)])
def loadProcess(self, program, priority=0, args=[]):
"""
@note: this method load a program into the ram
@param program: the next program to load
priority: the priority of the program
args: the program will be loaded with this args
@return: the program id
"""
self.myProgram = self.hdd.getProgram(program)
self.myProgram.initializePreValues(args)
self.scope = self.mmu.getMemoryScope(self.myProgram)
self.pages = self.scope.getListInstructionPages()
self.dataScope = self.scope.getListDataPages()
self.miPCB = PCB(self.getNextId(), self.pages, self.myProgram.size(),
priority, self.mmu.getFrameSize(), self.dataScope)
self.instructions = self.myProgram.getInstructions()
current = 0
for slipping in xrange(self.mmu.getFrameSize()):
if current >= len(self.instructions): break
self.memory.putDir(
self.mmu.fromPageToAbsolutePosition(
self.pages[0].getPageNumber()) + slipping,
self.instructions[current])
current = current + 1
self.pages[0].changeMemoryFlag()
self.miPCB.toReady()
self.processQueue.put(self.miPCB)
self.pcbTable.addPCB(self.miPCB, self.myProgram.getName())
return self.pids
def test_when_fetching_last_instruction_then_pcbEnd_interruption(self):
page0 = Page(0)
page1 = Page(1)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
self.anotherPcb = PCB(
0, [page0, page1], 2, 4, 1,
[123]) #The difference with aPcb, are their sizes... Arrange
self.anotherPcb.runing()
self.cpu.setPCB(self.anotherPcb)
self.cpu.tick() # Act
self.cpu.tick()
self.cpu.tick()
verify(self.interruptor, 1).kill(self.anotherPcb.getPid()) # Assert
def setUp(self):
self.memory = RAM(65535)
self.mmu = MMU(1,self.memory)
self.scheduler = Mock()
self.hdd = Mock()
self.queue = Mock()
self.interruptor2 = Mock()
self.interruptor = Mock()
self.logger = Mock()
self.semaphore = RLock()
self.cpu = CPU(self.memory,self.interruptor, self.semaphore,self.mmu)
self.cpu.setLogger(self.logger)
self.clock = Clock(self.cpu)
self.mov = InstCPU("Matar a Flanders")
self.Instruction2 = InstCPU("Y Tambien A Selma")
self.instructionIO = InstIO("Soy de IO", 0)
self.memory.putDir(0, self.mov)
self.memory.putDir(1, self.Instruction2)
self.memory.putDir(2, self.instructionIO)
page0 = Page(0)
page1 = Page(1)
page2 = Page(2)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
page2.changeMemoryFlag()
self.aPcb = PCB(0,[page0,page1,page2],3,4,1,[Page(123)])
def loadProcess(self, program, priority=0,args=[]):
"""
@note: this method load a program into the ram
@param program: the next program to load
priority: the priority of the program
args: the program will be loaded with this args
@return: the program id
"""
self.myProgram = self.hdd.getProgram(program)
self.myProgram.initializePreValues(args)
self.scope = self.mmu.getMemoryScope(self.myProgram)
self.pages = self.scope.getListInstructionPages()
self.dataScope = self.scope.getListDataPages()
self.miPCB = PCB(self.getNextId(),self.pages,self.myProgram.size(), priority,self.mmu.getFrameSize(),self.dataScope)
self.instructions = self.myProgram.getInstructions()
current = 0
for slipping in xrange(self.mmu.getFrameSize()):
if current >= len(self.instructions): break
self.memory.putDir(self.mmu.fromPageToAbsolutePosition(self.pages[0].getPageNumber()) + slipping, self.instructions[current])
current = current+1
self.pages[0].changeMemoryFlag()
self.miPCB.toReady()
self.processQueue.put(self.miPCB)
self.pcbTable.addPCB(self.miPCB,self.myProgram.getName())
return self.pids
def test_when_fetching_last_instruction_then_pcbEnd_interruption(self):
page0 = Page(0)
page1 = Page(1)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
self.anotherPcb = PCB(0,[page0,page1],2,4,1,[123]) #The difference with aPcb, are their sizes... Arrange
self.anotherPcb.runing()
self.cpu.setPCB(self.anotherPcb)
self.cpu.tick() # Act
self.cpu.tick()
self.cpu.tick()
verify(self.interruptor, 1).kill(self.anotherPcb.getPid()) # Assert
class PCBTest(unittest.TestCase):
def repeat(self, f, N):
for _ in itertools.repeat(None, N):
f()
def test_when_baseDir_is_N_getBaseDir_returns_N(self):
self.sut = PCB(0, [0], 1, 0, 1, [1])
self.assertEqual(0, self.sut.getCurrentPage())
def test_when_baseDir_is_N_incrementPc_plus_getPC_returns_N_Because_PCBReady_shuldnt_increment_pc(
self):
self.sut = PCB(0, [0], 1)
self.sut.incrementPc()
self.assertEqual(0, self.sut.getPc())
def test_when_PCB_isRuning_incrementPC_sums_one_to_the_pc(self):
self.sut = PCB(0, [0], 1)
self.sut.runing()
self.sut.incrementPc()
self.assertEqual(1, self.sut.getPc())
def test_when_PCB_has_size_N_getSize_returns_N(self):
self.sut = PCB(0, [0], 5)
self.assertEqual(5, self.sut.getSize())
def test_when_size_isEquals_to_pc_then_it_is_Finished(self):
self.sut = PCB(0, [0], 5)
self.sut.runing()
self.repeat(self.sut.incrementPc, 6)
self.assertTrue(self.sut.finished())
class CPUTest(unittest.TestCase):
def setUp(self):
self.memory = RAM(65535)
self.mmu = MMU(1,self.memory)
self.scheduler = Mock()
self.hdd = Mock()
self.queue = Mock()
self.interruptor2 = Mock()
self.interruptor = Mock()
self.logger = Mock()
self.semaphore = RLock()
self.cpu = CPU(self.memory,self.interruptor, self.semaphore,self.mmu)
self.cpu.setLogger(self.logger)
self.clock = Clock(self.cpu)
self.mov = InstCPU("Matar a Flanders")
self.Instruction2 = InstCPU("Y Tambien A Selma")
self.instructionIO = InstIO("Soy de IO", 0)
self.memory.putDir(0, self.mov)
self.memory.putDir(1, self.Instruction2)
self.memory.putDir(2, self.instructionIO)
page0 = Page(0)
page1 = Page(1)
page2 = Page(2)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
page2.changeMemoryFlag()
self.aPcb = PCB(0,[page0,page1,page2],3,4,1,[Page(123)])
def test_when_fetch_then_instruction_valid(self):
self.expected = self.mov # Arrange
self.cpu.setPCB(self.aPcb)
self.value = self.cpu.fetch() # Act
self.assertEquals(self.value , self.expected) # Assert
def test_when_fetching_third_intruction_then_IO_interruption(self):
self.aPcb.runing()
self.cpu.setPCB(self.aPcb)
self.data = [self.aPcb , self.instructionIO]
self.cod = 0 # Arrange
self.cpu.tick()
self.cpu.tick() # Act
self.cpu.tick()
verify(self.interruptor).ioQueue(self.data, self.cod) # Assert
def test_when_fetching_last_instruction_then_pcbEnd_interruption(self):
page0 = Page(0)
page1 = Page(1)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
self.anotherPcb = PCB(0,[page0,page1],2,4,1,[123]) #The difference with aPcb, are their sizes... Arrange
self.anotherPcb.runing()
self.cpu.setPCB(self.anotherPcb)
self.cpu.tick() # Act
self.cpu.tick()
self.cpu.tick()
verify(self.interruptor, 1).kill(self.anotherPcb.getPid()) # Assert
def test_when_PCB_has_size_N_getSize_returns_N(self):
self.sut = PCB(0, [0], 5)
self.assertEqual(5, self.sut.getSize())
def test_when_size_isEquals_to_pc_then_it_is_Finished(self):
self.sut = PCB(0, [0], 5)
self.sut.runing()
self.repeat(self.sut.incrementPc, 6)
self.assertTrue(self.sut.finished())
def test_when_baseDir_is_N_incrementPc_plus_getPC_returns_N_Because_PCBReady_shuldnt_increment_pc(
self):
self.sut = PCB(0, [0], 1)
self.sut.incrementPc()
self.assertEqual(0, self.sut.getPc())
def test_when_PCB_isRuning_incrementPC_sums_one_to_the_pc(self):
self.sut = PCB(0, [0], 1)
self.sut.runing()
self.sut.incrementPc()
self.assertEqual(1, self.sut.getPc())
class PCBTest(unittest.TestCase):
def repeat(self, f, N):
for _ in itertools.repeat(None, N): f()
def test_when_baseDir_is_N_getBaseDir_returns_N(self):
self.sut = PCB(0,[0],1,0,1,[1])
self.assertEqual(0, self.sut.getCurrentPage())
def test_when_baseDir_is_N_incrementPc_plus_getPC_returns_N_Because_PCBReady_shuldnt_increment_pc(self):
self.sut = PCB(0,[0],1)
self.sut.incrementPc()
self.assertEqual(0, self.sut.getPc())
def test_when_PCB_isRuning_incrementPC_sums_one_to_the_pc(self):
self.sut = PCB(0,[0],1)
self.sut.runing()
self.sut.incrementPc()
self.assertEqual(1, self.sut.getPc())
def test_when_PCB_has_size_N_getSize_returns_N(self):
self.sut = PCB(0,[0],5)
self.assertEqual(5, self.sut.getSize())
def test_when_size_isEquals_to_pc_then_it_is_Finished(self):
self.sut = PCB(0,[0],5)
self.sut.runing()
self.repeat(self.sut.incrementPc, 6)
self.assertTrue(self.sut.finished())
def setUp(self):
self.pcb1 = PCB(1, 1, 1, 8)
self.pcb2 = PCB(2, 4, 3, 9)
self.pcb3 = PCB(3, 7, 6, 13)
self.pcb4 = PCB(4, 9, 8, 17)
class ProgramLoader:
def __init__(self, memory,hdd,processQueue,mmu):
"""
Constructor it requires a memory, a hard disk, a process queue and a memory management unity
"""
self.memory = memory
self.mmu = mmu
self.hdd = hdd
self.pids = 0
self.processQueue = processQueue
self.pcbTable = TableOfPCB()
def manual(self, programName):
"""
@param programName: the name of a program
@return the manual of a program called programName
"""
return self.hdd.getProgram(programName)
def in_disk(self, program_name):
"""
@param program_name: the program's name to looking for
@return it tells if a program_name is in disk
"""
return program_name in self.hdd.programs
def loadProcess(self, program, priority=0,args=[]):
"""
@note: this method load a program into the ram
@param program: the next program to load
priority: the priority of the program
args: the program will be loaded with this args
@return: the program id
"""
self.myProgram = self.hdd.getProgram(program)
self.myProgram.initializePreValues(args)
self.scope = self.mmu.getMemoryScope(self.myProgram)
self.pages = self.scope.getListInstructionPages()
self.dataScope = self.scope.getListDataPages()
self.miPCB = PCB(self.getNextId(),self.pages,self.myProgram.size(), priority,self.mmu.getFrameSize(),self.dataScope)
self.instructions = self.myProgram.getInstructions()
current = 0
for slipping in xrange(self.mmu.getFrameSize()):
if current >= len(self.instructions): break
self.memory.putDir(self.mmu.fromPageToAbsolutePosition(self.pages[0].getPageNumber()) + slipping, self.instructions[current])
current = current+1
self.pages[0].changeMemoryFlag()
self.miPCB.toReady()
self.processQueue.put(self.miPCB)
self.pcbTable.addPCB(self.miPCB,self.myProgram.getName())
return self.pids
def getPcbTable(self):
return self.pcbTable
def getNextId(self):
self.pids = self.pids + 1
return self.pids
def storeNeededPage(self,pcb):
'''
@invariant: the pcb's pc is in the beginning of a page not in memory RAM.
'''
currentValue = pcb.getCurrentLogicPage() * self.mmu.getFrameSize()
programName = self.pcbTable.getProgramName(pcb.getPid())
instructions = self.hdd.getProgram(programName).getInstructions()
for slipping in xrange(self.mmu.getFrameSize()):
if currentValue >= len(instructions): break
self.memory.putDir(self.mmu.fromPageToAbsolutePosition(pcb.getCurrentPage().getPageNumber()) + slipping, instructions[currentValue])
currentValue = currentValue + 1
pcb.getCurrentPage().changeMemoryFlag()
def test_when_size_isEquals_to_pc_then_it_is_Finished(self):
self.sut = PCB(0,[0],5)
self.sut.runing()
self.repeat(self.sut.incrementPc, 6)
self.assertTrue(self.sut.finished())
def test_when_PCB_isRuning_incrementPC_sums_one_to_the_pc(self):
self.sut = PCB(0,[0],1)
self.sut.runing()
self.sut.incrementPc()
self.assertEqual(1, self.sut.getPc())
def test_when_baseDir_is_N_incrementPc_plus_getPC_returns_N_Because_PCBReady_shuldnt_increment_pc(self):
self.sut = PCB(0,[0],1)
self.sut.incrementPc()
self.assertEqual(0, self.sut.getPc())
def test_when_baseDir_is_N_getBaseDir_returns_N(self):
self.sut = PCB(0,[0],1,0,1,[1])
self.assertEqual(0, self.sut.getCurrentPage())
class ProgramLoader:
def __init__(self, memory, hdd, processQueue, mmu):
"""
Constructor it requires a memory, a hard disk, a process queue and a memory management unity
"""
self.memory = memory
self.mmu = mmu
self.hdd = hdd
self.pids = 0
self.processQueue = processQueue
self.pcbTable = TableOfPCB()
def manual(self, programName):
"""
@param programName: the name of a program
@return the manual of a program called programName
"""
return self.hdd.getProgram(programName)
def in_disk(self, program_name):
"""
@param program_name: the program's name to looking for
@return it tells if a program_name is in disk
"""
return program_name in self.hdd.programs
def loadProcess(self, program, priority=0, args=[]):
"""
@note: this method load a program into the ram
@param program: the next program to load
priority: the priority of the program
args: the program will be loaded with this args
@return: the program id
"""
self.myProgram = self.hdd.getProgram(program)
self.myProgram.initializePreValues(args)
self.scope = self.mmu.getMemoryScope(self.myProgram)
self.pages = self.scope.getListInstructionPages()
self.dataScope = self.scope.getListDataPages()
self.miPCB = PCB(self.getNextId(), self.pages, self.myProgram.size(),
priority, self.mmu.getFrameSize(), self.dataScope)
self.instructions = self.myProgram.getInstructions()
current = 0
for slipping in xrange(self.mmu.getFrameSize()):
if current >= len(self.instructions): break
self.memory.putDir(
self.mmu.fromPageToAbsolutePosition(
self.pages[0].getPageNumber()) + slipping,
self.instructions[current])
current = current + 1
self.pages[0].changeMemoryFlag()
self.miPCB.toReady()
self.processQueue.put(self.miPCB)
self.pcbTable.addPCB(self.miPCB, self.myProgram.getName())
return self.pids
def getPcbTable(self):
return self.pcbTable
def getNextId(self):
self.pids = self.pids + 1
return self.pids
def storeNeededPage(self, pcb):
'''
@invariant: the pcb's pc is in the beginning of a page not in memory RAM.
'''
currentValue = pcb.getCurrentLogicPage() * self.mmu.getFrameSize()
programName = self.pcbTable.getProgramName(pcb.getPid())
instructions = self.hdd.getProgram(programName).getInstructions()
for slipping in xrange(self.mmu.getFrameSize()):
if currentValue >= len(instructions): break
self.memory.putDir(
self.mmu.fromPageToAbsolutePosition(
pcb.getCurrentPage().getPageNumber()) + slipping,
instructions[currentValue])
currentValue = currentValue + 1
pcb.getCurrentPage().changeMemoryFlag()
def test_when_baseDir_is_N_getBaseDir_returns_N(self):
self.sut = PCB(0, [0], 1, 0, 1, [1])
self.assertEqual(0, self.sut.getCurrentPage())
def test_when_PCB_has_size_N_getSize_returns_N(self):
self.sut = PCB(0,[0],5)
self.assertEqual(5, self.sut.getSize())
class CPUTest(unittest.TestCase):
def setUp(self):
self.memory = RAM(65535)
self.mmu = MMU(1, self.memory)
self.scheduler = Mock()
self.hdd = Mock()
self.queue = Mock()
self.interruptor2 = Mock()
self.interruptor = Mock()
self.logger = Mock()
self.semaphore = RLock()
self.cpu = CPU(self.memory, self.interruptor, self.semaphore, self.mmu)
self.cpu.setLogger(self.logger)
self.clock = Clock(self.cpu)
self.mov = InstCPU("Matar a Flanders")
self.Instruction2 = InstCPU("Y Tambien A Selma")
self.instructionIO = InstIO("Soy de IO", 0)
self.memory.putDir(0, self.mov)
self.memory.putDir(1, self.Instruction2)
self.memory.putDir(2, self.instructionIO)
page0 = Page(0)
page1 = Page(1)
page2 = Page(2)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
page2.changeMemoryFlag()
self.aPcb = PCB(0, [page0, page1, page2], 3, 4, 1, [Page(123)])
def test_when_fetch_then_instruction_valid(self):
self.expected = self.mov # Arrange
self.cpu.setPCB(self.aPcb)
self.value = self.cpu.fetch() # Act
self.assertEquals(self.value, self.expected) # Assert
def test_when_fetching_third_intruction_then_IO_interruption(self):
self.aPcb.runing()
self.cpu.setPCB(self.aPcb)
self.data = [self.aPcb, self.instructionIO]
self.cod = 0 # Arrange
self.cpu.tick()
self.cpu.tick() # Act
self.cpu.tick()
verify(self.interruptor).ioQueue(self.data, self.cod) # Assert
def test_when_fetching_last_instruction_then_pcbEnd_interruption(self):
page0 = Page(0)
page1 = Page(1)
page0.changeMemoryFlag()
page1.changeMemoryFlag()
self.anotherPcb = PCB(
0, [page0, page1], 2, 4, 1,
[123]) #The difference with aPcb, are their sizes... Arrange
self.anotherPcb.runing()
self.cpu.setPCB(self.anotherPcb)
self.cpu.tick() # Act
self.cpu.tick()
self.cpu.tick()
verify(self.interruptor, 1).kill(self.anotherPcb.getPid()) # Assert
