Supprot C-EDF Task Priorty Inversion, Tasklet Priorty Inversion, and Work Priorty Inversion.

Support New Feather Trace Event:
ST_TASKLET_RELEASE, ST_TASKLET_BEGIN, ST_TASKLET_END,
ST_WORK_RELEASE, ST_WORK_BEGIN, ST_WORK_END,
and, ST_EFF_PRIO_CHANGE

4 files changed, 406 insertions, 30 deletions

diff --git a/unit_trace/gedf_inversion_stat_printer.py b/unit_trace/gedf_inversion_stat_printer.py
index c35632a..5ea7916 100644
--- a/unit_trace/gedf_inversion_stat_printer.py
+++ b/unit_trace/gedf_inversion_stat_printer.py
@@ -8,7 +8,7 @@
 # Public Functions
 ###############################################################################
 
-def gedf_inversion_stat_printer(stream,num):
+def gedf_inversion_stat_printer(stream,num,pi_type):
 
     # State
     min_inversion = -1
@@ -19,7 +19,7 @@ def gedf_inversion_stat_printer(stream,num):
 
     # Iterate over records, updating state
     for record in stream:
-        if record.type_name == 'inversion_end':
+        if record.type_name == pi_type+'_inversion_end':
             length = record.job.inversion_end - record.job.inversion_start
             if length > 0:
                 num_inversions += 1
@@ -53,13 +53,13 @@ def gedf_inversion_stat_printer(stream,num):
     # Print out our information
     # NOTE: Here, we assume nanoseconds as the time unit.
     # May have to be changed in the future.
-    print "Num inversions: %d" % (num_inversions)
-    print "Min inversion: %f ms" % (float(min_inversion) / 1000000)
-    print "Max inversion: %f ms" % (float(max_inversion) / 1000000)
-    print "Avg inversion: %f ms" % (float(avg_inversion) / 1000000)
+    print "Num "+pi_type+ "_inversions: %d" % (num_inversions)
+    print "Min "+pi_type+ "_inversion: %f ms" % (float(min_inversion) / 1000000)
+    print "Max "+pi_type+ "_inversion: %f ms" % (float(max_inversion) / 1000000)
+    print "Avg "+pi_type+ "_inversion: %f ms" % (float(avg_inversion) / 1000000)
     for inv in longest_inversions:
         print ""
