Add Color Queue tracing.

author: Christopher Kenna <cjk@cs.unc.edu> 2012-10-24 16:39:04 -0400
committer: Christopher Kenna <cjk@cs.unc.edu> 2012-10-24 16:40:21 -0400
commit: 0a6081a7798ce1ac61823c41a670beafbafb0435 (patch)
tree: fea2547df8b34126f06d037d2d5765b48205d9cc
parent: 97f6b3f52bc3059f6e5fb7c6744d6384b4fca95d (diff)
3 files changed, 91 insertions, 4 deletions
diff --git a/include/litmus/trace.h b/include/litmus/trace.h
index c0842247ad8e..a1d68d99c4df 100644
--- a/include/litmus/trace.h
+++ b/include/litmus/trace.h
@@ -115,9 +115,41 @@ feather_callback void save_task_latency(unsigned long event, unsigned long when_
 #define TS_PLUGIN_TICK_START            /* TIMESTAMP(130) */
 #define TS_PLUGIN_TICK_END              /* TIMESTAMP(131) */
+/* Color Queue stuff */
+#define TS_CQ_ENQUEUE_READ_START        DTIMESTAMP(124, TSK_RT)
+#define TS_CQ_ENQUEUE_READ_END          DTIMESTAMP(125, TSK_RT)
+#define TS_CQ_ENQUEUE_FLUSH_START       DTIMESTAMP(126, TSK_RT)
+#define TS_CQ_ENQUEUE_FLUSH_END         DTIMESTAMP(127, TSK_RT)
+#define TS_CQ_SUBMIT_WORK_START         DTIMESTAMP(128, TSK_RT)
+#define TS_CQ_SUBMIT_WORK_END           DTIMESTAMP(129, TSK_RT)
+/* Skip 130/131 */
+#define TS_CQ_LOOP_WORK_CHECK_START     DTIMESTAMP(132, TSK_RT)
+#define TS_CQ_LOOP_WORK_CHECK_END       DTIMESTAMP(133, TSK_RT)
+#define TS_CQ_LOOP_PEACE_OUT_START      DTIMESTAMP(134, TSK_RT)
+#define TS_CQ_LOOP_PEACE_OUT_END        DTIMESTAMP(135, TSK_RT)
+#define TS_CQ_LOOP_BRANCH_START         DTIMESTAMP(136, TSK_RT)
+#define TS_CQ_LOOP_BRANCH_END           DTIMESTAMP(137, TSK_RT)
+#define TS_CQ_WORK_DO_WORK_START        DTIMESTAMP(138, TSK_RT)
+#define TS_CQ_WORK_DO_WORK_END          DTIMESTAMP(139, TSK_RT)
+/* Not Color Queue */
 #define TS_ENTER_NP_START               TIMESTAMP(140)
 #define TS_ENTER_NP_END                 TIMESTAMP(141)
+/* Two more Color Queue event */
+#define TS_CQ_WORK_NOTIFY_START         DTIMESTAMP(142, TSK_RT)
+#define TS_CQ_WORK_NOTIFY_END           DTIMESTAMP(143, TSK_RT)
+#define TS_CQ_PHASE_WAIT_START          DTIMESTAMP(144, TSK_RT)
+#define TS_CQ_PHASE_WAIT_END            DTIMESTAMP(145, TSK_RT)
 #define TS_EXIT_NP_START                TIMESTAMP(150)
 #define TS_EXIT_NP_END                  TIMESTAMP(151)
@@ -137,4 +169,6 @@ feather_callback void save_task_latency(unsigned long event, unsigned long when_
 #define TS_RELEASE_LATENCY(when)        LTIMESTAMP(208, &(when))
 #endif /* !_SYS_TRACE_H_ */
diff --git a/litmus/color_queue.c b/litmus/color_queue.c
index 46c725799308..c37aeb8c1389 100644
--- a/litmus/color_queue.c
+++ b/litmus/color_queue.c
@@ -7,6 +7,7 @@
 #include <litmus/lockdown.h>
 #include <litmus/color.h>
 #include <litmus/litmus.h>
+#include <litmus/trace.h>
 /* Uncomment to debug. */
 #define QTRACE(q, fmt, args...) TRACE_CUR("q.phase: %llu  q.way: %d  " \
@@ -97,6 +98,7 @@ static void cpu_add_work(struct color_queue_request *req)
 */
 static void color_page_info_add_work(struct color_page_info *info, void *vaddr_start)
 {
+        const int cpu = smp_processor_id();
        int i;
        TRACE_CUR("adding work for color_page_info: 0x%p\n", info);
@@ -109,7 +111,7 @@ static void color_page_info_add_work(struct color_page_info *info, void *vaddr_s
                                "request was not idle!\n");
                req->request_type = COLOR_QUEUE_READ;
-                req->cpu = smp_processor_id();
+                req->cpu = cpu;
                req->request_data.read.vaddr = work_vaddr;
                cpu_add_work(req);
        }
@@ -127,6 +129,8 @@ int color_queue_enqueue_read(struct task_struct *ts)
 {
        struct color_page_info *cur_info;
+        TS_CQ_ENQUEUE_READ_START;
        TRACE_CUR("enqueue read prev: %p  next: %p\n",
                        tsk_rt(ts)->color_page_info_list.prev,
                        tsk_rt(ts)->color_page_info_list.next);
@@ -141,6 +145,8 @@ int color_queue_enqueue_read(struct task_struct *ts)
                color_page_info_add_work(cur_info, vaddr_start);
        }
+        TS_CQ_ENQUEUE_READ_END;
        return color_queue_submit_work();
 }
@@ -155,6 +161,8 @@ int color_queue_enqueue_flush(struct task_struct *ts)
 {
        struct color_page_info *cur_info;
+        TS_CQ_ENQUEUE_FLUSH_START;
        list_for_each_entry(cur_info,
                        &tsk_rt(ts)->color_page_info_list,
                        list)
@@ -165,6 +173,8 @@ int color_queue_enqueue_flush(struct task_struct *ts)
                color_page_info_add_work(cur_info, vaddr_start);
        }
+        TS_CQ_ENQUEUE_FLUSH_END;
        return color_queue_submit_work();
 }
