posix_cpu_timers: Some code consolidation
cover posix_cpu_timers: Some code consolidation
Hi,
Some interesting consolidation comes when we unify the expiry time type.
I'm also wondering: can't we implement CPUCLOCK_PROF using CPUCLOCK_SCHED? One is using the tick, the other is using the sched. But they both seem to account the same thing: utime + stime.
Thanks.
Frederic Weisbecker (3):
posix_cpu_timers: Consolidate expiry time type
posix_cpu_timers: Consolidate timer list cleanups
posix_cpu_timers: Consolidate expired timers check
include/linux/posix-timers.h | 16 ++- kernel/posix-cpu-timers.c | 387 +++++++++++++++--------------------------- 2 files changed, 146 insertions(+), 257 deletions(-)
Signature · 1 line
1.7.5.4
PATCH 1/3 posix_cpu_timer: Consolidate expiry time type
The posix cpu timer expiry time is stored in a union of two types: a 64 bits field if we rely on scheduler precise accounting, or a cputime_t if we rely on jiffies.
This result in quite some duplicate code and special cases to handle the two types.
Just unify this into a single 64 bits field. cputime_t can always fit into it.
--- include/linux/posix-timers.h | 16 ++- kernel/posix-cpu-timers.c | 263 +++++++++++++++++------------------------- 2 files changed, 115 insertions(+), 164 deletions(-)
include/linux/posix-timers.h +11 -5
@@ -7,14 +7,20 @@#include <linux/timex.h> #include <linux/alarmtimer.h> -union cpu_time_count { -cputime_t cpu; -unsigned long long sched; -}; + +static inline unsigned long long cputime_to_expires (cputime_t expires) +{ +return (__force unsigned long long )expires; +} + +static inline cputime_t expires_to_cputime (unsigned long long expires) +{ +return (__force cputime_t )expires; +}struct cpu_timer_list {struct list_head entry; -union cpu_time_count expires, incr; +unsigned long long expires, incr;struct task_struct *task;int firing; };
kernel/posix-cpu-timers.c +104 -159
589 lines not on this page · raw message
Signature · 1 line
1.7.5.4
PATCH 2/3 posix_cpu_timers: Consolidate timer list cleanups
In reply to Frederic WeisbeckerCleaning up the posix cpu timers on task exit shares some common code among timer list types, most notably the list traversal and expiry time update.
Unify this in a common helper.
--- kernel/posix-cpu-timers.c | 48 +++++++++++++++++--------------------------- 1 files changed, 19 insertions(+), 29 deletions(-)
kernel/posix-cpu-timers.c +19 -29
@@ -382,6 +382,21 @@ static int posix_cpu_timer_del(struct k_itimer *timer)return ret; } +static void cleanup_timers_list (struct list_head *head, +unsigned long long curr) +{ +struct cpu_timer_list *timer, *next; + +list_for_each_entry_safe (timer, next, head, entry) { +list_del_init (&timer->entry); +if (timer->expires < curr) { + timer->expires =0 ; + }else { + timer->expires -= curr; + } + } +} +/* * Clean out CPU timers still ticking when a thread exited. The task * pointer is cleared, and the expiry time is replaced with the residual
@@ -392,37 +407,12 @@ static void cleanup_timers(struct list_head *head, cputime_t utime, cputime_t stime, unsigned long long sum_exec_runtime) { - struct cpu_timer_list *timer, *next; -cputime_t ptime = utime + stime; -list_for_each_entry_safe (timer, next, head, entry) { -list_del_init (&timer->entry); -if (timer->expires <cputime_to_expires (ptime)) { - timer->expires =0 ; - }else { - timer->expires -=cputime_to_expires (ptime); - } - } - - ++head; -list_for_each_entry_safe (timer, next, head, entry) { -list_del_init (&timer->entry); -if (timer->expires <cputime_to_expires (utime)) { - timer->expires =0 ; - }else { - timer->expires -=cputime_to_expires (utime); - } - } + cputime_t ptime = utime + stime; - ++head; -list_for_each_entry_safe (timer, next, head, entry) { -list_del_init (&timer->entry); -if (timer->expires < sum_exec_runtime) { - timer->expires =0 ; - }else { - timer->expires -= sum_exec_runtime; - } - } +cleanup_timers_list (head,cputime_to_expires (ptime)); +cleanup_timers_list (++head,cputime_to_expires (utime)); +cleanup_timers_list (++head, sum_exec_runtime); }/*
Signature · 1 line
1.7.5.4
PATCH 3/3 posix_cpu_timers: Consolidate expired timers check
In reply to Frederic WeisbeckerConsolidate the common code amongst per thread and per process timers list on tick time.
List traversal, expiry check and subsequent updates can be shared in a common helper.
--- kernel/posix-cpu-timers.c | 118 +++++++++++++-------------------------------- 1 files changed, 33 insertions(+), 85 deletions(-)
kernel/posix-cpu-timers.c +33 -85
@@ -812,6 +812,28 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp) } } +static unsigned long long +check_timers_list (struct list_head *timers, +struct list_head *firing, +unsigned long long curr) +{ +int maxfire =20 ; + +while (!list_empty (timers)) { +struct cpu_timer_list *t; + + t = list_first_entry(timers, struct cpu_timer_list, entry); + +if (!--maxfire || curr < t->expires) +return t->expires; + + t->firing =1 ; +list_move_tail (&t->entry, firing); + } + +return 0 ; +} +/* * Check for any per-thread CPU timers that have fired and move them off * the tsk->cpu_timers[N] list onto the firing list. Here we update the
@@ -820,54 +842,20 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)static void check_thread_timers (struct task_struct *tsk,struct list_head *firing) { -int maxfire;struct list_head *timers = tsk->cpu_timers;struct signal_struct *const sig = tsk->signal; +struct task_cputime *tsk_expires = &tsk->cputime_expires; +unsigned long long expires;unsigned long soft; - maxfire =20 ; - tsk->cputime_expires.prof_exp =0 ; -while (!list_empty (timers)) { -struct cpu_timer_list *t =list_first_entry (timers, - struct cpu_timer_list, - entry); -if (!--maxfire ||prof_ticks (tsk) < t->expires) { - tsk->cputime_expires.prof_exp =expires_to_cputime (t->expires); -break ; - } - t->firing =1 ; -list_move_tail (&t->entry, firing); - } + expires =check_timers_list (timers, firing,prof_ticks (tsk)); + tsk_expires->prof_exp =expires_to_cputime (expires); - ++timers; - maxfire =20 ; - tsk->cputime_expires.virt_exp =0 ; -while (!list_empty (timers)) { -struct cpu_timer_list *t =list_first_entry (timers, - struct cpu_timer_list, - entry); -if (!--maxfire ||virt_ticks (tsk) < t->expires) { - tsk->cputime_expires.virt_exp =expires_to_cputime (t->expires); -break ; - } - t->firing =1 ; -list_move_tail (&t->entry, firing); - } + expires =check_timers_list (++timers, firing,virt_ticks (tsk)); + tsk_expires->virt_exp =expires_to_cputime (expires); - ++timers; - maxfire =20 ; - tsk->cputime_expires.sched_exp =0 ; -while (!list_empty (timers)) { -struct cpu_timer_list *t =list_first_entry (timers, - struct cpu_timer_list, - entry); -if (!--maxfire || tsk->se.sum_exec_runtime < t->expires) { - tsk->cputime_expires.sched_exp = t->expires; -break ; - } - t->firing =1 ; -list_move_tail (&t->entry, firing); - } + tsk_expires->sched_exp =check_timers_list (++timers, firing, + tsk->se.sum_exec_runtime);/* * Check for the special case thread timers.
@@ -966,7 +954,6 @@ static inline int task_cputime_zero(const struct task_cputime *cputime)static void check_process_timers (struct task_struct *tsk,struct list_head *firing) { -int maxfire;struct signal_struct *const sig = tsk->signal;unsigned long long utime, ptime, virt_expires, prof_expires;unsigned long long sum_sched_runtime, sched_expires;
@@ -981,49 +968,10 @@ static void check_process_timers(struct task_struct *tsk, utime =cputime_to_expires (cputime.utime); ptime = utime +cputime_to_expires (cputime.stime); sum_sched_runtime = cputime.sum_exec_runtime; - maxfire =20 ; - prof_expires =0 ; -while (!list_empty (timers)) { -struct cpu_timer_list *tl =list_first_entry (timers, - struct cpu_timer_list, - entry); -if (!--maxfire || ptime < tl->expires) { - prof_expires = tl->expires; -break ; - } - tl->firing =1 ; -list_move_tail (&tl->entry, firing); - } - ++timers; - maxfire =20 ; - virt_expires =0 ; -while (!list_empty (timers)) { -struct cpu_timer_list *tl =list_first_entry (timers, - struct cpu_timer_list, - entry); -if (!--maxfire || utime < tl->expires) { - virt_expires = tl->expires; -break ; - } - tl->firing =1 ; -list_move_tail (&tl->entry, firing); - } - - ++timers; - maxfire =20 ; - sched_expires =0 ; -while (!list_empty (timers)) { -struct cpu_timer_list *tl =list_first_entry (timers, - struct cpu_timer_list, - entry); -if (!--maxfire || sum_sched_runtime < tl->expires) { - sched_expires = tl->expires; -break ; - } - tl->firing =1 ; -list_move_tail (&tl->entry, firing); - } + prof_expires =check_timers_list (timers, firing, ptime); + virt_expires =check_timers_list (++timers, firing, utime); + sched_expires =check_timers_list (++timers, firing, sum_sched_runtime);/* * Check for the special case process timers.
Signature · 1 line
1.7.5.4