-        print "Inversion record IDs: (%d, %d)" % (inv.inversion_start_id,
+        print pi_type+"_Inversion record IDs: (%d, %d)" % (inv.inversion_start_id,
             inv.id)
         print("Triggering Event IDs: (%d, %d)" %
             (inv.inversion_start_triggering_event_id,
diff --git a/unit_trace/gedf_test.py b/unit_trace/gedf_test.py
index 478a852..7c2ed14 100644
--- a/unit_trace/gedf_test.py
+++ b/unit_trace/gedf_test.py
@@ -21,6 +21,13 @@ def gedf_test(stream):
     # System model
     on_cpu = []     # Tasks on a CPU
     off_cpu = []    # Tasks not on a CPU
+    
+    tasklet_off_cpu = [] # Tasklets on a CPU
+    tasklet_on_cpu = []  # Tasklets on a CPU
+    
+    work_off_cpu = [] # Work items on a CPU
+    work_on_cpu = []  # Work items on a CPU
+    
     m = None        # CPUs
 
     # Time of the last record we saw. Only run the G-EDF test when the time
@@ -45,16 +52,23 @@ def gedf_test(stream):
         # so we only check when the time has moved forward)
         # Also, need to update the first_event_this_timestamp variable
         if last_time is not None and last_time != record.when:
-            errors = _gedf_check(off_cpu,on_cpu,last_time,m,
-                first_event_this_timestamp)
-            first_event_this_timestamp = record.id
-            for error in errors:
-                yield error
+                        errors = _gedf_check(off_cpu,on_cpu,last_time,m,
+                                first_event_this_timestamp)
+                        errors += _gedf_check_tasklet(off_cpu,on_cpu,
+                                tasklet_off_cpu,tasklet_on_cpu,last_time,m,
+                                first_event_this_timestamp)
+                        errors += _gedf_check_work(off_cpu,on_cpu,
+                                work_off_cpu,work_on_cpu,last_time,m,
+                                first_event_this_timestamp)
+
+                        first_event_this_timestamp = record.id
+                        for error in errors:
+                                yield error
 
         # Add a newly-released Job to the off_cpu queue
         if record.type_name == 'release':
             off_cpu.append(Job(record))
-
+            
         # Move a Job from the off_cpu queue to on_cpu
         elif record.type_name == 'switch_to':
             pos = _find_job(record,off_cpu)
@@ -93,6 +107,8 @@ def gedf_test(stream):
             del on_cpu[pos]
             if job.is_complete == False:
                 off_cpu.append(job)
+                
+                
 
         # A job has been blocked.
         elif record.type_name == 'block':
@@ -114,6 +130,94 @@ def gedf_test(stream):
 
         last_time = record.when
         yield record
+        
+        # Add a newly-released Takslet to the tasklet_off_cpu queue
+        if record.type_name == 'tasklet_release':
+            tasklet_off_cpu.append(Job(record))
+                
+                # Move a Takslet from the tasklet_off_cpu queue to tasklet_on_cpu
+        elif record.type_name == 'tasklet_begin':
+            pos = _find_job(record,tasklet_off_cpu)
+            if pos is None:
+                msg = "Event %d tried to begin to a tasklet that was not on the"
+                msg += " tasklet_off_cpu queue\n"
+                msg = msg % (record.id)
+                sys.stderr.write(msg)
+                exit()
+            job = tasklet_off_cpu[pos]
+            del tasklet_off_cpu[pos]
+            tasklet_on_cpu.append(job)
+        
+       
+        # A Takslet is end from a CPU.
+        elif record.type_name == 'tasklet_end':
+            pos = _find_job(record,tasklet_on_cpu)
+            if pos is None:
+                msg = ("Event %d tried to end a tasklet" +
+                    " that was not running\n")
+                msg = msg % (record.id)
+                sys.stderr.write(msg)
+                exit()
+            job = tasklet_on_cpu[pos]
+            del tasklet_on_cpu[pos]
+            
+        # Add a newly-released Work item to the work_off_cpu queue
+        if record.type_name == 'work_release':
+            work_off_cpu.append(Job(record))
+                
+                # Register a klitirqd threadto a Work item in the work_off_cpu
+        elif record.type_name == 'work_begin':
+            pos = _find_job(record,work_off_cpu)
+            if pos is None:
+                msg = "Event %d tried to begin to a work item that was not on the"
+                msg += " work_off_cpu queue\n"
+                msg = msg % (record.id)
+                sys.stderr.write(msg)
+                exit()
+            job = work_off_cpu[pos]
+            job.exe_pid = record.exe_pid
+            del work_off_cpu[pos]
+            work_on_cpu.append(job)
+       
+        # A Work item is end from a CPU.
+        elif record.type_name == 'work_end':
+                pos = _find_job(record,work_on_cpu)
+                if pos is not None:
+                        del work_on_cpu[pos]
+                else:
+                        pos = _find_job(record,work_off_cpu)
+                        if pos is not None:
+                                msg = ("Event %d tried to end a work item" +
+                            " that hasn't not executed\n")
+                        msg = msg % (record.id)
+                        sys.stderr.write(msg)
+                        exit()            
+            
+        # a Tasklet has Priority inheritance 
+        elif record.type_name == 'eff_prio_change':
+                        pos = _find_job(record,on_cpu)
+            
+                        if pos is None:
+                                msg = ("Event %d tried to change a jobs priority " + 
+                                        " that was not running\n")
+                                msg = msg % (record.id)
+                                sys.stderr.write(msg)
+                        exit()
+             
+                        inh_pos = _find_inh_job(record,off_cpu)
+                        if inh_pos is None:
+                                inh_pos = _find_inh_job(record,on_cpu)
+                                inh_job = on_cpu[pos]
+                        else:
+                                inh_job = off_cpu[pos]
+
+                        if inh_pos is not None:
+                                on_cpu[pos].is_prio_inh=True
+                                on_cpu[pos].inh_deadline = inh_job.deadline
+                        else:
+                                on_cpu[pos].is_prio_inh=False
+                                on_cpu[pos].inh_deadline =job.deadline
+
 
 ###############################################################################
 # Private Functions
@@ -125,6 +229,9 @@ class Job(object):
         self.pid = record.pid
         self.job = record.job
         self.deadline = record.deadline
+        self.inh_deadline = record.deadline
+        self.exe_pid = None
+        self.is_prio_inh = False
         self.is_complete = False
         self.is_blocked = False
         self.inversion_start = None
@@ -137,7 +244,7 @@ class Job(object):
 # G-EDF errors: the start or end of an inversion
 class Error(object):
     id = 0
-    def __init__(self, job, off_cpu, on_cpu,first_event_this_timestamp):
+    def __init__(self, job, off_cpu, on_cpu,first_event_this_timestamp,pi_type):
         Error.id += 1
         self.id = Error.id
         self.job = copy.copy(job)
@@ -146,13 +253,15 @@ class Error(object):
         self.record_type = 'error'
         self.triggering_event_id = first_event_this_timestamp
         if job.inversion_end is None:
-            self.type_name = 'inversion_start'
+            self.type_name = pi_type+'_inversion_start'
             job.inversion_start_id = self.id
             job.inversion_start_triggering_event_id = self.triggering_event_id
         else:
-            self.type_name = 'inversion_end'
+            self.type_name = pi_type+'_inversion_end'
             self.inversion_start_id = job.inversion_start_id
             self.inversion_start_triggering_event_id = job.inversion_start_triggering_event_id
+            
+
 
 # Returns the position of a Job in a list, or None
 def _find_job(record,list):
@@ -161,6 +270,20 @@ def _find_job(record,list):
             return i
     return None
 
+# Returns the position of a Job in a list, or None
+def _find_work_carrier(record,list):
+    for i in range(0,len(list)):
+        if list[i].pid == exe_pid:
+            return i
+    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
+
 # Return records for any inversion_starts and inversion_ends
 def _gedf_check(off_cpu,on_cpu,when,m,first_event_this_timestamp):
 
@@ -192,14 +315,14 @@ def _gedf_check(off_cpu,on_cpu,when,m,first_event_this_timestamp):
         if job not in on_cpu and job.inversion_start is None:
             job.inversion_start = when
             errors.append(Error(job, off_cpu, on_cpu,
-                first_event_this_timestamp))
+                first_event_this_timestamp,"Task"))
 
         # It is running and an inversion_start exists (i.e. it it still
         # marked as being inverted)
         elif job in on_cpu and job.inversion_start is not None:
             job.inversion_end = when
             errors.append(Error(job, off_cpu, on_cpu,
-                first_event_this_timestamp))
+                first_event_this_timestamp,"Task"))
             job.inversion_start = None
             job.inversion_end = None
 