@@ -190,6 +200,7 @@ static void do_work_son(struct color_queue_request *request)
 {
        struct cpu_entry *entry;
+        TS_CQ_WORK_DO_WORK_START;
        switch (request->request_type) {
                case COLOR_QUEUE_IDLE:
                        TRACE_CUR("idle work in the queue!\n");
@@ -200,7 +211,9 @@ static void do_work_son(struct color_queue_request *request)
                        do_work_read(request);
                        break;
        }
+        TS_CQ_WORK_DO_WORK_END;
+        TS_CQ_WORK_NOTIFY_START;
        /* Tell the (possibly remote) CPU that we're a bro and helped out. */
        entry = &per_cpu(cpu_entries, request->cpu);
        raw_spin_lock(&entry->lock);
@@ -210,6 +223,7 @@ static void do_work_son(struct color_queue_request *request)
        /* work is done, set it idle */
        request->request_type = COLOR_QUEUE_IDLE;
+        TS_CQ_WORK_NOTIFY_END;
 }
 static void wait_next_phase(void)
@@ -217,6 +231,8 @@ static void wait_next_phase(void)
        struct cpu_entry *entry = &__get_cpu_var(cpu_entries);
        struct color_queue_request *request;
+        TS_CQ_PHASE_WAIT_START;
        for (;;) {
                raw_spin_lock(&color_queue.lock);
                if (entry->phase < color_queue.phase) {
@@ -228,6 +244,7 @@ static void wait_next_phase(void)
                                        "cpu->phase: %d advances to a higher phase\n",
                                        entry->phase);
                        raw_spin_unlock(&color_queue.lock);
+                        TS_CQ_PHASE_WAIT_END;
                        return;
                }
@@ -271,11 +288,14 @@ static int color_queue_loop(void)
        int nr_work, nr_work_done_by_task = 0;
        for (;;) {
+                TS_CQ_LOOP_WORK_CHECK_START;
                raw_spin_lock(&entry->lock);
                nr_work = entry->nr_work;
                raw_spin_unlock(&entry->lock);
+                TS_CQ_LOOP_WORK_CHECK_END;
                if (0 == nr_work) {
+                        TS_CQ_LOOP_PEACE_OUT_START;
                        /* All the work is done for this CPU. We can leave. */
                        raw_spin_lock(&color_queue.lock);
                        color_queue.nr_cpus--;
@@ -286,17 +306,20 @@ static int color_queue_loop(void)
                        }
                        QTRACE(color_queue, "just left the queue\n");
                        raw_spin_unlock(&color_queue.lock);
+                        TS_CQ_LOOP_PEACE_OUT_END;
                        return nr_work_done_by_task;
                }
                /* Our work is not done, so continue processing more work. */
