Example #1
0
def main2():

        instruction1 = BasicInstruction()
        instruction2 = BasicInstruction()      
        memory = Memory()
        memory.buildMemory(5)
        frame1 = Frame(memory,0,1)
        frame2 = Frame(memory,1,2)
        frame3 = Frame(memory,3,1)
        frame4 = Frame(memory,4,1)
        mmu = MMU()
        mmu.fullFrames.append(frame1)
        mmu.fullFrames.append(frame3)
        mmu.emptyFrames.append(frame2)
        mmu.emptyFrames.append(frame4)
        program = Program('a')
        program.addInstruction(instruction1)
        pcbA = PCB('a',0,0,1)
        programb = Program('b')
        pcbB = PCB('b',0,3,1)
        programb.addInstruction(instruction1)
        frame1.load(pcbA,program)
        frame3.load(pcbB,programb)
        memory.printMemory()
        print(memory.getEmptyCells())
        mmu.compact()
        memory.printMemory()
 def setUp(self):
     self.program = Program("AProgram")
     self.program.addInstruction(Instruction("Hola"))
     self.program.addInstruction(Instruction("Chau"))
     self.page_holder = PageHolder(self.program)
     self.pcb = PCB(0, 2, self.page_holder)
     self.page_creator = PageCreator(1)
     self.page_creator.create(self.pcb,1)
Example #3
0
 def saveProgram(self,program):
     try:
         pid = program.getName()
         priority = self.addPriority(program)
         size = program.size()
         base = self.mmu.getBase(size)
         pcb = PCB(pid,priority,base,size)
         self.mmu.load(pcb,program,base)
         self.scheduler.add(pcb)
     except (Exception):
         try:
             self.mmu.compact()
             base = self.mmu.getBase(size)
             pcb = PCB(pid,priority,base,size)
             self.mmu.load(pcb,program,base)
             self.scheduler.add(pcb)
         except (Exception):
             self.getDisk().save(program)
    def setUp(self):
        program1 = Program('D')
        program2 = Program('E')
        program3 = Program('H')
        program4 = Program('S')

        self.pcb1 = PCB(1, 20, PageHolder(program1))
        self.pcb1.set_priority(PCBPriorities.HIGH)

        self.pcb2 = PCB(2, 25, PageHolder(program2))
        self.pcb2.set_priority(PCBPriorities.MEDIUM)

        self.pcb3 = PCB(3, 15, PageHolder(program3))
        self.pcb3.set_priority(PCBPriorities.LOW)

        self.pcb4 = PCB(4, 6, PageHolder(program4))
        self.pcb4.set_priority(PCBPriorities.LOW)

        self.scheduler = Scheduler()
Example #5
0
def main3():
    if(1==1):
        instruction1 = BasicInstruction()
        instruction2 = BasicInstruction()      
        memory = Memory()
        memory.buildMemory(5)
        frame1 = Frame(memory,0,1)
        frame2 = Frame(memory,1,2)
        frame3 = Frame(memory,3,1)
        frame4 = Frame(memory,4,1)
        mmu = MMU()
        mmu.fullFrames.append(frame1)
        mmu.fullFrames.append(frame3)
        mmu.emptyFrames.append(frame2)
        mmu.emptyFrames.append(frame4)
        program = Program('a')
        program.addInstruction(instruction1)
        pcbA = PCB('a',0,0,1)
        programb = Program('b')
        pcbB = PCB('b',0,3,1)
        programb.addInstruction(instruction1)
        frame1.load(pcbA,program)
        frame3.load(pcbB,programb)
        programc = Program('c')
        programc.addInstruction(instruction1)
        programc.addInstruction(instruction1)
        programc.addInstruction(instruction1)
        programd = Program('d')
        programd.addInstruction(instruction2)
        programd.addInstruction(instruction2)
        programd.addInstruction(instruction2)
        scheduler = Scheduler(PFIFO())
        disk = Disk(None)
        kernel = Kernel (None,None,scheduler,mmu,disk)
        disk.setKernel(kernel)
        memory.printMemory()
        kernel.saveProgram(programc)
        print( "     ")
        memory.printMemory()
        kernel.saveProgram(programd)
        print( "     ")
        memory.printMemory()
        print(len(disk.programList))