@@ -210,7 +333,7 @@ def _gedf_check(off_cpu,on_cpu,when,m,first_event_this_timestamp):
         if job not in on_cpu and job.inversion_start is not None:
             job.inversion_end = when
             errors.append(Error(job, off_cpu, on_cpu,
-                first_event_this_timestamp))
+                first_event_this_timestamp,"Task"))
             job.inversion_start = None
             job.inversion_end = None
 
@@ -220,8 +343,204 @@ def _gedf_check(off_cpu,on_cpu,when,m,first_event_this_timestamp):
     for job in all:
         job.inversion_end = when
         errors.append(Error(job, off_cpu, on_cpu,
-            first_event_this_timestamp))
+            first_event_this_timestamp,"Task"))
         job.inversion_start = None
         job.inversion_end = None
 
     return errors
+
+# Return records for any inversion_starts and inversion_ends
+def _gedf_check_work(off_cpu,on_cpu,
+        work_off_cpu,work_on_cpu,
+    when,m,first_event_this_timestamp):
+
+    # List of error records to be returned
+    errors = []
+        
+    # List of all jobs 
+    all_prio = []
+    for x in on_cpu:
+        all_prio.append(x)
+    for x in off_cpu:
+        all_prio.append(x)
+
+    # Sort all task by then by deadline (inh_deadline). 
+    all_prio.sort(key=lambda x: x.inh_deadline)
+    
+        #Look for all tasklet is tasklet_off_cpu (not running)
+    for work in work_off_cpu:
+        _on = _find_job(work,on_cpu)
+        pos = _find_job(work,all_prio)
+        # owner task must be completed!! weird
+        if pos is None: 
+                        continue
+        # if the owner task is running
+        if _on is not None:
+                # if the owner task is not blocked
+                if on_cpu[_on].is_blocked==False and work.inversion_start is not None:
+                        work.inversion_end = when
+                        errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                first_event_this_timestamp,"Work_Item"))
+                        work.inversion_start = None
+                        work.inversion_end = None
+                # if the owner task is  blocked
+                elif on_cpu[_on].is_blocked==True:
+                        # if the owner task prioirty is smaller than m
+                        if pos<m and work.inversion_start is None:
+                                work.inversion_start = when
+                                errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                        first_event_this_timestamp,"Work_Item"))
+                        # if the owner task prioirty is bigger than m
+                        elif pos>=m and work.inversion_start is not None:
+                                work.inversion_end = when
+                                errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                        first_event_this_timestamp,"Work_Item"))
+                                work.inversion_start = None
+                                work.inversion_end = None
+        # if the owner task is not running
+        else:
+                # if the owner task prioirty is smaller than m
+                if pos<m and work.inversion_start is None:
+                        work.inversion_start = when
+                        errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                first_event_this_timestamp,"Work_Item"))
+                # if the owner task prioirty is bigger than m
+                elif pos >= m and work.inversion_start is not None:
+                        work.inversion_end = when
+                        errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                first_event_this_timestamp,"Work_Item"))
+                        work.inversion_start = None
+                        work.inversion_end = None
+
+    # have klitirqd take care of
+    for work in work_on_cpu:
+        _on = _find_job(work,on_cpu)
+        pos = _find_job(work,all_prio)
+        # owner task must be completed!! weird
+        if pos is None: 
+                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 == False and work.inversion_start is not None: 
+                work.inversion_end = when
+                errors.append(Error(work, work_off_cpu, work_on_cpu,
+                        first_event_this_timestamp,"Work_Item"))
+                work.inversion_start = None
+                work.inversion_end = None
+        else:           
+                # if the owner task is running
+                if _on is not None:
+                        # if the owner task is not blocked
+                        if on_cpu[_on].is_blocked==False and work.inversion_start is not None: 
+                                        work.inversion_end = when
+                                        errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                                first_event_this_timestamp,"Work_Item"))
+                                        work.inversion_start = None
+                                        work.inversion_end = None
+                        # if the owner task is  blocked
+                        elif on_cpu[_on].is_blocked==True :
+                                # if the owner task prioirty is smaller than m
+                                if pos<m and work.inversion_start is None:
+                                        work.inversion_start = when
+                                        errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                                first_event_this_timestamp,"Work_Item"))
+                                # if the owner task prioirty is bigger than m
+                                elif pos>=m and work.inversion_start is not None:
+                                        work.inversion_end = when
+                                        errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                                first_event_this_timestamp,"Work_Item"))
+                                        work.inversion_start = None
+                                        work.inversion_end = None
+                # if the owner task is not running
+                else:
+                        # if the owner task prioirty is smaller than m
+                        if pos<m and work.inversion_start is None:
+                                work.inversion_start = when
+                                errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                        first_event_this_timestamp,"Work_Item"))
+                        # if the owner task prioirty is bigger than m
+                        elif pos>=m and work.inversion_start is not None:
+                                work.inversion_end = when
+                                errors.append(Error(work, work_off_cpu, work_on_cpu,
+                                        first_event_this_timestamp,"Work_Item"))
+                                work.inversion_start = None
+                                work.inversion_end = None
+
+    
+    return errors
+
+
+
+# Return records for any inversion_starts and inversion_ends
+def _gedf_check_tasklet(off_cpu,on_cpu,
+        tasklet_off_cpu, tasklet_on_cpu, 
+        when,m,first_event_this_timestamp):
+
+    # List of error records to be returned
+    errors = []
+
+    # List of all jobs 
+    all = []
+    for x in on_cpu:
+        all.append(x)
+    for x in off_cpu:
+        all.append(x)
+
+    # Sort all task by then by deadline (inh_deadline). 
+    all.sort(key=lambda x: x.inh_deadline)
+
+        #Look for all tasklet is tasklet_off_cpu (not running)
+    for tasklet in tasklet_off_cpu:
+        _on = _find_job(tasklet,on_cpu)
+        pos = _find_job(tasklet,all)
+        # owner task must be completed!! weird
+        if pos is None: 
+                        continue
+        # if the owner task is running
+        if _on is not None:
+                # if the owner task is not blocked
+                if on_cpu[_on].is_blocked==False and tasklet.inversion_start is not None: 
+                        tasklet.inversion_end = when
+                        errors.append(Error(tasklet, tasklet_off_cpu, tasklet_on_cpu,
+                                first_event_this_timestamp,"Tasklet"))
+                        tasklet.inversion_start = None
+                        tasklet.inversion_end = None
+                # if the owner task is  blocked
+                elif on_cpu[_on].is_blocked==True :
+                        # if the owner task prioirty is smaller than m
+                        if pos<m and tasklet.inversion_start is None:
+                                tasklet.inversion_start = when
+                                errors.append(Error(tasklet, tasklet_off_cpu, tasklet_on_cpu,
+                                first_event_this_timestamp,"Tasklet"))
+                        # if the owner task prioirty is bigger than m
+                        elif pos>=m and tasklet.inversion_start is not None:
+                                tasklet.inversion_end = when
+                                errors.append(Error(tasklet, tasklet_off_cpu, tasklet_on_cpu,
+                                        first_event_this_timestamp,"Tasklet"))
+                                tasklet.inversion_start = None
+                                tasklet.inversion_end = None
+        # if the owner task is not running
+        else:
+                # if the owner task prioirty is smaller than m
+                if pos<m and tasklet.inversion_start is None:
+                        tasklet.inversion_start = when
+                        errors.append(Error(tasklet, tasklet_off_cpu, tasklet_on_cpu,
+                        first_event_this_timestamp,"Tasklet"))
+                # if the owner task prioirty is bigger than m
+                elif pos>=m and tasklet.inversion_start is not None:
+                        tasklet.inversion_end = when
+                        errors.append(Error(tasklet, tasklet_off_cpu, tasklet_on_cpu,
+                                first_event_this_timestamp,"Tasklet"))
+                        tasklet.inversion_start = None
+                        tasklet.inversion_end = None
+        
+        #Look for all tasklet is tasklet_on_cpu (running)
+        for tasklet in tasklet_on_cpu:
+                if tasklet.inversion_start is not None: 
+                        tasklet.inversion_end = when
+                        errors.append(Error(tasklet, tasklet_off_cpu, tasklet_on_cpu,
+                                first_event_this_timestamp,"Tasklet"))
+                        tasklet.inversion_start = None
+                        tasklet.inversion_end = None
+                
+    return errors
diff --git a/unit_trace/stdout_printer.py b/unit_trace/stdout_printer.py
index b70b31a..c8fba1f 100644
--- a/unit_trace/stdout_printer.py
+++ b/unit_trace/stdout_printer.py
@@ -14,10 +14,18 @@ def stdout_printer(stream):
             _print_event(record)
         elif record.record_type == "meta" and record.type_name == "stats":
             _print_stats(record)
