Merge branch 'mpi-staging' into mpi-master

6 files changed, 404 insertions, 66 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);
 
diff --git a/src/ftcat.c b/src/ftcat.c
index 61e007f..685f65b 100644
--- a/src/ftcat.c
+++ b/src/ftcat.c
@@ -24,43 +24,52 @@
 #include <unistd.h>
 #include <errno.h>
 
+#include <sys/ioctl.h>
+
 #include "timestamp.h"
 
 #define MAX_EVENTS 128
 
 static int fd;
-static int event_count = 1;
+static int event_count = 0;
 static cmd_t  ids[MAX_EVENTS];
 static unsigned long total_bytes = 0;
 
 
 static int disable_all(int fd)
 {
-        int ret, size;
-        ids[0] = DISABLE_CMD;
-        fprintf(stderr, "Disabling %d events.\n", event_count - 1);
-        size = event_count * sizeof(cmd_t);
-        ret  = write(fd, ids, size);
-        if (ret != size)
-                fprintf(stderr, "write = %d, meant to write %d (%m)\n", ret, size);
-        return size == ret;
+        int disabled = 0;
+        int i;
+
+        fprintf(stderr, "Disabling %d events.\n", event_count);
+        for (i = 0; i < event_count; i++)
+                if (ioctl(fd, DISABLE_CMD, ids[i]) < 0)
+                        perror("ioctl(DISABLE_CMD)");
+                else
+                        disabled++;
+
+        return  disabled == event_count;
 }
 
 static int enable_event(int fd, char* str)
 {
         cmd_t   *id;
-        cmd_t   cmd[2];
+        int err;
 
         id = ids + event_count;
         if (!str2event(str, id)) {
                 errno = EINVAL;
                 return 0;
         }
-
         event_count += 1;
-        cmd[0] = ENABLE_CMD;
-        cmd[1] = id[0];
-        return write(fd, cmd, sizeof(cmd)) == sizeof(cmd_t)  * 2;
+
+        err = ioctl(fd, ENABLE_CMD, *id);
+
+        if (err < 0)
+                printf("ioctl(%d, %d, %d) => %d (errno: %d)\n", fd, (int) ENABLE_CMD, *id,
+                       err, errno);
+
+        return err == 0;
 }
 
 
diff --git a/src/ftdump.c b/src/ftdump.c
index 599473b..1462c4d 100644
--- a/src/ftdump.c
+++ b/src/ftdump.c
@@ -29,10 +29,31 @@
 static void dump(struct timestamp* ts, size_t count)
 {
         struct timestamp *x;
+        unsigned int last_seq = 0;
+        const char* name;
         while (count--) {
                 x = ts++;
-                printf("event:%d seq:%u cpu:%d type:%d\n",
-                       (int) x->event, x->seq_no, x->cpu, x->task_type);
+                name = event2str(x->event);
+                if (last_seq && last_seq + 1 != x->seq_no)
+                        printf("==== non-consecutive sequence number ====\n");
+                last_seq = x->seq_no;
+                if (name)
+                        printf("%-20s seq:%u  timestamp:%llu  cpu:%d  type:%-8s irq:%u irqc:%02u \n",
+                               name,  x->seq_no,
+                               (unsigned long long)  x->timestamp,
+                               x->cpu,
+                               task_type2str(x->task_type),
+                               x->irq_flag,
+                               x->irq_count);
+                else
+                        printf("%16s:%3u seq:%u  timestamp:%llu  cpu:%u  type:%-8s irq:%u irqc:%02u\n",
+                               "event",
+                               (unsigned int) x->event, x->seq_no,
+                               (unsigned long long)  x->timestamp,
+                               x->cpu,
+                               task_type2str(x->task_type),
+                               x->irq_flag,
+                               x->irq_count);
         }
 }
 
@@ -57,14 +78,12 @@ int main(int argc, char** argv)
                "\t offset(timestamp) = %3lu\n"
                "\t offset(seq_no)    = %3lu\n"
                "\t offset(cpu)       = %3lu\n"
-               "\t offset(event)     = %3lu\n"
-               "\t offset(task_type) = %3lu\n",
+               "\t offset(event)     = %3lu\n",
                (unsigned long) sizeof(struct timestamp),
                offset(struct timestamp, timestamp),
                offset(struct timestamp, seq_no),
                offset(struct timestamp, cpu),
