コード例 #1
0
class RRStrategyTestCase(BaseScenario):
    def setUp(self):
        super(RRStrategyTestCase, self).setUp()
        self.se = StrategyEvaluator()
        self.pe = ProcessEvaluator()

    def _run_rr(self, quantum, timeslice):
        strategy = RoundRobin(quantum=quantum, timeslice=timeslice)
        scheduler = Scheduler(strategy=strategy)
        scheduler.initialize("FOO")
        scheduler.run()

    def test_RR_t10_q1(self):
        self._run_rr(quantum=1, timeslice=10)
        start, end = self.pe.getPeriodForPCB("FOO")
        self.assertEqual(end, 30)  # work(10),launch(BAR),ready(10),work(10) -> 30

    def test_RR_t10_q2(self):
        self._run_rr(quantum=2, timeslice=10)
        start, end = self.pe.getPeriodForPCB("FOO")
        self.assertEqual(end, 20)  # work(10),launch(BAR),work(10) -> 20

    def test_RR_t5_q1(self):
        self._run_rr(quantum=1, timeslice=5)
        start, end = self.pe.getPeriodForPCB("BAR")
        self.assertTupleEqual((10, 25), (start, end))

    def test_RR_t5_q2(self):
        self._run_rr(quantum=2, timeslice=5)
        start, end = self.pe.getPeriodForPCB("FOO")
        self.assertTupleEqual((0, 30), (start, end))
コード例 #2
0
ファイル: simple.py プロジェクト: c7h/process_scheduler
 def __calculate_left_work(self, pcb):
     """
     we have to find out how much cpu-time is left in the workplan
     :param pcb: the PCB of the target Process
     :return: int. left service time
     """
     pe = ProcessEvaluator() # we 'abuse' the process evaluator
     # @TODO: change this. The evaluator module is not meant to be used this way
     service_time = pe.getServiceTime(pcb)
     return service_time
コード例 #3
0
    def setUp(self):
        super(ProcessEvaluatorTestCase, self).setUp()
        scheduler = SchedulerFactory.getScheduler("FiFo", timeslice=10)
        scheduler.initialize("A")
        scheduler.run()

        self.evaluator = ProcessEvaluator()
コード例 #4
0
class SJFStrategyTestCase(BaseScenario):
    def setUp(self):
        super(SJFStrategyTestCase, self).setUp()
        self.pe = ProcessEvaluator()

    def run_scheduler(self):
        strategy = ShortesJobFirst()
        scheduler = Scheduler(strategy=strategy)
        scheduler.initialize("FOO")
        scheduler.run()

    def test_SJF_01(self):
        self.run_scheduler()
        start, end = self.pe.getPeriodForPCB("FOO")
        self.assertTupleEqual((0,20), (start, end))
コード例 #5
0
class ProcessEvaluatorComplexTestCase(FiFoScenario2):
    def setUp(self):
        super(ProcessEvaluatorComplexTestCase, self).setUp()
        scheduler = SchedulerFactory.getScheduler("FiFo", timeslice=10)
        scheduler.initialize("A")
        scheduler.run()

        self.evaluator = ProcessEvaluator()

    def test_getReadySectionsForPCB_01(self):
        # process A got a ready section at 30 - 35 after wait
        # and another at the beginning with duration 0 (process got active)
        ready_secs = self.evaluator._getReadySectionsForPCB("A")
        self.assertListEqual(ready_secs, [Ready(0), Ready(5)])

    def test_getReadySectionsForPCB_02(self):
        # process B got a ready section at 10-20 after launch
        ready_secs = self.evaluator._getReadySectionsForPCB("B")
        self.assertEqual(len(ready_secs), 1)

    def test_geResponseTime_01(self):
        response_time = self.evaluator.getResponseTime("A")
        self.assertListEqual([0, 5], response_time)

    def test_geResponseTime_02(self):
        response_time = self.evaluator.getResponseTime("B")
        self.assertListEqual([10], response_time)

    def test_getTurnaroundTime_01(self):
        turnaroundtime = self.evaluator.getTurnaroundTime("A")
        self.assertEqual(turnaroundtime, 35)

    def test_getTurnaroundTime_02(self):
        turnaroundtime = self.evaluator.getTurnaroundTime("B")
        self.assertEqual(turnaroundtime, 15)

    def test_getWaitTime_01(self):
        waittime = self.evaluator.getWaitTime("A")
        self.assertEqual(waittime, 15)

    def test_getWaitTime_02(self):
        waittime = self.evaluator.getWaitTime("B")
        self.assertEqual(waittime, 10)
コード例 #6
0
class ProcessEvaluatorTestCase(SimpleFiFoScenario):
    def setUp(self):
        super(ProcessEvaluatorTestCase, self).setUp()
        scheduler = SchedulerFactory.getScheduler("FiFo", timeslice=10)
        scheduler.initialize("A")
        scheduler.run()

        self.evaluator = ProcessEvaluator()

    def test_getPeriodForPCB_01(self):
        # test get pcb by name
        period_B = self.evaluator.getPeriodForPCB("B")
        self.assertTupleEqual(period_B, (10, 20))

    def test_getPeriodForPCB_02(self):
        period_A = self.evaluator.getPeriodForPCB("A")
        self.assertTupleEqual(period_A, (0, 35))

    def test_getPeriodForPCB_03(self):
        # test get pcb by reference
        period_B = self.evaluator.getPeriodForPCB(self.pcb2)
        self.assertTupleEqual(period_B, (10, 20))

    def test_getServiceTime_01(self):
        service_time = self.evaluator.getServiceTime("A")
        self.assertEqual(service_time, 20)

    def test_getServiceTime_02(self):
        service_time = self.evaluator.getServiceTime("B")
        self.assertEqual(service_time, 10)

    def test_getWaitTime_01(self):
        wait_time = self.evaluator.getWaitTime("A")
        self.assertEqual(wait_time, 15)

    def test_getWaitTime_02(self):
        wait_time = self.evaluator.getWaitTime("B")
        self.assertEqual(wait_time, 0)
コード例 #7
0
 def setUp(self):
     super(SJFStrategyTestCase, self).setUp()
     self.pe = ProcessEvaluator()