class TestScheduler(unittest.TestCase):

    def setUp(self):
        program1 = Program('D')
        program2 = Program('E')
        program3 = Program('H')
        program4 = Program('S')

        self.pcb1 = PCB(1, 20, PageHolder(program1))
        self.pcb1.set_priority(PCBPriorities.HIGH)

        self.pcb2 = PCB(2, 25, PageHolder(program2))
        self.pcb2.set_priority(PCBPriorities.MEDIUM)

        self.pcb3 = PCB(3, 15, PageHolder(program3))
        self.pcb3.set_priority(PCBPriorities.LOW)

        self.pcb4 = PCB(4, 6, PageHolder(program4))
        self.pcb4.set_priority(PCBPriorities.LOW)

        self.scheduler = Scheduler()

    def test_scheduler_with_fifo(self):
        self.fifo = FifoPolicy(self.scheduler)
        self.fifo.add_pcb(self.pcb1)
        self.fifo.add_pcb(self.pcb2)
        self.fifo.add_pcb(self.pcb3)
        self.fifo.add_pcb(self.pcb4)
        result = self.scheduler.next_process()
        self.assertEquals(self.pcb1.get_pid, result.get_pid)

    def test_scheduler_with_round_robin(self):
        quantum = 1
        self.round_robin = RoundRobinPolicy(self.scheduler, quantum)
        self.round_robin.add_pcb(self.pcb1)
        self.round_robin.add_pcb(self.pcb2)
        self.round_robin.add_pcb(self.pcb3)
        self.round_robin.add_pcb(self.pcb4)
        expected_elements = [self.pcb1, self.pcb2, self.pcb3, self.pcb4]
        for expected_element in expected_elements:
            self.assertEqual(expected_element.get_pid, self.round_robin.next_process().get_pid)

    def test_scheduler_with_priority(self):
        self.priority_policy = PriorityPolicy(self.scheduler)
        self.priority_policy.add_pcb(self.pcb1)
        self.priority_policy.add_pcb(self.pcb2)
        self.priority_policy.add_pcb(self.pcb3)
        self.priority_policy.add_pcb(self.pcb4)
        expected_elems = [self.pcb1, self.pcb2, self.pcb3, self.pcb4]
        for expected_elem in expected_elems:
            self.assertEqual(expected_elem.get_pid, self.scheduler.next_process().get_pid)
 def setUp(self):
     program = Program('Excel')
     pageHolder = PageHolder(program)
     self.frame1 = Frame(0, 9, -1)
     self.frame2 = Frame(1, 9, -1)
     self.frame3 = Frame(2, 9, -1)
     self.frame4 = Frame(3, 9, -1)
     self.frames = [self.frame1, self.frame2, self.frame3, self.frame4]
     self.hdd = HDD(50)
     self.frame_manager = FrameManager(self.frames, self.hdd)
     self.page_creator = PageCreator()
     self.pcb = PCB(0, 30, pageHolder)
     self.page_creator.create(self.pcb, 5)
class FrameManagerTest(unittest.TestCase):

    # Arrange
    def setUp(self):
        program = Program('Excel')
        pageHolder = PageHolder(program)
        self.frame1 = Frame(0, 9, -1)
        self.frame2 = Frame(1, 9, -1)
        self.frame3 = Frame(2, 9, -1)
        self.frame4 = Frame(3, 9, -1)
        self.frames = [self.frame1, self.frame2, self.frame3, self.frame4]
        self.hdd = HDD(50)
        self.frame_manager = FrameManager(self.frames, self.hdd)
        self.page_creator = PageCreator()
        self.pcb = PCB(0, 30, pageHolder)
        self.page_creator.create(self.pcb, 5)

    def test_whenIAssignAPCBTheFirstTime_ThenFrameManagerUsesTheFirstFrame(self):
        # Pages
        first_frame = self.frame_manager.get_frames()[0]
        self.frame_manager.map_page_to_frame(self.pcb)
        first_pcb_page = self.pcb.get_page_assigned_by_number(0)
        self.assertEquals(first_frame.get_page(), first_pcb_page)

    def test_whenTheFirstPCBPageIsUsedAndPCBIsAssigned_ThenFrameManagerUsesTheSecondFrame(self):
        # Pages
        first_pcb_page = self.pcb.get_page_assigned_by_number(0)
        second_pcb_page =self.pcb.get_page_assigned_by_number(1)

        self.frame_manager.map_page_to_frame(self.pcb)
        first_pcb_page.set_used()

        self.frame_manager.map_page_to_frame(self.pcb)
        second_frame = self.frame_manager.get_frames()[1]
        self.assertEquals(second_frame.get_page(), second_pcb_page)

    def test_whenAllFramesAreUsedAndPCBAssignsOneMorePage_ThenTheYoungestFrameGetsEmpty(self):
        # Pages
        first_pcb_page = self.pcb.get_page_assigned_by_number(0)
        second_pcb_page = self.pcb.get_page_assigned_by_number(1)
        assert (second_pcb_page != None)
        third_pcb_page = self.pcb.get_page_assigned_by_number(2)
        forth_pcb_page = self.pcb.get_page_assigned_by_number(3)
        fifth_pcb_page = self.pcb.get_page_assigned_by_number(4)

        self.frame_manager.map_page_to_frame(self.pcb)
        first_pcb_page.set_used()
        self.frame_manager.map_page_to_frame(self.pcb)
        second_pcb_page.set_used()
        self.frame_manager.map_page_to_frame(self.pcb)
        third_pcb_page.set_used()
        self.frame_manager.map_page_to_frame(self.pcb)
        forth_pcb_page.set_used()

        forth_frame = self.frame_manager.get_frames()[3]

        self.frame_manager.map_page_to_frame(self.pcb)
        self.assertEqual(forth_frame.get_page(), fifth_pcb_page)
