Skip to content

Commit

Permalink
CAPACITY SHIFTING
Browse files Browse the repository at this point in the history
  • Loading branch information
@gokulvasan
gokulvasan committed May 17, 2016
1 parent 2a8f550 commit 1aad710
Show file tree
Hide file tree
Showing 6 changed files with 139 additions and 56 deletions.
31 changes: 17 additions & 14 deletions SlotShifting.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,9 +7,9 @@ def init(self):
self.interval = self.data
self.curr_job = None
print " IN SCHEDULER"
self.interval.print_def_interval()
#self.interval.print_def_interval()
self.state = state()
self.quantum = self.sim.cycles_per_ms * 5
self.quantum = 5
self.start = 0

def on_activate(self, job):
Expand All @@ -23,8 +23,9 @@ def on_activate(self, job):
if self.start == 0:
self.start = 1
self.time = chronos(self.sim,
self.processors[0],
time_progress_discrete(self.quantum))
self.processors[0],
time_progress_continous(self.interval.nxt_decn))
#time_progress_discrete(self.quantum))

#print "job got activated {}".format(job.name)
if job.task.data.set_current_job(job.task._job_count) > 0:
Expand All @@ -33,10 +34,11 @@ def on_activate(self, job):
print "Adding job Failed"
else:
print "job cannot be added as certainity ended"

self.processors[0].resched()
def on_terminated(self, job):
print "::::::::::::job terminated {} c: {}".format(job.name, job.computation_time)
self.state.rmv_job(job)
self.processors[0].resched()

def schedule(self, cpu):
"""
Expand All @@ -45,19 +47,20 @@ def schedule(self, cpu):
3. run EDF on ready_list
"""
if self.time.in_sched == 0:
return None
print ">>>>>SCHED "
while self.state.transit_unconcluded_tsk(self.interval.aperiodic_test):
print "Acceptance test"

self.curr_job = self.state.selection_function()
return self.curr_job
print ">>>>>SCHED ", self.sim.now_ms()
if self.curr_job:
print("selected job : %s %.3f ms" % (self.curr_job.name, self.curr_job.computation_time))
print("prev selected job : %s %.3f ms" % (self.curr_job.name, self.curr_job.computation_time))
tsk = self.curr_job.task
else:
print "selected job is None"
print "prev selected job is None"
tsk = None
#self.time.get_curr_time
self.interval.update_intr(self.sim.now_ms(), tsk)

self.interval.update_intr(self.time.get_curr_time, tsk)
while self.state.transit_unconcluded_tsk(self.interval.aperiodic_test):
print "Acceptance test"

self.curr_job = self.state.selection_function()

return (self.curr_job, self.processors[0])
98 changes: 74 additions & 24 deletions interval.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -74,7 +74,6 @@ def end(self):
return self.end
@property
def sc(self):
print "setting interval"
return self.sc
def set_sc(self, val):
self.sc = int(val)
Expand All @@ -88,7 +87,7 @@ def __init__(self):
self.curr_interval=None
self.intr_count=0
self.intr_list = ss_list.locallist()
self.curr_point = None #works like generator
self.curr_point = None #works like generator

def new_intr_append(self, intr_id, start, end, sc):
"""
Expand Down Expand Up @@ -162,7 +161,7 @@ def get_curr_interval(self):
# return self.intr_list.get_data(self.curr_interval)
#return None
return self.curr_interval

def get_intr_count(self):
return self.intr_count

Expand All @@ -171,14 +170,18 @@ def intr_reverse(self):

def intr_list(self):
return self.intr_list

def get_last_intr(self):
head = self.intr_list.get_head()
return head.get_prev().get_data()

def check_set_curr_interval(self, time_progressed):

curr_intr = self.curr_interval
if None == curr_intr:
return None

if time_progressed >= curr_intr.end:
if time_progressed > curr_intr.end:
curr_intr = self.goto_nxt_interval(None)
if None == curr_intr:
return None
Expand All @@ -202,15 +205,16 @@ def update_intr(self, time_progressed, task):
We have reached point of uncertainity so return
"""
if None == task.data.curr_intr:
return
return None

if 0 != self.check_set_curr_interval(time_progressed):
if self.update_sc(time_progressed, task) < 0:
return None
if self.update_sc(task) < 0:
if 0 != self.check_set_curr_interval(time_progressed):
return None

return 1

def update_sc(self, task):
def update_sc(self, time_progressed, task):
"""
Original update_sc
"""
Expand Down Expand Up @@ -277,18 +281,18 @@ def split_intr(self, intr_right, split_point, time_progressed):

