Merge branch 'mpi-staging' into mpi-master

1 files changed, 105 insertions, 41 deletions

diff --git a/src/ft2csv.c b/src/ft2csv.c
index cc6636f..aceeb25 100644
--- a/src/ft2csv.c
+++ b/src/ft2csv.c
@@ -30,23 +30,41 @@
 static int want_interleaved    = 1;
 static int want_best_effort    = 0;
 
+/* discard samples from a specific CPU */
+static int avoid_cpu = -1;
+/* only use samples from a specific CPU */
+static int only_cpu  = -1;
+
 static unsigned int complete   = 0;
 static unsigned int incomplete = 0;
 static unsigned int filtered   = 0;
 static unsigned int skipped    = 0;
 static unsigned int non_rt     = 0;
 static unsigned int interleaved = 0;
+static unsigned int avoided    = 0;
 
 #define CYCLES_PER_US 2128
 
-static unsigned long long threshold = CYCLES_PER_US * 1000; /* 1 ms == 1 full tick */
+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)
 {
         struct timestamp* pos;
-        for (pos = start; pos != end && pos->cpu != cpu; pos++);
-        return pos != end ? pos : NULL;
+        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;
+
+                if (pos->cpu == cpu)
+                        return pos;
+        }
+        return NULL;
 }
 
 static struct timestamp* next_id(struct timestamp* start, struct timestamp* end,
@@ -79,10 +97,35 @@ static struct timestamp* find_second_ts(struct timestamp* start,
                        start->event);
 }
 
+typedef void (*pair_fmt_t)(struct timestamp* first, struct timestamp* second);
+
+static void print_pair_csv(struct timestamp* first, struct timestamp* second)
+{
+        printf("%llu, %llu, %llu\n",
+               (unsigned long long) first->timestamp,
+               (unsigned long long) second->timestamp,
+               (unsigned long long)
+               (second->timestamp - first->timestamp));
+}
+
+static void print_pair_bin(struct timestamp* first, struct timestamp* second)
+{
+        float delta = second->timestamp - first->timestamp;
+        fwrite(&delta, sizeof(delta), 1, stdout);
+}
+
+pair_fmt_t format_pair = print_pair_csv;
+
 static void show_csv(struct timestamp* first, struct timestamp *end)
 {
         struct timestamp *second;
 
+        if (first->cpu == avoid_cpu ||
+            (only_cpu != -1 && first->cpu != only_cpu)) {
+                avoided++;
+                return;
+        }
+
         second = find_second_ts(first, end);
         if (second) {
                 if (second->timestamp - first->timestamp > threshold)
@@ -91,45 +134,40 @@ static void show_csv(struct timestamp* first, struct timestamp *end)
                          second->task_type != TSK_RT && !want_best_effort)
                         non_rt++;
                 else {
-                        printf("%llu, %llu, %llu\n",
-                               (unsigned long long) first->timestamp,
-                               (unsigned long long) second->timestamp,
-                               (unsigned long long)
-                               (second->timestamp - first->timestamp));
+                        format_pair(first, second);
                         complete++;
                 }
         } else
                 incomplete++;
-
 }
 
-static inline uint64_t bget(int x, uint64_t quad)
+typedef void (*single_fmt_t)(struct timestamp* ts);
 
+static void print_single_csv(struct timestamp* ts)
 {
-        return (((0xffll << 8 * x) & quad) >> 8 * x);
+        printf("0, 0, %llu\n",
+               (unsigned long long) (ts->timestamp));
 }
 
-static inline uint64_t bput(uint64_t b, int pos)
+static void print_single_bin(struct timestamp* ts)
 {
-        return (b << 8 * pos);
-}
+        float delta = ts->timestamp;
 
-static inline uint64_t ntohx(uint64_t q)
-{
-        return (bput(bget(0, q), 7) | bput(bget(1, q), 6) |
-                bput(bget(2, q), 5) | bput(bget(3, q), 4) |
-                bput(bget(4, q), 3) | bput(bget(5, q), 2) |
-                bput(bget(6, q), 1) | bput(bget(7, q), 0));
+        fwrite(&delta, sizeof(delta), 1, stdout);
 }
 
