def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(100, 1000),
tasks.SporadicTask(39, 1050),
tasks.SporadicTask(51, 599),
])
self.qlen = 50
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
])
r.initialize_resource_model(self.ts)
# dummy response-time guess
for t in self.ts:
t.response_time = 40
# every task holds the resource for up to 1ms
for t in self.ts:
t.resmodel[0].add_request(1)
# assign tasks to partitions
self.ts[0].partition = 0
self.ts[1].partition = 0
self.ts[2].partition = 1
self.ts[3].partition = 1
self.p0 = tasks.TaskSystem((t for t in self.ts if t.partition == 0))
self.p1 = tasks.TaskSystem((t for t in self.ts if t.partition == 1))
# assign preemption levels
lb.assign_fp_preemption_levels(self.ts)
def setUp(self):
self.ts1 = tasks.TaskSystem([
tasks.SporadicTask(66, 100),
tasks.SporadicTask(66, 100),
tasks.SporadicTask(66, 100),
])
for t in self.ts1:
t.affinity = set([1, 2])
self.ts1.assign_ids()
self.ts2 = tasks.TaskSystem([
tasks.SporadicTask(14, 40),
tasks.SporadicTask(16, 48),
])
self.ts3 = tasks.TaskSystem([
tasks.SporadicTask(1, 16, deadline=11),
tasks.SporadicTask(6, 15),
tasks.SporadicTask(9, 20),
])
self.ts4 = tasks.TaskSystem([
tasks.SporadicTask(10, 100),
tasks.SporadicTask(30, 100),
])
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10000, 100000),
tasks.SporadicTask(5000, 50000),
])
for t in self.ts:
t.wss = 0
self.o = m.Overheads()
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
r.initialize_resource_model(self.ts)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(9995, 100000),
tasks.SporadicTask(4995, 50000),
])
for t in self.ts:
t.wss = 0
self.o = m.Overheads()
self.o.quantum_length = 500
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(7, 10),
tasks.SporadicTask(6, 10),
tasks.SporadicTask(10, 20),
])
self.ts[0].affinity = set([1])
self.ts[1].affinity = set([2])
self.ts[2].affinity = set([1, 2])
self.ts.assign_ids()
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
r.initialize_resource_model(self.ts)
for i, t in enumerate(self.ts):
t.partition = 0
t.response_time = t.period
t.resmodel[1].add_request(1)
def test_first_fit(self):
failed, mapping = apa.edf_first_fit_decreasing_difficulty(
self.ts, [1, 2, 3])
self.assertEqual(failed, set())
self.assertEqual(len(mapping), 3)
self.assertEqual(mapping[1], [self.ts[0], self.ts[1]])
self.assertEqual(mapping[2], [self.ts[3]])
self.assertEqual(mapping[3], [self.ts[2]])
failed, mapping = apa.edf_first_fit_decreasing_difficulty(
self.ts, [2, 1, 3])
self.assertEqual(failed, set())
self.assertEqual(len(mapping), 3)
self.assertEqual(mapping[2], [self.ts[2], self.ts[1]])
self.assertEqual(mapping[1], [self.ts[0], self.ts[3]])
self.assertEqual(mapping[3], [])
# give it one more to place
self.ts.append(tasks.SporadicTask(19, 31))
self.ts[-1].affinity = set([2, 3])
self.ts.assign_ids()
failed, mapping = apa.edf_first_fit_decreasing_difficulty(
self.ts, [1, 2, 3])
self.assertEqual(failed, set([self.ts[-1]]))
failed, mapping = apa.edf_first_fit_decreasing_difficulty(
self.ts, [2, 1, 3])
self.assertEqual(failed, set())
self.assertEqual(len(mapping), 3)
self.assertEqual(mapping[2], [self.ts[2], self.ts[1]])
self.assertEqual(mapping[1], [self.ts[0], self.ts[3]])
self.assertEqual(mapping[3], [self.ts[4]])
# give it yet another more to place
self.ts.append(tasks.SporadicTask(40, 50))
self.ts[-1].affinity = set([1, 2, 3])
self.ts.assign_ids()
failed, mapping = apa.edf_first_fit_decreasing_difficulty(
self.ts, [2, 1, 3])
self.assertEqual(failed, set([self.ts[4]]))
self.assertEqual(len(mapping), 3)
self.assertEqual(mapping[1], [self.ts[0], self.ts[5]])
self.assertEqual(mapping[2], [self.ts[2], self.ts[1]])
self.assertEqual(mapping[3], [self.ts[3]])
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
self.ts_ = self.ts.copy()
r.initialize_resource_model(self.ts)
for i, t in enumerate(self.ts):
t.partition = i % 2
t.response_time = t.period
t.resmodel[0].add_request(1)
t.resmodel[1].add_request(1)
lb.assign_fp_preemption_levels(self.ts)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10, 100),
tasks.SporadicTask(30, 100),
tasks.SporadicTask(20, 100, deadline=30),
tasks.SporadicTask(21, 30),
])
self.ts[0].affinity = set([1])
self.ts[1].affinity = set([1, 2])
self.ts[2].affinity = set([2, 3])
self.ts[3].affinity = set([1, 2, 3])
self.ts.assign_ids()
self.cores = set([1, 2, 3])
def setUp(self):
example_tasks = [
(51, 1000, 1000, 0, 0, 51),
(3000, 2000000, 5000, 300, 0, 3504),
(2000, 25000, 25000, 600, 0, 5906),
(5000, 25000, 25000, 900, 0, 11512),
(1000, 40000, 40000, 1350, 0, 13064),
(3000, 50000, 50000, 1350, 0, 16217),
(5000, 50000, 50000, 750, 0, 20821),
(8000, 59000, 59000, 750, 0, 36637),
(9000, 80000, 80000, 1350, 0, 47798),
(2000, 80000, 80000, 450, 0, 48949),
(5000, 100000, 100000, 1050, 0, 99150),
(1000, 200000, 200000, 450, 1000, 99550),
(3000, 200000, 200000, 450, 0, 140641),
(1000, 200000, 200000, 450, 0, 141692),
(1000, 200000, 200000, 1350, 0, 143694),
(3000, 1000000, 1000000, 0, 0, 145446),
(1000, 1000000, 1000000, 0, 0, 146497),
(1000, 1000000, 1000000, 0, 0, 147548),
]
self.ts = tasks.TaskSystem()
for (cost, period, deadline, blocking, jitter,
expected) in example_tasks:
t = tasks.SporadicTask(cost, period, deadline)
t.jitter = jitter
t.pcp = blocking
t.expected = expected + jitter
self.ts.append(t)
def tasks(self,
max_tasks=None,
max_util=None,
squeeze=False,
time_conversion=trunc):
"""Generate a sequence of tasks until either max_tasks is reached
or max_util is reached. If max_util would be exceeded and squeeze is
true, then the last-generated task's utilization is scaled to exactly
match max_util. Otherwise, the last-generated task is discarded.
time_conversion is used to convert the generated (non-integral) values
into integral task parameters.
"""
count = 0
usum = 0
while ((max_tasks is None or count < max_tasks)
and (max_util is None or usum < max_util)):
period = self.period()
util = self.util()
cost = period * util
deadline = self.deadline(cost, period)
# scale as required
period = max(1, int(time_conversion(period)))
cost = max(1, int(time_conversion(cost)))
deadline = max(1, int(time_conversion(deadline)))
util = cost / period
count += 1
usum += util
if max_util and usum > max_util:
if squeeze:
# make last task fit exactly
util -= (usum - max_util)
cost = trunc(period * util)
else:
break
yield ts.SporadicTask(cost, period, deadline)
def yang(app):
t_list = []
for ti in range(len(app.tasks)):
response_time = app.tasks[ti].response_time()
t_list.append(tasks.SporadicTask(response_time, response_time * 1000))
ts = tasks.TaskSystem(t_list)
fp.bound_response_times(1, ts)
resources.initialize_resource_model(ts)
for ti in range(len(app.tasks)):
for cs in app.tasks[ti].cs:
ts[ti].resmodel[cs.resource].add_request(cs.duration)
for t in ts:
t.partition = 0
bounds.assign_fp_preemption_levels(ts)
r_but = buttazzo(a)
res = bounds.apply_pip_bounds(ts, 1)
ret = {}
for n in range(len(app.tasks) -
1): # the blocking time of last task is always 0
costH = 0
for h in range(n):
costH += ts[h].cost
y_Bn = res.get_blocking_term(
n) - costH #cost of all the processes with higher priority
if y_Bn > r_but[n][0]:
feasible = False
else:
_, feasible, _ = schedule(app, app.tasks[n], r_but[n][1])
ret[n] = (y_Bn, feasible)
return ret
def vmlist_to_ts(info, max_pcpus):
ts = []
# Generate task set based on passed info
for k, vm in info.iteritems():
if os.getenv('DEBUG', '') != '':
print vm
# For every VM, add the required number of VCPUs
for v in xrange(0, vm['num_vcpus']):
dom_id = vm['id']
util = vm['utilization'] / vm['num_vcpus']
affinity = vm['affinity']
max_latency = vm['latency']
burstable = vm['burstable']
period, budget = util_to_task_params(util, max_latency)
assert util > 0 and util <= 1.0, "Utilization must be in (0, 1]"
assert period > 0 and budget > 0, "No suitable parameters"
t = tasks.SporadicTask(budget, period, deadline=period)
t.dom_id = dom_id
t.vcpu_id = v
t.max_latency = max_latency
t.burstable = burstable
t.util = util # Double value between 0 and 1
t.affinity = set(affinity)
t.release_time = 0
t.allocations = []
ts.append(t)
return ts
def test_infeasible_bad_task(self):
self.ts.append(tasks.SporadicTask(110, 100))
self.ts[3].affinity = set([1, 2, 3])
aff = sched.get_native_affinities(self.ts)
ts = sched.get_native_taskset(self.ts)
sol = sched.native.apa_implicit_deadline_feasible(ts, aff)
self.assertIsNone(sol)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(6000, 31000, deadline=18000),
tasks.SporadicTask(2000, 9800, deadline=9000),
tasks.SporadicTask(1000, 17000, deadline=12000),
tasks.SporadicTask(90, 4200, deadline=3000),
tasks.SporadicTask(8, 96, deadline=78),
tasks.SporadicTask(2, 12, deadline=16),
tasks.SporadicTask(10, 280, deadline=120),
tasks.SporadicTask(26, 660, deadline=160),
])
def setUp(self):
mscale = 100
self.ts = tasks.TaskSystem([
tasks.SporadicTask(17 * mscale, 100 * mscale),
tasks.SporadicTask(67 * mscale, 340 * mscale),
tasks.SporadicTask(27 * mscale, 150 * mscale),
])
self.ts[0].partition = 0
self.ts[1].partition = 1
self.ts[2].partition = 0
self.ts.assign_ids()
r.initialize_resource_model(self.ts)
lb.assign_fp_preemption_levels(self.ts)
self.ts[0].resmodel[0].add_read_request(1 * mscale)
self.ts[1].resmodel[0].add_read_request(1 * mscale)
self.ts[2].resmodel[0].add_write_request(1 * mscale)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10000, 100000),
tasks.SporadicTask(5000, 50000),
])
for t in self.ts:
t.wss = 0
res.initialize_resource_model(self.ts)
self.ts[0].resmodel[0].add_request(11)
self.ts[0].resmodel[0].add_request(7)
self.ts[1].resmodel[0].add_request(17)
self.ts[0].resmodel[1].add_read_request(11)
self.ts[0].resmodel[1].add_read_request(1)
self.ts[1].resmodel[1].add_read_request(17)
self.ts[0].resmodel[2].add_read_request(11)
self.ts[0].resmodel[2].add_read_request(1)
self.ts[1].resmodel[2].add_write_request(17)
self.ts[1].resmodel[2].add_write_request(1)
self.o = m.Overheads()
def test_worst_fit_with_splits2(self):
self.ts1.append(tasks.SporadicTask(31, 100))
self.ts1[-1].affinity = set([1, 2])
failed, mapping = apa.edf_worst_fit_decreasing_difficulty(
self.ts1, with_splits=True)
self.assertNotEqual(failed, set())
self.assertEqual(failed.pop().id, self.ts1[-1].id)
self.assertEqual(len(mapping), 2)
self.assertEqual(mapping[1][0].cost, 66)
self.assertEqual(mapping[1][1].cost, 34)
self.assertEqual(mapping[2][0].cost, 66)
self.assertEqual(mapping[2][1].cost, 32)
self.assertEqual(mapping[2][2].cost, 2)
def setUp(self):
self.t1 = tasks.SporadicTask(10, 100)
self.t2 = tasks.SporadicTask(25, 200)
self.t3 = tasks.SporadicTask(33, 33)
self.ts = tasks.TaskSystem([self.t1, self.t2, self.t3])
self.ts.assign_ids()
lb.assign_fp_preemption_levels(self.ts)
for t in self.ts:
t.response_time = t.period
t.partition = t.id % 2
self.ts_no_req = self.ts.copy()
r.initialize_resource_model(self.ts)
r.initialize_resource_model(self.ts_no_req)
self.t1.resmodel[0].add_request(1)
self.t2.resmodel[0].add_request(2)
self.t3.resmodel[0].add_request(3)
# only one resource, assigned to the first processor
self.resource_locality = { 0: 0 }
def test_copy(self):
ts = m.TaskSystem([
m.SporadicTask(10, 100),
])
r.initialize_resource_model(ts)
ts[0].resmodel[0].add_request(10)
ts2 = ts.copy()
ts[0].resmodel[0].add_request(30)
self.assertEqual(ts[0].resmodel[0].max_length, 30)
self.assertEqual(ts[0].resmodel[0].max_requests, 2)
self.assertEqual(ts2[0].resmodel[0].max_length, 10)
self.assertEqual(ts2[0].resmodel[0].max_requests, 1)
def setUp(self):
self.trivial_ts = tasks.TaskSystem([
tasks.SporadicTask(20, 200),
tasks.SporadicTask(20, 200),
tasks.SporadicTask(50, 500),
tasks.SporadicTask(20, 400),
tasks.SporadicTask(100, 800),
])
self.trivial_num_cpus = 2
r.initialize_resource_model(self.trivial_ts)
lb.assign_fp_preemption_levels(self.trivial_ts)
for i, t in enumerate(self.trivial_ts):
t.partition = 0
t.response_time = 4*t.cost
self.trivial_ts[0].resmodel[1].add_request(5)
self.trivial_ts[0].resmodel[1].add_request(5)
self.trivial_ts[1].resmodel[2].add_request(5)
self.trivial_ts[1].resmodel[2].add_request(5)
self.trivial_ts[2].resmodel[1].add_request(10)
self.trivial_ts[4].resmodel[2].add_request(10)
def setUp(self):
mscale = 100
self.ts = tasks.TaskSystem([
tasks.SporadicTask( 17 * mscale, 100 * mscale),
tasks.SporadicTask( 64 * mscale, 132 * mscale),
tasks.SporadicTask( 67 * mscale, 340 * mscale),
tasks.SporadicTask( 74 * mscale, 137 * mscale),
tasks.SporadicTask( 31 * mscale, 249 * mscale),
tasks.SporadicTask( 47 * mscale, 115 * mscale),
tasks.SporadicTask( 27 * mscale, 150 * mscale),
tasks.SporadicTask( 53 * mscale, 424 * mscale),
tasks.SporadicTask(192 * mscale, 884 * mscale),
])
self.ts[0].partition = 0
self.ts[1].partition = 1
self.ts[2].partition = 2
self.ts[3].partition = 3
self.ts[4].partition = 4
self.ts[5].partition = 0
self.ts[6].partition = 0
self.ts[7].partition = 2
self.ts[8].partition = 4
self.ts.assign_ids()
r.initialize_resource_model(self.ts)
lb.assign_fp_preemption_levels(self.ts)
self.ts[0].resmodel[0].add_read_request(1 * mscale)
self.ts[1].resmodel[0].add_read_request(1 * mscale)
self.ts[2].resmodel[0].add_read_request(1 * mscale)
self.ts[3].resmodel[0].add_read_request(1 * mscale)
self.ts[4].resmodel[0].add_read_request(1 * mscale)
self.ts[6].resmodel[0].add_write_request(1 * mscale)
self.ts[7].resmodel[0].add_write_request(1 * mscale)
self.ts[8].resmodel[0].add_write_request(1 * mscale)
def test_qpa_known_unschedulable(self):
qpa = edf.native.QPATest(1)
ts1 = tasks.TaskSystem([
tasks.SporadicTask(331, 15000, deadline=2688),
tasks.SporadicTask(3654, 77000, deadline=3849)
])
self.assertFalse(qpa.is_schedulable(sched.get_native_taskset(ts1)))
ts2 = tasks.TaskSystem([
tasks.SporadicTask(331, 15000, deadline=2688),
tasks.SporadicTask(413, 34000, deadline=1061),
tasks.SporadicTask(3654, 77000, deadline=3849),
tasks.SporadicTask(349, 70000, deadline=20189),
tasks.SporadicTask(1113, 83000, deadline=10683),
])
self.assertFalse(qpa.is_schedulable(sched.get_native_taskset(ts2)))
def ts_random(n, U_sum):
while 1:
ts = tasks.TaskSystem()
U = UUniFast(n, U_sum)
for i in range(0, n):
p = random.randint(1000, 15000)
c = int(p * U[i])
if c == 0: # Cost of zero leads to other problems
break
ts.append(tasks.SporadicTask(c, p))
if len(ts) != n:
continue
if ts.utilization() > (U_sum - 0.001) and ts.utilization() <= U_sum:
break
return ts
def main():
if len(sys.argv) != 3:
raise Exception("Invalid parameters")
fname = sys.argv[1]
cpus = int(sys.argv[2])
with open(fname, 'r') as f:
data = f.read().strip()
try:
schedule = eval(data)
except:
schedule = run_exps.convert_data(data)
ts = []
for task_conf in schedule['task']:
(task, args) = (task_conf[0], task_conf[1])
real_args = args.split()
index = 0
if '-S' in real_args:
index = real_args.index('-S') + 2
if '-p' in real_args:
index = real_args.index('-p') + 2
ts.append(
tasks.SporadicTask(int(real_args[index + 0]),
int(real_args[index + 1])))
ts.sort(key=lambda x: x.utilization(), reverse=True)
_pack(ts, cpus)
with open('out_sched.py', 'w') as out_file:
for t in ts:
out_file.write("-p {0} {1} {2}\n".format(t.cpu, t.cost, t.period))
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(x * 10, x * 100) for x in xrange(1, 10)
])
def setUp(self):
self.t1 = tasks.SporadicTask(5000, 10000)
self.t2 = tasks.SporadicTask(5000, 10000, deadline=7000)
