3 files changed, 244 insertions, 231 deletions

diff --git a/unit-trace b/unit-trace
index 002625a..52fad4e 100755
--- a/unit-trace
+++ b/unit-trace
@@ -111,7 +111,7 @@ if options.progress is True:
 #    stream = gedf_test.gedf_test(stream)
 
 # Produce C-EDF error records
-if options.cedf is True:
+if options.cedf is True and options.maxnum > 0:
     from unit_trace import cedf_test
     stream = cedf_test.cedf_test(stream,options.csize,options.maxnum)
 
@@ -165,10 +165,10 @@ if options.dist is True:
         #cedf_stat_printer.cedf_stat_printer(stream9,options.cdf_unit,False,1,"Work_Item_inversion",options.out_file)
 
         
-        #cedf_stat_printer.cedf_stat_printer(stream5,options.cdf_unit,False,0,"Tasklet_simultaneous",options.out_file) 
+        cedf_stat_printer.cedf_stat_printer(stream5,options.cdf_unit,False,0,"Tasklet_simultaneous",options.out_file) 
         #cedf_stat_printer.cedf_stat_printer(stream12,options.cdf_unit,False,1,"Tasklet_simultaneous",options.out_file)
 
-        #cedf_stat_printer.cedf_stat_printer(stream6,options.cdf_unit,False,0,"Work_Item_simultaneous",options.out_file)
+        cedf_stat_printer.cedf_stat_printer(stream6,options.cdf_unit,False,0,"Work_Item_simultaneous",options.out_file)
         #cedf_stat_printer.cedf_stat_printer(stream15,options.cdf_unit,False,1,"Work_Item_simultaneous",options.out_file)
 
         
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