* [PATCH] whole-process CPU usage
@ 2004-08-31 8:10 Albert Cahalan
0 siblings, 0 replies; only message in thread
From: Albert Cahalan @ 2004-08-31 8:10 UTC (permalink / raw)
To: linux-kernel mailing list; +Cc: Andrew Morton OSDL, Linus Torvalds
This looks like it ought to work. Due to undocumented
locking, it may need a bit of work. The two ungreppable
old names are replaced with these six:
->task_sys_time Per-thread CPU usage
->signal->proc_sys_time Per-process CPU usage
->signal->dead_sys_time CPU usage of dead children
(and 3 more, with "usr" in place of "sys")
Some of the changes appear to fix UNIX non-compliance.
For example, times() and getrusage() are per-process.
I assume that the OOM killer wants per-process data too.
BSD accounting appears to be per-thread, so that's what
I gave it for now, but per-process accounting makes more
sense.
Context switch and fault counts can get this treatment
in some future patch.
It's long past time for "signal" to get renamed. Ideas?
diff -Naurd a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c
--- a/arch/alpha/kernel/osf_sys.c 2004-08-24 03:01:50.000000000 -0400
+++ b/arch/alpha/kernel/osf_sys.c 2004-08-31 00:53:16.000000000 -0400
@@ -1073,21 +1073,21 @@
memset(&r, 0, sizeof(r));
switch (who) {
case RUSAGE_SELF:
- jiffies_to_timeval32(current->utime, &r.ru_utime);
- jiffies_to_timeval32(current->stime, &r.ru_stime);
+ jiffies_to_timeval32(current->signal->proc_usr_time, &r.ru_utime);
+ jiffies_to_timeval32(current->signal->proc_sys_time, &r.ru_stime);
r.ru_minflt = current->min_flt;
r.ru_majflt = current->maj_flt;
break;
case RUSAGE_CHILDREN:
- jiffies_to_timeval32(current->cutime, &r.ru_utime);
- jiffies_to_timeval32(current->cstime, &r.ru_stime);
+ jiffies_to_timeval32(current->signal->dead_usr_time, &r.ru_utime);
+ jiffies_to_timeval32(current->signal->dead_sys_time, &r.ru_stime);
r.ru_minflt = current->cmin_flt;
r.ru_majflt = current->cmaj_flt;
break;
default:
- jiffies_to_timeval32(current->utime + current->cutime,
+ jiffies_to_timeval32(current->signal->proc_usr_time + current->signal->dead_usr_time,
&r.ru_utime);
- jiffies_to_timeval32(current->stime + current->cstime,
+ jiffies_to_timeval32(current->signal->proc_sys_time + current->signal->dead_sys_time,
&r.ru_stime);
r.ru_minflt = current->min_flt + current->cmin_flt;
r.ru_majflt = current->maj_flt + current->cmaj_flt;
diff -Naurd a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c
--- a/arch/i386/kernel/apm.c 2004-08-24 03:01:53.000000000 -0400
+++ b/arch/i386/kernel/apm.c 2004-08-31 00:48:38.000000000 -0400
@@ -837,18 +837,18 @@
if (jiffies_since_last_check > IDLE_CALC_LIMIT) {
use_apm_idle = 0;
last_jiffies = jiffies;
- last_stime = current->stime;
+ last_stime = current->task_sys_time;
} else if (jiffies_since_last_check > idle_period) {
unsigned int idle_percentage;
- idle_percentage = current->stime - last_stime;
+ idle_percentage = current->task_sys_time - last_stime;
idle_percentage *= 100;
idle_percentage /= jiffies_since_last_check;
use_apm_idle = (idle_percentage > idle_threshold);
if (apm_info.forbid_idle)
use_apm_idle = 0;
last_jiffies = jiffies;
- last_stime = current->stime;
+ last_stime = current->task_sys_time;
}
bucket = IDLE_LEAKY_MAX;
diff -Naurd a/fs/binfmt_elf.c b/fs/binfmt_elf.c
--- a/fs/binfmt_elf.c 2004-08-24 03:02:33.000000000 -0400
+++ b/fs/binfmt_elf.c 2004-08-30 22:38:48.000000000 -0400
@@ -1176,10 +1176,10 @@
prstatus->pr_ppid = p->parent->pid;
prstatus->pr_pgrp = process_group(p);
prstatus->pr_sid = p->signal->session;
- jiffies_to_timeval(p->utime, &prstatus->pr_utime);
- jiffies_to_timeval(p->stime, &prstatus->pr_stime);
- jiffies_to_timeval(p->cutime, &prstatus->pr_cutime);
- jiffies_to_timeval(p->cstime, &prstatus->pr_cstime);
+ jiffies_to_timeval(p->task_usr_time, &prstatus->pr_utime);
+ jiffies_to_timeval(p->task_sys_time, &prstatus->pr_stime);
+ jiffies_to_timeval(p->signal->dead_usr_time, &prstatus->pr_cutime);
+ jiffies_to_timeval(p->signal->dead_sys_time, &prstatus->pr_cstime);
}
static void fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
diff -Naurd a/fs/proc/array.c b/fs/proc/array.c
--- a/fs/proc/array.c 2004-08-24 03:02:58.000000000 -0400
+++ b/fs/proc/array.c 2004-08-31 02:57:25.000000000 -0400
@@ -300,9 +300,10 @@
}
extern unsigned long task_vsize(struct mm_struct *);
-int proc_pid_stat(struct task_struct *task, char * buffer)
+static int do_task_stat(struct task_struct *task, char * buffer, int whole)
{
unsigned long vsize, eip, esp, wchan;
+ unsigned long dead_usr_time, dead_sys_time, usr_time, sys_time;
long priority, nice;
int tty_pgrp = -1, tty_nr = 0;
sigset_t sigign, sigcatch;
@@ -330,10 +331,10 @@
}
get_task_comm(tcomm, task);
- wchan = get_wchan(task);
sigemptyset(&sigign);
sigemptyset(&sigcatch);
+
read_lock(&tasklist_lock);
if (task->sighand) {
spin_lock_irq(&task->sighand->siglock);
@@ -349,6 +350,7 @@
pgid = process_group(task);
sid = task->signal->session;
}
+ ppid = task->pid ? task->real_parent->pid : 0;
read_unlock(&tasklist_lock);
/* scale priority and nice values from timeslices to -20..20 */
@@ -356,16 +358,32 @@
priority = task_prio(task);
nice = task_nice(task);
- read_lock(&tasklist_lock);
- ppid = task->pid ? task->real_parent->pid : 0;
- read_unlock(&tasklist_lock);
+ /* if this is found to need siglock or tasklist_lock, DOCUMENT WHY */
+ dead_usr_time = jiffies_to_clock_t(task->signal->dead_usr_time);
+ dead_sys_time = jiffies_to_clock_t(task->signal->dead_sys_time);
+ if (whole) {
+ usr_time = jiffies_to_clock_t(task->signal->proc_usr_time);
+ sys_time = jiffies_to_clock_t(task->signal->proc_sys_time);
+ } else {
+ usr_time = jiffies_to_clock_t(task->task_usr_time);
+ sys_time = jiffies_to_clock_t(task->task_sys_time);
+ }
+
+ /* compute whole-process wchan only if single-threaded */
+ wchan = (whole && num_threads>1) ? ~0ul : get_wchan(task);
/* Temporary variable needed for gcc-2.96 */
start_time = jiffies_64_to_clock_t(task->start_time - INITIAL_JIFFIES);
- res = sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
-%lu %lu %lu %lu %lu %ld %ld %ld %ld %d %ld %llu %lu %ld %lu %lu %lu %lu %lu \
-%lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu\n",
+ res = sprintf(
+ buffer,
+ "%d (%s) %c %d %d %d %d %d %lu "
+ "%lu %lu %lu %lu %lu %lu %lu %lu "
+ "%ld %ld %d %ld %llu %lu "
+ "%ld %lu %lu %lu %lu %lu %lu "
+ "%lu %lu %lu %lu %lu 0 0 %d %d %lu %lu\n",
+
+ /* arg 3 */
task->pid,
tcomm,
state,
@@ -375,20 +393,26 @@
tty_nr,
tty_pgrp,
task->flags,
+
+ /* arg 12 */
task->min_flt,
task->cmin_flt,
task->maj_flt,
task->cmaj_flt,
- jiffies_to_clock_t(task->utime),
- jiffies_to_clock_t(task->stime),
- jiffies_to_clock_t(task->cutime),
- jiffies_to_clock_t(task->cstime),
+ usr_time,
+ sys_time,
+ dead_usr_time,
+ dead_sys_time,
+
+ /* arg 20 */
priority,
nice,
num_threads,
jiffies_to_clock_t(task->it_real_value),
start_time,
vsize,
+
+ /* arg 26 */
mm ? mm->rss : 0, /* you might want to shift this left 3 */
task->rlim[RLIMIT_RSS].rlim_cur,
mm ? mm->start_code : 0,
@@ -396,26 +420,39 @@
mm ? mm->start_stack : 0,
esp,
eip,
+
/* The signal information here is obsolete.
* It must be decimal for Linux 2.0 compatibility.
* Use /proc/#/status for real-time signals.
*/
+ /* arg 33 */
task->pending.signal.sig[0] & 0x7fffffffUL,
- task->blocked.sig[0] & 0x7fffffffUL,
- sigign .sig[0] & 0x7fffffffUL,
- sigcatch .sig[0] & 0x7fffffffUL,
+ task->blocked .sig[0] & 0x7fffffffUL,
+ sigign .sig[0] & 0x7fffffffUL,
+ sigcatch .sig[0] & 0x7fffffffUL,
wchan,
- 0UL,
- 0UL,
+ /* 0UL, */
+ /* 0UL, */
task->exit_signal,
task_cpu(task),
task->rt_priority,
- task->policy);
+ task->policy
+ );
if(mm)
mmput(mm);
return res;
}
+int proc_tid_stat(struct task_struct *task, char * buffer)
+{
+ return do_task_stat(task, buffer, 0);
+}
+
+int proc_tgid_stat(struct task_struct *task, char * buffer)
+{
+ return do_task_stat(task, buffer, 1);
+}
+
extern int task_statm(struct mm_struct *, int *, int *, int *, int *);
int proc_pid_statm(struct task_struct *task, char *buffer)
{
diff -Naurd a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
--- a/fs/proc/proc_misc.c 2004-08-24 03:01:55.000000000 -0400
+++ b/fs/proc/proc_misc.c 2004-08-31 01:04:45.000000000 -0400
@@ -136,7 +136,7 @@
struct timespec uptime;
struct timespec idle;
int len;
- u64 idle_jiffies = init_task.utime + init_task.stime;
+ u64 idle_jiffies = init_task.task_usr_time + init_task.task_sys_time;
do_posix_clock_monotonic_gettime(&uptime);
jiffies_to_timespec(idle_jiffies, &idle);
diff -Naurd a/include/linux/sched.h b/include/linux/sched.h
--- a/include/linux/sched.h 2004-08-24 03:01:54.000000000 -0400
+++ b/include/linux/sched.h 2004-08-30 22:20:29.000000000 -0400
@@ -284,6 +284,9 @@
int leader;
struct tty_struct *tty; /* NULL if no tty */
+
+ unsigned long proc_sys_time, proc_usr_time; /* whole process */
+ unsigned long dead_sys_time, dead_usr_time; /* dead children */
};
/*
@@ -460,7 +463,7 @@
unsigned long it_real_value, it_prof_value, it_virt_value;
unsigned long it_real_incr, it_prof_incr, it_virt_incr;
struct timer_list real_timer;
- unsigned long utime, stime, cutime, cstime;
+ unsigned long task_sys_time, task_usr_time;
unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw; /* context switch counts */
u64 start_time;
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
diff -Naurd a/kernel/acct.c b/kernel/acct.c
--- a/kernel/acct.c 2004-08-24 03:02:48.000000000 -0400
+++ b/kernel/acct.c 2004-08-30 22:59:30.000000000 -0400
@@ -418,8 +418,14 @@
#endif
do_div(elapsed, AHZ);
ac.ac_btime = xtime.tv_sec - elapsed;
- ac.ac_utime = encode_comp_t(jiffies_to_AHZ(current->utime));
- ac.ac_stime = encode_comp_t(jiffies_to_AHZ(current->stime));
+
+ /*
+ * accounting is called once per thread -- maybe not the best
+ * (if that changes, use current->signal->proc_usr_time, etc.)
+ */
+ ac.ac_utime = encode_comp_t(jiffies_to_AHZ(current->task_usr_time));
+ ac.ac_stime = encode_comp_t(jiffies_to_AHZ(current->task_sys_time));
+
/* we really need to bite the bullet and change layout */
ac.ac_uid = current->uid;
ac.ac_gid = current->gid;
diff -Naurd a/kernel/compat.c b/kernel/compat.c
--- a/kernel/compat.c 2004-08-24 03:02:47.000000000 -0400
+++ b/kernel/compat.c 2004-08-30 23:01:52.000000000 -0400
@@ -160,10 +160,10 @@
*/
if (tbuf) {
struct compat_tms tmp;
- tmp.tms_utime = compat_jiffies_to_clock_t(current->utime);
- tmp.tms_stime = compat_jiffies_to_clock_t(current->stime);
- tmp.tms_cutime = compat_jiffies_to_clock_t(current->cutime);
- tmp.tms_cstime = compat_jiffies_to_clock_t(current->cstime);
+ tmp.tms_utime = compat_jiffies_to_clock_t(current->signal->proc_usr_time);
+ tmp.tms_stime = compat_jiffies_to_clock_t(current->signal->proc_sys_time);
+ tmp.tms_cutime = compat_jiffies_to_clock_t(current->signal->dead_usr_time);
+ tmp.tms_cstime = compat_jiffies_to_clock_t(current->signal->dead_sys_time);
if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
return -EFAULT;
}
diff -Naurd a/kernel/cpu.c b/kernel/cpu.c
--- a/kernel/cpu.c 2004-08-24 03:03:31.000000000 -0400
+++ b/kernel/cpu.c 2004-08-30 23:21:47.000000000 -0400
@@ -49,7 +49,7 @@
write_lock_irq(&tasklist_lock);
for_each_process(p) {
- if (task_cpu(p) == cpu && (p->utime != 0 || p->stime != 0))
+ if (task_cpu(p) == cpu && (p->signal->proc_usr_time || p->signal->proc_sys_time))
printk(KERN_WARNING "Task %s (pid = %d) is on cpu %d\
(state = %ld, flags = %lx) \n",
p->comm, p->pid, cpu, p->state, p->flags);
diff -Naurd a/kernel/exit.c b/kernel/exit.c
--- a/kernel/exit.c 2004-08-24 03:03:31.000000000 -0400
+++ b/kernel/exit.c 2004-08-31 00:04:13.000000000 -0400
@@ -90,12 +90,18 @@
zap_leader = (leader->exit_signal == -1);
}
- p->parent->cutime += p->utime + p->cutime;
- p->parent->cstime += p->stime + p->cstime;
+ /* credit parent's dead-child stats (proper: when parent waits) */
+ if (leader == p && thread_group_empty(leader)) {
+ p->parent->signal->dead_usr_time += p->signal->proc_usr_time + p->signal->dead_usr_time;
+ p->parent->signal->dead_sys_time += p->signal->proc_sys_time + p->signal->dead_sys_time;
+ }
+
+ /* TODO: these should get the same treatment as CPU time */
p->parent->cmin_flt += p->min_flt + p->cmin_flt;
p->parent->cmaj_flt += p->maj_flt + p->cmaj_flt;
p->parent->cnvcsw += p->nvcsw + p->cnvcsw;
p->parent->cnivcsw += p->nivcsw + p->cnivcsw;
+
sched_exit(p);
write_unlock_irq(&tasklist_lock);
spin_unlock(&p->proc_lock);
diff -Naurd a/kernel/fork.c b/kernel/fork.c
--- a/kernel/fork.c 2004-08-24 03:01:54.000000000 -0400
+++ b/kernel/fork.c 2004-08-31 00:10:31.000000000 -0400
@@ -822,6 +822,8 @@
if (!sig)
return -ENOMEM;
atomic_set(&sig->count, 1);
+ sig->proc_usr_time = sig->proc_sys_time = 0;
+ sig->dead_usr_time = sig->dead_sys_time = 0;
sig->group_exit = 0;
sig->group_exit_code = 0;
sig->group_exit_task = NULL;
@@ -959,8 +961,7 @@
init_timer(&p->real_timer);
p->real_timer.data = (unsigned long) p;
- p->utime = p->stime = 0;
- p->cutime = p->cstime = 0;
+ p->task_usr_time = p->task_sys_time = 0;
p->lock_depth = -1; /* -1 = no lock */
p->start_time = get_jiffies_64();
p->security = NULL;
diff -Naurd a/kernel/signal.c b/kernel/signal.c
--- a/kernel/signal.c 2004-08-24 03:02:32.000000000 -0400
+++ b/kernel/signal.c 2004-08-31 00:19:24.000000000 -0400
@@ -1445,8 +1445,8 @@
info.si_uid = tsk->uid;
/* FIXME: find out whether or not this is supposed to be c*time. */
- info.si_utime = tsk->utime;
- info.si_stime = tsk->stime;
+ info.si_utime = tsk->signal->proc_usr_time + tsk->signal->dead_usr_time;
+ info.si_stime = tsk->signal->proc_sys_time + tsk->signal->dead_sys_time;
status = tsk->exit_code & 0x7f;
why = SI_KERNEL; /* shouldn't happen */
@@ -1534,8 +1534,8 @@
info.si_uid = tsk->uid;
/* FIXME: find out whether or not this is supposed to be c*time. */
- info.si_utime = tsk->utime;
- info.si_stime = tsk->stime;
+ info.si_utime = tsk->signal->proc_usr_time + tsk->signal->dead_usr_time;
+ info.si_stime = tsk->signal->proc_sys_time + tsk->signal->dead_sys_time;
info.si_status = tsk->exit_code & 0x7f;
info.si_code = CLD_STOPPED;
diff -Naurd a/kernel/sys.c b/kernel/sys.c
--- a/kernel/sys.c 2004-08-24 03:01:54.000000000 -0400
+++ b/kernel/sys.c 2004-08-31 00:29:43.000000000 -0400
@@ -944,13 +944,14 @@
* the times increment as we use it. Since the value is an
* atomically safe type this is just fine. Conceptually its
* as if the syscall took an instant longer to occur.
+ * The UNIX spec seems to indicate that these are per-process.
*/
if (tbuf) {
struct tms tmp;
- tmp.tms_utime = jiffies_to_clock_t(current->utime);
- tmp.tms_stime = jiffies_to_clock_t(current->stime);
- tmp.tms_cutime = jiffies_to_clock_t(current->cutime);
- tmp.tms_cstime = jiffies_to_clock_t(current->cstime);
+ tmp.tms_utime = jiffies_to_clock_t(current->signal->proc_usr_time);
+ tmp.tms_stime = jiffies_to_clock_t(current->signal->proc_sys_time);
+ tmp.tms_cutime = jiffies_to_clock_t(current->signal->dead_usr_time);
+ tmp.tms_cstime = jiffies_to_clock_t(current->signal->dead_sys_time);
if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
return -EFAULT;
}
@@ -1526,12 +1527,9 @@
}
/*
- * It would make sense to put struct rusage in the task_struct,
- * except that would make the task_struct be *really big*. After
- * task_struct gets moved into malloc'ed memory, it would
- * make sense to do this. It will make moving the rest of the information
- * a lot simpler! (Which we're not doing right now because we're not
- * measuring them yet).
+ * It would make sense to put struct rusage in the signal_struct,
+ * except that would make the signal_struct be *really big*.
+ * TODO: Perhaps a thread-specific rusage value would be useful.
*
* This is SMP safe. Either we are called from sys_getrusage on ourselves
* below (we know we aren't going to exit/disappear and only we change our
@@ -1547,24 +1545,27 @@
memset((char *) &r, 0, sizeof(r));
switch (who) {
case RUSAGE_SELF:
- jiffies_to_timeval(p->utime, &r.ru_utime);
- jiffies_to_timeval(p->stime, &r.ru_stime);
+ jiffies_to_timeval(p->signal->proc_usr_time, &r.ru_utime);
+ jiffies_to_timeval(p->signal->proc_sys_time, &r.ru_stime);
+ /* these are still broken -- should be per-process */
r.ru_nvcsw = p->nvcsw;
r.ru_nivcsw = p->nivcsw;
r.ru_minflt = p->min_flt;
r.ru_majflt = p->maj_flt;
break;
case RUSAGE_CHILDREN:
- jiffies_to_timeval(p->cutime, &r.ru_utime);
- jiffies_to_timeval(p->cstime, &r.ru_stime);
+ jiffies_to_timeval(p->signal->dead_usr_time, &r.ru_utime);
+ jiffies_to_timeval(p->signal->dead_sys_time, &r.ru_stime);
+ /* these are still broken -- should be per-process */
r.ru_nvcsw = p->cnvcsw;
r.ru_nivcsw = p->cnivcsw;
r.ru_minflt = p->cmin_flt;
r.ru_majflt = p->cmaj_flt;
break;
default:
- jiffies_to_timeval(p->utime + p->cutime, &r.ru_utime);
- jiffies_to_timeval(p->stime + p->cstime, &r.ru_stime);
+ jiffies_to_timeval(p->signal->proc_usr_time + p->signal->dead_usr_time, &r.ru_utime);
+ jiffies_to_timeval(p->signal->proc_sys_time + p->signal->dead_sys_time, &r.ru_stime);
+ /* these are still broken -- should be per-process */
r.ru_nvcsw = p->nvcsw + p->cnvcsw;
r.ru_nivcsw = p->nivcsw + p->cnivcsw;
r.ru_minflt = p->min_flt + p->cmin_flt;
diff -Naurd a/kernel/timer.c b/kernel/timer.c
--- a/kernel/timer.c 2004-08-24 03:03:31.000000000 -0400
+++ b/kernel/timer.c 2004-08-31 00:33:25.000000000 -0400
@@ -790,8 +790,10 @@
{
unsigned long psecs;
- psecs = (p->utime += user);
- psecs += (p->stime += system);
+ p->task_usr_time += user;
+ p->task_sys_time += system;
+ psecs = (p->signal->proc_usr_time += user);
+ psecs += (p->signal->proc_sys_time += system);
if (psecs / HZ >= p->rlim[RLIMIT_CPU].rlim_cur) {
/* Send SIGXCPU every second.. */
if (!(psecs % HZ))
diff -Naurd a/mm/oom_kill.c b/mm/oom_kill.c
--- a/mm/oom_kill.c 2004-08-24 03:02:48.000000000 -0400
+++ b/mm/oom_kill.c 2004-08-31 00:43:00.000000000 -0400
@@ -60,7 +60,7 @@
* particular reason for this other than that it turned out to work
* very well in practice.
*/
- cpu_time = (p->utime + p->stime) >> (SHIFT_HZ + 3);
+ cpu_time = (p->signal->proc_usr_time + p->signal->proc_sys_time) >> (SHIFT_HZ + 3);
run_time = (get_jiffies_64() - p->start_time) >> (SHIFT_HZ + 10);
s = int_sqrt(cpu_time);
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2004-08-31 8:13 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2004-08-31 8:10 [PATCH] whole-process CPU usage Albert Cahalan
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.