class PageCreatorTest(unittest.TestCase):

    # Arrange
    def setUp(self):
        self.page_creator = PageCreator()
        self.program = Program("Duke Nukem",20)
        id = 0
        cantidadDeInstrucciones = 20
        self.pcb = PCB(id, cantidadDeInstrucciones,PageHolder(self.program))

    def test_whenICreatePagesForPCB_ThenTheInfoHolderHasThemAsItShould(self):
        self.page_creator.create(self.pcb, 5)
        self.assertEqual(len(self.pcb.get_memory_policy_for_pcb().get_pages()), 4)

    def test_whenICreatePagesForPCB_ThenTheInfoTheyHaveIsCorrect(self):
        self.page_creator.create(self.pcb, 5)

        page1 = self.pcb.get_page_assigned_by_number(0)
        page2 = self.pcb.get_page_assigned_by_number(1)
        page3 = self.pcb.get_page_assigned_by_number(2)
        page4 = self.pcb.get_page_assigned_by_number(3)

        self.assertEqual(page1.get_starting_index(), 0)
        self.assertEqual(page1.get_ending_index(), 4)
        self.assertEqual(page1.get_amount_of_instructions(), 5)

        self.assertEqual(page2.get_starting_index(), 5)
        self.assertEqual(page2.get_ending_index(), 9)
        self.assertEqual(page2.get_amount_of_instructions(), 5)

        self.assertEqual(page3.get_starting_index(), 10)
        self.assertEqual(page3.get_ending_index(), 14)
        self.assertEqual(page3.get_amount_of_instructions(), 5)

        self.assertEqual(page4.get_starting_index(), 15)
        self.assertEqual(page4.get_ending_index(), 19)
        self.assertEqual(page4.get_amount_of_instructions(), 5)
class TestPCBInfoHolder(unittest.TestCase):

    def setUp(self):
        self.program = Program("AProgram")
        self.program.addInstruction(Instruction("Hola"))
        self.program.addInstruction(Instruction("Chau"))
        self.page_holder = PageHolder(self.program)
        self.pcb = PCB(0, 2, self.page_holder)
        self.page_creator = PageCreator(1)
        self.page_creator.create(self.pcb,1)

    def test_pcb_ni_idea(self):
        self.assertEqual(2, len(self.pcb.get_pages()))

    def test_i_increment_my_pc_and_ask_if_has_finished(self):
        self.page_holder.increment()
        self.assertTrue(self.page_holder.has_finished())
 def setUp(self):
     self.page_creator = PageCreator()
     self.program = Program("Duke Nukem",20)
     id = 0
     cantidadDeInstrucciones = 20
     self.pcb = PCB(id, cantidadDeInstrucciones,PageHolder(self.program))
Example #12
0
 def createPcb(self, priority, pageTable=None):
     newPcb = PCB(priority, pageTable)
     newPcb._pid = self.newPid()
     self._table[newPcb._pid] = newPcb
     return newPcb