[IA64] VIRT_CPU_ACCOUNTING (accurate cpu time accounting)

This patch implements VIRT_CPU_ACCOUNTING for ia64,
which enable us to use more accurate cpu time accounting.

The VIRT_CPU_ACCOUNTING is an item of kernel config, which s390
and powerpc arch have.  By turning this config on, these archs
change the mechanism of cpu time accounting from tick-sampling
based one to state-transition based one.

The state-transition based accounting is done by checking time
(cycle counter in processor) at every state-transition point,
such as entrance/exit of kernel, interrupt, softirq etc.
The difference between point to point is the actual time consumed
during in the state. There is no doubt about that this value is
more accurate than that of tick-sampling based accounting.

Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>

1 files changed, 78 insertions, 0 deletions

diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index 17fda5293c6..48e15a51782 100644
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -59,6 +59,84 @@ static struct clocksource clocksource_itc = {
 };
 static struct clocksource *itc_clocksource;
 
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING
+
+#include <linux/kernel_stat.h>
+
+extern cputime_t cycle_to_cputime(u64 cyc);
+
+/*
+ * Called from the context switch with interrupts disabled, to charge all
+ * accumulated times to the current process, and to prepare accounting on
+ * the next process.
+ */
+void ia64_account_on_switch(struct task_struct *prev, struct task_struct *next)
+{
+        struct thread_info *pi = task_thread_info(prev);
+        struct thread_info *ni = task_thread_info(next);
+        cputime_t delta_stime, delta_utime;
+        __u64 now;
+
+        now = ia64_get_itc();
+
+        delta_stime = cycle_to_cputime(pi->ac_stime + (now - pi->ac_stamp));
+        account_system_time(prev, 0, delta_stime);
+        account_system_time_scaled(prev, delta_stime);
+
+        if (pi->ac_utime) {
+                delta_utime = cycle_to_cputime(pi->ac_utime);
+                account_user_time(prev, delta_utime);
+                account_user_time_scaled(prev, delta_utime);
+        }
+
+        pi->ac_stamp = ni->ac_stamp = now;
+        ni->ac_stime = ni->ac_utime = 0;
+}
+
+/*
+ * Account time for a transition between system, hard irq or soft irq state.
+ * Note that this function is called with interrupts enabled.
+ */
+void account_system_vtime(struct task_struct *tsk)
+{
+        struct thread_info *ti = task_thread_info(tsk);
+        unsigned long flags;
+        cputime_t delta_stime;
+        __u64 now;
+
+        local_irq_save(flags);
+
+        now = ia64_get_itc();
+
+        delta_stime = cycle_to_cputime(ti->ac_stime + (now - ti->ac_stamp));
+        account_system_time(tsk, 0, delta_stime);
+        account_system_time_scaled(tsk, delta_stime);
+        ti->ac_stime = 0;
+
+        ti->ac_stamp = now;
+
+        local_irq_restore(flags);
+}
+
+/*
+ * Called from the timer interrupt handler to charge accumulated user time
+ * to the current process.  Must be called with interrupts disabled.
+ */
+void account_process_tick(struct task_struct *p, int user_tick)
+{
+        struct thread_info *ti = task_thread_info(p);
+        cputime_t delta_utime;
+
+        if (ti->ac_utime) {
+                delta_utime = cycle_to_cputime(ti->ac_utime);
+                account_user_time(p, delta_utime);
+                account_user_time_scaled(p, delta_utime);
+                ti->ac_utime = 0;
+        }
+}
+
+#endif /* CONFIG_VIRT_CPU_ACCOUNTING */
+
 static irqreturn_t
 timer_interrupt (int irq, void *dev_id)
 {