event naming

7 files changed, 221 insertions, 22 deletions

diff --git a/Makefile b/Makefile
index d87dd9b..0bea02f 100644
--- a/Makefile
+++ b/Makefile
@@ -6,10 +6,17 @@ vpath %.c src/
 
 .PHONY: clean
 
-all: ftcat
+TOOLS = ftcat ft2csv
 
-ftcat: ftcat.o
-        ${CC} -o ftcat ftcat.o
+all: ${TOOLS}
+
+FTCAT_OBJ = ftcat.o timestamp.o
+ftcat: ${FTCAT_OBJ}
+        ${CC} -o ftcat ${FTCAT_OBJ}
+
+FT2CSV_OBJ = ft2csv.o mapping.o timestamp.o
+ft2csv: ${FT2CSV_OBJ}
+        ${CC} -o ft2csv ${FT2CSV_OBJ}
 
 clean: 
-        rm -rf *.o ftcat
+        rm -rf *.o ${TOOLS}
diff --git a/include/mapping.h b/include/mapping.h
new file mode 100644
index 0000000..2a7b6a8
--- /dev/null
+++ b/include/mapping.h
@@ -0,0 +1,8 @@
+#ifndef _MAPPING_H_
+#define _MAPPING_H_
+
+int map_file(const char* filename, void **addr, size_t *size);
+
+
+#endif
+
diff --git a/include/timestamp.h b/include/timestamp.h
index ae50ae1..7874458 100644
--- a/include/timestamp.h
+++ b/include/timestamp.h
@@ -8,6 +8,8 @@ struct timestamp {
         int                     cpu;
 };
 
+int  str2event(const char* str, unsigned long *id);
+
 #define ENABLE_CMD 0L
 
 #define TIMESTAMP(id) id ## L
diff --git a/src/ft2csv.c b/src/ft2csv.c
new file mode 100644
index 0000000..a5fdf0a
--- /dev/null
+++ b/src/ft2csv.c
@@ -0,0 +1,117 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "mapping.h"
+
+#include "timestamp.h"
+
+static unsigned int incomplete = 0;
+
+static struct timestamp* next(struct timestamp** pos, size_t* count, int cpu)
+{
+        while (*count--)
+                if ((++(*pos))->cpu == cpu)
+                        return *pos;       
+        return NULL;
+}
+
+static struct timestamp* next_id(struct timestamp** pos, size_t* count, 
+                                 int cpu, unsigned long id) 
+{
+        struct timestamp* ret;
+        while ((ret = next(pos, count, cpu)) && (*pos)->event != id);
+        return ret;
+}
+
+static int find_pair(struct timestamp* start, 
+                     struct timestamp** end,
+                     size_t count)
+{
+        struct timestamp *pos = start;
+        /* convention: the end->event is start->event + 1 */
+        *end = next_id(&pos, &count, start->cpu, start->event + 1);
+        return *end != NULL;
+}
+
+static void show_csv(struct timestamp* ts, size_t count)
+{
+        struct timestamp* start = ts;
+        struct timestamp* stop;
+
+        if (find_pair(start, &stop, count)) {
+                printf("%llu, %llu, %llu\n",
+                       start->timestamp, stop->timestamp, 
+                       stop->timestamp - start->timestamp);
+        } else
+                incomplete++;
+        
+}
+
+/*static void show_all_per_cpu(struct timestamp* ts, size_t count)
+{
+        struct timestamp* _ts = ts;
+        size_t _count = count;
+        int cpu;
+        
+        for (cpu = 0; cpu < 4; cpu++) {
+                count = _count;
+                ts    = _ts;
+                while (count--) {
+                        if (ts->cpu == cpu)
+                                show(ts, count);        
+                        ts++;
+                }
+        }
+}*/
+
+static void show_id(struct timestamp* ts, size_t count,  unsigned long id)
+{
+        while (count--)
+                if (ts->event == id)
+                        show_csv(ts++, count);
+                else
+                        ts++;
+}
+
+
+static void dump(struct timestamp* ts, size_t count,  unsigned long id)
+{
+        while (count--)
+                printf("%lu\n", (ts++)->event);
+}
+
+
+static void die(char* msg)
+{
+        if (errno)
+                perror("error: ");
+        fprintf(stderr, "%s\n", msg);   
+        exit(1);
+}
+
+int main(int argc, char** argv) 
+{
+        void* mapped;
+        size_t size, count;
+        struct timestamp* ts;   
+        unsigned long id;
+
+        if (argc != 3)
+                die("Usage: ft2csv  <event_name>  <logfile>");
+        if (map_file(argv[2], &mapped, &size))
+                die("could not map file");
+
+        if (!str2event(argv[1], &id))
+                die("Unknown event!");
+
+        ts    = (struct timestamp*) mapped;
+        count = size / sizeof(struct timestamp);                
+
+        show_id(ts, count, id);
+
+        fprintf(stderr, "Incomplete: %d\n", incomplete);
+
+        return 0;
+}
diff --git a/src/ftcat.c b/src/ftcat.c
index bb7b3e6..151fa29 100644
--- a/src/ftcat.c
+++ b/src/ftcat.c
@@ -2,34 +2,34 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
+#include <signal.h>
+#include <stdlib.h>
 
 #include "timestamp.h"
 
