Commit e7f340ca authored by Frederic Weisbecker's avatar Frederic Weisbecker Committed by Ingo Molnar
Browse files

powerpc, sched/cputime: Remove unused cputime definitions 



Since the core doesn't deal with cputime_t anymore, most of these APIs
have been left unused. Lets remove these.

Signed-off-by: default avatarFrederic Weisbecker <fweisbec@gmail.com>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Wanpeng Li <wanpeng.li@hotmail.com>
Link: http://lkml.kernel.org/r/1485832191-26889-33-git-send-email-fweisbec@gmail.com


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent 42b425b3

arch/powerpc/include/asm/cputime.h

+0 −173
Original line number Diff line number Diff line
@@ -18,9 +18,6 @@ 


#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

#include <asm-generic/cputime.h>

#ifdef __KERNEL__

static inline void setup_cputime_one_jiffy(void) { }

#endif

#else



#include <linux/types.h>
@@ -36,65 +33,6 @@ typedef u64 __nocast cputime64_t; 
#define cmpxchg_cputime(ptr, old, new) cmpxchg(ptr, old, new)



#ifdef __KERNEL__



/*

 * One jiffy in timebase units computed during initialization

 */

extern cputime_t cputime_one_jiffy;



/*

 * Convert cputime <-> jiffies

 */

extern u64 __cputime_jiffies_factor;



static inline unsigned long cputime_to_jiffies(const cputime_t ct)

{

	return mulhdu((__force u64) ct, __cputime_jiffies_factor);

}



static inline cputime_t jiffies_to_cputime(const unsigned long jif)

{

	u64 ct;

	unsigned long sec;



	/* have to be a little careful about overflow */

	ct = jif % HZ;

	sec = jif / HZ;

	if (ct) {

		ct *= tb_ticks_per_sec;

		do_div(ct, HZ);

	}

	if (sec)

		ct += (cputime_t) sec * tb_ticks_per_sec;

	return (__force cputime_t) ct;

}



static inline void setup_cputime_one_jiffy(void)

{

	cputime_one_jiffy = jiffies_to_cputime(1);

}



static inline cputime64_t jiffies64_to_cputime64(const u64 jif)

{

	u64 ct;

	u64 sec = jif;



	/* have to be a little careful about overflow */

	ct = do_div(sec, HZ);

	if (ct) {

		ct *= tb_ticks_per_sec;

		do_div(ct, HZ);

	}

	if (sec)

		ct += (u64) sec * tb_ticks_per_sec;

	return (__force cputime64_t) ct;

}



static inline u64 cputime64_to_jiffies64(const cputime_t ct)

{

	return mulhdu((__force u64) ct, __cputime_jiffies_factor);

}



/*

 * Convert cputime <-> microseconds

 */
@@ -105,117 +43,6 @@ static inline unsigned long cputime_to_usecs(const cputime_t ct) 
	return mulhdu((__force u64) ct, __cputime_usec_factor);

}



static inline cputime_t usecs_to_cputime(const unsigned long us)

{

	u64 ct;

	unsigned long sec;



	/* have to be a little careful about overflow */

	ct = us % 1000000;

	sec = us / 1000000;

	if (ct) {

		ct *= tb_ticks_per_sec;

		do_div(ct, 1000000);

	}

	if (sec)

		ct += (cputime_t) sec * tb_ticks_per_sec;

	return (__force cputime_t) ct;

}



#define usecs_to_cputime64(us)		usecs_to_cputime(us)



/*

 * Convert cputime <-> seconds

 */

extern u64 __cputime_sec_factor;



static inline unsigned long cputime_to_secs(const cputime_t ct)

{

	return mulhdu((__force u64) ct, __cputime_sec_factor);

}



static inline cputime_t secs_to_cputime(const unsigned long sec)

{

	return (__force cputime_t)((u64) sec * tb_ticks_per_sec);

}



/*

 * Convert cputime <-> timespec

 */

static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p)

{

	u64 x = (__force u64) ct;

	unsigned int frac;



	frac = do_div(x, tb_ticks_per_sec);

	p->tv_sec = x;

	x = (u64) frac * 1000000000;

	do_div(x, tb_ticks_per_sec);

	p->tv_nsec = x;

}