-        elif record.record_type == "error" and record.type_name == 'inversion_start':
-            _print_inversion_start(record)
-        elif record.record_type == "error" and record.type_name == 'inversion_end':
-            _print_inversion_end(record)
+        elif record.record_type == "error" and record.type_name == 'Task_inversion_start':
+            _print_inversion_start(record,"Task_")
+        elif record.record_type == "error" and record.type_name == 'Task_inversion_end':
+            _print_inversion_end(record,"Task_")
+        elif record.record_type == "error" and record.type_name == 'Tasklet_inversion_start':
+                _print_inversion_start(record,"Tasklet_")
+        elif record.record_type == "error" and record.type_name == 'Tasklet_inversion_end':
+                _print_inversion_end(record,"Tasklet_")
+        elif record.record_type == "error" and record.type_name == 'Work_Item_inversion_start':
+                _print_inversion_start(record,"Work_Item_")
+        elif record.record_type == "error" and record.type_name == 'Work_Item_inversion_end':
+                _print_inversion_end(record,"Work_Item_")
         else:
             continue
         print ""
@@ -32,8 +40,8 @@ def _print_event(record):
     print "Type: %s" % (record.type_name)
     print "Time: %d" % (record.when)
 
-def _print_inversion_start(record):
-    print "Type: %s" % ("Inversion start")
+def _print_inversion_start(record,pi_type):
+    print "Type: %s" % (pi_type+"Inversion start")
     print "Inversion Record IDs: (%d, U)" % (record.id)
     print "Triggering Event IDs: (%d, U)" % (record.triggering_event_id)
     print "Time: %d" % (record.job.inversion_start)
