From 9c7329f6c8fb07e557bbb0c4e526b99dbbcdd1f9 Mon Sep 17 00:00:00 2001 From: chsun Date: Thu, 28 Apr 2011 19:20:02 -0400 Subject: Put back detection for simultaneous --- unit_trace/cedf_test.py | 386 +++++++++++++++++++++---------------------- unit_trace/stdout_printer.py | 83 ++++++---- 2 files changed, 241 insertions(+), 228 deletions(-) (limited to 'unit_trace') diff --git a/unit_trace/cedf_test.py b/unit_trace/cedf_test.py index d09d001..7d9cc77 100644 --- a/unit_trace/cedf_test.py +++ b/unit_trace/cedf_test.py @@ -66,12 +66,7 @@ def cedf_test(stream,csize,number): # All records with when ==0 are garbage if record.when == 0: continue - #if processing count reach number(maximum) start to process - if number > 0: - number -= 1 - elif number == 0: - break - + #yield record #continue @@ -83,7 +78,7 @@ def cedf_test(stream,csize,number): if last_time is not None and last_time != record.when: # check PI for tasklet - errors = _cedf_check_irq( + errors = _cedf_check_irq_inversion( off_cpu,on_cpu, tasklet_on_cpu,work_on_cpu, tasklet_off_cpu,tasklet_on_cpu, @@ -91,15 +86,19 @@ def cedf_test(stream,csize,number): first_event_this_timestamp, "Tasklet") for error in errors: yield error - # check Simultaneous execution of tasklet and owner - #errors = _cedf_check_tasklet_simultaneous(off_cpu,on_cpu, - # tasklet_off_cpu,tasklet_on_cpu,last_time,csize, - # first_event_this_timestamp) - #for error in errors: - # yield error + + # check Simultaneous for tasklet + errors = _cedf_check_irq_simultaneous( + off_cpu,on_cpu, + tasklet_on_cpu,work_on_cpu, + tasklet_off_cpu,tasklet_on_cpu, + last_time,csize, + first_event_this_timestamp, "Tasklet") + for error in errors: + yield error # check PI for work item - errors = _cedf_check_irq( + errors = _cedf_check_irq_inversion( off_cpu,on_cpu, tasklet_on_cpu,work_on_cpu, work_off_cpu,work_on_cpu, @@ -108,12 +107,16 @@ def cedf_test(stream,csize,number): for error in errors: yield error - # check Simultaneous execution of work item and owner - #errors = _cedf_check_work_simultaneous(off_cpu,on_cpu, - # work_off_cpu,work_on_cpu,last_time,csize, - # first_event_this_timestamp) - #for error in errors: - # yield error + # check Simultaneous for work item + errors = _cedf_check_irq_simultaneous( + off_cpu,on_cpu, + tasklet_on_cpu,work_on_cpu, + work_off_cpu,work_on_cpu, + last_time,csize, + first_event_this_timestamp, "Work_Item") + for error in errors: + yield error + # check PI for task for c in range(0,int(m/csize)): @@ -178,6 +181,7 @@ def cedf_test(stream,csize,number): msg = msg % (record.id,record.pid) print msg #sys.stderr.write(msg) + yield record #exit() continue @@ -204,7 +208,7 @@ def cedf_test(stream,csize,number): " that was not running\n") msg = msg % (record.id, record.pid) print msg - #sys.stderr.write(msg) + #sys.stderr.write(msg) #exit() yield record continue @@ -229,6 +233,7 @@ def cedf_test(stream,csize,number): msg = msg % (record.id,record.pid) print msg #sys.stderr.write(msg) + yield record #exit() continue off_cpu[pos].is_blocked =True @@ -248,6 +253,7 @@ def cedf_test(stream,csize,number): msg = msg % (record.id,record.pid) print msg #sys.stderr.write(msg) + yield record #exit() continue off_cpu[pos].is_blocked = False @@ -303,6 +309,7 @@ def cedf_test(stream,csize,number): msg = msg % (record.id, record.pid) print msg #sys.stderr.write(msg) + yield record #exit() #Continue see if anything wrong continue job = tasklet_off_cpu[pos] @@ -320,6 +327,7 @@ def cedf_test(stream,csize,number): msg = msg % (record.id, record.pid) print msg #sys.stderr.write(msg) + yield record #exit() #Continue see if anything wrong continue job = work_off_cpu[pos] @@ -335,6 +343,7 @@ def cedf_test(stream,csize,number): " that was not running\n") msg = msg % (record.id, record.pid) print msg + yield record #sys.stderr.write(msg) pos = _find_job(record,tasklet_off_cpu) if pos is not None: @@ -359,6 +368,7 @@ def cedf_test(stream,csize,number): " that was not running\n") msg = msg % (record.id, record.pid) print msg + yield record #sys.stderr.write(msg) pos = _find_job(record,work_off_cpu) if pos is not None: @@ -374,34 +384,38 @@ def cedf_test(stream,csize,number): del work_on_cpu[pos] # a Task has Priority inheritance - #elif record.type_name == 'eff_prio_change': - # inh_pos = _find_inh_job(record,off_cpu) - # if inh_pos is None: - # inh_pos = _find_inh_job(record,on_cpu) - # if inh_pos is not None: - # inh_job = on_cpu[inh_pos] - # else: - # inh_job = off_cpu[inh_pos] - # - # pos = _find_job(record,on_cpu) - # if pos is None: - # pos = _find_job(record,off_cpu) - # if pos is None: - # msg = ("Event %d tried to change a jobs priority " + - # " that cannot found\n") - # msg = msg % (record.id) - # sys.stderr.write(msg) - # #exit() #Continue see if anything wrong - # continue - # if inh_pos is not None: - # off_cpu[pos].inh_deadline = inh_job.deadline - # else: - # off_cpu[pos].inh_deadline = off_cpu[pos].deadline - # else: - # if inh_pos is not None: - # on_cpu[pos].inh_deadline = inh_job.deadline - # else: - # on_cpu[pos].inh_deadline = on_cpu[pos].deadline + elif record.type_name == 'eff_prio_change': + inh_pos = _find_inh_job(record,off_cpu) + if inh_pos is None: + inh_pos = _find_inh_job(record,on_cpu) + if inh_pos is not None: + inh_job = on_cpu[inh_pos] + else: + inh_job = off_cpu[inh_pos] + + pos = _find_job(record,on_cpu) + if pos is None: + pos = _find_job(record,off_cpu) + if pos is None: + msg = ("Event %d tried to change a jobs %d priority " + + " that cannot found\n") + msg = msg % (record.id,record.pid) + print msg + #sys.stderr.write(msg) + yield record + #exit() #Continue see if anything wrong + continue + if inh_pos is not None: + off_cpu[pos].base_deadline = off_cpu[pos].deadline + off_cpu[pos].deadline = inh_job.deadline + else: + off_cpu[pos].deadline = off_cpu[pos].base_deadline + else: + if inh_pos is not None: + on_cpu[pos].base_deadline = on_cpu[pos].deadline + on_cpu[pos].deadline = inh_job.deadline + else: + on_cpu[pos].deadline = on_cpu[pos].base_deadline else: continue # illegal event @@ -415,6 +429,11 @@ def cedf_test(stream,csize,number): start_time = time.time() count = record.id + #if processing count reach number(maximum) start to process + if record.id > number: + break + + yield record @@ -431,7 +450,7 @@ class Job(object): self.cpu = record.cpu # for target cpu (-1: not assigned yet) self.cluster = -1 # for target cluster (-1: not assigned yet) self.deadline = None - #self.inh_deadline = None + self.base_deadline = None self.exe_pid = -1 # handleing klitthread (-1: not assigned yet) self.is_complete = False self.is_blocked = False @@ -439,10 +458,11 @@ class Job(object): self.inversion_end = None self.inversion_start_id = None self.inversion_start_triggering_event_id = None - #self.simultaneous_start = None - #self.simultaneous_end = None - #self.simultaneous_start_id = None - #self.simultaneous_start_triggering_event_id = None + + self.simultaneous_start = None + self.simultaneous_end = None + self.simultaneous_start_id = None + self.simultaneous_start_triggering_event_id = None def __str__(self): return "(%d.%d:%d)" % (self.pid,self.job,self.deadline) @@ -470,24 +490,26 @@ class Error(object): # C-EDF errors: the start or end of a simultaneous execution of owner and tasklet(work_item) -#class Error_simultaneous(object): -# id = 0 -# def __init__(self, job, c, first_event_this_timestamp,irq_type): -# Error_simultaneous.id += 1 -# self.error_type = "simultaneous" -# self.id = Error_simultaneous.id -# self.job = copy.copy(job) -# self.cluster = c -# self.record_type = 'error' -# self.triggering_event_id = first_event_this_timestamp -# if job.simultaneous_end is None: -# self.type_name = irq_type+'_simultaneous_start' -# job.simultaneous_start_id = self.id -# job.simultaneous_start_triggering_event_id = self.triggering_event_id -# else: -# self.type_name = irq_type+'_simultaneous_end' -# self.simultaneous_start_id = job.simultaneous_start_id -# self.simultaneous_start_triggering_event_id = job.simultaneous_start_triggering_event_id +class Error_simultaneous(object): + id = 0 + def __init__(self, job, off_cpu, on_cpu,first_event_this_timestamp,irq_type): + Error_simultaneous.id += 1 + self.error_type = "simultaneous" + self.id = Error_simultaneous.id + self.job = copy.copy(job) + self.off_cpu = copy.copy(off_cpu) + self.on_cpu = copy.copy(on_cpu) + self.record_type = 'error' + self.triggering_event_id = first_event_this_timestamp + if job.simultaneous_end is None: + self.type_name = irq_type+'_simultaneous_start' + job.simultaneous_start_id = self.id + job.simultaneous_start_triggering_event_id = self.triggering_event_id + else: + self.type_name = irq_type+'_simultaneous_end' + self.simultaneous_start_id = job.simultaneous_start_id + self.simultaneous_start_triggering_event_id = job.simultaneous_start_triggering_event_id + #insert into cluster map def _insert_cluster_map(job, cluster_map): @@ -531,11 +553,11 @@ def _find_irq_carrier(job,list): return None # Returns the position of a inheritanced Job in a list, or None -#def _find_inh_job(record,list): -# for i in range(0,len(list)): -# if list[i].pid == record.inh_pid: -# return i -# return None +def _find_inh_job(record,list): + for i in range(0,len(list)): + if list[i].pid == record.inh_pid: + return i + return None # Return True if owner in off_cpu or on_cpu def _is_owner(record,off_cpu,on_cpu): @@ -630,8 +652,8 @@ def _cedf_check(c, return errors -# Return records for any inversion_starts and inversion_ends -def _cedf_check_irq( +# Return records for any inversion_start and inversion_end +def _cedf_check_irq_inversion( off_cpu,on_cpu, tasklet_on_cpu, work_on_cpu, irq_off_cpu,irq_on_cpu, @@ -694,7 +716,7 @@ def _cedf_check_irq( errors.append(Error(irq, off_cpu, on_cpu, first_event_this_timestamp,irq_type)) irq.inversion_start = None - irq.inversion_end = None + irq.inversion_end = None # have klitirqd take care of (already work_begin or tasklet_begin and assinged a klitthread) for irq in irq_on_cpu: @@ -717,20 +739,22 @@ def _cedf_check_irq( pos = _find_job(irq,all) _on = _find_job(irq,on_cpu) + klit_pos = _find_irq_carrier(irq,on_cpu) # owner task is completed (weird!!!) - if pos is None and irq.inversion_start is not None: - irq.inversion_end = when - errors.append(Error(irq, off_cpu, on_cpu, - first_event_this_timestamp,irq_type)) - irq.inversion_start = None - irq.inversion_end = None + if pos is None : + if irq.inversion_start is not None: + irq.inversion_end = when + errors.append(Error(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + irq.inversion_start = None + irq.inversion_end = None + elif pos is not None: # look for priorit of owner task # owner task is m-priority task in the cluster if pos in range(0,min(csize,len(all))): # owner task is not running - if _on is None: - klit_pos = _find_irq_carrier(irq,on_cpu) + if _on is None: # if the klitirqd task is running and is not blocked if klit_pos is not None and on_cpu[klit_pos].is_blocked is False: if irq.inversion_start is not None: @@ -739,12 +763,16 @@ def _cedf_check_irq( first_event_this_timestamp,irq_type)) irq.inversion_start = None irq.inversion_end = None - #if the klitirqd task is not running or blocked + + + #if the klitirqd task is not running or blocked (Or in noirqd case) else: if irq.inversion_start is None: irq.inversion_start = when errors.append(Error(irq, off_cpu, on_cpu, - first_event_this_timestamp,irq_type)) + first_event_this_timestamp,irq_type)) + + else: # here is very weird situation becasue owner must be blocked if irq.inversion_start is not None: @@ -754,116 +782,78 @@ def _cedf_check_irq( irq.inversion_start = None irq.inversion_end = None + + # owner task is not m-priority task in the cluster elif pos in range(csize,len(all)): - if irq.inversion_start is not None: - irq.inversion_end = when - errors.append(Error(irq, off_cpu, on_cpu, - first_event_this_timestamp,irq_type)) - irq.inversion_start = None - irq.inversion_end = None + if _on is None: + # if the klitirqd task is running and is not blocked + if klit_pos is not None and on_cpu[klit_pos].is_blocked is False: + if irq.inversion_start is None: + irq.inversion_start = when + errors.append(Error(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + #if the klitirqd task is not running or blocked (Or in noirqd case) + else: + if irq.inversion_start is not None: + irq.inversion_end = when + errors.append(Error(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + irq.inversion_start = None + irq.inversion_end = None + + + else: + # here is very weird situation becasue owner must be blocked + # don't count into tasklet inversion but task inversion + if irq.inversion_start is not None: + irq.inversion_end = when + errors.append(Error(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + irq.inversion_start = None + irq.inversion_end = None + return errors + +# Return records for any simultaneous_start and simultaneous_end +def _cedf_check_irq_simultaneous( + off_cpu,on_cpu, + tasklet_on_cpu, work_on_cpu, + irq_off_cpu,irq_on_cpu, + when,csize, + first_event_this_timestamp, irq_type): + # List of error records to be returned + errors = [] + + #Look for all irq is irq_off_cpu (not assign klitithread yet) + for irq in irq_off_cpu: + if irq.simultaneous_start is not None: + irq.simultaneous_end = when + errors.append(Error_simultaneous(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + irq.simultaneous_start = None + irq.simultaneous_end = None -# Return records for any inversion_starts and inversion_ends -#def _cedf_check_work_simultaneous(off_cpu,on_cpu, -# work_off_cpu,work_on_cpu, -# when,csize,first_event_this_timestamp): -# -# # List of error records to be returned -# errors = [] -# -# #Look for all work is work_off_cpu (not running) -# for work in work_off_cpu: -# # find owner's cpu -# owner_cpu = _get_cpu(work,off_cpu,on_cpu,"Work_Item") -# if owner_cpu is None: -# work_off_cpu.remove(work) -# continue -# -# if work.simultaneous_start is not None: -# work.simultaneous_end = when -# errors.append(Error_simultaneous(tasklet, int(owner_cpu/csize), -# first_event_this_timestamp,"Work_Item")) -# work.simultaneous_start = None -# work.simultaneous_end = None -# -# # have klitirqd take care of -# for work in work_on_cpu: -# # find owner's cpu -# owner_cpu = _get_cpu(work,off_cpu,on_cpu,"Work_Item") -# if owner_cpu is None: -# work_on_cpu.remove(work) -# continue -# klit_pos = _find_work_carrier(work,on_cpu) -# # if the klitirqd task is running and is not blocked -# if klit_pos is not None and on_cpu[klit_pos].is_blocked is False: -# _on = _find_job(work,on_cpu) -# # owner task is running -# if _on is not None and on_cpu[_on].is_complete is not True and on_cpu[_on].is_blocked is not True: -# if work.simultaneous_start is None: -# work.simultaneous_start = when -# errors.append(Error_simultaneous(work,int(owner_cpu/csize), -# first_event_this_timestamp,"Work_Item")) -# continue -# -# if work.simultaneous_start is not None: -# work.simultaneous_end = when -# errors.append(Error_simultaneous(work, int(owner_cpu/csize), -# first_event_this_timestamp,"Work_Item")) -# work.simultaneous_start = None -# work.simultaneous_end = None -# -# -# return errors - - -# Return records for any inversion_starts and inversion_ends -#def _cedf_check_tasklet_simultaneous(off_cpu,on_cpu, -# tasklet_off_cpu, tasklet_on_cpu, -# when,csize,first_event_this_timestamp): -# -# # List of error records to be returned -# errors = [] -# -# #Look for all tasklet is tasklet_off_cpu (not running) -# for tasklet in tasklet_off_cpu: -# # find owner's cpu -# owner_cpu = _get_cpu(tasklet,off_cpu,on_cpu,"Tasklet") -# if owner_cpu is None: -# tasklet_off_cpu.remove(tasklet) -# continue -# -# if tasklet.simultaneous_start is not None: -# tasklet.simultaneous_end = when -# errors.append(Error_simultaneous(tasklet, int(owner_cpu/csize), -# first_event_this_timestamp,"Tasklet")) -# tasklet.simultaneous_start = None -# tasklet.simultaneous_end = None -# -# -# #Look for all tasklet is tasklet_on_cpu (running) -# for tasklet in tasklet_on_cpu: -# # find owner's cpu -# owner_cpu = _get_cpu(tasklet,off_cpu,on_cpu,"Tasklet") -# if owner_cpu is None: -# tasklet_on_cpu.remove(tasklet) -# continue -# _on = _find_job(tasklet,on_cpu) -# # owner task is running -# if _on is not None and on_cpu[_on].is_complete is not True and on_cpu[_on].is_blocked is not True: -# if tasklet.simultaneous_start is None: -# tasklet.simultaneous_start = when -# errors.append(Error_simultaneous(tasklet,int(owner_cpu/csize), -# first_event_this_timestamp,"Tasklet")) -# else: -# if tasklet.simultaneous_start is not None: -# tasklet.simultaneous_end = when -# errors.append(Error_simultaneous(tasklet, int(owner_cpu/csize), -# first_event_this_timestamp,"Tasklet")) -# tasklet.simultaneous_start = None -# tasklet.simultaneous_end = None -# -# return errors - - + # have klitirqd take care of (already work_begin or tasklet_begin and assinged a klitthread) + for irq in irq_on_cpu: + _on = _find_job(irq,on_cpu) + klit_pos = _find_irq_carrier(irq,on_cpu) + if _on is None: + if irq.simultaneous_start is not None: + irq.simultaneous_end = when + errors.append(Error_simultaneous(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + irq.simultaneous_start = None + irq.simultaneous_end = None + else: + # here is very weird situation becasue owner must be blocked + if klit_pos is not None and on_cpu[klit_pos].is_blocked is False: + if irq.simultaneous_start is None: + irq.simultaneous_start = when + errors.append(Error_simultaneous(irq, off_cpu, on_cpu, + first_event_this_timestamp,irq_type)) + + return errors + + diff --git a/unit_trace/stdout_printer.py b/unit_trace/stdout_printer.py index 2e4c783..111e0d1 100644 --- a/unit_trace/stdout_printer.py +++ b/unit_trace/stdout_printer.py @@ -25,16 +25,14 @@ def stdout_printer(stream,csize): elif record.record_type == "error" and record.type_name == 'Work_Item_inversion_end': _print_inversion_end(csize,record,"Work_Item_") - #elif record.record_type == "error" and record.type_name == 'Tasklet_simultaneous_start': - # _print_simultaneous_start(csize,record,"Tasklet_") - #elif record.record_type == "error" and record.type_name == 'Tasklet_simultaneous_end': - # _print_simultaneous_end(csize,record,"Tasklet_") - #elif record.record_type == "error" and record.type_name == 'Work_Item_simultaneous_start': - # _print_simultaneous_start(csize,record,"Work_Item_") - #elif record.record_type == "error" and record.type_name == 'Work_Item_simultaneous_end': - # _print_simultaneous_end(csize,record,"Work_Item_") - - + elif record.record_type == "error" and record.type_name == 'Tasklet_simultaneous_start': + _print_simultaneous_start(csize,record,"Tasklet_") + elif record.record_type == "error" and record.type_name == 'Tasklet_simultaneous_end': + _print_simultaneous_end(csize,record,"Tasklet_") + elif record.record_type == "error" and record.type_name == 'Work_Item_simultaneous_start': + _print_simultaneous_start(csize,record,"Work_Item_") + elif record.record_type == "error" and record.type_name == 'Work_Item_simultaneous_end': + _print_simultaneous_end(csize,record,"Work_Item_") else: continue print "" @@ -103,25 +101,50 @@ def _print_inversion_end(csize,record,pi_type): print str(job) + " ", print #newline -#def _print_simultaneous_start(csize,record,irq_type): -# print "Type: %s" % (irq_type+"Simultaneous start") -# print "Inversion Record IDs: (%d, U)" % (record.id) -# print "Triggering Event IDs: (%d, U)" % (record.triggering_event_id) -# print "Time: %d" % (record.job.simultaneous_start) -# print "Job: %d.%d" % (record.job.pid,record.job.job) +def _print_simultaneous_start(csize,record,irq_type): + print "Type: %s" % (irq_type+"Simultaneous start") + print "Inversion Record IDs: (%d, U)" % (record.id) + print "Triggering Event IDs: (%d, U)" % (record.triggering_event_id) + print "Time: %d" % (record.job.simultaneous_start) + print "Job: %d.%d" % (record.job.pid,record.job.job) + print "Deadline: %d" % (record.job.deadline) + print "Cluster: %d" % (record.job.cluster) + print "Handling Klit thread: %d" % (record.job.exe_pid) + print "Off CPU: ", + for job in record.off_cpu: + if job.cluster==record.job.cluster : + print str(job) + " ", + print + print "On CPU: ", + for job in record.on_cpu: + if job.cluster==record.job.cluster : + print str(job) + " ", + print #newline -#def _print_simultaneous_end(csize,record,irq_type): -# print "Type: %s" % (irq_type+"Simultaneous end") -# print "Inversion record IDs: (%d, %d)" % (record.simultaneous_start_id, -# record.id) -# print("Triggering Event IDs: (%d, %d)" % -# (record.simultaneous_start_triggering_event_id, -# record.triggering_event_id)) -# print "Time: %d" % (record.job.simultaneous_end) -# # NOTE: Here, we assume nanoseconds as the time unit. -# # May have to be changed in the future. -# print "Duration: %f ms" % ( -# float(record.job.simultaneous_end - record.job.simultaneous_start)/1000000) -# print "Job: %d.%d" % (record.job.pid,record.job.job) - +def _print_simultaneous_end(csize,record,irq_type): + print "Type: %s" % (irq_type+"Simultaneous end") + print "Inversion record IDs: (%d, %d)" % (record.simultaneous_start_id, + record.id) + print("Triggering Event IDs: (%d, %d)" % + (record.simultaneous_start_triggering_event_id, + record.triggering_event_id)) + print "Time: %d" % (record.job.simultaneous_end) + # NOTE: Here, we assume nanoseconds as the time unit. + # May have to be changed in the future. + print "Duration: %f ms" % ( + float(record.job.simultaneous_end - record.job.simultaneous_start)/1000000) + print "Job: %d.%d" % (record.job.pid,record.job.job) + print "Deadline: %d" % (record.job.deadline) + print "Cluster: %d" % (record.job.cluster) + print "Handling Klit thread: %d" % (record.job.exe_pid) + print "Off CPU: ", + for job in record.off_cpu: + if job.cluster==record.job.cluster : + print str(job) + " ", + print + print "On CPU: ", + for job in record.on_cpu: + if job.cluster==record.job.cluster : + print str(job) + " ", + print #newline -- cgit v1.2.2