make sched_trace independent from liblitmus and the kernel

This is in preparation of integration with libcairo, which
isn't available as a 64bit build on Flare.

This change will also allow us to use sched_trace tools on
systems that do not have a properly configured kernel lying around
(e.g., department machines).

4 files changed, 314 insertions, 19 deletions

diff --git a/SConstruct b/SConstruct
index fa9db86..18c040c 100644
--- a/SConstruct
+++ b/SConstruct
@@ -1,13 +1,11 @@
 # #####################################################################
 # User configuration.
-LITMUS_KERNEL = '../litmus2008'
-LIBLITMUS     = '../liblitmus2008'
+# -- Nothing to configure at the moment.
 
 # #####################################################################
 # Internal configuration.
 DEBUG_FLAGS  = '-Wall -g -Wdeclaration-after-statement'
-INCLUDE_DIRS = 'include/  %s/include/ %s/include/' % (LITMUS_KERNEL, LIBLITMUS)
-
+INCLUDE_DIRS = 'include/'
 # #####################################################################
 # Build configuration.
 from os import uname
@@ -18,25 +16,21 @@ if os != 'Linux':
     print 'Error: Building sched_trace tools is only supported on Linux.'
     Exit(1)
 
-if arch not in ('sparc64', 'i686'):
-    print 'Error: Building sched_trace tools is only supported on i686 and sparc64.'
-    Exit(1)
-
-st = Environment(
+# base config
+env = Environment(
     CC = 'gcc',
-    CPPPATH = Split(INCLUDE_DIRS),
     CCFLAGS = Split(DEBUG_FLAGS),
-    LIBS    =  'st',
-    LIBPATH = LIBLITMUS
+    CPPPATH = Split(INCLUDE_DIRS),
 )
 
-if arch == 'sparc64':
-    # build 64 bit sparc v9 binaries
-    v9 = Split('-mcpu=v9 -m64')
-    st.Append(CCFLAGS = v9, LINKFLAGS = v9)
+# Link with libcairo. For now without sched_trace support.
+cairo = env.Clone()
+cairo.ParseConfig('pkg-config --cflags --libs cairo')
 
 # #####################################################################
 # Targets: sched_trace tools
-common = ['src/load.c', 'src/eheap.c']
-st.Program('st_convert', ['src/st2pl.c'] + common)
-st.Program('st_show', ['src/showst.c'] + common)
+common = ['src/load.c', 'src/eheap.c', 'src/util.c']
+env.Program('st_convert', ['src/st2pl.c'] + common)
+env.Program('st_show', ['src/showst.c'] + common)
+
+cairo.Program('cairo_test', ['src/cairo_test.c'])
diff --git a/include/sched_trace.h b/include/sched_trace.h
new file mode 100644
index 0000000..8bdd253
--- /dev/null
+++ b/include/sched_trace.h
@@ -0,0 +1,127 @@
+#ifndef __SCHED_TRACE_H_
+#define __SCHED_TRACE_H_
+
+#include <stdint.h>
+
+typedef uint8_t  u8;
+typedef uint32_t u32;
+typedef uint16_t u16;
+typedef uint64_t u64;
+
+/* A couple of notes about the format:
+ *
+ * - make sure it is in sync with the kernel
+ * - all times in nanoseconds
+ * - endianess issues are the problem of the app
+ */
+
+struct st_trace_header {
+        u8      type;           /* Of what type is this record?  */
+        u8      cpu;            /* On which CPU was it recorded? */
+        u16     pid;            /* PID of the task.              */
+        u32     job;            /* The job sequence number.      */
+};
+
+#define ST_NAME_LEN 16
+struct st_name_data {
+        char    cmd[ST_NAME_LEN];/* The name of the executable of this process. */
+};
+
+struct st_param_data {          /* regular params */
+        u32     wcet;
+        u32     period;
+        u32     phase;
+        u8      partition;
+        u8      __unused[3];
+};
+
+struct st_release_data {        /* A job is was/is going to be released. */
+        u64     release;        /* What's the release time?              */
+        u64     deadline;       /* By when must it finish?               */
+};
+
+struct st_assigned_data {       /* A job was asigned to a CPU.           */
+        u64     when;
+        u8      target;         /* Where should it execute?              */
+        u8      __unused[3];
+};
+
+struct st_switch_to_data {      /* A process was switched to on a given CPU.   */
+        u64     when;           /* When did this occur?                        */
+        u32     exec_time;      /* Time the current job has executed.          */
+
+};
+
+struct st_switch_away_data {    /* A process was switched away from on a given CPU. */
+        u64     when;
+        u64     exec_time;
+};
+
+struct st_completion_data {     /* A job completed. */
+        u64     when;
+        u8      forced:1;       /* Set to 1 if job overran and kernel advanced to the
+                                 * next task automatically; set to 0 otherwise.
+                                 */
+        u8      __uflags:7;
+        u8      __unused[3];
+};
+
+struct st_block_data {          /* A task blocks. */
+        u64     when;
+        u64     __unused;
+};
+
+struct st_resume_data {         /* A task resumes. */
+        u64     when;
+        u64     __unused;
+};
+
+struct st_sys_release_data {
+        u64     when;
+        u64     release;
+};
+
+#define DATA(x) struct st_ ## x ## _data x;
+
+typedef enum {
+        ST_NAME = 1,            /* Start at one, so that we can spot
+                                 * uninitialized records. */
+        ST_PARAM,
+        ST_RELEASE,
+        ST_ASSIGNED,
+        ST_SWITCH_TO,
+        ST_SWITCH_AWAY,
+        ST_COMPLETION,
+        ST_BLOCK,
+        ST_RESUME,
+        ST_SYS_RELEASE,
+} st_event_record_type_t;
+
+struct st_event_record {
+        struct st_trace_header hdr;
+        union {
+                u64 raw[2];
+
+                DATA(name);
+                DATA(param);
+                DATA(release);
+                DATA(assigned);
+                DATA(switch_to);
+                DATA(switch_away);
+                DATA(completion);
+                DATA(block);
+                DATA(resume);
+                DATA(sys_release);
+
+        } data;
+};
+
+#undef DATA
+
+const char* event2name(unsigned int id);
+u64 event_time(struct st_event_record* rec);
+
+void print_event(struct st_event_record *rec);
+void print_all(struct st_event_record *rec, unsigned int count);
+
+#endif
diff --git a/src/cairo_test.c b/src/cairo_test.c
new file mode 100644
index 0000000..9c3683a
--- /dev/null
+++ b/src/cairo_test.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <cairo.h>
+
+static double in2pts(double in)
+{
+        /* 72 pts per inch */
+        return in * 72;
+}
+
+static double cm2in(double cm)
+{
+        /* 1in = 2.54 cm */
+        return cm / 2.54;
+}
+
+static double cm2pts(double cm)
+{
+        return in2pts(cm2in(cm));
+}
+
+void cairo_test(void)
+{
+        cairo_surface_t *surface;
+        cairo_t *cr;
+        
+        surface = cairo_pdf_surface_create("test.pdf", cm2pts(10), cm2pts(10));
+        cr = cairo_create(surface);
+        cairo_set_source_rgb(cr, 1.0, 0.3, 0.7);
+        cairo_rectangle(cr, cm2pts(0.25), cm2pts(0.25), cm2pts(0.5), cm2pts(0.5));
+        cairo_fill(cr);
+        cairo_destroy(cr);
+        cairo_surface_destroy(surface);
+}
+
+int main (int argc, char** argv)
+{
+        cairo_test();
+        return 0;
+}
diff --git a/src/util.c b/src/util.c
new file mode 100644
index 0000000..b603c4a
--- /dev/null
+++ b/src/util.c
@@ -0,0 +1,133 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "sched_trace.h"
+
+static const char* event_names[] = {
+        "INVALID",
+        "NAME",
+        "PARAM",
+        "RELEASE",
+        "ASSIGNED",
+        "SWITCH_TO",
+        "SWITCH_FROM",
+        "COMPLETION",
+        "BLOCK",
+        "RESUME",
+        "SYS_RELEASE",
+        "INVALID"
+};
+
+#define ST_INVALID (ST_SYS_RELEASE + 1)
+
+
+const char* event2name(unsigned int id)
+{
+        if (id >= ST_INVALID)
+                id = ST_INVALID;
+        return event_names[id];
+}
+
+
+u64 event_time(struct st_event_record* rec)
+{
+        u64 when;
+        switch (rec->hdr.type) {
+                /* the time stamp is encoded in the first payload u64 */
+        case ST_RELEASE:
+        case ST_ASSIGNED:
+        case ST_SWITCH_TO:
+        case ST_SWITCH_AWAY:
+        case ST_COMPLETION:
+        case ST_BLOCK:
+        case ST_RESUME:
+        case ST_SYS_RELEASE:
+                when = rec->data.raw[0];
+                break;
+        default:
+                /* stuff that doesn't have a time stamp should occur "early" */
+                when = 0;
+                break;
+        };
+        return when;
+}
+
+void print_header(struct st_trace_header* hdr)
+{
+        printf("%-14s %5u/%-5u on CPU%3u ",
+               event2name(hdr->type),
+               hdr->pid, hdr->job,
+               hdr->cpu);
+}
+
+typedef void (*print_t)(struct st_event_record* rec);
+
+static void print_nothing(struct st_event_record* _)
+{
+}
+
+static void print_raw(struct st_event_record* rec)
+{
+        printf(" type=%u", rec->hdr.type);
+}
+
+static void print_name(struct st_event_record* rec)
+{
+        /* terminate in all cases */
+        rec->data.name.cmd[ST_NAME_LEN - 1] = 0;
+        printf("%s", rec->data.name.cmd);
+}
+
+static void print_param(struct st_event_record* rec)
+{
+        printf("T=(cost:%6.2fms, period:%6.2fms, phase:%6.2fms), part=%d",
+               rec->data.param.wcet   / 1000000.0,
+               rec->data.param.period / 1000000.0,
+               rec->data.param.phase  / 1000000.0,\
+               rec->data.param.partition);
+}
+
+static void print_time_data2(struct st_event_record* rec)
+{
+        printf("%6.2fms", rec->data.raw[1] / 1000000.0);
+}
+
+static print_t print_detail[] = {
+        print_raw,              /* invalid */
+        print_name,             /* NAME  */
+        print_param,            /* PARAM */
+        print_time_data2,       /* RELEASE */
+        print_nothing,          /* ASSIGNED */
+        print_nothing,          /* SWITCH_TO */
+        print_nothing,          /* SWITCH_FROM */
+        print_nothing,          /* COMPLETION */
+        print_nothing,          /* BLOCK */
+        print_nothing,          /* RESUME */
+        print_time_data2,       /* SYS_RELEASE */
+        print_raw,              /* invalid */
+};
+
+void print_event(struct st_event_record *rec)
+{
+        unsigned int id = rec->hdr.type;
+
+        if (id >= ST_INVALID)
+                id = ST_INVALID;
+        print_header(&rec->hdr);
+        print_detail[id](rec);
+        printf("\n");
+}
+
+void print_all(struct st_event_record *rec, unsigned int count)
+{
+        unsigned int i;
+        for (i = 0; i < count; i++)
+                print_event(&rec[i]);
+}