+static int fd;
+
+static void on_sigint(int sig)
+{
+        close(fd);
+        exit(0);
+}
 
 static int enable_events(int fd, char* str) 
 {
-        long   id;
-        long   cmd[3];
+        unsigned long   id;
+        unsigned long   cmd[3];
 
-        if        (!strcmp(str, "sched")) {
-                id = TS_SCHED_START;            
-        } else if (!strcmp(str, "tick")) {
-                id = TS_TICK_START;
-        } else if (!strcmp(str, "plug_tick")) {
-                id = TS_PLUGIN_TICK_START;
-        } else if (!strcmp(str, "plug_sched")) {
-                id = TS_PLUGIN_SCHED_START;
-        } else
+        if (!str2event(str, &id))
                 return 0;
 
         cmd[0] = ENABLE_CMD;
         cmd[1] = id;
-        cmd[2] = id + 2;
+        cmd[2] = id + 1;
         return write(fd, cmd, 3 * sizeof(long)) == 3 * sizeof(long);
 }
 
 
-
 static void cat2stdout(int fd) 
 {
         static char buf[4096];
@@ -43,19 +43,17 @@ static void usage(void)
 {
         fprintf(stderr, 
                 "Usage: ftcat <ft device> TS1 TS2 ....\n\n"
-                "where TS1, TS2, ... is one of "
-                " sched, tick, plug_tick, plug_sched"
+                //              "where TS1, TS2, ... is one of "
+                //              " sched, tick, plug_tick, plug_sche"
                 "\n");
         exit(1);
 }
 
 int main(int argc, char** argv) 
 {
-        int fd;
-
         if (argc < 3) 
                 usage();
-
+        
         fd = open(argv[1], O_RDWR);
         if (fd < 0) {
                 perror("could not open feathertrace");
@@ -63,6 +61,7 @@ int main(int argc, char** argv)
         }
         argc -= 2;
         argv += 2;
+        signal(SIGINT,on_sigint);
         while (argc--) {
                 if (!enable_events(fd, *argv)) {
                         fprintf(stderr, "Enabling %s failed.\n", *argv);
diff --git a/src/mapping.c b/src/mapping.c
new file mode 100644
index 0000000..19d7129
--- /dev/null
+++ b/src/mapping.c
@@ -0,0 +1,35 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "mapping.h"
+
+int map_file(const char* filename, void **addr, size_t *size)
+{
+        struct stat info;
+        int error = 0;
+        int fd;
+
+        error = stat(filename, &info);
+        if (!error) {
+                *size = info.st_size;
+                if (info.st_size > 0) {
+                        fd = open(filename, O_RDWR);
+                        if (fd >= 0) {
+                                *addr = mmap(NULL, *size, 
+                                             PROT_READ | PROT_WRITE, 
+                                             MAP_PRIVATE,
+                                             fd, 0);
+                                if (*addr == MAP_FAILED)
+                                        error = -1;
+                                close(fd);
+                        } else
+                                error = fd;
+                } else
+                        *addr = NULL;
+        }
+        return error;
+}
diff --git a/src/timestamp.c b/src/timestamp.c
new file mode 100644
index 0000000..850e437
--- /dev/null
+++ b/src/timestamp.c
@@ -0,0 +1,31 @@
+#include <string.h>
+
+#include "timestamp.h"
+
+
+struct event_name {
+        const char*     name;
+        unsigned long   id;
+};
+
+#define EVENT(name) {#name, TS_ ## name ## _START}
+
+static struct event_name event_table[] = 
+{
+        EVENT(SCHED),
+        EVENT(TICK),
+        EVENT(PLUGIN_SCHED),
+        EVENT(PLUGIN_TICK)
+};
+
+int  str2event(const char* str, unsigned long *id)
+{
+        int 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;
+                }
+        return 0;
+}