@@ -48,8 +56,8 @@ def _print_inversion_start(record):
         print str(job) + " ",
     print #newline
 
-def _print_inversion_end(record):
-    print "Type: %s" % ("Inversion end")
+def _print_inversion_end(record,pi_type):
+    print "Type: %s" % (pi_type+"Inversion end")
     print "Inversion record IDs: (%d, %d)" % (record.inversion_start_id,
         record.id)
     print("Triggering Event IDs: (%d, %d)" %
diff --git a/unit_trace/trace_reader.py b/unit_trace/trace_reader.py
index db36c13..45b29e1 100644
--- a/unit_trace/trace_reader.py
+++ b/unit_trace/trace_reader.py
@@ -266,12 +266,58 @@ class StSysReleaseData:
     formatStr = struct.Struct(StHeader.format + format)
     keys = StHeader.keys + ['when','release']
     message = 'All tasks have checked in, task system released by user'
+    
+class StTaskletReleaseData:
+    format =  'Q'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when']
+    message = 'A tasklet is queued'
+    
+class StTaskletBeginData:
+    format =  'Q'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when']
+    message = 'A tasklet begins execution'
+    
+class StTaskletEndData:
+    format =  'Qc'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','flushed']
+    message = 'A tasklet completes execution'
+    
+class StWorkReleaseData:
+    format =  'Q'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when']
+    message = 'A work item is queued'
+    
+class StWorkBeginData:
+    format =  'Qh'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','exe_pid']
+    message = 'A work item begins execution'
+    
+class StWorkEndData:
+    format =  'Qhc'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','exe_pid','flushed']
+    message = 'A work item completes execution'
+
+    
+class StEffPrioChangeData:
+    format =  'Qh'
+    formatStr = struct.Struct(StHeader.format + format)
+    keys = StHeader.keys + ['when','inh_pid']
+    message = 'A tasklet priorty gets changed by inheritance'
 
 # Return the binary data type, given the type_num
 def _get_type(type_num):
     types = [None,StNameData,StParamData,StReleaseData,StAssignedData,
              StSwitchToData,StSwitchAwayData,StCompletionData,StBlockData,
-             StResumeData,StSysReleaseData]
+             StResumeData,StSysReleaseData,
+             StTaskletReleaseData,StTaskletBeginData,StTaskletEndData,
+             StWorkReleaseData,StWorkBeginData,StWorkEndData,
+             StEffPrioChangeData]
     if type_num > len(types)-1 or type_num < 1:
         raise Exception
     return types[type_num]
@@ -280,5 +326,8 @@ def _get_type(type_num):
 #     programmers of other modules)
 def _get_type_name(type_num):
     type_names = [None,"name","params","release","assign","switch_to",
-        "switch_away","completion","block","resume","sys_release"]
+        "switch_away","completion","block","resume","sys_release",
+        "tasklet_release","tasklet_begin","tasklet_end",
+        "work_release","work_begin","work_end",
+        "eff_prio_change"]
     return type_names[type_num]