2278 lines
58 KiB
C
Executable file
2278 lines
58 KiB
C
Executable file
/*
|
|
* Copyright (C) 2019 Park Bumgyu <bumgyu.park@samsung.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#undef TRACE_SYSTEM
|
|
#define TRACE_SYSTEM ems_debug
|
|
|
|
#if !defined(_TRACE_EMS_DEBUG_H) || defined(TRACE_HEADER_MULTI_READ)
|
|
#define _TRACE_EMS_DEBUG_H
|
|
|
|
#include <linux/tracepoint.h>
|
|
|
|
struct mlt;
|
|
struct rq;
|
|
struct tp_env;
|
|
struct cpu_profile;
|
|
|
|
/*
|
|
* Tracepoint for multiple test
|
|
*/
|
|
TRACE_EVENT(ems_test,
|
|
|
|
TP_PROTO(struct task_struct *p, int cpu, u64 arg1, u64 arg2, char *event),
|
|
|
|
TP_ARGS(p, cpu, arg1, arg2, event),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, cpu )
|
|
__field( u64, arg1 )
|
|
__field( u64, arg2 )
|
|
__array( char, event, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p ? p->comm : "no task", TASK_COMM_LEN);
|
|
__entry->pid = p ? p->pid : -1;
|
|
__entry->cpu = cpu;
|
|
__entry->arg1 = arg1;
|
|
__entry->arg2 = arg2;
|
|
strncpy(__entry->event, event ? event : "no event", 63);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d cpu=%d arg1=%llu arg2=%llu event=%s",
|
|
__entry->comm, __entry->pid, __entry->cpu,
|
|
__entry->arg1, __entry->arg2, __entry->event)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for taking util snapshot
|
|
*/
|
|
TRACE_EVENT(ems_take_util_snapshot,
|
|
|
|
TP_PROTO(int cpu, struct tp_env *env),
|
|
|
|
TP_ARGS(cpu, env),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( unsigned long, cpu)
|
|
__field( unsigned long, task_util)
|
|
__field( unsigned long, task_util_clamped)
|
|
__field( unsigned long, task_load_avg)
|
|
__field( unsigned long, util)
|
|
__field( unsigned long, util_wo)
|
|
__field( unsigned long, util_with)
|
|
__field( unsigned long, runnable)
|
|
__field( unsigned long, load_avg)
|
|
__field( unsigned long, rt_util)
|
|
__field( unsigned long, dl_util)
|
|
__field( unsigned int, nr_running)
|
|
__field( int, idle)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, env->p->comm, TASK_COMM_LEN);
|
|
__entry->pid = env->p->pid;
|
|
__entry->cpu = cpu;
|
|
__entry->task_util = env->task_util;
|
|
__entry->task_util_clamped = env->task_util_clamped;
|
|
__entry->task_load_avg = env->task_load_avg;
|
|
__entry->util = env->cpu_stat[cpu].util;
|
|
__entry->util_wo = env->cpu_stat[cpu].util_wo;
|
|
__entry->util_with = env->cpu_stat[cpu].util_with;
|
|
__entry->runnable = env->cpu_stat[cpu].runnable;
|
|
__entry->load_avg = env->cpu_stat[cpu].load_avg;
|
|
__entry->rt_util = env->cpu_stat[cpu].rt_util;
|
|
__entry->dl_util = env->cpu_stat[cpu].dl_util;
|
|
__entry->nr_running = env->cpu_stat[cpu].nr_running;
|
|
__entry->idle = env->cpu_stat[cpu].idle;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d cpu=%u "
|
|
"task_util=%lu task_util_clamped=%lu task_load_avg=%lu "
|
|
"util=%lu util_wo=%lu util_with=%lu runnable=%lu load_avg=%lu "
|
|
"rt_util=%lu dl_util=%lu nr_running=%u idle=%d",
|
|
__entry->comm, __entry->pid, __entry->cpu,
|
|
__entry->task_util, __entry->task_util_clamped,
|
|
__entry->task_load_avg,
|
|
__entry->util, __entry->util_wo, __entry->util_with,
|
|
__entry->runnable, __entry->load_avg,
|
|
__entry->rt_util, __entry->dl_util,
|
|
__entry->nr_running, __entry->idle)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for setting fit_cpus by prio pinning
|
|
*/
|
|
TRACE_EVENT(tex_boosted_fit_cpus,
|
|
|
|
TP_PROTO(struct task_struct *p, int sync, struct cpumask *fit_cpus),
|
|
|
|
TP_ARGS(p, sync, fit_cpus),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, prev_cpu )
|
|
__field( int, sync )
|
|
__field( unsigned int, fit_cpus )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->prev_cpu = task_cpu(p);
|
|
__entry->sync = sync;
|
|
__entry->fit_cpus = *(unsigned int *)cpumask_bits(fit_cpus);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d prev_cpu=%d sync=%d fit_cpus=%#x",
|
|
__entry->comm, __entry->pid, __entry->prev_cpu, __entry->sync,
|
|
__entry->fit_cpus)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for prio pinning schedule
|
|
*/
|
|
TRACE_EVENT(tex_pinning_schedule,
|
|
|
|
TP_PROTO(int target_cpu, struct cpumask *candidates),
|
|
|
|
TP_ARGS(target_cpu, candidates),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, target_cpu )
|
|
__field( unsigned int, candidates )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->target_cpu = target_cpu;
|
|
__entry->candidates = *(unsigned int *)cpumask_bits(candidates);
|
|
),
|
|
|
|
TP_printk("target_cpu=%d candidates=%#x",
|
|
__entry->target_cpu, __entry->candidates)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for tex update stats
|
|
*/
|
|
TRACE_EVENT(tex_update_stats,
|
|
|
|
TP_PROTO(struct task_struct *p, char *reason),
|
|
|
|
TP_ARGS(p, reason),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, tex_lv )
|
|
__field( int, prio )
|
|
__field( u64, tex_runtime )
|
|
__field( u64, tex_chances )
|
|
__array( char, reason, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->tex_lv = get_tex_level(p);
|
|
__entry->prio = p->prio;
|
|
__entry->tex_runtime = ems_tex_runtime(p);
|
|
__entry->tex_chances = ems_tex_chances(p);
|
|
strncpy(__entry->reason, reason, 63);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d tex_lv=%d prio=%d tex_runtime=%llu tex_chances=%llu reason=%s",
|
|
__entry->comm, __entry->pid, __entry->tex_lv,
|
|
__entry->prio, __entry->tex_runtime, __entry->tex_chances,
|
|
__entry->reason)
|
|
);
|
|
|
|
/*
|
|
* Template for tex task
|
|
*/
|
|
DECLARE_EVENT_CLASS(tex_task_trace_template,
|
|
|
|
TP_PROTO(struct task_struct *p),
|
|
|
|
TP_ARGS(p),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, tex_lv )
|
|
__field( int, prio )
|
|
__field( u64, tex_runtime )
|
|
__field( u64, tex_chances )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->tex_lv = get_tex_level(p);
|
|
__entry->prio = p->prio;
|
|
__entry->tex_runtime = ems_tex_runtime(p);
|
|
__entry->tex_chances = ems_tex_chances(p);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d tex_lv=%d prio=%d tex_runtime=%llu tex_chances=%llu",
|
|
__entry->comm, __entry->pid, __entry->tex_lv,
|
|
__entry->prio, __entry->tex_runtime, __entry->tex_chances)
|
|
);
|
|
|
|
/* Tracepoint for task picked by queue jump */
|
|
DEFINE_EVENT(tex_task_trace_template, tex_qjump_pick_next_task,
|
|
TP_PROTO(struct task_struct *p), TP_ARGS(p));
|
|
|
|
/* Tracepoint for insert tex task to qjump list */
|
|
DEFINE_EVENT(tex_task_trace_template, tex_insert_to_qjump_list,
|
|
TP_PROTO(struct task_struct *p), TP_ARGS(p));
|
|
|
|
/* Tracepoint for remove tex task from qjump list*/
|
|
DEFINE_EVENT(tex_task_trace_template, tex_remove_from_qjump_list,
|
|
TP_PROTO(struct task_struct *p), TP_ARGS(p));
|
|
|
|
/*
|
|
* Tracepoint for check preempt
|
|
*/
|
|
TRACE_EVENT(tex_check_preempt_wakeup,
|
|
|
|
TP_PROTO(struct task_struct *curr, struct task_struct *p, bool preempt, bool ignore),
|
|
|
|
TP_ARGS(curr, p, preempt, ignore),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, curr_comm, TASK_COMM_LEN )
|
|
__field( int, curr_tex )
|
|
__array( char, p_comm, TASK_COMM_LEN )
|
|
__field( int, p_tex )
|
|
__field( bool, preempt )
|
|
__field( bool, ignore )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->curr_comm, curr->comm, TASK_COMM_LEN);
|
|
__entry->curr_tex = get_tex_level(curr);
|
|
memcpy(__entry->p_comm, p->comm, TASK_COMM_LEN);
|
|
__entry->p_tex = get_tex_level(p);
|
|
__entry->preempt = preempt;
|
|
__entry->ignore = ignore;
|
|
),
|
|
|
|
TP_printk("curr_comm=%s curr_tex=%d p_comm=%s p_tex=%d preempt=%d ignore=%d",
|
|
__entry->curr_comm, __entry->curr_tex, __entry->p_comm, __entry->p_tex,
|
|
__entry->preempt, __entry->ignore)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for finding best perf cpu
|
|
*/
|
|
TRACE_EVENT(ems_find_best_perf_cpu,
|
|
|
|
TP_PROTO(struct tp_env *env, int best_cpu),
|
|
|
|
TP_ARGS(env, best_cpu),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, task_util )
|
|
__field( int, best_cpu )
|
|
__field( int, idle )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, env->p->comm, TASK_COMM_LEN);
|
|
__entry->pid = env->p->pid;
|
|
__entry->task_util = env->task_util;
|
|
__entry->best_cpu = best_cpu;
|
|
__entry->idle = best_cpu < 0 ? -1 : env->cpu_stat[best_cpu].idle;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d tsk_util=%d best_cpu=%d idle=%d",
|
|
__entry->comm, __entry->pid, __entry->task_util,
|
|
__entry->best_cpu, __entry->idle)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for finding lowest energy cpu
|
|
*/
|
|
TRACE_EVENT(ems_find_energy_cpu,
|
|
|
|
TP_PROTO(struct task_struct *p, struct cpumask *candidates,
|
|
int energy_cpu, int adv_energy_cpu),
|
|
|
|
TP_ARGS(p, candidates, energy_cpu, adv_energy_cpu),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( unsigned int, candidates )
|
|
__field( int, energy_cpu )
|
|
__field( int, adv_energy_cpu )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->candidates = *(unsigned int *)cpumask_bits(candidates);
|
|
__entry->energy_cpu = energy_cpu;
|
|
__entry->adv_energy_cpu = adv_energy_cpu;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d candidates=%#x energy_cpu=%d adv_energy_cpu=%d",
|
|
__entry->comm, __entry->pid, __entry->candidates,
|
|
__entry->energy_cpu, __entry->adv_energy_cpu)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for computing energy
|
|
*/
|
|
TRACE_EVENT(ems_compute_energy,
|
|
|
|
TP_PROTO(int cpu, unsigned long util, unsigned long cap,
|
|
unsigned long f, unsigned long v, unsigned long t,
|
|
unsigned long dp, unsigned long sp, unsigned long energy),
|
|
|
|
TP_ARGS(cpu, util, cap, f, v, t, dp, sp, energy),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, util )
|
|
__field( unsigned long, cap )
|
|
__field( unsigned long, f )
|
|
__field( unsigned long, v )
|
|
__field( unsigned long, t )
|
|
__field( unsigned long, dp )
|
|
__field( unsigned long, sp )
|
|
__field( unsigned long, energy )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->util = util;
|
|
__entry->cap = cap;
|
|
__entry->f = f;
|
|
__entry->v = v;
|
|
__entry->t = t;
|
|
__entry->dp = dp;
|
|
__entry->sp = sp;
|
|
__entry->energy = energy;
|
|
),
|
|
|
|
TP_printk("cpu=%d util=%lu cap=%lu f=%lu v=%lu t=%lu dp=%lu sp=%lu energy=%lu",
|
|
__entry->cpu, __entry->util, __entry->cap,
|
|
__entry->f, __entry->v, __entry->t, __entry->dp, __entry->sp, __entry->energy)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for computing DSU energy
|
|
*/
|
|
TRACE_EVENT(ems_compute_sl_energy,
|
|
|
|
TP_PROTO(struct cpumask *cpus, unsigned long sp, unsigned long energy),
|
|
|
|
TP_ARGS(cpus, sp, energy),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( unsigned int, cpus )
|
|
__field( unsigned long, sp )
|
|
__field( unsigned long, energy )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpus = *(unsigned int *)cpumask_bits(cpus);
|
|
__entry->sp = sp;
|
|
__entry->energy = energy;
|
|
),
|
|
|
|
TP_printk("cpus=%#x sp=%lu energy=%lu",
|
|
__entry->cpus, __entry->sp, __entry->energy)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for computing DSU energy
|
|
*/
|
|
TRACE_EVENT(ems_compute_dsu_energy,
|
|
|
|
TP_PROTO(unsigned long freq, unsigned long volt,
|
|
unsigned long dp, unsigned long sp, unsigned long energy),
|
|
|
|
TP_ARGS(freq, volt, dp, sp, energy),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( unsigned long, freq )
|
|
__field( unsigned long, volt )
|
|
__field( unsigned long, dp )
|
|
__field( unsigned long, sp )
|
|
__field( unsigned long, energy )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->freq = freq;
|
|
__entry->volt = volt;
|
|
__entry->dp = dp;
|
|
__entry->sp = sp;
|
|
__entry->energy = energy;
|
|
),
|
|
|
|
TP_printk("freq=%lu volt=%lu dp=%lu sp=%lu energy=%lu",
|
|
__entry->freq, __entry->volt, __entry->dp, __entry->sp, __entry->energy)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for computing system energy
|
|
*/
|
|
TRACE_EVENT(ems_compute_system_energy,
|
|
|
|
TP_PROTO(struct task_struct *p, const struct cpumask *candidates,
|
|
int target_cpu, unsigned long energy),
|
|
|
|
TP_ARGS(p, candidates, target_cpu, energy),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( unsigned int, candidates )
|
|
__field( int, target_cpu )
|
|
__field( unsigned long, energy )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->candidates = *(unsigned int *)cpumask_bits(candidates);
|
|
__entry->target_cpu = target_cpu;
|
|
__entry->energy = energy;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d candidates=%#x target_cpu=%d energy=%lu",
|
|
__entry->comm, __entry->pid, __entry->candidates,
|
|
__entry->target_cpu, __entry->energy)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for core selection by sysbusy schedule
|
|
*/
|
|
TRACE_EVENT(sysbusy_schedule,
|
|
|
|
TP_PROTO(struct task_struct *p, int state, int target_cpu),
|
|
|
|
TP_ARGS(p, state, target_cpu),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field(unsigned long, util )
|
|
__field(int, state )
|
|
__field(int, target_cpu )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->util = p->se.avg.util_avg;
|
|
__entry->state = state;
|
|
__entry->target_cpu = target_cpu;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d util=%ld state=%d target_cpu=%d",
|
|
__entry->comm, __entry->pid, __entry->util,
|
|
__entry->state, __entry->target_cpu)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for monitoring sysbusy state
|
|
*/
|
|
TRACE_EVENT(ems_cpu_profile,
|
|
|
|
TP_PROTO(int cpu, struct cpu_profile *cs, int ar_avg, int nr_running),
|
|
|
|
TP_ARGS(cpu, cs, ar_avg, nr_running),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( s32, cpu )
|
|
__field( u64, cpu_util )
|
|
__field( u64, cpu_util_busy )
|
|
__field( u64, cpu_wratio )
|
|
__field( u64, cpu_wratio_busy )
|
|
__field( u64, hratio )
|
|
__field( u64, pid )
|
|
__field( int, ar_avg )
|
|
__field( int, nr_running )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->cpu_util = cs[CPU_UTIL].value;
|
|
__entry->cpu_util_busy = cs[CPU_UTIL].data;
|
|
__entry->cpu_wratio = cs[CPU_WRATIO].value;
|
|
__entry->cpu_wratio_busy = cs[CPU_WRATIO].data;
|
|
__entry->hratio = cs[CPU_HTSK].value;
|
|
__entry->pid = cs[CPU_HTSK].data;
|
|
__entry->ar_avg = ar_avg;
|
|
__entry->nr_running = nr_running;
|
|
),
|
|
|
|
TP_printk("cpu=%d cpu_util=%lld(busy=%lld), cpu_wratio=%lld(busy=%lld), hratio=%lld (pid=%lld), "
|
|
"ar_avg=%d, nr_running=%d",
|
|
__entry->cpu, __entry->cpu_util, __entry->cpu_util_busy,
|
|
__entry->cpu_wratio, __entry->cpu_wratio_busy,
|
|
__entry->hratio, __entry->pid, __entry->ar_avg, __entry->nr_running)
|
|
);
|
|
|
|
|
|
/*
|
|
* Tracepoint for tracking tasks in system
|
|
*/
|
|
TRACE_EVENT(ems_profile_tasks,
|
|
|
|
TP_PROTO(int busy_cpu_count, unsigned long cpu_util_sum,
|
|
int heavy_task_count, unsigned long heavy_task_util_sum,
|
|
int misfit_task_count, unsigned long misfit_task_util_sum,
|
|
int pd_nr_running),
|
|
|
|
TP_ARGS(busy_cpu_count, cpu_util_sum,
|
|
heavy_task_count, heavy_task_util_sum,
|
|
misfit_task_count, misfit_task_util_sum,
|
|
pd_nr_running),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, busy_cpu_count )
|
|
__field( unsigned long, cpu_util_sum )
|
|
__field( int, heavy_task_count )
|
|
__field( unsigned long, heavy_task_util_sum )
|
|
__field( int, misfit_task_count )
|
|
__field( unsigned long, misfit_task_util_sum )
|
|
__field( int, pd_nr_running)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->busy_cpu_count = busy_cpu_count;
|
|
__entry->cpu_util_sum = cpu_util_sum;
|
|
__entry->heavy_task_count = heavy_task_count;
|
|
__entry->heavy_task_util_sum = heavy_task_util_sum;
|
|
__entry->misfit_task_count = misfit_task_count;
|
|
__entry->misfit_task_util_sum = misfit_task_util_sum;
|
|
__entry->pd_nr_running = pd_nr_running;
|
|
),
|
|
|
|
TP_printk("busy_cpu_count=%d cpu_util_sum=%lu "
|
|
"heavy_task_count=%d heavy_task_util_sum=%lu "
|
|
"misfit_task_count=%d misfit_task_util_sum=%lu "
|
|
"pd_nr_running=%d",
|
|
__entry->busy_cpu_count, __entry->cpu_util_sum,
|
|
__entry->heavy_task_count, __entry->heavy_task_util_sum,
|
|
__entry->misfit_task_count, __entry->misfit_task_util_sum,
|
|
__entry->pd_nr_running)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for somac scheduling
|
|
*/
|
|
TRACE_EVENT(sysbusy_somac,
|
|
|
|
TP_PROTO(struct task_struct *p, unsigned long util,
|
|
int src_cpu, int dst_cpu, unsigned long time),
|
|
|
|
TP_ARGS(p, util, src_cpu, dst_cpu, time),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( unsigned long, util )
|
|
__field( int, src_cpu )
|
|
__field( int, dst_cpu )
|
|
__field( unsigned long, time )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->util = util;
|
|
__entry->src_cpu = src_cpu;
|
|
__entry->dst_cpu = dst_cpu;
|
|
__entry->time = time;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d util_avg=%lu src_cpu=%d dst_cpu=%d time=%lu",
|
|
__entry->comm, __entry->pid, __entry->util,
|
|
__entry->src_cpu, __entry->dst_cpu, __entry->time)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for move somac task
|
|
*/
|
|
TRACE_EVENT(sysbusy_mv_somac_task,
|
|
|
|
TP_PROTO(int src_cpu, char *label),
|
|
|
|
TP_ARGS(src_cpu, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, src_cpu )
|
|
__field( int, cfs_nr )
|
|
__field( int, cfs_h_nr )
|
|
__field( int, active_bal )
|
|
__field( u64, somac_deq )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->src_cpu = src_cpu;
|
|
__entry->cfs_nr = cpu_rq(src_cpu)->cfs.nr_running;
|
|
__entry->cfs_h_nr = cpu_rq(src_cpu)->cfs.h_nr_running;
|
|
__entry->active_bal = cpu_rq(src_cpu)->active_balance;
|
|
__entry->somac_deq = ems_somac_dequeued(cpu_rq(src_cpu));
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("src_cpu=%d cfs_nr=%d cfs_h_nr=%d active_bal=%d somac_deq=%d reason=%s",
|
|
__entry->src_cpu, __entry->cfs_nr, __entry->cfs_h_nr, __entry->active_bal,
|
|
__entry->somac_deq, __entry->label)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for somac reason
|
|
*/
|
|
TRACE_EVENT(sysbusy_somac_reason,
|
|
|
|
TP_PROTO(int src_cpu, int dst_cpu, char *label),
|
|
|
|
TP_ARGS(src_cpu, dst_cpu, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, src_cpu )
|
|
__field( int, dst_cpu )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->src_cpu = src_cpu;
|
|
__entry->dst_cpu = dst_cpu;
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("src_cpu=%d dst_cpu=%d reason=%s",
|
|
__entry->src_cpu, __entry->dst_cpu, __entry->label)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for the STT
|
|
*/
|
|
TRACE_EVENT(stt_update_cpu,
|
|
|
|
TP_PROTO(int cpu, int cur_ar, int htsk_ar, int pid, int ht_en, u64 next_update,
|
|
int hcnt, u64 last_update, int htask_boost, int state),
|
|
|
|
TP_ARGS(cpu, cur_ar, htsk_ar, pid, ht_en, next_update, hcnt, last_update, htask_boost, state),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, cur_ar )
|
|
__field( int, htsk_ar )
|
|
__field( int, pid )
|
|
__field( int, ht_en )
|
|
__field( u64, next_update )
|
|
__field( int, hcnt )
|
|
__field( u64, last_update )
|
|
__field( int, htask_boost )
|
|
__field( int, state )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->cur_ar = cur_ar;
|
|
__entry->htsk_ar = htsk_ar;
|
|
__entry->pid = pid;
|
|
__entry->ht_en = ht_en;
|
|
__entry->next_update = next_update;
|
|
__entry->hcnt = hcnt;
|
|
__entry->last_update = last_update;
|
|
__entry->htask_boost = htask_boost;
|
|
__entry->state = state;
|
|
),
|
|
|
|
TP_printk("cpu=%d cur_ar=%d htask_ar=%d pid=%d(hten=%d) nextup=%lu hcnt=%d lastup=%lu hboost=%d state=%d",
|
|
__entry->cpu, __entry->cur_ar, __entry->htsk_ar,
|
|
__entry->pid, __entry->ht_en, __entry->next_update, __entry->hcnt,
|
|
__entry->last_update, __entry->htask_boost, __entry->state)
|
|
);
|
|
|
|
TRACE_EVENT(stt_update_htsk_heaviness,
|
|
|
|
TP_PROTO(int cpu, int pid, int idx, int ratio, int cnt),
|
|
|
|
TP_ARGS(cpu, pid, idx, ratio, cnt),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, pid )
|
|
__field( int, idx )
|
|
__field( int, ratio )
|
|
__field( int, cnt )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->pid = pid;
|
|
__entry->idx = idx;
|
|
__entry->ratio = ratio;
|
|
__entry->cnt = cnt;
|
|
),
|
|
|
|
TP_printk("cpu=%d pid=%d idx=%d ratio=%d cnt=%d",
|
|
__entry->cpu, __entry->pid, __entry->idx, __entry->ratio, __entry->cnt)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for EGO
|
|
*/
|
|
TRACE_EVENT(ego_sched_util,
|
|
|
|
TP_PROTO(int cpu, unsigned long util, unsigned long cfs, unsigned long rt,
|
|
unsigned long dl, unsigned long bwdl, unsigned long irq),
|
|
|
|
TP_ARGS(cpu, util, cfs, rt, dl, bwdl, irq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, util )
|
|
__field( unsigned long, cfs )
|
|
__field( unsigned long, rt )
|
|
__field( unsigned long, dl )
|
|
__field( unsigned long, bwdl )
|
|
__field( unsigned long, irq )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->util = util;
|
|
__entry->cfs = cfs;
|
|
__entry->rt = rt;
|
|
__entry->dl = dl;
|
|
__entry->bwdl = bwdl;
|
|
__entry->irq = irq;
|
|
),
|
|
|
|
TP_printk("cpu=%d util=%ld cfs=%ld rt=%ld dl=%ld dlbw=%ld irq=%ld",
|
|
__entry->cpu, __entry->util, __entry->cfs, __entry->rt,
|
|
__entry->dl, __entry->bwdl, __entry->irq)
|
|
);
|
|
|
|
TRACE_EVENT(ego_cpu_util,
|
|
|
|
TP_PROTO(int cpu, unsigned long pelt_boost, unsigned long util, unsigned long io_util, unsigned long bst_util),
|
|
|
|
TP_ARGS(cpu, pelt_boost, util, io_util, bst_util),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, pelt_boost )
|
|
__field( unsigned long, util )
|
|
__field( unsigned long, io_util )
|
|
__field( unsigned long, bst_util )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->pelt_boost = pelt_boost;
|
|
__entry->util = util;
|
|
__entry->io_util = io_util;
|
|
__entry->bst_util = bst_util;
|
|
),
|
|
|
|
TP_printk("cpu=%d pelt_boost=%ld, util=%ld io_util=%ld bst_util=%ld",
|
|
__entry->cpu, __entry->pelt_boost, __entry->util, __entry->io_util,
|
|
__entry->bst_util)
|
|
);
|
|
|
|
TRACE_EVENT(ego_cpu_idle_ratio,
|
|
|
|
TP_PROTO(int cpu, int flag, int idx, u64 s1, u64 s2, u64 s3, u64 s4, int last_idx),
|
|
|
|
TP_ARGS(cpu, flag, idx, s1, s2, s3, s4, last_idx),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, flag )
|
|
__field( int, idx )
|
|
__field( u64, s1 )
|
|
__field( u64, s2 )
|
|
__field( u64, s3 )
|
|
__field( u64, s4 )
|
|
__field( int, last_idx )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->flag = flag;
|
|
__entry->idx = idx;
|
|
__entry->s1 = s1;
|
|
__entry->s2 = s2;
|
|
__entry->s3 = s3;
|
|
__entry->s4 = s4;
|
|
__entry->last_idx = last_idx;
|
|
),
|
|
|
|
TP_printk("cpu=%d f=%2d(lidx=%d, %ld->%ld) idx=%d clkoff=%ld pwroff=%ld",
|
|
__entry->cpu, __entry->flag, __entry->last_idx, __entry->s3, __entry->s4,
|
|
__entry->idx, __entry->s1, __entry->s2)
|
|
);
|
|
|
|
TRACE_EVENT(ego_cpu_eng,
|
|
|
|
TP_PROTO(int cpu, unsigned long cap, unsigned int dyn,
|
|
unsigned long sta, unsigned long idle_sum,
|
|
unsigned long active_eng, unsigned long idle_eng),
|
|
|
|
TP_ARGS(cpu, cap, dyn, sta, idle_sum, active_eng, idle_eng),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, cap )
|
|
__field( unsigned long, dyn )
|
|
__field( unsigned long, sta )
|
|
__field( unsigned long, idle_sum )
|
|
__field( unsigned long, active_eng )
|
|
__field( unsigned long, idle_eng )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->cap = cap;
|
|
__entry->dyn = dyn;
|
|
__entry->sta = sta;
|
|
__entry->idle_sum = idle_sum;
|
|
__entry->active_eng = active_eng;
|
|
__entry->idle_eng = idle_eng;
|
|
),
|
|
|
|
TP_printk("cpu=%d cap=%lu dyn=%lu sta=%lu isum=%lu aeng=%lu ieng=%lu eng=%lu",
|
|
__entry->cpu, __entry->cap, __entry->dyn,
|
|
__entry->sta, __entry->idle_sum,
|
|
__entry->active_eng, __entry->idle_eng,
|
|
(__entry->active_eng + __entry->idle_eng))
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for slack timer
|
|
*/
|
|
TRACE_EVENT(slack_timer,
|
|
|
|
TP_PROTO(int cpu),
|
|
|
|
TP_ARGS(cpu),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, cpu)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
),
|
|
|
|
TP_printk("cpu=%d slack timer expired", __entry->cpu)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for checking need for slack timer
|
|
*/
|
|
TRACE_EVENT(ego_need_slack_timer,
|
|
|
|
TP_PROTO(int cpu, unsigned long boosted_util, unsigned long min_cap,
|
|
int heaviest_cpu, unsigned int cur_freq, unsigned int min_freq,
|
|
unsigned int energy_freq, unsigned int orig_freq, int need),
|
|
|
|
TP_ARGS(cpu, boosted_util, min_cap, heaviest_cpu, cur_freq,
|
|
min_freq, energy_freq, orig_freq, need),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, cpu)
|
|
__field(unsigned long, boosted_util)
|
|
__field(unsigned long, min_cap)
|
|
__field(int, heaviest_cpu)
|
|
__field(unsigned int, cur_freq)
|
|
__field(unsigned int, min_freq)
|
|
__field(unsigned int, energy_freq)
|
|
__field(unsigned int, orig_freq)
|
|
__field(int, need)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->boosted_util = boosted_util;
|
|
__entry->min_cap = min_cap;
|
|
__entry->heaviest_cpu = heaviest_cpu;
|
|
__entry->cur_freq = cur_freq;
|
|
__entry->min_freq = min_freq;
|
|
__entry->energy_freq = energy_freq;
|
|
__entry->orig_freq = orig_freq;
|
|
__entry->need = need;
|
|
),
|
|
|
|
TP_printk("cpu=%d boosted_util=%lu min_cap=%lu heaviest_cpu=%d cur_freq=%u min_freq=%u energy_freq=%u orig_freq=%u need=%d",
|
|
__entry->cpu, __entry->boosted_util, __entry->min_cap,
|
|
__entry->heaviest_cpu, __entry->cur_freq, __entry->min_freq,
|
|
__entry->energy_freq, __entry->orig_freq, __entry->need)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for slack timer func called
|
|
*/
|
|
TRACE_EVENT(cpufreq_gov_slack_func,
|
|
|
|
TP_PROTO(int cpu),
|
|
|
|
TP_ARGS(cpu),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, cpu)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
),
|
|
|
|
TP_printk("cpu=%d SLACK EXPIRED", __entry->cpu)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for detalis of slack timer func called
|
|
*/
|
|
TRACE_EVENT(cpufreq_gov_slack,
|
|
|
|
TP_PROTO(int cpu, unsigned long util,
|
|
unsigned long min, unsigned long action),
|
|
|
|
TP_ARGS(cpu, util, min, action),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, cpu)
|
|
__field(unsigned long, util)
|
|
__field(unsigned long, min)
|
|
__field(unsigned long, action)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->util = util;
|
|
__entry->min = min;
|
|
__entry->action = action;
|
|
),
|
|
|
|
TP_printk("cpu=%d util=%ld min=%ld action=%ld",
|
|
__entry->cpu, __entry->util, __entry->min, __entry->action)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for available cpus in FRT
|
|
*/
|
|
TRACE_EVENT(frt_available_cpus,
|
|
|
|
TP_PROTO(unsigned int domain, int util_sum, int busy_thr, unsigned int available_mask),
|
|
|
|
TP_ARGS(domain, util_sum, busy_thr, available_mask),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( unsigned int, domain )
|
|
__field( int, util_sum )
|
|
__field( int, busy_thr )
|
|
__field( unsigned int, available_mask )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->domain = domain;
|
|
__entry->util_sum = util_sum;
|
|
__entry->busy_thr = busy_thr;
|
|
__entry->available_mask = available_mask;
|
|
),
|
|
|
|
TP_printk("domain=%x util_sum=%d busy_thr=%d available_mask=%x",
|
|
__entry->domain, __entry->util_sum,
|
|
__entry->busy_thr, __entry->available_mask)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for multi load tracking for cpu
|
|
*/
|
|
TRACE_EVENT(mlt_update_cpu,
|
|
|
|
TP_PROTO(struct mlt *mlt),
|
|
|
|
TP_ARGS(mlt),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, cur_period )
|
|
__field( int, state )
|
|
__field( int, g0_recent )
|
|
__field( int, g1_recent )
|
|
__field( int, g2_recent )
|
|
__field( int, g3_recent )
|
|
__field( int, g4_recent )
|
|
__field( int, g5_recent )
|
|
__field( int, g6_recent )
|
|
__field( int, g7_recent )
|
|
__field( int, g8_recent )
|
|
__field( int, recent_sum )
|
|
__field( int, g0_last )
|
|
__field( int, g1_last )
|
|
__field( int, g2_last )
|
|
__field( int, g3_last )
|
|
__field( int, g4_last )
|
|
__field( int, g5_last )
|
|
__field( int, g6_last )
|
|
__field( int, g7_last )
|
|
__field( int, g8_last )
|
|
__field( int, last_sum )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
int i = mlt->cur_period;
|
|
|
|
__entry->cpu = mlt->cpu;
|
|
__entry->cur_period = mlt->cur_period;
|
|
__entry->state = mlt->state;
|
|
__entry->g0_recent = mlt->recent[0];
|
|
__entry->g1_recent = mlt->recent[1];
|
|
__entry->g2_recent = mlt->recent[2];
|
|
__entry->g3_recent = mlt->recent[3];
|
|
__entry->g4_recent = mlt->recent[4];
|
|
__entry->g5_recent = mlt->recent[5];
|
|
__entry->g6_recent = mlt->recent[6];
|
|
__entry->g7_recent = mlt->recent[7];
|
|
__entry->g8_recent = mlt->recent[8];
|
|
__entry->recent_sum = mlt->recent[0] + mlt->recent[1] +
|
|
mlt->recent[2] + mlt->recent[3] +
|
|
mlt->recent[4] + mlt->recent[5] +
|
|
mlt->recent[6] + mlt->recent[7] +
|
|
mlt->recent[8];
|
|
__entry->g0_last = mlt->periods[0][i];
|
|
__entry->g1_last = mlt->periods[1][i];
|
|
__entry->g2_last = mlt->periods[2][i];
|
|
__entry->g3_last = mlt->periods[3][i];
|
|
__entry->g4_last = mlt->periods[4][i];
|
|
__entry->g5_last = mlt->periods[5][i];
|
|
__entry->g6_last = mlt->periods[6][i];
|
|
__entry->g7_last = mlt->periods[7][i];
|
|
__entry->g8_last = mlt->periods[8][i];
|
|
__entry->last_sum = mlt->periods[0][i] + mlt->periods[1][i] +
|
|
mlt->periods[2][i] + mlt->periods[3][i] +
|
|
mlt->periods[4][i] + mlt->periods[5][i] +
|
|
mlt->periods[6][i] + mlt->periods[7][i] +
|
|
mlt->periods[8][i];
|
|
),
|
|
|
|
TP_printk("cpu=%d cur_period=%d state=%d recent=%d,%d,%d,%d,%d,%d,%d,%d,%d(%d) "
|
|
"last=%d,%d,%d,%d,%d,%d,%d,%d,%d(%d)",
|
|
__entry->cpu, __entry->cur_period, __entry->state,
|
|
__entry->g0_recent, __entry->g1_recent, __entry->g2_recent,
|
|
__entry->g3_recent, __entry->g4_recent, __entry->g5_recent,
|
|
__entry->g6_recent, __entry->g7_recent, __entry->g8_recent, __entry->recent_sum,
|
|
__entry->g0_last, __entry->g1_last, __entry->g2_last,
|
|
__entry->g3_last, __entry->g4_last, __entry->g5_last,
|
|
__entry->g6_last, __entry->g7_last, __entry->g8_last, __entry->last_sum)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for multi load tracking for cpu IPC
|
|
*/
|
|
TRACE_EVENT(mlt_update_cpu_ipc,
|
|
|
|
TP_PROTO(struct mlt *mlt),
|
|
|
|
TP_ARGS(mlt),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, cur_period )
|
|
__field( int, state )
|
|
__field( int, g0_recent )
|
|
__field( int, g1_recent )
|
|
__field( int, g2_recent )
|
|
__field( int, g3_recent )
|
|
__field( int, g4_recent )
|
|
__field( int, g5_recent )
|
|
__field( int, g6_recent )
|
|
__field( int, g7_recent )
|
|
__field( int, g8_recent )
|
|
__field( int, recent_sum )
|
|
__field( int, g0_last )
|
|
__field( int, g1_last )
|
|
__field( int, g2_last )
|
|
__field( int, g3_last )
|
|
__field( int, g4_last )
|
|
__field( int, g5_last )
|
|
__field( int, g6_last )
|
|
__field( int, g7_last )
|
|
__field( int, g8_last )
|
|
__field( int, last_sum )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
int i = mlt->cur_period;
|
|
|
|
__entry->cpu = mlt->cpu;
|
|
__entry->cur_period = mlt->cur_period;
|
|
__entry->state = mlt->state;
|
|
__entry->g0_recent = mlt->uarch->ipc_recent[0];
|
|
__entry->g1_recent = mlt->uarch->ipc_recent[1];
|
|
__entry->g2_recent = mlt->uarch->ipc_recent[2];
|
|
__entry->g3_recent = mlt->uarch->ipc_recent[3];
|
|
__entry->g4_recent = mlt->uarch->ipc_recent[4];
|
|
__entry->g5_recent = mlt->uarch->ipc_recent[5];
|
|
__entry->g6_recent = mlt->uarch->ipc_recent[6];
|
|
__entry->g7_recent = mlt->uarch->ipc_recent[7];
|
|
__entry->g8_recent = mlt->uarch->ipc_recent[8];
|
|
__entry->recent_sum = mlt->uarch->ipc_recent[0] +
|
|
mlt->uarch->ipc_recent[1] +
|
|
mlt->uarch->ipc_recent[2] +
|
|
mlt->uarch->ipc_recent[3] +
|
|
mlt->uarch->ipc_recent[4] +
|
|
mlt->uarch->ipc_recent[5] +
|
|
mlt->uarch->ipc_recent[6] +
|
|
mlt->uarch->ipc_recent[7] +
|
|
mlt->uarch->ipc_recent[8];
|
|
__entry->g0_last = mlt->uarch->ipc_periods[0][i];
|
|
__entry->g1_last = mlt->uarch->ipc_periods[1][i];
|
|
__entry->g2_last = mlt->uarch->ipc_periods[2][i];
|
|
__entry->g3_last = mlt->uarch->ipc_periods[3][i];
|
|
__entry->g4_last = mlt->uarch->ipc_periods[4][i];
|
|
__entry->g5_last = mlt->uarch->ipc_periods[5][i];
|
|
__entry->g6_last = mlt->uarch->ipc_periods[6][i];
|
|
__entry->g7_last = mlt->uarch->ipc_periods[7][i];
|
|
__entry->g8_last = mlt->uarch->ipc_periods[8][i];
|
|
__entry->last_sum = mlt->uarch->ipc_periods[0][i] +
|
|
mlt->uarch->ipc_periods[1][i] +
|
|
mlt->uarch->ipc_periods[2][i] +
|
|
mlt->uarch->ipc_periods[3][i] +
|
|
mlt->uarch->ipc_periods[4][i] +
|
|
mlt->uarch->ipc_periods[5][i] +
|
|
mlt->uarch->ipc_periods[6][i] +
|
|
mlt->uarch->ipc_periods[7][i] +
|
|
mlt->uarch->ipc_periods[8][i];
|
|
),
|
|
|
|
TP_printk("cpu=%d cur_period=%d state=%d recent=%d,%d,%d,%d,%d,%d,%d,%d,%d(%d) "
|
|
"last=%d,%d,%d,%d,%d,%d,%d,%d,%d(%d)",
|
|
__entry->cpu, __entry->cur_period, __entry->state,
|
|
__entry->g0_recent, __entry->g1_recent, __entry->g2_recent,
|
|
__entry->g3_recent, __entry->g4_recent, __entry->g5_recent,
|
|
__entry->g6_recent, __entry->g7_recent, __entry->g8_recent, __entry->recent_sum,
|
|
__entry->g0_last, __entry->g1_last, __entry->g2_last,
|
|
__entry->g3_last, __entry->g4_last, __entry->g5_last,
|
|
__entry->g6_last, __entry->g7_last, __entry->g8_last, __entry->last_sum)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for multi load tracking for cpu MSPC
|
|
*/
|
|
TRACE_EVENT(mlt_update_cpu_mspc,
|
|
|
|
TP_PROTO(struct mlt *mlt),
|
|
|
|
TP_ARGS(mlt),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, cur_period )
|
|
__field( int, state )
|
|
__field( int, g0_recent )
|
|
__field( int, g1_recent )
|
|
__field( int, g2_recent )
|
|
__field( int, g3_recent )
|
|
__field( int, g4_recent )
|
|
__field( int, g5_recent )
|
|
__field( int, g6_recent )
|
|
__field( int, g7_recent )
|
|
__field( int, g8_recent )
|
|
__field( int, recent_sum )
|
|
__field( int, g0_last )
|
|
__field( int, g1_last )
|
|
__field( int, g2_last )
|
|
__field( int, g3_last )
|
|
__field( int, g4_last )
|
|
__field( int, g5_last )
|
|
__field( int, g6_last )
|
|
__field( int, g7_last )
|
|
__field( int, g8_last )
|
|
__field( int, last_sum )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
int i = mlt->cur_period;
|
|
|
|
__entry->cpu = mlt->cpu;
|
|
__entry->cur_period = mlt->cur_period;
|
|
__entry->state = mlt->state;
|
|
__entry->g0_recent = mlt->uarch->mspc_recent[0];
|
|
__entry->g1_recent = mlt->uarch->mspc_recent[1];
|
|
__entry->g2_recent = mlt->uarch->mspc_recent[2];
|
|
__entry->g3_recent = mlt->uarch->mspc_recent[3];
|
|
__entry->g4_recent = mlt->uarch->mspc_recent[4];
|
|
__entry->g5_recent = mlt->uarch->mspc_recent[5];
|
|
__entry->g6_recent = mlt->uarch->mspc_recent[6];
|
|
__entry->g7_recent = mlt->uarch->mspc_recent[7];
|
|
__entry->g8_recent = mlt->uarch->mspc_recent[8];
|
|
__entry->recent_sum = mlt->uarch->mspc_recent[0] +
|
|
mlt->uarch->mspc_recent[1] +
|
|
mlt->uarch->mspc_recent[2] +
|
|
mlt->uarch->mspc_recent[3] +
|
|
mlt->uarch->mspc_recent[4] +
|
|
mlt->uarch->mspc_recent[5] +
|
|
mlt->uarch->mspc_recent[6] +
|
|
mlt->uarch->mspc_recent[7] +
|
|
mlt->uarch->mspc_recent[8];
|
|
__entry->g0_last = mlt->uarch->mspc_periods[0][i];
|
|
__entry->g1_last = mlt->uarch->mspc_periods[1][i];
|
|
__entry->g2_last = mlt->uarch->mspc_periods[2][i];
|
|
__entry->g3_last = mlt->uarch->mspc_periods[3][i];
|
|
__entry->g4_last = mlt->uarch->mspc_periods[4][i];
|
|
__entry->g5_last = mlt->uarch->mspc_periods[5][i];
|
|
__entry->g6_last = mlt->uarch->mspc_periods[6][i];
|
|
__entry->g7_last = mlt->uarch->mspc_periods[7][i];
|
|
__entry->g8_last = mlt->uarch->mspc_periods[8][i];
|
|
__entry->last_sum = mlt->uarch->mspc_periods[0][i] +
|
|
mlt->uarch->mspc_periods[1][i] +
|
|
mlt->uarch->mspc_periods[2][i] +
|
|
mlt->uarch->mspc_periods[3][i] +
|
|
mlt->uarch->mspc_periods[4][i] +
|
|
mlt->uarch->mspc_periods[5][i] +
|
|
mlt->uarch->mspc_periods[6][i] +
|
|
mlt->uarch->mspc_periods[7][i] +
|
|
mlt->uarch->mspc_periods[8][i];
|
|
),
|
|
|
|
TP_printk("cpu=%d cur_period=%d state=%d recent=%d,%d,%d,%d,%d,%d,%d,%d,%d(%d) "
|
|
"last=%d,%d,%d,%d,%d,%d,%d,%d,%d(%d)",
|
|
__entry->cpu, __entry->cur_period, __entry->state,
|
|
__entry->g0_recent, __entry->g1_recent, __entry->g2_recent,
|
|
__entry->g3_recent, __entry->g4_recent, __entry->g5_recent,
|
|
__entry->g6_recent, __entry->g7_recent, __entry->g8_recent, __entry->recent_sum,
|
|
__entry->g0_last, __entry->g1_last, __entry->g2_last,
|
|
__entry->g3_last, __entry->g4_last, __entry->g5_last,
|
|
__entry->g6_last, __entry->g7_last, __entry->g8_last, __entry->last_sum)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for multi load tracking for cstate
|
|
*/
|
|
TRACE_EVENT(mlt_update_cstate,
|
|
|
|
TP_PROTO(struct mlt *mlt),
|
|
|
|
TP_ARGS(mlt),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, cur_period )
|
|
__field( int, state )
|
|
__field( int, c0_recent )
|
|
__field( int, c1_recent )
|
|
__field( int, recent_sum )
|
|
__field( int, c0_last )
|
|
__field( int, c1_last )
|
|
__field( int, last_sum )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
int i = mlt->cur_period;
|
|
|
|
__entry->cpu = mlt->cpu;
|
|
__entry->cur_period = mlt->cur_period;
|
|
__entry->state = mlt->state;
|
|
__entry->c0_recent = mlt->recent[0];
|
|
__entry->c1_recent = mlt->recent[1];
|
|
__entry->recent_sum = mlt->recent[0] + mlt->recent[1];
|
|
__entry->c0_last = mlt->periods[0][i];
|
|
__entry->c1_last = mlt->periods[1][i];
|
|
__entry->last_sum = mlt->periods[0][i] + mlt->periods[1][i];
|
|
),
|
|
|
|
TP_printk("cpu=%d cur_period=%d state=%d recent=%d,%d(%d) last=%d,%d(%d)",
|
|
__entry->cpu, __entry->cur_period, __entry->state,
|
|
__entry->c0_recent, __entry->c1_recent, __entry->recent_sum,
|
|
__entry->c0_last, __entry->c1_last, __entry->last_sum)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for multi load tracking for task
|
|
*/
|
|
TRACE_EVENT(mlt_update_task,
|
|
|
|
TP_PROTO(struct task_struct *p, struct mlt *mlt),
|
|
|
|
TP_ARGS(p, mlt),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, cpu )
|
|
__field( int, cur_period )
|
|
__field( int, state )
|
|
__field( int, recent )
|
|
__field( int, last )
|
|
__field( int, ipc_recent )
|
|
__field( int, ipc_last )
|
|
__field( int, mspc_recent )
|
|
__field( int, mspc_last )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
int i = mlt->cur_period;
|
|
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->cpu = mlt->cpu;
|
|
__entry->cur_period = mlt->cur_period;
|
|
__entry->state = mlt->state;
|
|
__entry->recent = mlt->recent[0];
|
|
__entry->last = mlt->periods[0][i];
|
|
__entry->ipc_recent = mlt->uarch ? mlt->uarch->ipc_recent[0] : 0;
|
|
__entry->ipc_last = mlt->uarch ? mlt->uarch->ipc_periods[0][i] : 0;
|
|
__entry->mspc_recent = mlt->uarch ? mlt->uarch->mspc_recent[0] : 0;
|
|
__entry->mspc_last = mlt->uarch ? mlt->uarch->mspc_periods[0][i] : 0;
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d cpu=%d cur_period=%d state=%d recent=%d last=%d "
|
|
"ipc_recent=%d ipc_last=%d mspc_recent=%d mspc_last=%d",
|
|
__entry->comm, __entry->pid, __entry->cpu, __entry->cur_period,
|
|
__entry->state, __entry->recent, __entry->last, __entry->ipc_recent,
|
|
__entry->ipc_last, __entry->mspc_recent, __entry->mspc_last)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for task migration control
|
|
*/
|
|
TRACE_EVENT(ontime_can_migrate_task,
|
|
|
|
TP_PROTO(struct task_struct *tsk, int dst_cpu, int migrate, char *label),
|
|
|
|
TP_ARGS(tsk, dst_cpu, migrate, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, src_cpu )
|
|
__field( int, dst_cpu )
|
|
__field( int, migrate )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
|
|
__entry->pid = tsk->pid;
|
|
__entry->src_cpu = task_cpu(tsk);
|
|
__entry->dst_cpu = dst_cpu;
|
|
__entry->migrate = migrate;
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d src_cpu=%d dst_cpu=%d migrate=%d reason=%s",
|
|
__entry->comm, __entry->pid, __entry->src_cpu, __entry->dst_cpu,
|
|
__entry->migrate, __entry->label)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for ecs
|
|
*/
|
|
struct dynamic_dom;
|
|
TRACE_EVENT(dynamic_domain_info,
|
|
|
|
TP_PROTO(int cpu, struct dynamic_dom *domain),
|
|
|
|
TP_ARGS(cpu, domain),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned int, cpus )
|
|
__field( int, nr_busy_cpu )
|
|
__field( int, avg_nr_run )
|
|
__field( int, slower_misfit )
|
|
__field( int, active_ratio )
|
|
__field( u64, util )
|
|
__field( u64, cap )
|
|
__field( int, throttle_cnt )
|
|
__field( int, flag )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->cpus = *(unsigned int *)cpumask_bits(&domain->governor_cpus);
|
|
__entry->avg_nr_run = domain->avg_nr_run;
|
|
__entry->nr_busy_cpu = domain->nr_busy_cpu;
|
|
__entry->slower_misfit = domain->slower_misfit;
|
|
__entry->active_ratio = domain->active_ratio;
|
|
__entry->util = domain->util;
|
|
__entry->cap = domain->cap;
|
|
__entry->throttle_cnt = domain->throttle_cnt;
|
|
__entry->flag = domain->flag;
|
|
),
|
|
|
|
TP_printk("cpu=%d cpus=%#x avg_nr_run=%d nr_busy_cpu=%d slower_misfit=%d ar=%d util=%llu cap=%llu tcnt=%d flag=%d",
|
|
__entry->cpu, __entry->cpus, __entry->avg_nr_run, __entry->nr_busy_cpu,
|
|
__entry->slower_misfit, __entry->active_ratio, __entry->util,
|
|
__entry->cap, __entry->throttle_cnt, __entry->flag)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for updating spared cpus
|
|
*/
|
|
TRACE_EVENT(ecs_update_domain,
|
|
|
|
TP_PROTO(char *move, unsigned int id,
|
|
unsigned int util_sum, unsigned int threshold,
|
|
unsigned int prev_cpus, unsigned int next_cpus),
|
|
|
|
TP_ARGS(move, id, util_sum, threshold, prev_cpus, next_cpus),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, move, 64 )
|
|
__field( unsigned int, id )
|
|
__field( unsigned int, util_sum )
|
|
__field( unsigned int, threshold )
|
|
__field( unsigned int, prev_cpus )
|
|
__field( unsigned int, next_cpus )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
strncpy(__entry->move, move, 63);
|
|
__entry->id = id;
|
|
__entry->util_sum = util_sum;
|
|
__entry->threshold = threshold;
|
|
__entry->prev_cpus = prev_cpus;
|
|
__entry->next_cpus = next_cpus;
|
|
),
|
|
|
|
TP_printk("move=%s id=%d util_sum=%u threshold=%u cpus=%#x->%#x",
|
|
__entry->move, __entry->id,
|
|
__entry->util_sum, __entry->threshold,
|
|
__entry->prev_cpus, __entry->next_cpus)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for updating spared cpus with fastest cpus
|
|
*/
|
|
TRACE_EVENT(ecs_reflect_fastest_cpus,
|
|
|
|
TP_PROTO(int heavy_task_count,
|
|
unsigned int prev_cpus, unsigned int next_cpus),
|
|
|
|
TP_ARGS(heavy_task_count, prev_cpus, next_cpus),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, heavy_task_count )
|
|
__field( unsigned int, prev_cpus )
|
|
__field( unsigned int, next_cpus )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->heavy_task_count = heavy_task_count;
|
|
__entry->prev_cpus = prev_cpus;
|
|
__entry->next_cpus = next_cpus;
|
|
),
|
|
|
|
TP_printk("heavy_task_count=%d cpus=%#x->%#x",
|
|
__entry->heavy_task_count,
|
|
__entry->prev_cpus, __entry->next_cpus)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for updating spared cpus
|
|
*/
|
|
TRACE_EVENT(ecs_update_governor_cpus,
|
|
|
|
TP_PROTO(char *reason, unsigned int prev_cpus, unsigned int next_cpus),
|
|
|
|
TP_ARGS(reason, prev_cpus, next_cpus),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, reason, 64 )
|
|
__field( unsigned int, prev_cpus )
|
|
__field( unsigned int, next_cpus )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
strncpy(__entry->reason, reason, 63);
|
|
__entry->prev_cpus = prev_cpus;
|
|
__entry->next_cpus = next_cpus;
|
|
),
|
|
|
|
TP_printk("reason=%s cpus=%#x->%#x",
|
|
__entry->reason, __entry->prev_cpus, __entry->next_cpus)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for frequency boost
|
|
*/
|
|
TRACE_EVENT(freqboost_boosted_util,
|
|
|
|
TP_PROTO(int cpu, int ratio, unsigned long util, long margin),
|
|
|
|
TP_ARGS(cpu, ratio, util, margin),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, ratio )
|
|
__field( unsigned long, util )
|
|
__field( long, margin )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->ratio = ratio;
|
|
__entry->util = util;
|
|
__entry->margin = margin;
|
|
),
|
|
|
|
TP_printk("cpu=%d ratio=%d util=%lu margin=%ld",
|
|
__entry->cpu, __entry->ratio, __entry->util, __entry->margin)
|
|
);
|
|
|
|
TRACE_EVENT(freqboost_htsk_boosted_util,
|
|
|
|
TP_PROTO(int cpu, int hratio, int ratio, int boost,
|
|
unsigned long util, long margin),
|
|
|
|
TP_ARGS(cpu, hratio, ratio, boost, util, margin),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, hratio )
|
|
__field( int, ratio )
|
|
__field( int, boost )
|
|
__field( unsigned long, util )
|
|
__field( long, margin )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->hratio = hratio;
|
|
__entry->ratio = ratio;
|
|
__entry->boost = boost;
|
|
__entry->util = util;
|
|
__entry->margin = margin;
|
|
),
|
|
|
|
TP_printk("cpu=%d hratio=%d ratio=%d boost=%d util=%lu margin=%ld",
|
|
__entry->cpu, __entry->hratio, __entry->ratio,
|
|
__entry->boost, __entry->util, __entry->margin)
|
|
);
|
|
|
|
struct fclamp_data;
|
|
|
|
/*
|
|
* Tracepoint for fclamp applying result
|
|
*/
|
|
TRACE_EVENT(fclamp_apply,
|
|
|
|
TP_PROTO(int cpu, unsigned int orig_freq, unsigned int new_freq,
|
|
int boost, struct fclamp_data *fcd),
|
|
|
|
TP_ARGS(cpu, orig_freq, new_freq, boost, fcd),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned int, orig_freq )
|
|
__field( unsigned int, new_freq )
|
|
__field( int, boost )
|
|
__field( int, clamp_freq )
|
|
__field( int, target_period )
|
|
__field( int, target_ratio )
|
|
__field( int, type )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->orig_freq = orig_freq;
|
|
__entry->new_freq = new_freq;
|
|
__entry->boost = boost;
|
|
__entry->clamp_freq = fcd->freq;
|
|
__entry->target_period = fcd->target_period;
|
|
__entry->target_ratio = fcd->target_ratio;
|
|
__entry->type = fcd->type;
|
|
),
|
|
|
|
TP_printk("cpu=%d orig_freq=%u new_freq=%u boost=%d clamp_freq=%d "
|
|
"target_period=%d target_ratio=%d type=%s",
|
|
__entry->cpu, __entry->orig_freq, __entry->new_freq, __entry->boost,
|
|
__entry->clamp_freq, __entry->target_period, __entry->target_ratio,
|
|
__entry->type ? "MAX" : "MIN")
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for checking fclamp release
|
|
*/
|
|
TRACE_EVENT(fclamp_can_release,
|
|
|
|
TP_PROTO(int cpu, int type, int period, int period_count,
|
|
int target_ratio, int active_ratio),
|
|
|
|
TP_ARGS(cpu, type, period, period_count, target_ratio, active_ratio),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, type )
|
|
__field( int, period )
|
|
__field( int, period_count )
|
|
__field( int, target_ratio )
|
|
__field( int, active_ratio )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->type = type;
|
|
__entry->period = period;
|
|
__entry->period_count = period_count;
|
|
__entry->target_ratio = target_ratio;
|
|
__entry->active_ratio = active_ratio;
|
|
),
|
|
|
|
TP_printk("cpu=%d type=%s period=%d period_count=%d target_ratio=%d active_ratio=%d",
|
|
__entry->cpu, __entry->type ? "MAX" : "MIN",
|
|
__entry->period, __entry->period_count,
|
|
__entry->target_ratio, __entry->active_ratio)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for cfs_rq load tracking:
|
|
*/
|
|
TRACE_EVENT(sched_load_cfs_rq,
|
|
|
|
TP_PROTO(struct cfs_rq *cfs_rq),
|
|
|
|
TP_ARGS(cfs_rq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, load )
|
|
__field( unsigned long, rbl_load )
|
|
__field( unsigned long, util )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
struct rq *rq = __trace_get_rq(cfs_rq);
|
|
|
|
__entry->cpu = rq->cpu;
|
|
__entry->load = cfs_rq->avg.load_avg;
|
|
__entry->rbl_load = cfs_rq->avg.runnable_avg;
|
|
__entry->util = cfs_rq->avg.util_avg;
|
|
),
|
|
|
|
TP_printk("cpu=%d load=%lu rbl_load=%lu util=%lu",
|
|
__entry->cpu, __entry->load,
|
|
__entry->rbl_load,__entry->util)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for rt_rq load tracking:
|
|
*/
|
|
TRACE_EVENT(sched_load_rt_rq,
|
|
|
|
TP_PROTO(struct rq *rq),
|
|
|
|
TP_ARGS(rq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, util )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = rq->cpu;
|
|
__entry->util = rq->avg_rt.util_avg;
|
|
),
|
|
|
|
TP_printk("cpu=%d util=%lu", __entry->cpu,
|
|
__entry->util)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for dl_rq load tracking:
|
|
*/
|
|
TRACE_EVENT(sched_load_dl_rq,
|
|
|
|
TP_PROTO(struct rq *rq),
|
|
|
|
TP_ARGS(rq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, util )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = rq->cpu;
|
|
__entry->util = rq->avg_dl.util_avg;
|
|
),
|
|
|
|
TP_printk("cpu=%d util=%lu", __entry->cpu,
|
|
__entry->util)
|
|
);
|
|
|
|
#ifdef CONFIG_HAVE_SCHED_AVG_IRQ
|
|
/*
|
|
* Tracepoint for irq load tracking:
|
|
*/
|
|
TRACE_EVENT(sched_load_irq,
|
|
|
|
TP_PROTO(struct rq *rq),
|
|
|
|
TP_ARGS(rq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned long, util )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = rq->cpu;
|
|
__entry->util = rq->avg_irq.util_avg;
|
|
),
|
|
|
|
TP_printk("cpu=%d util=%lu", __entry->cpu,
|
|
__entry->util)
|
|
);
|
|
#endif
|
|
|
|
#ifdef CREATE_TRACE_POINTS
|
|
static inline
|
|
struct rq * __trace_get_rq(struct cfs_rq *cfs_rq)
|
|
{
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
return cfs_rq->rq;
|
|
#else
|
|
return container_of(cfs_rq, struct rq, cfs);
|
|
#endif
|
|
}
|
|
#endif /* CREATE_TRACE_POINTS */
|
|
|
|
/*
|
|
* Tracepoint for sched_entity load tracking:
|
|
*/
|
|
TRACE_EVENT(sched_load_se,
|
|
|
|
TP_PROTO(struct sched_entity *se),
|
|
|
|
TP_ARGS(se),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( unsigned long, load )
|
|
__field( unsigned long, rbl_load )
|
|
__field( unsigned long, util )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
struct cfs_rq *gcfs_rq = se->my_q;
|
|
#else
|
|
struct cfs_rq *gcfs_rq = NULL;
|
|
#endif
|
|
struct task_struct *p = gcfs_rq ? NULL
|
|
: container_of(se, struct task_struct, se);
|
|
struct rq *rq = gcfs_rq ? __trace_get_rq(gcfs_rq) : NULL;
|
|
|
|
__entry->cpu = rq ? rq->cpu
|
|
: task_cpu((container_of(se, struct task_struct, se)));
|
|
memcpy(__entry->comm, p ? p->comm : "(null)",
|
|
p ? TASK_COMM_LEN : sizeof("(null)"));
|
|
__entry->pid = p ? p->pid : -1;
|
|
__entry->load = se->avg.load_avg;
|
|
__entry->rbl_load = se->avg.runnable_avg;
|
|
__entry->util = se->avg.util_avg;
|
|
),
|
|
|
|
TP_printk("cpu=%d comm=%s pid=%d load=%lu rbl_load=%lu util=%lu",
|
|
__entry->cpu, __entry->comm, __entry->pid,
|
|
__entry->load, __entry->rbl_load, __entry->util)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for system overutilized flag
|
|
*/
|
|
TRACE_EVENT(sched_overutilized,
|
|
|
|
TP_PROTO(int overutilized),
|
|
|
|
TP_ARGS(overutilized),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, overutilized )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->overutilized = overutilized;
|
|
),
|
|
|
|
TP_printk("overutilized=%d",
|
|
__entry->overutilized)
|
|
);
|
|
|
|
TRACE_EVENT(gsc_cpu_group_load,
|
|
|
|
TP_PROTO(int cpu, int grp_id, u64 load),
|
|
|
|
TP_ARGS(cpu, grp_id, load),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, grp_id )
|
|
__field( u64, load )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->grp_id = grp_id;
|
|
__entry->load = load;
|
|
),
|
|
|
|
TP_printk("cpu=%d grp_id=%d load=%llu",
|
|
__entry->cpu, __entry->grp_id, __entry->load)
|
|
);
|
|
|
|
TRACE_EVENT(gsc_decision_activate,
|
|
|
|
TP_PROTO(int gid, u64 group_load, u64 now, u64 last_update_time, char *label),
|
|
|
|
TP_ARGS(gid, group_load, now, last_update_time, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, gid )
|
|
__field( u64, group_load )
|
|
__field( u64, now )
|
|
__field( u64, last_update_time )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->gid = gid;
|
|
__entry->group_load = group_load;
|
|
__entry->now = now;
|
|
__entry->last_update_time = last_update_time;
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("group_id=%d group_load=%llu now=%llu last_uptime=%llu reason=%s",
|
|
__entry->gid, __entry->group_load, __entry->now,
|
|
__entry->last_update_time, __entry->label)
|
|
);
|
|
|
|
/* CPUIDLE Governor */
|
|
TRACE_EVENT(halo_reflect,
|
|
|
|
TP_PROTO(u32 cpu, u32 waker, u64 slen),
|
|
|
|
TP_ARGS(cpu, waker, slen),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, cpu)
|
|
__field(u32, waker)
|
|
__field(u64, slen)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->waker = waker;
|
|
__entry->slen = slen;
|
|
),
|
|
|
|
TP_printk("cpu=%d waker=%d slen=%lld) ",
|
|
__entry->cpu, __entry->waker, __entry->slen)
|
|
);
|
|
|
|
TRACE_EVENT(halo_timer_fn,
|
|
|
|
TP_PROTO(u32 cpu, u32 worked),
|
|
|
|
TP_ARGS(cpu, worked),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, cpu)
|
|
__field(u32, worked)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->worked = worked;
|
|
),
|
|
|
|
TP_printk("cpu=%d worked=%d", __entry->cpu, __entry->worked)
|
|
);
|
|
|
|
TRACE_EVENT(halo_tick,
|
|
|
|
TP_PROTO(u32 cpu, s64 now),
|
|
|
|
TP_ARGS(cpu, now),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, cpu)
|
|
__field(s64, now)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->now = now;
|
|
),
|
|
|
|
TP_printk("cpu=%d now=%d", __entry->cpu, __entry->now)
|
|
);
|
|
|
|
TRACE_EVENT(halo_fps,
|
|
|
|
TP_PROTO(s64 vtime, s64 dtime, s64 dcnt, s64 vrr, s64 period, s64 next_ns, s64 slen_ns),
|
|
|
|
TP_ARGS(vtime, dtime, dcnt, vrr, period, next_ns, slen_ns),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(s64, vtime)
|
|
__field(s64, dtime)
|
|
__field(s64, dcnt)
|
|
__field(s64, vrr)
|
|
__field(s64, period)
|
|
__field(s64, next_ns)
|
|
__field(s64, slen_ns)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->vtime = vtime;
|
|
__entry->dtime = dtime;
|
|
__entry->dcnt = dcnt;
|
|
__entry->vrr = vrr;
|
|
__entry->period = period;
|
|
__entry->next_ns = next_ns;
|
|
__entry->slen_ns = slen_ns;
|
|
),
|
|
|
|
TP_printk("vtime=%lld dtime=%lld dcnt=%lld vrr=%lld period=%lld nxt_ns=%lld, slen_ns=%lld",
|
|
__entry->vtime, __entry->dtime, __entry->dcnt,
|
|
__entry->vrr, __entry->period, __entry->next_ns, __entry->slen_ns)
|
|
);
|
|
|
|
|
|
TRACE_EVENT(halo_ipi,
|
|
|
|
TP_PROTO(s32 cpu, s32 heavy, s64 min, s64 max, s64 cur, s64 avg, s64 correct, s64 pred),
|
|
|
|
TP_ARGS(cpu, heavy, min, max, cur, avg, correct, pred),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(s32, cpu)
|
|
__field(s32, heavy)
|
|
__field(s64, min)
|
|
__field(s64, max)
|
|
__field(s64, cur)
|
|
__field(s64, avg)
|
|
__field(s64, correct)
|
|
__field(s64, pred)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->heavy = heavy;
|
|
__entry->min = min;
|
|
__entry->max = max;
|
|
__entry->cur = cur;
|
|
__entry->avg = avg;
|
|
__entry->correct = correct;
|
|
__entry->pred = pred;
|
|
),
|
|
|
|
TP_printk("cpu=%d heavy=%d min=%lld max=%lld cur=%lld avg=%lld corrrect=%lld pred=%lld",
|
|
__entry->cpu, __entry->heavy, __entry->min, __entry->max, __entry->cur,
|
|
__entry->avg, __entry->correct, __entry->pred)
|
|
);
|
|
|
|
TRACE_EVENT(halo_hstate,
|
|
|
|
TP_PROTO(s32 cpu, s32 idx, u64 hit, u64 miss),
|
|
|
|
TP_ARGS(cpu, idx, hit, miss),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(s32, cpu)
|
|
__field(s32, idx)
|
|
__field(u64, hit)
|
|
__field(u64, miss)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->idx = idx;
|
|
__entry->hit = hit;
|
|
__entry->miss = miss;
|
|
),
|
|
|
|
TP_printk("cpu=%d idx=%d hit=%llu miss=%llu",
|
|
__entry->cpu, __entry->idx, __entry->hit, __entry->miss)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for lb cpu util
|
|
*/
|
|
TRACE_EVENT(lb_cpu_util,
|
|
|
|
TP_PROTO(int cpu, char *label),
|
|
|
|
TP_ARGS(cpu, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( int, active_balance )
|
|
__field( int, idle )
|
|
__field( int, nr_running )
|
|
__field( int, cfs_nr_running )
|
|
__field( int, nr_misfits )
|
|
__field( unsigned long, cpu_util )
|
|
__field( unsigned long, capacity_orig )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->active_balance = cpu_rq(cpu)->active_balance;
|
|
__entry->idle = available_idle_cpu(cpu);
|
|
__entry->nr_running = cpu_rq(cpu)->nr_running;
|
|
__entry->cfs_nr_running = cpu_rq(cpu)->cfs.h_nr_running;
|
|
__entry->nr_misfits = ems_rq_nr_misfited(cpu_rq(cpu));
|
|
__entry->cpu_util = ml_cpu_util(cpu);
|
|
__entry->capacity_orig = capacity_orig_of(cpu);
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("cpu=%d ab=%d idle=%d nr_running=%d cfs_nr_running=%d nr_misfits=%d cpu_util=%lu capacity=%lu reason=%s",
|
|
__entry->cpu, __entry->active_balance, __entry->idle, __entry->nr_running,
|
|
__entry->cfs_nr_running, __entry->nr_misfits, __entry->cpu_util, __entry->capacity_orig, __entry->label)
|
|
);
|
|
|
|
|
|
/*
|
|
* Tracepoint for task migration control
|
|
*/
|
|
TRACE_EVENT(lb_can_migrate_task,
|
|
|
|
TP_PROTO(struct task_struct *tsk, int dst_cpu, int migrate, char *label),
|
|
|
|
TP_ARGS(tsk, dst_cpu, migrate, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, src_cpu )
|
|
__field( int, dst_cpu )
|
|
__field( int, migrate )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
|
|
__entry->pid = tsk->pid;
|
|
__entry->src_cpu = task_cpu(tsk);
|
|
__entry->dst_cpu = dst_cpu;
|
|
__entry->migrate = migrate;
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d src_cpu=%d dst_cpu=%d migrate=%d reason=%s",
|
|
__entry->comm, __entry->pid, __entry->src_cpu, __entry->dst_cpu,
|
|
__entry->migrate, __entry->label)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for misfit
|
|
*/
|
|
TRACE_EVENT(lb_update_misfit,
|
|
TP_PROTO(struct task_struct *p, bool old, bool cur, int cpu, u64 rq_nr_misfit, char *label),
|
|
|
|
TP_ARGS(p, old, cur, cpu, rq_nr_misfit, label),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( unsigned long, util )
|
|
__field( bool, old )
|
|
__field( bool, cur )
|
|
__field( int, cpu )
|
|
__field( u64, rq_nr_misfit )
|
|
__array( char, label, 64 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
__entry->pid = p->pid;
|
|
__entry->util = ml_uclamp_task_util(p);
|
|
__entry->old = old;
|
|
__entry->cur = cur;
|
|
__entry->cpu = cpu;
|
|
__entry->rq_nr_misfit = rq_nr_misfit;
|
|
strncpy(__entry->label, label, 63);
|
|
),
|
|
|
|
TP_printk("comm=%s pid=%d util=%ld old=%d cur=%d cpu=%d rq_nr_misfit=%llu, tag=%s",
|
|
__entry->comm, __entry->pid, __entry->util, __entry->old,
|
|
__entry->cur, __entry->cpu, __entry->rq_nr_misfit, __entry->label)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for nohz balancer kick
|
|
*/
|
|
TRACE_EVENT(lb_nohz_balancer_kick,
|
|
|
|
TP_PROTO(struct rq *rq),
|
|
|
|
TP_ARGS(rq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( unsigned int, nr_running )
|
|
__field( unsigned int, cfs_nr_running )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = rq->cpu;
|
|
__entry->nr_running = rq->nr_running;
|
|
__entry->cfs_nr_running = rq->cfs.h_nr_running;
|
|
),
|
|
|
|
TP_printk("cpu=%d nr_running=%u cfs_nr_running=%u",
|
|
__entry->cpu, __entry->nr_running, __entry->cfs_nr_running)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for lb idle pull tasks rt
|
|
*/
|
|
TRACE_EVENT(lb_idle_pull_tasks_rt,
|
|
|
|
TP_PROTO(int src_cpu, struct task_struct *p, int pulled),
|
|
|
|
TP_ARGS(src_cpu, p, pulled),
|
|
|
|
TP_STRUCT__entry(
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
__field( pid_t, pid )
|
|
__field( int, src_cpu )
|
|
__field( int, pulled )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->comm, p ? p->comm : "no task", TASK_COMM_LEN);
|
|
__entry->pid = p ? p->pid : -1;
|
|
__entry->src_cpu = src_cpu;
|
|
__entry->pulled = pulled;
|
|
),
|
|
|
|
TP_printk("src_cpu=%d pulled=%d comm=%s pid=%d",
|
|
__entry->src_cpu, __entry->pulled, __entry->comm, __entry->pid)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for mhdvfs profile
|
|
*/
|
|
TRACE_EVENT(mhdvfs_profile,
|
|
|
|
TP_PROTO(u64 ipc_sum, u64 mspc_sum),
|
|
|
|
TP_ARGS(ipc_sum, mspc_sum),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( u64, ipc_sum )
|
|
__field( u64, mspc_sum )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ipc_sum = ipc_sum;
|
|
__entry->mspc_sum = mspc_sum;
|
|
),
|
|
|
|
TP_printk("ipc_sum=%llu mspc_sum=%llu",
|
|
__entry->ipc_sum, __entry->mspc_sum)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for kicking dsufreq by mhdvfs
|
|
*/
|
|
TRACE_EVENT(mhdvfs_kick_dsufreq,
|
|
|
|
TP_PROTO(u64 mspc, int ratio),
|
|
|
|
TP_ARGS(mspc, ratio),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( u64, mspc )
|
|
__field( int, ratio )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->mspc = mspc;
|
|
__entry->ratio = ratio;
|
|
),
|
|
|
|
TP_printk("mspc=%llu ratio=%d", __entry->mspc, __entry->ratio)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for kicking miffreq by mhdvfs
|
|
*/
|
|
TRACE_EVENT(mhdvfs_kick_miffreq,
|
|
|
|
TP_PROTO(u64 mspc, u32 ratio, u64 duration_ms),
|
|
|
|
TP_ARGS(mspc, ratio, duration_ms),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( u64, mspc )
|
|
__field( u32, ratio )
|
|
__field( u64, duration_ms )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->mspc = mspc;
|
|
__entry->ratio = ratio;
|
|
__entry->duration_ms = duration_ms;
|
|
),
|
|
|
|
TP_printk("mspc=%llu ratio=%u duration=%llu",
|
|
__entry->mspc, __entry->ratio, __entry->duration_ms)
|
|
);
|
|
|
|
/*
|
|
* Tracepoint for kicking cpufreq by mhdvfs
|
|
*/
|
|
TRACE_EVENT(mhdvfs_kick_cpufreq,
|
|
|
|
TP_PROTO(int cpu, u64 ipc, int ratio),
|
|
|
|
TP_ARGS(cpu, ipc, ratio),
|
|
|
|
TP_STRUCT__entry(
|
|
__field( int, cpu )
|
|
__field( u64, ipc )
|
|
__field( int, ratio )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->cpu = cpu;
|
|
__entry->ipc = ipc;
|
|
__entry->ratio = ratio;
|
|
),
|
|
|
|
TP_printk("cpu=%d ipc=%llu ratio=%d",
|
|
__entry->cpu, __entry->ipc, __entry->ratio)
|
|
);
|
|
#endif /* _TRACE_EMS_DEBUG_H */
|
|
|
|
/* This part must be outside protection */
|
|
#include <trace/define_trace.h>
|