Still seeing decreasing stime/utime
Subsystems (2)
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): 1220095656.8426.23.camel@twins
Quoted 10 lines · Peter Zijlstra
Quoted 9 lines · Balbir Singh
Quoted 7 lines · Spencer Candland
Quoted 3 lines
Here is an experimental patch (I've just compiled and booted a machine with it, I am unable to reproduce your problem), could you please test it for me and see if it helps solve the problem
Looks like this fixed it. I have been testing this for the last 16 hours and everything is looking good.
Quoted 6 lines
Quoted 2 lines
Excellent! Ingo, Peter, do you like the patch? If so, could you please pick it up Ingo. I think we should even push the fix to stable releases.
Looks good, except for the issue you yourself earlier raised, a few of those functions looks too large to be inlined.
Here's the updated revision with task_*time functions moved to sched.c and inlining removed, except for task_gtime(). I've compiled and booted a machine (x86_64) with this patch applied.
Spencer reported a problem where utime and stime were going negative despite the fixes in commit b27f03d4bdc145a09fb7b0c0e004b29f1ee555fa. The suspected reason for the problem is that signal_struct maintains it's own utime and stime (of exited tasks), these are not updated using the new task_utime() routine, hence sig->utime can go backwards and cause the same problem to occur (sig->utime, adds tsk->utime and not task_utime()). This patch fixes the problem
TODO: using max(task->prev_utime, derived utime) works for now, but a more generic solution is to implement cputime_max() and use the cputime_gt() function for comparison.
Comments?
---
fs/proc/array.c | 59 -------------------------------------------------- include/linux/sched.h | 4 +++ kernel/exit.c | 6 ++--- kernel/sched.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 66 insertions(+), 62 deletions(-)
kernel/exit.c renamed from kernel/exit.c~fix-utime-stime-moving-backwards +3 -3
@@ -115,9 +115,9 @@ static void __exit_signal(struct task_st* We won't ever get here for the group leader, since it * will have been the last reference on the signal_struct. */ - sig->utime =cputime_add (sig->utime, tsk->utime); - sig->stime =cputime_add (sig->stime, tsk->stime); - sig->gtime =cputime_add (sig->gtime, tsk->gtime); + sig->utime =cputime_add (sig->utime,task_utime (tsk)); + sig->stime =cputime_add (sig->stime,task_stime (tsk)); + sig->gtime =cputime_add (sig->gtime,task_gtime (tsk)); sig->min_flt += tsk->min_flt; sig->maj_flt += tsk->maj_flt; sig->nvcsw += tsk->nvcsw;
fs/proc/array.c renamed from fs/proc/array.c~fix-utime-stime-moving-backwards +0 -59
65 lines not on this page · raw message
include/linux/sched.h renamed from include/linux/sched.h~fix-utime-stime-moving-backwards +4 -0
@@ -1430,6 +1430,10 @@ static inline void put_task_struct(struc__put_task_struct (t); } +extern cputime_t task_utime (struct task_struct *p); +extern cputime_t task_stime (struct task_struct *p); +extern cputime_t task_gtime (struct task_struct *p); +/* * Per process flags */
kernel/sched.c renamed from kernel/sched.c~fix-utime-stime-moving-backwards +59 -0
65 lines not on this page · raw message
_
Signature · 1 line
Balbir
Peter Zijlstra
Acked-byQuoted 33 lines · Balbir Singh
Quoted 10 lines · Peter Zijlstra
Quoted 9 lines · Balbir Singh
Quoted 7 lines · Spencer Candland
Quoted 3 lines
Here is an experimental patch (I've just compiled and booted a machine with it, I am unable to reproduce your problem), could you please test it for me and see if it helps solve the problem
Looks like this fixed it. I have been testing this for the last 16 hours and everything is looking good.
Quoted 6 lines
Quoted 2 lines
Excellent! Ingo, Peter, do you like the patch? If so, could you please pick it up Ingo. I think we should even push the fix to stable releases.
Looks good, except for the issue you yourself earlier raised, a few of those functions looks too large to be inlined.
Here's the updated revision with task_*time functions moved to
sched.cand inlining removed, except fortask_gtime(). I've compiled and booted a machine (x86_64) with this patch applied.Reported-by [email protected]Spencer reported a problem where utime and stime were going negative despite the fixes in commit
b27f03d4bdc145a09fb7b0c0e004b29f1ee555fa. The suspected reason for the problem is thatsignal_structmaintains it's own utime and stime (of exited tasks), these are not updated using the newtask_utime()routine, hencesig->utimecan go backwards and cause the same problem to occur (sig->utime, addstsk->utimeand nottask_utime()). This patch fixes the problem
Quoted 7 lines
TODO: using
max(task->prev_utime, derived utime)works for now, but a more generic solution is to implementcputime_max()and use thecputime_gt()function for comparison.Comments?
Signed-off-by Balbir Singh <[email protected]>
Thanks Balbir!
Quoted 178 lines
---
fs/proc/array.c | 59 -------------------------------------------------- include/linux/sched.h | 4 +++ kernel/exit.c | 6 ++--- kernel/sched.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 66 insertions(+), 62 deletions(-)diff -puN
kernel/exit.c~fix-utime-stime-moving-backwardskernel/exit.ckernel/exit.c renamed from kernel/exit.c~fix-utime-stime-moving-backwards +3
-3@@ -115,9 +115,9 @@ static void __exit_signal(struct task_st* We won't ever get here for the group leader, since it * will have been the last reference on the signal_struct. */ - sig->utime =cputime_add (sig->utime, tsk->utime); - sig->stime =cputime_add (sig->stime, tsk->stime); - sig->gtime =cputime_add (sig->gtime, tsk->gtime); + sig->utime =cputime_add (sig->utime,task_utime (tsk)); + sig->stime =cputime_add (sig->stime,task_stime (tsk)); + sig->gtime =cputime_add (sig->gtime,task_gtime (tsk)); sig->min_flt += tsk->min_flt; sig->maj_flt += tsk->maj_flt; sig->nvcsw += tsk->nvcsw;diff -puN
fs/proc/array.c~fix-utime-stime-moving-backwardsfs/proc/array.cfs/proc/array.c renamed from fs/proc/array.c~fix-utime-stime-moving-backwards +0
-59@@ -349,65 +349,6 @@ int proc_pid_status(struct seq_file *m,return 0 ; } -/* -* Use precise platform statistics if available: -*/ -#ifdef CONFIG_VIRT_CPU_ACCOUNTING -static cputime_t task_utime (struct task_struct *p) -{ -return p->utime; -} - -static cputime_t task_stime (struct task_struct *p) -{ -return p->stime; -} -#else -static cputime_t task_utime (struct task_struct *p) -{ -clock_t utime =cputime_to_clock_t (p->utime), - total = utime +cputime_to_clock_t (p->stime); -u64 temp; - -/* -* Use CFS's precise accounting: -*/ - temp = (u64 )nsec_to_clock_t (p->se.sum_exec_runtime); - -if (total) { - temp *= utime; -do_div (temp, total); - } - utime = (clock_t )temp; - - p->prev_utime =max (p->prev_utime,clock_t_to_cputime (utime)); -return p->prev_utime; -} - -static cputime_t task_stime (struct task_struct *p) -{ -clock_t stime; - -/* -* Use CFS's precise accounting. (we subtract utime from -* the total, to make sure the total observed by userspace -* grows monotonically - apps rely on that): -*/ - stime =nsec_to_clock_t (p->se.sum_exec_runtime) - -cputime_to_clock_t (task_utime (p)); - -if (stime >=0 ) - p->prev_stime =max (p->prev_stime,clock_t_to_cputime (stime)); - -return p->prev_stime; -} -#endif - -static cputime_t task_gtime (struct task_struct *p) -{ -return p->gtime; -} -static int do_task_stat (struct seq_file *m,struct pid_namespace *ns,struct pid *pid,struct task_struct *task,int whole) {diff -puN
include/linux/sched.h~fix-utime-stime-moving-backwardsinclude/linux/sched.hinclude/linux/sched.h renamed from include/linux/sched.h~fix-utime-stime-moving-backwards +4
-0@@ -1430,6 +1430,10 @@ static inline void put_task_struct(struc__put_task_struct (t); } +extern cputime_t task_utime (struct task_struct *p); +extern cputime_t task_stime (struct task_struct *p); +extern cputime_t task_gtime (struct task_struct *p); +/* * Per process flags */ diff -puN
kernel/sched.c~fix-utime-stime-moving-backwardskernel/sched.ckernel/sched.c renamed from kernel/sched.c~fix-utime-stime-moving-backwards +59
-0@@ -4176,6 +4176,65 @@ void account_steal_time(struct task_stru }/* +* Use precise platform statistics if available: +*/ +#ifdef CONFIG_VIRT_CPU_ACCOUNTING +cputime_t task_utime (struct task_struct *p) +{ +return p->utime; +} + +cputime_t task_stime (struct task_struct *p) +{ +return p->stime; +} +#else +cputime_t task_utime (struct task_struct *p) +{ +clock_t utime =cputime_to_clock_t (p->utime), + total = utime +cputime_to_clock_t (p->stime); +u64 temp; + +/* +* Use CFS's precise accounting: +*/ + temp = (u64 )nsec_to_clock_t (p->se.sum_exec_runtime); + +if (total) { + temp *= utime; +do_div (temp, total); + } + utime = (clock_t )temp; + + p->prev_utime =max (p->prev_utime,clock_t_to_cputime (utime)); +return p->prev_utime; +} + +cputime_t task_stime (struct task_struct *p) +{ +clock_t stime; + +/* +* Use CFS's precise accounting. (we subtract utime from +* the total, to make sure the total observed by userspace +* grows monotonically - apps rely on that): +*/ + stime =nsec_to_clock_t (p->se.sum_exec_runtime) - +cputime_to_clock_t (task_utime (p)); + +if (stime >=0 ) + p->prev_stime =max (p->prev_stime,clock_t_to_cputime (stime)); + +return p->prev_stime; +} +#endif + +inline cputime_t task_gtime (struct task_struct *p) +{ +return p->gtime; +} + +/* * This function gets called by the timer code, with HZ frequency. * We call it with interrupts disabled. * _
Quoted 34 lines · Peter Zijlstra
Quoted 33 lines · Balbir Singh
Quoted 5 lines · Peter Zijlstra
Quoted 4 lines · Balbir Singh
Quoted 3 lines · Spencer Candland
Quoted 3 lines
Here is an experimental patch (I've just compiled and booted a machine with it, I am unable to reproduce your problem), could you please test it for me and see if it helps solve the problem
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
Looks like this fixed it. I have been testing this for the last 16 hours and everything is looking good.
Excellent! Ingo, Peter, do you like the patch? If so, could you please pick it up Ingo. I think we should even push the fix to stable releases.
Looks good, except for the issue you yourself earlier raised, a few of those functions looks too large to be inlined.
Here's the updated revision with task_*time functions moved to
sched.cand inlining removed, except fortask_gtime(). I've compiled and booted a machine (x86_64) with this patch applied.Reported-by [email protected]Spencer reported a problem where utime and stime were going negative despite the fixes in commit
b27f03d4bdc145a09fb7b0c0e004b29f1ee555fa. The suspected reason for the problem is thatsignal_structmaintains it's own utime and stime (of exited tasks), these are not updated using the newtask_utime()routine, hencesig->utimecan go backwards and cause the same problem to occur (sig->utime, addstsk->utimeand nottask_utime()). This patch fixes the problemTODO: using
max(task->prev_utime, derived utime)works for now, but a more generic solution is to implementcputime_max()and use thecputime_gt()function for comparison.
Quoted 7 lines
Quoted 3 lines
Comments?
Signed-off-by Balbir Singh <[email protected]>Thanks Balbir!
Acked-by Peter Zijlstra <[email protected]>
Ingo, could you please pick this one.
Signature · 2 lines
Thanks, Balbir
Ingo Molnar
AppliedQuoted 38 lines · Peter Zijlstra
Quoted 37 lines · Balbir Singh
Quoted 10 lines · Peter Zijlstra
Quoted 9 lines · Balbir Singh
Quoted 7 lines · Spencer Candland
Quoted 3 lines
Here is an experimental patch (I've just compiled and booted a machine with it, I am unable to reproduce your problem), could you please test it for me and see if it helps solve the problem
Looks like this fixed it. I have been testing this for the last 16 hours and everything is looking good.
Quoted 6 lines
Quoted 2 lines
Excellent! Ingo, Peter, do you like the patch? If so, could you please pick it up Ingo. I think we should even push the fix to stable releases.
Looks good, except for the issue you yourself earlier raised, a few of those functions looks too large to be inlined.
Here's the updated revision with task_*time functions moved to
sched.cand inlining removed, except fortask_gtime(). I've compiled and booted a machine (x86_64) with this patch applied.Reported-by [email protected]Spencer reported a problem where utime and stime were going negative despite the fixes in commit
b27f03d4bdc145a09fb7b0c0e004b29f1ee555fa. The suspected reason for the problem is thatsignal_structmaintains it's own utime and stime (of exited tasks), these are not updated using the newtask_utime()routine, hencesig->utimecan go backwards and cause the same problem to occur (sig->utime, addstsk->utimeand nottask_utime()). This patch fixes the problemTODO: using
max(task->prev_utime, derived utime)works for now, but a more generic solution is to implementcputime_max()and use thecputime_gt()function for comparison.
Quoted 7 lines
Quoted 3 lines
Comments?
Signed-off-by Balbir Singh <[email protected]>Thanks Balbir!
Acked-by Peter Zijlstra <[email protected]>
applied to tip/sched/urgent, thanks!
Ingo