Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 61420f59 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'cputime' of git://git390.osdl.marist.edu/pub/scm/linux-2.6 

* 'cputime' of git://git390.osdl.marist.edu/pub/scm/linux-2.6:
  [PATCH] fast vdso implementation for CLOCK_THREAD_CPUTIME_ID
  [PATCH] improve idle cputime accounting
  [PATCH] improve precision of idle time detection.
  [PATCH] improve precision of process accounting.
  [PATCH] idle cputime accounting
  [PATCH] fix scaled & unscaled cputime accounting
parents d97106ab c742b31c

arch/ia64/kernel/time.c

+10 −8
Original line number Original line Diff line number Diff line
@@ -93,13 +93,14 @@ void ia64_account_on_switch(struct task_struct *prev, struct task_struct *next) 
	now = ia64_get_itc();

	now = ia64_get_itc();





	delta_stime = cycle_to_cputime(pi->ac_stime + (now - pi->ac_stamp));

	delta_stime = cycle_to_cputime(pi->ac_stime + (now - pi->ac_stamp));

	account_system_time(prev, 0, delta_stime);

	if (idle_task(smp_processor_id()) != prev)

	account_system_time_scaled(prev, delta_stime);

		account_system_time(prev, 0, delta_stime, delta_stime);

	else

		account_idle_time(delta_stime);





	if (pi->ac_utime) {

	if (pi->ac_utime) {

		delta_utime = cycle_to_cputime(pi->ac_utime);

		delta_utime = cycle_to_cputime(pi->ac_utime);

		account_user_time(prev, delta_utime);

		account_user_time(prev, delta_utime, delta_utime);

		account_user_time_scaled(prev, delta_utime);

	}

	}





	pi->ac_stamp = ni->ac_stamp = now;

	pi->ac_stamp = ni->ac_stamp = now;
@@ -122,8 +123,10 @@ void account_system_vtime(struct task_struct *tsk) 
	now = ia64_get_itc();

	now = ia64_get_itc();





	delta_stime = cycle_to_cputime(ti->ac_stime + (now - ti->ac_stamp));

	delta_stime = cycle_to_cputime(ti->ac_stime + (now - ti->ac_stamp));

	account_system_time(tsk, 0, delta_stime);

	if (irq_count() || idle_task(smp_processor_id()) != tsk)

	account_system_time_scaled(tsk, delta_stime);

		account_system_time(tsk, 0, delta_stime, delta_stime);

	else

		account_idle_time(delta_stime);

	ti->ac_stime = 0;

	ti->ac_stime = 0;





	ti->ac_stamp = now;

	ti->ac_stamp = now;
@@ -143,8 +146,7 @@ void account_process_tick(struct task_struct *p, int user_tick) 




	if (ti->ac_utime) {

	if (ti->ac_utime) {

		delta_utime = cycle_to_cputime(ti->ac_utime);

		delta_utime = cycle_to_cputime(ti->ac_utime);

		account_user_time(p, delta_utime);

		account_user_time(p, delta_utime, delta_utime);

		account_user_time_scaled(p, delta_utime);

		ti->ac_utime = 0;

		ti->ac_utime = 0;

	}

	}

}

}

arch/powerpc/kernel/process.c

+1 −0
Original line number Original line Diff line number Diff line
@@ -33,6 +33,7 @@ 
#include <linux/mqueue.h>

#include <linux/mqueue.h>

#include <linux/hardirq.h>

#include <linux/hardirq.h>

#include <linux/utsname.h>

#include <linux/utsname.h>

#include <linux/kernel_stat.h>





#include <asm/pgtable.h>

#include <asm/pgtable.h>

#include <asm/uaccess.h>

#include <asm/uaccess.h>

arch/powerpc/kernel/time.c

+11 −7
Original line number Original line Diff line number Diff line
@@ -256,8 +256,10 @@ void account_system_vtime(struct task_struct *tsk) 
		delta += sys_time;

		delta += sys_time;

		get_paca()->system_time = 0;

		get_paca()->system_time = 0;

	}

	}

	account_system_time(tsk, 0, delta);

	if (in_irq() || idle_task(smp_processor_id()) != tsk)

	account_system_time_scaled(tsk, deltascaled);

		account_system_time(tsk, 0, delta, deltascaled);

	else

		account_idle_time(delta);

	per_cpu(cputime_last_delta, smp_processor_id()) = delta;

	per_cpu(cputime_last_delta, smp_processor_id()) = delta;

	per_cpu(cputime_scaled_last_delta, smp_processor_id()) = deltascaled;

	per_cpu(cputime_scaled_last_delta, smp_processor_id()) = deltascaled;

	local_irq_restore(flags);

	local_irq_restore(flags);