-static void restore_byte_order(struct timestamp* start, struct timestamp* end)
+single_fmt_t single_fmt = print_single_csv;
+
+static void show_single(struct timestamp* ts)
 {
-        struct timestamp* pos = start;
-        while (pos !=end) {
-                pos->timestamp = ntohx(pos->timestamp);
-                pos->seq_no    = ntohl(pos->seq_no);
-                pos++;
-        }
+        if (ts->cpu == avoid_cpu ||
+            (only_cpu != -1 && ts->cpu != only_cpu)) {
+                avoided++;
+        } else if (ts->task_type == TSK_RT) {
+                single_fmt(ts);
+                complete++;
+        } else
+                non_rt++;
 }
 
 static void show_id(struct timestamp* start, struct timestamp* end,
@@ -145,12 +183,22 @@ static void show_id(struct timestamp* start, struct timestamp* end,
                         show_csv(start, end);
 }
 
-#define USAGE \
-        "Usage: ft2csv [-e] [-i] [-b] <event_name>  <logfile> \n"       \
-        "   -e: endianess swap      -- restores byte order \n"  \
-        "   -i: ignore interleaved  -- ignore samples if start " \
-        "and end are non-consecutive\n"                         \
+static void show_single_records(struct timestamp* start, struct timestamp* end,
+                                unsigned long id)
+{
+        for (; start != end; start++)
+                if (start->event == id)
+                        show_single(start);
+}
+
+#define USAGE                                                           \
+        "Usage: ft2csv [-r] [-i] [-b] [-a CPU] [-o CPU] <event_name>  <logfile> \n" \
+        "   -i: ignore interleaved  -- ignore samples if start "        \
+        "and end are non-consecutive\n"                                 \
         "   -b: best effort         -- don't skip non-rt time stamps \n" \
+        "   -r: raw binary format   -- don't produce .csv output \n"    \
+        "   -a: avoid CPU           -- skip samples from a specific CPU\n" \
+        "   -o: only CPU            -- skip all samples from other CPUs\n" \
         ""
 
 static void die(char* msg)
@@ -162,7 +210,7 @@ static void die(char* msg)
         exit(1);
 }
 
-#define OPTS "eib"
+#define OPTS "ibra:o:"
 
 int main(int argc, char** argv)
 {
@@ -170,21 +218,35 @@ int main(int argc, char** argv)
         size_t size, count;
         struct timestamp *ts, *end;
         cmd_t id;
-        int swap_byte_order = 0;
         int opt;
         char event_name[80];
 
         while ((opt = getopt(argc, argv, OPTS)) != -1) {
                 switch (opt) {
-                case 'e':
-                        swap_byte_order = 1;
-                        break;
                 case 'i':
                         want_interleaved = 0;
+                        fprintf(stderr, "Discarging interleaved samples.\n");
                         break;
                 case 'b':
+                        fprintf(stderr,"Not filtering samples from best-effort"
+                                " tasks.\n");
                         want_best_effort = 1;
                         break;
+                case 'r':
+                        fprintf(stderr, "Generating binary (raw) output.\n");
+                        single_fmt  = print_single_bin;
+                        format_pair = print_pair_bin;
+                        break;
+                case 'a':
+                        avoid_cpu = atoi(optarg);
+                        fprintf(stderr, "Disarding all samples from CPU %d.\n",
+                                avoid_cpu);
+                        break;
+                case 'o':
+                        only_cpu = atoi(optarg);
+                        fprintf(stderr, "Using only samples from CPU %d.\n",
+                                only_cpu);
+                        break;
                 default:
                         die("Unknown option.");
                         break;
@@ -208,20 +270,22 @@ int main(int argc, char** argv)
         count = size / sizeof(struct timestamp);
         end   = ts + count;
 
-        if (swap_byte_order)
-                restore_byte_order(ts, end);
-        show_id(ts, end, id);
+        if (id >= SINGLE_RECORDS_RANGE)
+                show_single_records(ts, end, id);
+        else
+                show_id(ts, end, id);
 
         fprintf(stderr,
                 "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",
                 (int) count,
-                skipped, complete,
+                skipped, avoided, complete,
                 incomplete, filtered, non_rt,
                 interleaved);