TIME TO RUN PATCH

main.py

@@ -3,7 +3,7 @@
 from simso.configuration import Configuration
 from interval import *
 from ss_conf_table import *
-
+#from ss_offline_phase import gen_slotshift_table
 
 def main():
 
@@ -12,16 +12,23 @@ def main():
 	configuration = Configuration()
 
 	if remote == None:
+		print "remote is none"
 		#todo: this number should be generated randomly
 		table = gen_slotshift_table(1, 10, 10, 10, .10)
-		remote = local_table(table[0], table[1],
+		if table:
+			remote = local_table(table[0], table[1],
 				table[2], table[3])
+		else:
+			print "Cant Run because task set not generated"
+			return
 	else:
 		remote.recieve_table()
 
 	associate = association(remote)
 
 	interval = associate.create_def_intr_list(associate)
+
+	run_time = associate.get_running_time(interval)
 
 	associate.create_relation_window(associate, interval)
 
@@ -30,7 +37,7 @@ def main():
 		if(j != 0):
 			break
 
-	configuration.duration = 420 * configuration.cycles_per_ms
+	configuration.duration = run_time * configuration.cycles_per_ms
 
 	configuration.add_processor(name="CPU 1", identifier=1)
 

ss_offline_phase.py,bk

@@ -0,0 +1,166 @@
+from simso.generator.task_generator import gen_ripoll 
+from operator import itemgetter
+
+def _gcd(*numbers):
+    """Return the greatest common divisor of the given integers"""
+    from fractions import gcd
+    return reduce(gcd, numbers)
+
+def _lcm(numbers):
+    """Return lowest common multiple."""
+    def lcm(a, b):
+        return (a * b) // _gcd(a, b)
+    return reduce(lcm, numbers, 1)
+
+def get_hyperperiod(task_set):
+	"""
+	Compute and return the hyperperiod of the tasks.
+	"""
+	return _lcm([x[2] for x in task_set])
+
+def __calc_wcet(tmp_lst):
+	c = 0
+	for j in tmp_lst:
+		c += j[2]
+	return c
+
+def __gen_intr(job, job_set, tsk_lst, intr_lst, intr_id):
+	tmp_lst = []
+	j = job
+	while 1:
+		tmp_lst.append(j)
+		if job_set == None:
+			break
+		if job[3] == job_set[0][3]:
+			 j = job_set.pop(0)
+		else:
+			break
+
+	print "intr_id", intr_id, "job_lst", tmp_lst
+	if tmp_lst:
+		intr_est = min(tmp_lst, key=lambda x:x[4])
+		intr_est = intr_est[4]
+	else:
+		intr_est = 0
+
+	if intr_lst:
+		intr_before_end = intr_lst[intr_id - 1][2]
+		intr_start = max(intr_est, intr_before_end)
+	else:
+		intr_start = 0
+
+	intr_end = tmp_lst[0][3]
+	print "intr start and end", intr_start, intr_end
+	intr_sc = intr_end - intr_start
+	print "intr_sc: ", intr_sc, __calc_wcet(tmp_lst)
+	intr_sc = intr_sc - __calc_wcet(tmp_lst)
+
+	return [intr_id, intr_start, intr_end, intr_sc]
+
+def __correct_intr(intr_lst):
+	i_curr = 0
+	i_nxt  = 1
+	length = len(intr_lst)
+	while i_curr < length:
+		intr_lst[i_curr][0] = i_curr
+		if i_nxt < len(intr_lst):
+			if intr_lst[i_curr][2] != intr_lst[i_nxt][1]:
+				intr_lst.insert( i_curr, [i_curr+1,
+				intr_lst[i_curr][1],
+				intr_lst[i_nxt][2], 
+				intr_lst[i_nxt][2] - intr_lst[i_curr][1]] )
+		i_curr += 1
+		i_nxt +=1
+
+def __calculate_sc(intr_lst):
+	i = len(intr_lst) - 2
+	while i >= 0:
+		intr_lst[i][3] = intr_lst[i][3] + min(0, intr_lst[i+1][3])
+		i -= 1
+
+def gen_slotshifting_intervals(job_set, tsk_lst):
+	intr_lst = []
+	intr_id = 0
+	for j in job_set:
+		job = job_set.pop(0)
+		if job:
+			intr = __gen_intr(job, job_set, 
+				tsk_lst, intr_lst, intr_id)
+		else:
+			break
+		intr_lst.append(intr)
+		intr_id += 1
+	print "intr", intr_lst	
+	__correct_intr(intr_lst)
+	__calculate_sc(intr_lst)	
+	return intr_lst
+
+def gen_jobs(task, hp, i, job_lst):
+	"""
+	task: task that gets converted into jobs
+	hp : hyper period
+	job_list: job list to which current task->job gets appended
+	"""
+	tsk = []
+	tsk_job = []
+	job_cnt = hp/task[2]
+	jid  = 1
+	print job_cnt
+	while jid <= job_cnt:
+		# j_id = jid
+		if jid > 1:
+			c = task[0]
+			d = task[1] * jid
+			p = task[2] * jid
+		else:
+			c = task[0]
+			d = task[1]
+			p = 0 
+		t = i
+		tsk_job.append((t, jid, c, d, p))
+		jid += 1
+	job_lst.extend(tsk_job)	
+
+	# create task based on requirement	
+	tsk.append(i)  # id
+	tsk.append(0)  # est
+	tsk.append(task[0]) #wcet
+	tsk.append(task[1]) #dl
+	tsk.append(task[2]) #period
+	tsk.append(0) #intr_cnt
+	return tsk
+
+def gen_slotshift_table(nsets, compute, deadline, period, target_util):
+	"""
+	Args:
+	- `nsets`: Number of tasksets to generate.
+	- `compute`: Maximum computation time of a task.
+	- `deadline`: Maximum slack time.
+	- `period`: Maximum delay after the deadline.
+	- `target_util`: Total utilization to reach.
+	"""
+	i = 0
+	job_lst = []
+	tsks_lst = []
+	#tsk_set = gen_ripoll(nsets, compute, deadline, period, target_util)
+	tsk_set = [[(2,9,3), (5,13,4), (1,17,13)]]
+	print "task_set : {}".format(tsk_set)
+	hp = get_hyperperiod(tsk_set[0])
+	print "hyper period {}".format(hp)
+
+	tsk_cnt = len(tsk_set[0])
+	while i < tsk_cnt:
+		tsk = gen_jobs(tsk_set[0][i], hp, i, job_lst)
+		tsks_lst.append(tsk)
+		i += 1
+	job_lst.sort(key=itemgetter(3))
+	print "job_lst {}".format(job_lst)
+	print "tsk_lst {}",format(tsks_lst)
+	intr_lst = gen_slotshifting_intervals(job_lst, tsks_lst)
+	return(len(tsks_lst), tsks_lst, len(intr_lst), intr_lst)
+
+"""
+TEST CODE
+"""
+t = gen_slotshift_table(1, 1,2 , 2, .5)
+