@@ -275,10 +277,8 @@ void account_process_tick(struct task_struct *tsk, int user_tick) 




	utime = get_paca()->user_time;

	utime = get_paca()->user_time;

	get_paca()->user_time = 0;

	get_paca()->user_time = 0;

	account_user_time(tsk, utime);



	utimescaled = cputime_to_scaled(utime);

	utimescaled = cputime_to_scaled(utime);

	account_user_time_scaled(tsk, utimescaled);

	account_user_time(tsk, utime, utimescaled);

}

}





/*

/*
@@ -338,8 +338,12 @@ void calculate_steal_time(void) 
	tb = mftb();

	tb = mftb();

	purr = mfspr(SPRN_PURR);

	purr = mfspr(SPRN_PURR);

	stolen = (tb - pme->tb) - (purr - pme->purr);

	stolen = (tb - pme->tb) - (purr - pme->purr);

	if (stolen > 0)

	if (stolen > 0) {

		account_steal_time(current, stolen);

		if (idle_task(smp_processor_id()) != current)

			account_steal_time(stolen);

		else

			account_idle_time(stolen);

	}

	pme->tb = tb;

	pme->tb = tb;

	pme->purr = purr;

	pme->purr = purr;

}

}

arch/s390/include/asm/cpu.h

+3 −4
Original line number Original line Diff line number Diff line
@@ -14,7 +14,6 @@ 




struct s390_idle_data {

struct s390_idle_data {

	spinlock_t lock;

	spinlock_t lock;

	unsigned int in_idle;

	unsigned long long idle_count;

	unsigned long long idle_count;

	unsigned long long idle_enter;

	unsigned long long idle_enter;

	unsigned long long idle_time;

	unsigned long long idle_time;
@@ -22,12 +21,12 @@ struct s390_idle_data { 




DECLARE_PER_CPU(struct s390_idle_data, s390_idle);

DECLARE_PER_CPU(struct s390_idle_data, s390_idle);





void s390_idle_leave(void);

void vtime_start_cpu(void);





static inline void s390_idle_check(void)

static inline void s390_idle_check(void)

{

{

	if ((&__get_cpu_var(s390_idle))->in_idle)

	if ((&__get_cpu_var(s390_idle))->idle_enter != 0ULL)

		s390_idle_leave();

		vtime_start_cpu();

}

}





#endif /* _ASM_S390_CPU_H_ */
 
#endif /* _ASM_S390_CPU_H_ */

arch/s390/include/asm/cputime.h

+21 −21
Original line number Original line Diff line number Diff line
@@ -11,7 +11,7 @@ 




#include <asm/div64.h>

#include <asm/div64.h>





/* We want to use micro-second resolution. */

/* We want to use full resolution of the CPU timer: 2**-12 micro-seconds. */





typedef unsigned long long cputime_t;

typedef unsigned long long cputime_t;

typedef unsigned long long cputime64_t;

typedef unsigned long long cputime64_t;
@@ -53,9 +53,9 @@ __div(unsigned long long n, unsigned int base) 
#define cputime_ge(__a, __b)		((__a) >= (__b))

#define cputime_ge(__a, __b)		((__a) >= (__b))

#define cputime_lt(__a, __b)		((__a) <  (__b))

#define cputime_lt(__a, __b)		((__a) <  (__b))

#define cputime_le(__a, __b)		((__a) <= (__b))

#define cputime_le(__a, __b)		((__a) <= (__b))

#define cputime_to_jiffies(__ct)	(__div((__ct), 1000000 / HZ))

#define cputime_to_jiffies(__ct)	(__div((__ct), 4096000000ULL / HZ))

#define cputime_to_scaled(__ct)		(__ct)

#define cputime_to_scaled(__ct)		(__ct)

#define jiffies_to_cputime(__hz)	((cputime_t)(__hz) * (1000000 / HZ))

#define jiffies_to_cputime(__hz)	((cputime_t)(__hz) * (4096000000ULL / HZ))





#define cputime64_zero			(0ULL)

#define cputime64_zero			(0ULL)

#define cputime64_add(__a, __b)		((__a) + (__b))

#define cputime64_add(__a, __b)		((__a) + (__b))
@@ -64,7 +64,7 @@ __div(unsigned long long n, unsigned int base) 
static inline u64

static inline u64

cputime64_to_jiffies64(cputime64_t cputime)

cputime64_to_jiffies64(cputime64_t cputime)

{

{

	do_div(cputime, 1000000 / HZ);

	do_div(cputime, 4096000000ULL / HZ);

	return cputime;

	return cputime;

}

}
@@ -74,13 +74,13 @@ cputime64_to_jiffies64(cputime64_t cputime) 
static inline unsigned int

static inline unsigned int

cputime_to_msecs(const cputime_t cputime)