-               offset(struct timestamp, event),
-               offset(struct timestamp, task_type));
+               offset(struct timestamp, event));
 
         if (argc != 2)
                 die("Usage: ftdump  <logfile>");
diff --git a/src/ftsort.c b/src/ftsort.c
new file mode 100644
index 0000000..5ddb48f
--- /dev/null
+++ b/src/ftsort.c
@@ -0,0 +1,206 @@
+/*    ft2sort -- Sort Feather-Trace events in a binary file by sequence number.
+ *    Copyright (C) 2011  B. Brandenburg.
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License along
+ *    with this program; if not, write to the Free Software Foundation, Inc.,
+ *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <time.h>
+#include <sys/time.h>
+
+#include <errno.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/mman.h>
+
+#include "mapping.h"
+
+#include "timestamp.h"
+
+static unsigned int holes      = 0;
+static unsigned int reordered  = 0;
+
+#define LOOK_AHEAD 1000
+
+/* wall-clock time in seconds */
+double wctime(void)
+{
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        return (tv.tv_sec + 1E-6 * tv.tv_usec);
+}
+
+
+static struct timestamp* find_lowest_seq_no(struct timestamp* start,
+                                            struct timestamp* end,
+                                            unsigned int seqno)
+{
+        struct timestamp *pos, *min = start;
+
+        if (end > start + LOOK_AHEAD)
+                end = start + LOOK_AHEAD;
+
+        for (pos = start; pos != end && min->seq_no != seqno; pos++)
+                if (pos->seq_no < min->seq_no)
+                        min = pos;
+        return min;
+}
+
+
+static void move_record(struct timestamp* target, struct timestamp* pos)
+{
+        struct timestamp tmp, *prev;
+
+        while (pos > target) {
+                /* shift backwards */
+                tmp = *pos;
+                prev = pos - 1;
+
+                *pos = *prev;
+                *prev = tmp;
+
+                pos = prev;
+        }
+}
+
+static void reorder(struct timestamp* start, struct timestamp* end)
+{
+        struct timestamp* pos, *tmp;
+        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) {
+                        tmp = find_lowest_seq_no(pos, end, last_seqno + 1);
+                        if (tmp->seq_no == last_seqno + 1)
+                                /* Good, we found it. */
+                                /* Move it to the right place. */
+                                reordered++;
+                        else {
+                                /* bad, there's a hole here */
+                                holes++;
+                                fprintf(stderr, "HOLE: %u instead of %u\n", tmp->seq_no, last_seqno + 1);
+                        }
+                        move_record(pos, tmp);
+                }
+                last_seqno = pos->seq_no;
+        }
+}
+
+static inline uint64_t bget(int x, uint64_t quad)
+
+{
+        return (((0xffll << 8 * x) & quad) >> 8 * x);
+}
+
+static inline uint64_t bput(uint64_t b, int pos)
+{
+        return (b << 8 * pos);
+}
+
+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));
+}
+
+static void restore_byte_order(struct timestamp* start, struct timestamp* end)
+{
+        struct timestamp* pos = start;
+        while (pos !=end) {
+                pos->timestamp = ntohx(pos->timestamp);
+                pos->seq_no    = ntohl(pos->seq_no);
+                pos++;
+        }
+}
+
+#define USAGE                                                   \
+        "Usage: ftsort [-e] <logfile> \n"                       \
+        "   -e: endianess swap      -- restores byte order \n"  \
+        "\n"                                                    \
+        "WARNING: Changes are permanent.\n"
+
+static void die(char* msg)
+{
+        if (errno)
+                perror("error: ");
+        fprintf(stderr, "%s\n", msg);
+        fprintf(stderr, "%s", USAGE);
+        exit(1);
+}
+
+#define OPTS "e"
+
+int main(int argc, char** argv)
+{
+        void* mapped;
+        size_t size, count;
+        struct timestamp *ts, *end;
+        int swap_byte_order = 0;
+        int opt;
+        double start, stop;
+
+        while ((opt = getopt(argc, argv, OPTS)) != -1) {
+                switch (opt) {
+                case 'e':
+                        swap_byte_order = 1;
+                        break;
+                default:
+                        die("Unknown option.");
+                        break;
+                }
+        }
+
+        if (argc - optind != 1)
+                die("arguments missing");
+
+        start = wctime();
+
+        if (map_file_rw(argv[optind], &mapped, &size))
+                die("could not map file");
+
+        ts    = (struct timestamp*) mapped;
+        count = size / sizeof(struct timestamp);
+        end   = ts + count;
+
+        if (swap_byte_order)
+                restore_byte_order(ts, end);
+
+        reorder(ts, end);
+
+        /* write back */
+        msync(ts, size, MS_SYNC | MS_INVALIDATE);
+
+        stop = wctime();
+
+        fprintf(stderr,
+                "Total       : %10d\n"
+                "Holes       : %10d\n"
+                "Reordered   : %10d\n"
+                "Size        : %10.2f Mb\n"
+                "Time        : %10.2f s\n"
+                "Throughput  : %10.2f Mb/s\n",
+                (int) count,
+                holes, reordered,
+                ((double) size) / 1024.0 / 1024.0,
+                (stop - start),
+                ((double) size) / 1024.0 / 1024.0 / (stop - start));
+
+        return 0;
+}
diff --git a/src/mapping.c b/src/mapping.c
index 19d7129..e4ce96c 100644
--- a/src/mapping.c
+++ b/src/mapping.c
@@ -5,13 +5,16 @@
 #include <errno.h>
 #include <unistd.h>
 