if intr_right == self.curr_interval:
new_intr_start = time_progresed
else:
else:
new_intr_start = intr_right.start

new_intr_sc = (split_point - new_intr_start) + 1

intr_right.start = split_point + 1
intr_right.sc = intr.sc - new_intr_sc
new_intr_sc = new_intr_sc - min(0, intr_right.sc)

curr_point = self.get_curr_iterator()
insert_node = self.intr_list.go_prev(curr_point)

intr_left = new_intr_insert(new_intr_id,
new_intr_start,
new_intr_end,
Expand Down Expand Up @@ -366,12 +370,57 @@ def __print_intr(self, node):
class deferred_interval(interval):
def __init__(self):
super(deferred_interval, self).__init__()
self.sched_time = -1 # holds scheduled time progressed
self.time_diff = 0 # holds difference of prev time and curr
self.time_movt = 1
print "creating deferred interval"
def nxt_decn(self):
"""
This Function is written with assumption that it will be called before
update_intr function is called, if called other way then the solution
is pretty straight forward.
returns relative value from previous decision
"""
if self.curr_interval == None:
return 0
elif self.curr_interval == self.intr_list.get_head().get_data() and self.time_movt:
self.time_movt = 0
return self.curr_interval.end
else:
intr = self.intr_list.go_nxt(self.curr_point)
if intr == self.intr_list.get_head():
return 0
else:
timeout = (intr.get_data().end - self.curr_point.get_data().end)
return timeout
def update_tsk_intr(self, run_time, tsk_intr):
if tsk_intr.sc < 0:
tsk_intr.sc += run_time
if tsk_intr.sc > 0:
tsk_intr.update_val += (run_time - tsk_intr.sc)
return tsk_intr.sc
else:
tsk_intr.update_val += run_time
return 0
else:
tsk_intr.sc += run_time
return 0

def update_sc(self, task):
def update_sc(self, time_progressed, task):
"""
Simply update slots, O(1)
"""
if self.curr_interval == None:
return 0

if self.sched_time < 0:
self.sched_time = time_progressed
return 0
else:
self.time_diff = time_progressed - self.sched_time
self.sched_time = time_progressed

print "TIME DIFF:", self.time_diff
if task:
task_data = task.data
intr_task = task_data.curr_intr
Expand All @@ -387,25 +436,25 @@ def update_sc(self, task):
return 0

tsk_intr_sc = intr_task_data.sc
if intr_task_data.sc < 0:
print "task intr is negative so updating updat-val"
intr_task_data.update_val += 1
intr_task_data.sc += 1

# ERROR: Here is the error
#if intr_task_data.sc < 0:
#print "task intr is negative so updating updat-val"
#intr_task_data.update_val += self.time_diff
#intr_task_data.sc += self.time_diff
curr_intr_update = self.update_tsk_intr(self.time_diff, intr_task_data)
if ( (None == self.curr_interval.lender)
or (None == intr_task_data.lender) ):
print " GOING forward to negate"
#print " GOING forward to negate"
pass
elif ( (self.curr_interval.lender == intr_task_data.lender) and
(tsk_intr_sc < 0)):
print "task lender is current interval and negative"
print "task lender is current interval and negative"
self.curr_interval.sc -= curr_intr_update
return 0
else:
print "GOING forward to negate the current interval"

print "BFORE: negating SC {} ID{}".format(self.curr_interval.sc, self.curr_interval.id)
self.curr_interval.sc -= 1
#print "BFORE: negating SC {} ID{}".format(self.curr_interval.sc, self.curr_interval.id)
self.curr_interval.sc -= self.time_diff
print " AFTER: curr interval SC is {} id{}".format(self.curr_interval.sc, self.curr_interval.id)
return 0

Expand Down Expand Up @@ -459,12 +508,13 @@ def check_set_curr_interval(self, time_progressed):

if time_progressed >= curr_intr.end:
print "============MOVING TO NXT INTR: START==============="
#print "NXT DECN CHECK:",self.nxt_decn
print "Curr interval {} end{} SC{}".format(curr_intr.id, curr_intr.end, curr_intr.sc)
nxt_curr_intr = self.goto_nxt_interval(None)
self.set_curr_interval(nxt_curr_intr)
if None == nxt_curr_intr:
return None
print "Moving curr interval to:id {} SC{} end{}, time_progress {}".format(nxt_curr_intr.id, nxt_curr_intr.sc, nxt_curr_intr.end, time_progressed)
print "Moving curr interval to:id {} SC{} start{} end{}, time_progress {}".format(nxt_curr_intr.id, nxt_curr_intr.sc, nxt_curr_intr.start, nxt_curr_intr.end, time_progressed)
rec = self.deferred_update(nxt_curr_intr)
if curr_intr.lent_till == nxt_curr_intr.lent_till:
curr_intr.sc -= rec
Expand Down
43 changes: 34 additions & 9 deletions ss_chronos.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,14 +3,13 @@
class time_progress(object):
def __init__(self, time):
self.time = time

@property
def curr_time(self):
pass
@property
def nxt_decn(self):
return 0
def update_curr_time(self):
def update_curr_time(self, time):
pass

def reset_decn(self):
Expand All @@ -20,6 +19,27 @@ def set_decn(self):
@property
def decn(self):
pass
class time_progress_continous(time_progress):

def __init__(self, time):
time_progress.__init__(self, time)
self.time_progress = -1
@property
def curr_time(self):
return self.time_progress
@property
def nxt_decn(self):
return self.time()
@property
def decn(self):
return 1
def reset_decn(self):
pass
def set_decn(self):
pass
def update_curr_time(self, time):
self.time_progress = time
#print " >>>>TIME: ", self.slot_count * self.time

class time_progress_discrete(time_progress):

Expand All @@ -43,9 +63,9 @@ def reset_decn(self):
def set_decn(self):
self.slot_boundary = 1

def update_curr_time(self):
def update_curr_time(self, time):
self.slot_count += 1
print " >>>>TIME: ", self.slot_count * self.time
#print " >>>>TIME: ", self.slot_count * self.time
@property
def curr_time(self):
return self.slot_count
Expand All @@ -56,20 +76,25 @@ def __init__(self, sim, proc_id, time_progress):
self.cpu = proc_id
self.sim = sim
super(chronos, self).__init__( self.sim, chronos.decision,
(self, ), self.time.nxt_decn,
(self, ), 1,
in_ms=False, one_shot=True, cpu=self.cpu)
self.decision()

def decision(self, cpu=None):
if cpu is None:
proc_id = self.cpu
self.time.update_curr_time()
self.time.update_curr_time(self.sim.now_ms())
self.time.set_decn()
self.delay = self.time.nxt_decn
nxt_decn = self.time.nxt_decn
print "<<<<<<<<<<<<<<NXT DECN>>>>>>>>",nxt_decn
self.delay = (nxt_decn * self.sim.cycles_per_ms)
print "Timer Activation : nxt{} curr{}".format(self.delay, self.get_curr_time)
print ">>>>SIM:",self.sim.now_ms()
self.start()
proc_id.resched()
if self.delay:
self.start()
proc_id.resched()
else:
self.stop()

@property
def is_resched(self):
Expand Down
11 changes: 8 additions & 3 deletions ss_conf_table.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,6 +55,7 @@ def __recv_intr(self):
intr_node = self.__recv(intr_fmt)
self.intr.append(intr_node)
i = i + 1
self.intr.reverse()

def __recv(self, fmt):
data = self.__sock.recv(256)
Expand Down Expand Up @@ -238,9 +239,10 @@ def create_relation_window(self, interval):
# here check for the correctness
print "============printing deferred interval============="
interval.print_def_interval()
print "==========setting CURRENT INTR"
interval.reset_iterator()
curr_intr = interval.goto_nxt_interval(1)
interval.set_curr_interval(curr_intr.get_data())
print "==========setting CURRENT INTR",interval.curr_interval.id
interval.set_iterator(curr_intr)
"""
Creates deferred_interval object
Expand All @@ -250,15 +252,18 @@ def create_def_intr_list(self):
i = deferred_interval()
while self.intr_idx < self.rcvr.intr_cnt:
intr = self.rcvr.intr[self.intr_idx]
i.new_intr_append(intr[0],intr[1],intr[2],intr[3])
i.new_intr_append(intr[0],intr[1]*5,intr[2]*5,intr[3]*5)
self.intr_idx += 1
i.print_intr_list()
#print "=============NOW REVERSING==========="
#i.intr_reverse()
i.print_intr_list()

return i

def get_running_time(self, intr):
last_intr = intr.get_last_intr()
return ((last_intr.end + 1) * 5)

"""
class client:
def __init__(self):
Expand Down
Loading

0 comments on commit 1aad710

Please sign in to comment.