cputime_to_msecs(const cputime_t cputime)

{

{

	return __div(cputime, 1000);

	return __div(cputime, 4096000);

}

}





static inline cputime_t

static inline cputime_t

msecs_to_cputime(const unsigned int m)

msecs_to_cputime(const unsigned int m)

{

{

	return (cputime_t) m * 1000;

	return (cputime_t) m * 4096000;

}

}





/*

/*
@@ -89,13 +89,13 @@ msecs_to_cputime(const unsigned int m) 
static inline unsigned int

static inline unsigned int

cputime_to_secs(const cputime_t cputime)

cputime_to_secs(const cputime_t cputime)

{

{

	return __div(cputime, 1000000);

	return __div(cputime, 2048000000) >> 1;

}

}





static inline cputime_t

static inline cputime_t

secs_to_cputime(const unsigned int s)

secs_to_cputime(const unsigned int s)

{

{

	return (cputime_t) s * 1000000;

	return (cputime_t) s * 4096000000ULL;

}

}





/*

/*
@@ -104,7 +104,7 @@ secs_to_cputime(const unsigned int s) 
static inline cputime_t

static inline cputime_t

timespec_to_cputime(const struct timespec *value)

timespec_to_cputime(const struct timespec *value)

{

{

        return value->tv_nsec / 1000 + (u64) value->tv_sec * 1000000;

	return value->tv_nsec * 4096 / 1000 + (u64) value->tv_sec * 4096000000ULL;

}

}





static inline void

static inline void
@@ -114,12 +114,12 @@ cputime_to_timespec(const cputime_t cputime, struct timespec *value) 
	register_pair rp;

	register_pair rp;





	rp.pair = cputime >> 1;

	rp.pair = cputime >> 1;

	asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1));

	asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));

	value->tv_nsec = rp.subreg.even * 1000;

	value->tv_nsec = rp.subreg.even * 1000 / 4096;

	value->tv_sec = rp.subreg.odd;

	value->tv_sec = rp.subreg.odd;

#else

#else

	value->tv_nsec = (cputime % 1000000) * 1000;

	value->tv_nsec = (cputime % 4096000000ULL) * 1000 / 4096;

	value->tv_sec = cputime / 1000000;

	value->tv_sec = cputime / 4096000000ULL;

#endif

#endif

}

}
@@ -131,7 +131,7 @@ cputime_to_timespec(const cputime_t cputime, struct timespec *value) 
static inline cputime_t

static inline cputime_t

timeval_to_cputime(const struct timeval *value)

timeval_to_cputime(const struct timeval *value)

{

{

        return value->tv_usec + (u64) value->tv_sec * 1000000;

	return value->tv_usec * 4096 + (u64) value->tv_sec * 4096000000ULL;

}

}





static inline void

static inline void
@@ -141,12 +141,12 @@ cputime_to_timeval(const cputime_t cputime, struct timeval *value) 
	register_pair rp;

	register_pair rp;





	rp.pair = cputime >> 1;

	rp.pair = cputime >> 1;

	asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1));

	asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));

	value->tv_usec = rp.subreg.even;

	value->tv_usec = rp.subreg.even / 4096;

	value->tv_sec = rp.subreg.odd;

	value->tv_sec = rp.subreg.odd;

#else

#else

	value->tv_usec = cputime % 1000000;

	value->tv_usec = cputime % 4096000000ULL;

	value->tv_sec = cputime / 1000000;

	value->tv_sec = cputime / 4096000000ULL;

#endif

#endif

}

}
@@ -156,13 +156,13 @@ cputime_to_timeval(const cputime_t cputime, struct timeval *value) 
static inline clock_t

static inline clock_t

cputime_to_clock_t(cputime_t cputime)

cputime_to_clock_t(cputime_t cputime)

{

{

	return __div(cputime, 1000000 / USER_HZ);

	return __div(cputime, 4096000000ULL / USER_HZ);

}

}





static inline cputime_t

static inline cputime_t

clock_t_to_cputime(unsigned long x)

clock_t_to_cputime(unsigned long x)

{

{

	return (cputime_t) x * (1000000 / USER_HZ);

	return (cputime_t) x * (4096000000ULL / USER_HZ);

}

}





/*

/*
@@ -171,7 +171,7 @@ clock_t_to_cputime(unsigned long x) 
static inline clock_t

static inline clock_t

cputime64_to_clock_t(cputime64_t cputime)

cputime64_to_clock_t(cputime64_t cputime)

{

{

       return __div(cputime, 1000000 / USER_HZ);

       return __div(cputime, 4096000000ULL / USER_HZ);

}

}





#endif /* _S390_CPUTIME_H */
 
#endif /* _S390_CPUTIME_H */