static inline cputime_t timespec_to_cputime(const struct timespec *p)

{

	u64 ct;



	ct = (u64) p->tv_nsec * tb_ticks_per_sec;

	do_div(ct, 1000000000);

	return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec);

}



/*

 * Convert cputime <-> timeval

 */

static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p)

{

	u64 x = (__force u64) ct;

	unsigned int frac;



	frac = do_div(x, tb_ticks_per_sec);

	p->tv_sec = x;

	x = (u64) frac * 1000000;

	do_div(x, tb_ticks_per_sec);

	p->tv_usec = x;

}



static inline cputime_t timeval_to_cputime(const struct timeval *p)

{

	u64 ct;



	ct = (u64) p->tv_usec * tb_ticks_per_sec;

	do_div(ct, 1000000);

	return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec);

}



/*

 * Convert cputime <-> clock_t (units of 1/USER_HZ seconds)

 */

extern u64 __cputime_clockt_factor;



static inline unsigned long cputime_to_clock_t(const cputime_t ct)

{

	return mulhdu((__force u64) ct, __cputime_clockt_factor);

}



static inline cputime_t clock_t_to_cputime(const unsigned long clk)

{

	u64 ct;

	unsigned long sec;



	/* have to be a little careful about overflow */

	ct = clk % USER_HZ;

	sec = clk / USER_HZ;

	if (ct) {

		ct *= tb_ticks_per_sec;

		do_div(ct, USER_HZ);

	}

	if (sec)

		ct += (u64) sec * tb_ticks_per_sec;

	return (__force cputime_t) ct;

}



#define cputime64_to_clock_t(ct)	cputime_to_clock_t((cputime_t)(ct))



/*

 * PPC64 uses PACA which is task independent for storing accounting data while

 * PPC32 uses struct thread_info, therefore at task switch the accounting data

arch/powerpc/kernel/time.c

+2 −18
Original line number Diff line number Diff line
@@ -152,20 +152,11 @@ EXPORT_SYMBOL_GPL(ppc_tb_freq); 


#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

/*

 * Factors for converting from cputime_t (timebase ticks) to

 * jiffies, microseconds, seconds, and clock_t (1/USER_HZ seconds).

 * These are all stored as 0.64 fixed-point binary fractions.

 * Factor for converting from cputime_t (timebase ticks) to

 * microseconds. This is stored as 0.64 fixed-point binary fraction.

 */

u64 __cputime_jiffies_factor;

EXPORT_SYMBOL(__cputime_jiffies_factor);

u64 __cputime_usec_factor;

EXPORT_SYMBOL(__cputime_usec_factor);

u64 __cputime_sec_factor;

EXPORT_SYMBOL(__cputime_sec_factor);

u64 __cputime_clockt_factor;

EXPORT_SYMBOL(__cputime_clockt_factor);



cputime_t cputime_one_jiffy;



#ifdef CONFIG_PPC_SPLPAR

void (*dtl_consumer)(struct dtl_entry *, u64);
@@ -181,14 +172,8 @@ static void calc_cputime_factors(void) 
{

	struct div_result res;



	div128_by_32(HZ, 0, tb_ticks_per_sec, &res);

	__cputime_jiffies_factor = res.result_low;

	div128_by_32(1000000, 0, tb_ticks_per_sec, &res);

	__cputime_usec_factor = res.result_low;

	div128_by_32(1, 0, tb_ticks_per_sec, &res);

	__cputime_sec_factor = res.result_low;

	div128_by_32(USER_HZ, 0, tb_ticks_per_sec, &res);

	__cputime_clockt_factor = res.result_low;

}



/*
@@ -1053,7 +1038,6 @@ void __init time_init(void) 
	tb_ticks_per_sec = ppc_tb_freq;

	tb_ticks_per_usec = ppc_tb_freq / 1000000;

	calc_cputime_factors();

	setup_cputime_one_jiffy();



	/*

	 * Compute scale factor for sched_clock.

CRA Git | Maintained and supported by SUSTech CRA and CCSE