+#include <stdio.h>
+
 #include "mapping.h"
 
-int map_file(const char* filename, void **addr, size_t *size)
+static int _map_file(const char* filename, void **addr, size_t *size, int writable)
 {
         struct stat info;
         int error = 0;
         int fd;
+        int flags = writable ? MAP_SHARED : MAP_PRIVATE;
 
         error = stat(filename, &info);
         if (!error) {
@@ -19,12 +22,19 @@ int map_file(const char* filename, void **addr, size_t *size)
                 if (info.st_size > 0) {
                         fd = open(filename, O_RDWR);
                         if (fd >= 0) {
-                                *addr = mmap(NULL, *size, 
-                                             PROT_READ | PROT_WRITE, 
-                                             MAP_PRIVATE,
+                                *addr = mmap(NULL, *size,
+                                             PROT_READ | PROT_WRITE,
+                                             flags,
                                              fd, 0);
                                 if (*addr == MAP_FAILED)
                                         error = -1;
+                else {
+                        /* tell kernel to start getting the pages */
+                        error = madvise(*addr, *size, MADV_SEQUENTIAL | MADV_WILLNEED);
+                        if (error) {
+                                perror("madvise");
+                        }
+                }
                                 close(fd);
                         } else
                                 error = fd;
@@ -33,3 +43,14 @@ int map_file(const char* filename, void **addr, size_t *size)
         }
         return error;
 }
+
+
+int map_file(const char* filename, void **addr, size_t *size)
+{
+        return _map_file(filename, addr, size, 0);
+}
+
+int map_file_rw(const char* filename, void **addr, size_t *size)
+{
+        return _map_file(filename, addr, size, 1);
+}
diff --git a/src/timestamp.c b/src/timestamp.c
index 4c04ce7..442c445 100644
--- a/src/timestamp.c
+++ b/src/timestamp.c
@@ -22,17 +22,26 @@ static struct event_name event_table[] =
         EVENT(PLUGIN_TICK),
         EVENT(CXS),
         EVENT(SEND_RESCHED),
+        {"RELEASE_LATENCY", TS_RELEASE_LATENCY},
+
+        EVENT(SYSCALL_IN),
+        EVENT(SYSCALL_OUT),
+        EVENT(LOCK),
+        EVENT(UNLOCK),
+        {"LOCK_SUSPEND", TS_LOCK_SUSPEND},
+        {"LOCK_RESUME", TS_LOCK_RESUME},
 };
 
 int  str2event(const char* str, cmd_t *id)
 {
         int i;
 
-        for (i = 0; i < sizeof(event_table) / sizeof(event_table[0]); i++)
+        for (i = 0; i < sizeof(event_table) / sizeof(event_table[0]); i++) {
                 if (!strcmp(str, event_table[i].name)) {
                         *id = event_table[i].id;
                         return 1;
                 }
+        }
         /* try to parse it as a number */
         return sscanf(str, "%u", id);
 }
@@ -47,3 +56,13 @@ const char* event2str(cmd_t id)
 
         return NULL;
 }
+
+const char* task_type2str(int task_type)
+{
+        if (task_type == TSK_RT)
+                return "RT";
+        else if (task_type == TSK_BE)
+                return "BE";
+        else
+                return "UNKNOWN";
+}