2 files changed, 176 insertions, 25 deletions

diff --git a/src/ft2csv.c b/src/ft2csv.c
index a6b1bf2..b75b284 100644
--- a/src/ft2csv.c
+++ b/src/ft2csv.c
@@ -41,8 +41,14 @@ static unsigned int skipped    = 0;
 static unsigned int non_rt     = 0;
 static unsigned int interleaved = 0;
 static unsigned int avoided    = 0;
+static unsigned int lvl_a_sched = 0;
+static unsigned int lvl_b_sched = 0;
+static unsigned int lvl_c_sched = 0;
+static unsigned int other_sched = 0;
+static unsigned int filtered = 0;
 
 #define CYCLES_PER_US 2128
+static unsigned long long threshold = CYCLES_PER_US * 10000; /* 10 ms == 10 full ticks */
 
 static struct timestamp* next(struct timestamp* start, struct timestamp* end,
                               int cpu)
@@ -94,48 +100,180 @@ static struct timestamp* find_second_ts(struct timestamp* start,
                        start->event);
 }
 
-typedef void (*pair_fmt_t)(struct timestamp* first, struct timestamp* second);
+static struct timestamp* next_pid(struct timestamp* start, struct timestamp* end,
+                                  unsigned int pid, unsigned long id1, unsigned long id2)
+{
+        struct timestamp* pos;
+        unsigned int last_seqno = 0;
+
+        for (pos = start; pos != end;  pos++) {
+                /* check for for holes in the sequence number */
+                if (last_seqno && last_seqno + 1 != pos->seq_no) {
+                        /* stumbled across a hole */
+                        return NULL;
+                }
+                last_seqno = pos->seq_no;
+
+                /* only care about this PID */
+                if (ts_pid_fragment(pos) == pid) {
+                        /* is  it the right one? */
+                        if (pos->event == id1 || pos->event == id2)
+                                return pos;
+                        else
+                                /* Don't allow unexptected IDs interleaved.
+                                 * Tasks are sequential, there shouldn't be
+                                 * anything else. */
+                                return NULL;
+                }
+        }
+        return NULL;
+}
+
+static struct timestamp* accumulate_exec_time(
+        struct timestamp* start, struct timestamp* end,
+        unsigned int pid, unsigned long stop_id, uint64_t *sum)
+{
+        struct timestamp* pos = start;
+        uint64_t exec_start;
+
+        *sum = 0;
+
+        while (1) {
+                exec_start = pos->timestamp;
+
+                /* find a suspension */
+                pos = next_pid(pos + 1, end, pid, TS_LOCK_SUSPEND, stop_id);
+                if (!pos)
+                        /* broken stream */
+                        return NULL;
+
+                /* account for exec until pos */
+                *sum += pos->timestamp - exec_start;
+
+                if (pos->event == stop_id)
+                        /* no suspension */
+                        return pos;
+
+                /* find matching resume */
+                pos = next_pid(pos + 1, end, pid, TS_LOCK_RESUME, 0);
+                if (!pos)
+                        /* broken stream */
+                        return NULL;
+
+                /* must be a resume => start over */
+        }
+}
+
+typedef void (*pair_fmt_t)(struct timestamp* first, struct timestamp* second, uint64_t exec_time);
 
-static void print_pair_csv(struct timestamp* first, struct timestamp* second)
+static void print_pair_csv(struct timestamp* first, struct timestamp* second, uint64_t exec_time)
 {
         printf("%llu, %llu, %llu\n",
                (unsigned long long) first->timestamp,
                (unsigned long long) second->timestamp,
-               (unsigned long long)
-               (second->timestamp - first->timestamp));
+               (unsigned long long) exec_time);
 }
 
-static void print_pair_bin(struct timestamp* first, struct timestamp* second)
+static void print_pair_bin(struct timestamp* first, struct timestamp* second, uint64_t exec_time)
 {
-        float delta = second->timestamp - first->timestamp;
+        float delta =  exec_time;
         fwrite(&delta, sizeof(delta), 1, stdout);
 }
 
 pair_fmt_t format_pair = print_pair_csv;
 