+                TS_CQ_LOOP_BRANCH_START;
                raw_spin_lock(&color_queue.lock);
                if (unlikely(list_empty(&color_queue.queue))) {
                        /* can this happen? */
                        QTRACE(color_queue, "color queue was empty?\n");
                        WARN(1, "color queue list was empty...\n");
                        raw_spin_unlock(&color_queue.lock);
+                        TS_CQ_LOOP_BRANCH_END;
                        continue;
                }
                request = list_first_entry(&color_queue.queue,
@@ -306,6 +329,7 @@ static int color_queue_loop(void)
                        list_del(&request->list);
                        QTRACE(color_queue, "found a piece of work to do: %p\n", request);
                        raw_spin_unlock(&color_queue.lock);
+                        TS_CQ_LOOP_BRANCH_END;
                        do_work_son(request);
                        ++nr_work_done_by_task;
                } else {
@@ -313,6 +337,7 @@ static int color_queue_loop(void)
                        color_queue.at_barrier++;
                        QTRACE(color_queue, "begins to wait at barrier...\n");
                        raw_spin_unlock(&color_queue.lock);
+                        TS_CQ_LOOP_BRANCH_END;
                        wait_next_phase();
                }
        }
@@ -323,7 +348,11 @@ static int color_queue_loop(void)
 */
 static int color_queue_submit_work(void)
 {
-        struct cpu_entry *entry = &__get_cpu_var(cpu_entries);
+        struct cpu_entry *entry;
+        TS_CQ_SUBMIT_WORK_START;
+        entry = &__get_cpu_var(cpu_entries);
        raw_spin_lock(&color_queue.lock);
        QTRACE(color_queue, "start submit work\n");
@@ -332,6 +361,9 @@ static int color_queue_submit_work(void)
        list_splice_tail_init(&entry->enqueue, &color_queue.queue);
        QTRACE(color_queue, "end submit work\n");
        raw_spin_unlock(&color_queue.lock);
+        TS_CQ_SUBMIT_WORK_END;
        return color_queue_loop();
 }
@@ -427,7 +459,7 @@ static int __init init_color_queue(void)
        BUILD_BUG_ON((PAGE_SIZE % COLOR_QUEUE_REQ_SIZE) != 0);
-        for_each_online_cpu(cpu) {      
+        for_each_online_cpu(cpu) {
                cpu_entry = &per_cpu(cpu_entries, cpu);
                INIT_LIST_HEAD(&cpu_entry->enqueue);
                cpu_entry->nr_work = 0;
diff --git a/litmus/lockdown.c b/litmus/lockdown.c
index d0dee3ae2d83..bb93690c00c9 100644
--- a/litmus/lockdown.c
+++ b/litmus/lockdown.c
@@ -100,6 +100,27 @@ void set_lockdown(u32 lockdown_state)
        writel_relaxed(lockdown_state, lockreg_d);
 }
+u32 color_read_in_mem(u32 lock_val, u32 unlock_val, void *start, void *end)
+{
+        u32 v = 0;
+        __asm__ __volatile__ (
+"       .align 5\n"
+"       str     %[lockval], [%[cachereg]]\n"
+"1:     ldr     %[val], [%[addr]], #32          @ 32 bytes = 1 cache line\n"
+"       cmp     %[end], %[addr]                 @ subtracts addr from end\n"
+"       bgt     1b\n                            @ read more, if necessary\n"
+        : [addr] "+r" (start),
+          [val] "+r" (v)
+        : [end] "r" (end),
+          [cachereg] "r" (lockreg_d),
+          [lockval] "r" (lock_val)
+        : "cc");
+        return v;
+}
 /*
 * Prefetch by reading the first word of each cache line in a page.
 *
@@ -111,7 +132,7 @@ void set_lockdown(u32 lockdown_state)
 *
 * Assumes: addr < end_addr AND addr != end_addr
 */
-u32 color_read_in_mem(u32 lock_val, u32 unlock_val, void *start, void *end)
+u32 color_read_in_mem_lock(u32 lock_val, u32 unlock_val, void *start, void *end)
 {
        unsigned long flags;
        u32 v = 0;
author	Christopher Kenna <cjk@cs.unc.edu>	2012-10-24 16:39:04 -0400
committer	Christopher Kenna <cjk@cs.unc.edu>	2012-10-24 16:40:21 -0400
commit	0a6081a7798ce1ac61823c41a670beafbafb0435 (patch)
tree	fea2547df8b34126f06d037d2d5765b48205d9cc
parent	97f6b3f52bc3059f6e5fb7c6744d6384b4fca95d (diff)