From b5760d873dabcfbd062de3c49f52cb4957354fea Mon Sep 17 00:00:00 2001 From: Glenn Elliott Date: Tue, 14 Jan 2014 16:51:23 -0500 Subject: sched_trace: Trace PGM node type parameters --- include/litmus/rt_param.h | 8 ++++++++ include/litmus/sched_trace.h | 24 +++++++++++++++++++++--- include/trace/events/litmus.h | 21 +++++++++++++++++++++ litmus/litmus.c | 22 ++++++++++++++++++---- litmus/sched_cfl_split.c | 6 ++++-- litmus/sched_task_trace.c | 15 +++++++++++++-- 6 files changed, 85 insertions(+), 11 deletions(-) diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h index 6160a1635227..0ddc1973b0aa 100644 --- a/include/litmus/rt_param.h +++ b/include/litmus/rt_param.h @@ -51,6 +51,13 @@ typedef enum { TASK_EARLY } release_policy_t; +typedef enum { + PGM_NOT_A_NODE, + PGM_SRC, + PGM_SINK, + PGM_INTERNAL +} pgm_node_type_t; + /* We use the common priority interpretation "lower index == higher priority", * which is commonly used in fixed-priority schedulability analysis papers. * So, a numerically lower priority value implies higher scheduling priority, @@ -82,6 +89,7 @@ struct rt_task { task_class_t cls; budget_policy_t budget_policy; /* ignored by pfair */ release_policy_t release_policy; + pgm_node_type_t pgm_type; }; union np_flag { diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h index 3d3b06ced797..8e2aefecd1fe 100644 --- a/include/litmus/sched_trace.h +++ b/include/litmus/sched_trace.h @@ -80,6 +80,12 @@ struct st_sys_release_data { u64 release; }; +struct st_pgm_param_data { + u32 node_type; + u16 graph_pid; + u8 __unused[10]; +}; + struct st_pgm_release_data { u64 release; /* PGM-adjusted release time */ u64 deadline; /* PGM-adjusted deadline */ @@ -100,6 +106,7 @@ typedef enum { ST_RESUME, ST_ACTION, ST_SYS_RELEASE, + ST_PGM_PARAM, ST_PGM_RELEASE } st_event_record_type_t; @@ -119,6 +126,7 @@ struct st_event_record { DATA(resume); DATA(action); DATA(sys_release); + DATA(pgm_param); DATA(pgm_release); } data; }; @@ -161,6 +169,8 @@ feather_callback void do_sched_trace_action(unsigned long id, unsigned long action); feather_callback void do_sched_trace_sys_release(unsigned long id, lt_t* start); +feather_callback void do_sched_trace_pgm_param(unsigned long id, + struct task_struct* task); feather_callback void do_sched_trace_pgm_release(unsigned long id, struct task_struct* task); @@ -188,6 +198,7 @@ feather_callback void do_sched_trace_pgm_release(unsigned long id, #define trace_litmus_task_block(t) #define trace_litmus_task_resume(t) #define trace_litmus_sys_release(start) +#define trace_litmus_pgm_param(t) #define trace_litmus_pgm_release(t) #endif @@ -262,10 +273,17 @@ feather_callback void do_sched_trace_pgm_release(unsigned long id, trace_litmus_sys_release(when); \ } while (0) +#define sched_trace_pgm_param(t) \ + do { \ + SCHED_TRACE(SCHED_TRACE_BASE_ID + 11, \ + do_sched_trace_pgm_param, t); \ + trace_litmus_pgm_param(t); \ + } while (0) + #define sched_trace_pgm_release(t) \ - do { \ - SCHED_TRACE(SCHED_TRACE_BASE_ID + 11, \ - do_sched_trace_pgm_release, t); \ + do { \ + SCHED_TRACE(SCHED_TRACE_BASE_ID + 12, \ + do_sched_trace_pgm_release, t); \ trace_litmus_pgm_release(t); \ } while (0) diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h index 0b4eac386dfe..0822328144bc 100644 --- a/include/trace/events/litmus.h +++ b/include/trace/events/litmus.h @@ -225,6 +225,27 @@ TRACE_EVENT(litmus_sys_release, TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when) ); +/* Tracing PGM node parameters */ +TRACE_EVENT(litmus_pgm_param, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( pgm_node_type_t, node_type ) + __field( pid_t, graph_pid ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->node_type = t ? t->rt_params.task_params.pgm_type : PGM_NOT_A_NODE; + __entry->graph_pid = t ? t->tgid : 0; + ) + + TP_printk("pgm node (%u, node type = %d) in graph (%u)\n", + __entry->pid, __entry->node_type, __entry->graph_pid); /* * Tracing PGM-adjusted job release */ diff --git a/litmus/litmus.c b/litmus/litmus.c index 48d24eb5f4d8..6f6479b10db0 100644 --- a/litmus/litmus.c +++ b/litmus/litmus.c @@ -107,12 +107,19 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param) if (tp.relative_deadline == 0) tp.relative_deadline = tp.period; - if (tp.exec_cost <= 0) + if (tp.exec_cost <= 0) { + printk(KERN_INFO "litmus: real-time task %d rejected " + "because declared job execution time <= 0.", pid); goto out_unlock; - if (tp.period <= 0) + } + if (tp.period <= 0) { + printk(KERN_INFO "litmus: real-time task %d rejected " + "because declared job period <= 0.", pid); goto out_unlock; - if (!cpu_online(tp.cpu)) + } + if (!cpu_online(tp.cpu)) { goto out_unlock; + } if (min(tp.relative_deadline, tp.period) < tp.exec_cost) /*density check*/ { printk(KERN_INFO "litmus: real-time task %d rejected " @@ -331,9 +338,13 @@ long litmus_admit_task(struct task_struct* tsk) if (get_rt_relative_deadline(tsk) == 0 || get_exec_cost(tsk) > min(get_rt_relative_deadline(tsk), get_rt_period(tsk)) ) { + printk(KERN_INFO "litmus: invalid task parameters " + "(e = %llu, p = %llu, d = %llu)\n", + get_exec_cost(tsk), get_rt_period(tsk), + get_rt_relative_deadline(tsk)); TRACE_TASK(tsk, "litmus admit: invalid task parameters " - "(e = %lu, p = %lu, d = %lu)\n", + "(e = %llu, p = %llu, d = %llu)\n", get_exec_cost(tsk), get_rt_period(tsk), get_rt_relative_deadline(tsk)); retval = -EINVAL; @@ -341,6 +352,8 @@ long litmus_admit_task(struct task_struct* tsk) } if (!cpu_online(get_partition(tsk))) { + printk(KERN_INFO "litmus: cpu %d is not online\n", + get_partition(tsk)); TRACE_TASK(tsk, "litmus admit: cpu %d is not online\n", get_partition(tsk)); retval = -EINVAL; @@ -369,6 +382,7 @@ long litmus_admit_task(struct task_struct* tsk) if (!retval) { sched_trace_task_name(tsk); sched_trace_task_param(tsk); + sched_trace_pgm_param(tsk); atomic_inc(&rt_task_count); } diff --git a/litmus/sched_cfl_split.c b/litmus/sched_cfl_split.c index ad398470a495..b6dde71cdf84 100644 --- a/litmus/sched_cfl_split.c +++ b/litmus/sched_cfl_split.c @@ -850,8 +850,10 @@ static long cflsplit_admit_task(struct task_struct* tsk) if (remote_cluster(task_cpu(tsk)) != task_cpu_cluster(tsk)) { unsigned int assigned_cpu = get_partition(tsk); unsigned int cur_cpu = task_cpu(tsk); - TRACE_TASK(tsk, "cluster mismatch: assigned cpu %u but on cpu %u\n", - assigned_cpu, cur_cpu); + printk(KERN_INFO "cluster mismatch: %u assigned cpu %d but on cpu %d\n", + tsk->pid, assigned_cpu, cur_cpu); + TRACE_TASK(tsk, "cluster mismatch: assigned cpu %d but on cpu %d\n", + assigned_cpu, cur_cpu); return -EINVAL; } return 0; diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c index 422314f29a60..b9e772c07652 100644 --- a/litmus/sched_task_trace.c +++ b/litmus/sched_task_trace.c @@ -238,13 +238,24 @@ feather_callback void do_sched_trace_action(unsigned long id, } } +feather_callback void do_sched_trace_pgm_param(unsigned long id, unsigned long _task) +{ + struct task_struct *t = (struct task_struct*) _task; + struct st_event_record* rec = get_record(ST_PGM_PARAM, t); + if (rec) { + rec->data.pgm_param.node_type = tsk_rt(t)->task_params.pgm_type; + rec->data.pgm_param.graph_pid = t->tgid; + put_record(rec); + } +} + feather_callback void do_sched_trace_pgm_release(unsigned long id, unsigned long _task) { struct task_struct *t = (struct task_struct*) _task; struct st_event_record* rec = get_record(ST_PGM_RELEASE, t); if (rec) { - rec->data.release.release = get_release(t); - rec->data.release.deadline = get_deadline(t); + rec->data.pgm_release.release = get_release(t); + rec->data.pgm_release.deadline = get_deadline(t); put_record(rec); } } -- cgit v1.2.2