-static void show_csv(struct timestamp* first, struct timestamp *end)
+static void find_event_by_pid(struct timestamp* first, struct timestamp* end)
 {
         struct timestamp *second;
-
-        if (first->cpu == avoid_cpu ||
-            (only_cpu != -1 && first->cpu != only_cpu)) {
-                avoided++;
-                return;
+        uint64_t exec_time = 0;
+
+        /* special case: take suspensions into account */
+        if (first->event == TS_LOCK_START) {
+                second = accumulate_exec_time(first, end,
+                                              ts_pid_fragment(first),
+                                              first->event + 3, &exec_time);
+        } else {
+                second = next_pid(first + 1, end, ts_pid_fragment(first),
+                                  first->event + 1, 0);
+                if (second)
+                        exec_time = second->timestamp - first->timestamp;
         }
+        if (second) {
+                if (exec_time > threshold)
+                        filtered++;
+                else
+                        format_pair(first, second, exec_time);
+                        complete++;
+        } else
+                incomplete++;
+}
+
+static void find_event_by_eid(struct timestamp *first, struct timestamp* end)
+{
+        struct timestamp *second;
+        uint64_t exec_time;
 
         second = find_second_ts(first, end);
         if (second) {
-                if (first->task_type != TSK_RT &&
+                exec_time = second->timestamp - first->timestamp;
+                if (exec_time > threshold)
+                        filtered++;
+                else if (first->task_type != TSK_RT &&
                          second->task_type != TSK_RT && !want_best_effort)
-                        non_rt++;
-                else {
-                        format_pair(first, second);
+                {
+                        if (TS_LVLA_SCHED_END == second->event &&
+                            second->task_type == TSK_LVLA)
+                        {
+                                format_pair(first, second, exec_time);
+                                complete++;
+                                lvl_a_sched++;
+                        } else if (TS_LVLB_SCHED_END == second->event &&
+                                   second->task_type == TSK_LVLB)
+                        {
+                                format_pair(first, second, exec_time);
+                                complete++;
+                                lvl_b_sched++;
+                        } else if (TS_LVLC_SCHED_END == second->event &&
+                                   second->task_type == TSK_LVLC)
+                        {
+                                format_pair(first, second, exec_time);
+                                complete++;
+                                lvl_c_sched++;
+
+                        } else {
+                                non_rt++;
+                        }
+                } else if ((TS_LVLA_SCHED_END == second->event ||
+                            TS_LVLB_SCHED_END == second->event ||
+                            TS_LVLC_SCHED_END == second->event) &&
+                           TSK_RT == second->task_type)
+                {
+                        other_sched++;
+                } else
+                {
+                        format_pair(first, second, exec_time);
                         complete++;
                 }
         } else
                 incomplete++;
 }
 
+static void show_csv(struct timestamp* first, struct timestamp *end)
+{
+
+
+        if (first->cpu == avoid_cpu ||
+            (only_cpu != -1 && first->cpu != only_cpu)) {
+                avoided++;
+                return;
+        }
+
+        if (first->event <= PID_RECORDS_RANGE)
+                find_event_by_pid(first, end);
+        else
+                find_event_by_eid(first, end);
+}
+
 typedef void (*single_fmt_t)(struct timestamp* ts);
 
 static void print_single_csv(struct timestamp* ts)
@@ -271,17 +409,24 @@ int main(int argc, char** argv)
                 show_id(ts, end, id);
 
         fprintf(stderr,
-                "Total       : %10d\n"
-                "Skipped     : %10d\n"
-                "Avoided     : %10d\n"
-                "Complete    : %10d\n"
-                "Incomplete  : %10d\n"
-                "Non RT      : %10d\n"
-                "Interleaved : %10d\n",
+                "Total               : %10d\n"
+                "Skipped             : %10d\n"
+                "Avoided             : %10d\n"
+                "Complete            : %10d\n"
+                "Incomplete          : %10d\n"
+                "Filtered            : %10d\n"
+                "Non RT              : %10d\n"
+                "Interleaved         : %10d\n"
+                "Lvl-A Sched         : %10d\n"
+                "Lvl-B Sched         : %10d\n"
+                "Lvl-C Sched         : %10d\n"
+                "Other Sched (non-A) : %10d\n",
                 (int) count,
                 skipped, avoided, complete,
-                incomplete, non_rt,
-                interleaved);
+                incomplete, filtered, non_rt,
+                interleaved, lvl_a_sched, lvl_b_sched, lvl_c_sched,
+                other_sched);
+
 
         return 0;
 }
diff --git a/src/timestamp.c b/src/timestamp.c
index 442c445..cad3fb5 100644
--- a/src/timestamp.c
+++ b/src/timestamp.c
@@ -22,6 +22,12 @@ static struct event_name event_table[] =
         EVENT(PLUGIN_TICK),
         EVENT(CXS),
         EVENT(SEND_RESCHED),
+        EVENT(LVLA_RELEASE),
+        EVENT(LVLA_SCHED),
+        EVENT(LVLB_RELEASE),
+        EVENT(LVLB_SCHED),
+        EVENT(LVLC_RELEASE),
+        EVENT(LVLC_SCHED),
         {"RELEASE_LATENCY", TS_RELEASE_LATENCY},
 
         EVENT(SYSCALL_IN),