Python charge_scheduling_overheads 예제들

예제 #1

파일: overheads.py 프로젝트: ChenZewei/schedcat

    def test_dedicated(self):
        self.o.ipi_latency = const(100)
        self.assertEqual(jlfp.charge_scheduling_overheads(self.o, 4,  True, self.ts), self.ts)
        self.assertEqual(self.ts[0].cost, 10100)
        self.assertEqual(self.ts[1].cost,  5100)
        self.unchanged_period()
        self.unchanged_deadline()

        self.o.release = const(133)
        self.assertEqual(jlfp.charge_scheduling_overheads(self.o, 4,  True, self.ts), self.ts)
        self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
        self.assertEqual(self.ts[0].cost, 10333)
        self.assertEqual(self.ts[1].cost,  5333)

        self.unchanged_period()
        self.unchanged_deadline()

예제 #2

파일: overheads.py 프로젝트: ChenZewei/schedcat

 def test_release(self):
     self.o.release = const(1)
     self.assertEqual(jlfp.charge_scheduling_overheads(self.o, 4,  False, self.ts), self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.assertEqual(self.ts[0].cost, 10005)
     self.assertEqual(self.ts[1].cost,  5005)
     self.unchanged_period()
     self.unchanged_deadline()

예제 #3

파일: overheads.py 프로젝트: ChenZewei/schedcat

 def test_cache_affinity_loss(self):
     self.o.cache_affinity_loss = const(1)
     self.assertEqual(jlfp.charge_scheduling_overheads(self.o, 4,  False, self.ts), self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.assertEqual(self.ts[0].cost, 10001)
     self.assertEqual(self.ts[1].cost,  5001)
     self.unchanged_period()
     self.unchanged_deadline()

예제 #4

파일: overheads.py 프로젝트: ChenZewei/schedcat

 def test_release_latency(self):
     self.o.release_latency = const(1)
     self.assertEqual(jlfp.charge_scheduling_overheads(self.o, 4,  False, self.ts), self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.unchanged_cost()
     self.assertEqual(self.ts[0].period, 99999)
     self.assertEqual(self.ts[1].period, 49999)
     self.assertEqual(self.ts[0].deadline, 99999)
     self.assertEqual(self.ts[1].deadline, 49999)

예제 #5

 def test_release(self):
     self.o.release = const(1)
     self.assertEqual(
         jlfp.charge_scheduling_overheads(self.o, 4, False, self.ts),
         self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.assertEqual(self.ts[0].cost, 10005)
     self.assertEqual(self.ts[1].cost, 5005)
     self.unchanged_period()
     self.unchanged_deadline()

예제 #6

 def test_cache_affinity_loss(self):
     self.o.cache_affinity_loss = const(1)
     self.assertEqual(
         jlfp.charge_scheduling_overheads(self.o, 4, False, self.ts),
         self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.assertEqual(self.ts[0].cost, 10001)
     self.assertEqual(self.ts[1].cost, 5001)
     self.unchanged_period()
     self.unchanged_deadline()

예제 #7

파일: overheads.py 프로젝트: zhangtong1516/schedcat

def bound_cfl_with_oh(oheads, dedicated_irq, clusts):
    for clust in clusts:
        success = charge_scheduling_overheads(oheads, clust.cpus,
                                              dedicated_irq, clust)
        quantize_params(clust)
        if (success and has_bounded_tardiness(clust.cpus, clust)):
            bound_gfl_response_times(clust.cpus, clust, 15)
        else:
            return False
    return True

예제 #8

파일: locking.py 프로젝트: zhangtong1516/schedcat

def post_blocking_term_oh_inflation(oheads, clusts):
    for clust in clusts:
        inflation = oheads.syscall_in(len(clust))
        for t in clust:
            if t.arrival_blocked:
                t.cost += inflation
                t.arrival_blocked += inflation
        if not charge_scheduling_overheads(oheads, clust.cpus, True, clust):
            return False
        quantize_params(clust)
    return True

예제 #9

    def test_dedicated(self):
        self.o.ipi_latency = const(100)
        self.assertEqual(
            jlfp.charge_scheduling_overheads(self.o, 4, True, self.ts),
            self.ts)
        self.assertEqual(self.ts[0].cost, 10100)
        self.assertEqual(self.ts[1].cost, 5100)
        self.unchanged_period()
        self.unchanged_deadline()

        self.o.release = const(133)
        self.assertEqual(
            jlfp.charge_scheduling_overheads(self.o, 4, True, self.ts),
            self.ts)
        self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
        self.assertEqual(self.ts[0].cost, 10333)
        self.assertEqual(self.ts[1].cost, 5333)

        self.unchanged_period()
        self.unchanged_deadline()

예제 #10

 def test_release_latency(self):
     self.o.release_latency = const(1)
     self.assertEqual(
         jlfp.charge_scheduling_overheads(self.o, 4, False, self.ts),
         self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.unchanged_cost()
     self.assertEqual(self.ts[0].period, 99999)
     self.assertEqual(self.ts[1].period, 49999)
     self.assertEqual(self.ts[0].deadline, 99999)
     self.assertEqual(self.ts[1].deadline, 49999)

예제 #11

파일: overheads.py 프로젝트: ChenZewei/schedcat

def bound_cfl_with_oh(oheads, dedicated_irq, clusts):
    for clust in clusts:
        success = charge_scheduling_overheads(oheads, clust.cpus,
                                              dedicated_irq,
                                              clust)
        quantize_params(clust)
        if (success and has_bounded_tardiness(clust.cpus, clust)):
            bound_gfl_response_times(clust.cpus, clust, 15)
        else:
            return False
    return True

예제 #12

파일: locking.py 프로젝트: ChenZewei/schedcat

def post_blocking_term_oh_inflation(oheads, clusts):
    for clust in clusts:
        inflation = oheads.syscall_in(len(clust))
        for t in clust:
            if t.arrival_blocked:
                t.cost += inflation
                t.arrival_blocked += inflation
        if not charge_scheduling_overheads(oheads, clust.cpus,
                                           True, clust):
            return False
        quantize_params(clust)
    return True

예제 #13

파일: overheads.py 프로젝트: ChenZewei/schedcat

 def test_tick_example(self):
     e1  = 2000
     e2  = 3000
     Q   = 5000
     tck = 2000
     self.ts[0].cost = e1
     self.ts[1].cost = e2
     self.o.tick = const(tck)
     self.o.quantum_length = Q
     self.assertEqual(jlfp.charge_scheduling_overheads(self.o, 1,  False, self.ts), self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.assertEqual(self.ts[0].cost, int(ceil(30000 / 3)))
     self.assertEqual(self.ts[1].cost, 5000 + int(ceil(20000 / 3)))

예제 #14

 def test_tick_example(self):
     e1 = 2000
     e2 = 3000
     Q = 5000
     tck = 2000
     self.ts[0].cost = e1
     self.ts[1].cost = e2
     self.o.tick = const(tck)
     self.o.quantum_length = Q
     self.assertEqual(
         jlfp.charge_scheduling_overheads(self.o, 1, False, self.ts),
         self.ts)
     self.assertEqual(jlfp.quantize_params(self.ts), self.ts)
     self.assertEqual(self.ts[0].cost, int(ceil(30000 / 3)))
     self.assertEqual(self.ts[1].cost, 5000 + int(ceil(20000 / 3)))

예제 #15

파일: overheads.py 프로젝트: ChenZewei/schedcat

 def test_none(self):
     self.assertEqual(jlfp.charge_scheduling_overheads(None, 4,  False, self.ts), self.ts)
     self.unchanged_cost()
     self.unchanged_period()
     self.unchanged_deadline()

예제 #16

 def test_none(self):
     self.assertEqual(
         jlfp.charge_scheduling_overheads(None, 4, False, self.ts), self.ts)
     self.unchanged_cost()
     self.unchanged_period()
     self.unchanged_deadline()