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

Commit 0052af44 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'core-lib-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull core/lib update from Ingo Molnar:
 "This contains a single commit that removes an unused facility that the
  scheduler used to make use of"

* 'core-lib-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  lib/proportions: Remove unused code
parents 0fed3ac8 d18d12d0

include/linux/proportions.h

deleted100644 → 0
+0 −137
Original line number Diff line number Diff line 
/*

 * FLoating proportions

 *

 *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra

 *

 * This file contains the public data structure and API definitions.

 */



#ifndef _LINUX_PROPORTIONS_H

#define _LINUX_PROPORTIONS_H



#include <linux/percpu_counter.h>

#include <linux/spinlock.h>

#include <linux/mutex.h>

#include <linux/gfp.h>



struct prop_global {

	/*

	 * The period over which we differentiate

	 *

	 *   period = 2^shift

	 */

	int shift;

	/*

	 * The total event counter aka 'time'.

	 *

	 * Treated as an unsigned long; the lower 'shift - 1' bits are the

	 * counter bits, the remaining upper bits the period counter.

	 */

	struct percpu_counter events;

};



/*

 * global proportion descriptor

 *

 * this is needed to consistently flip prop_global structures.

 */

struct prop_descriptor {

	int index;

	struct prop_global pg[2];

	struct mutex mutex;		/* serialize the prop_global switch */

};



int prop_descriptor_init(struct prop_descriptor *pd, int shift, gfp_t gfp);

void prop_change_shift(struct prop_descriptor *pd, int new_shift);



/*

 * ----- PERCPU ------

 */



struct prop_local_percpu {

	/*

	 * the local events counter

	 */

	struct percpu_counter events;



	/*

	 * snapshot of the last seen global state

	 */

	int shift;

	unsigned long period;

	raw_spinlock_t lock;		/* protect the snapshot state */

};



int prop_local_init_percpu(struct prop_local_percpu *pl, gfp_t gfp);

void prop_local_destroy_percpu(struct prop_local_percpu *pl);

void __prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl);

void prop_fraction_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl,

		long *numerator, long *denominator);



static inline

void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)

{

	unsigned long flags;



	local_irq_save(flags);

	__prop_inc_percpu(pd, pl);

	local_irq_restore(flags);

}



/*

 * Limit the time part in order to ensure there are some bits left for the

 * cycle counter and fraction multiply.

 */

#if BITS_PER_LONG == 32

#define PROP_MAX_SHIFT (3*BITS_PER_LONG/4)

#else

#define PROP_MAX_SHIFT (BITS_PER_LONG/2)

#endif



#define PROP_FRAC_SHIFT		(BITS_PER_LONG - PROP_MAX_SHIFT - 1)

#define PROP_FRAC_BASE		(1UL << PROP_FRAC_SHIFT)



void __prop_inc_percpu_max(struct prop_descriptor *pd,

			   struct prop_local_percpu *pl, long frac);





/*

 * ----- SINGLE ------

 */



struct prop_local_single {

	/*

	 * the local events counter

	 */

	unsigned long events;



	/*

	 * snapshot of the last seen global state

	 * and a lock protecting this state

	 */

	unsigned long period;

	int shift;

	raw_spinlock_t lock;		/* protect the snapshot state */

};



#define INIT_PROP_LOCAL_SINGLE(name)			\

{	.lock = __RAW_SPIN_LOCK_UNLOCKED(name.lock),	\

}



int prop_local_init_single(struct prop_local_single *pl);

void prop_local_destroy_single(struct prop_local_single *pl);

void __prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl);

void prop_fraction_single(struct prop_descriptor *pd, struct prop_local_single *pl,

		long *numerator, long *denominator);



static inline

void prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl)

{

	unsigned long flags;



	local_irq_save(flags);

	__prop_inc_single(pd, pl);

	local_irq_restore(flags);

}



#endif /* _LINUX_PROPORTIONS_H */

include/linux/sched.h

+0 −1
Original line number Diff line number Diff line
@@ -40,7 +40,6 @@ struct sched_param { 
#include <linux/pid.h>

#include <linux/percpu.h>

#include <linux/topology.h>

#include <linux/proportions.h>

#include <linux/seccomp.h>

#include <linux/rcupdate.h>

#include <linux/rculist.h>

lib/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \ 
	 rbtree.o radix-tree.o dump_stack.o timerqueue.o\

	 idr.o int_sqrt.o extable.o \

	 sha1.o md5.o irq_regs.o argv_split.o \

	 proportions.o flex_proportions.o ratelimit.o show_mem.o \

	 flex_proportions.o ratelimit.o show_mem.o \

	 is_single_threaded.o plist.o decompress.o kobject_uevent.o \

	 earlycpio.o seq_buf.o nmi_backtrace.o

lib/proportions.c

deleted100644 → 0
+0 −407
Original line number Diff line number Diff line 
/*

 * Floating proportions

 *

 *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra

 *

 * Description:

 *

 * The floating proportion is a time derivative with an exponentially decaying

 * history:

 *

 *   p_{j} = \Sum_{i=0} (dx_{j}/dt_{-i}) / 2^(1+i)

 *

 * Where j is an element from {prop_local}, x_{j} is j's number of events,

 * and i the time period over which the differential is taken. So d/dt_{-i} is

 * the differential over the i-th last period.

 *

 * The decaying history gives smooth transitions. The time differential carries

 * the notion of speed.

 *

 * The denominator is 2^(1+i) because we want the series to be normalised, ie.

 *

 *   \Sum_{i=0} 1/2^(1+i) = 1

 *

 * Further more, if we measure time (t) in the same events as x; so that:

 *

 *   t = \Sum_{j} x_{j}

 *

 * we get that:

 *

 *   \Sum_{j} p_{j} = 1

 *

 * Writing this in an iterative fashion we get (dropping the 'd's):

 *

 *   if (++x_{j}, ++t > period)

 *     t /= 2;

 *     for_each (j)

 *       x_{j} /= 2;

 *

 * so that:

 *

 *   p_{j} = x_{j} / t;

 *

 * We optimize away the '/= 2' for the global time delta by noting that:

 *

 *   if (++t > period) t /= 2:

 *

 * Can be approximated by:

 *

 *   period/2 + (++t % period/2)

 *

 * [ Furthermore, when we choose period to be 2^n it can be written in terms of

 *   binary operations and wraparound artefacts disappear. ]

 *

 * Also note that this yields a natural counter of the elapsed periods:

 *

 *   c = t / (period/2)

 *

 * [ Its monotonic increasing property can be applied to mitigate the wrap-

 *   around issue. ]

 *

 * This allows us to do away with the loop over all prop_locals on each period

 * expiration. By remembering the period count under which it was last accessed

 * as c_{j}, we can obtain the number of 'missed' cycles from:

 *

 *   c - c_{j}

 *

 * We can then lazily catch up to the global period count every time we are

 * going to use x_{j}, by doing:

 *

 *   x_{j} /= 2^(c - c_{j}), c_{j} = c

 */



#include <linux/proportions.h>

#include <linux/rcupdate.h>



int prop_descriptor_init(struct prop_descriptor *pd, int shift, gfp_t gfp)

{

	int err;



	if (shift > PROP_MAX_SHIFT)

		shift = PROP_MAX_SHIFT;



	pd->index = 0;

	pd->pg[0].shift = shift;

	mutex_init(&pd->mutex);

	err = percpu_counter_init(&pd->pg[0].events, 0, gfp);

	if (err)

		goto out;



	err = percpu_counter_init(&pd->pg[1].events, 0, gfp);

	if (err)

		percpu_counter_destroy(&pd->pg[0].events);



out:

	return err;

}



/*

 * We have two copies, and flip between them to make it seem like an atomic

 * update. The update is not really atomic wrt the events counter, but

 * it is internally consistent with the bit layout depending on shift.

 *

 * We copy the events count, move the bits around and flip the index.

 */

void prop_change_shift(struct prop_descriptor *pd, int shift)

{

	int index;

	int offset;

	u64 events;

	unsigned long flags;



	if (shift > PROP_MAX_SHIFT)

		shift = PROP_MAX_SHIFT;



	mutex_lock(&pd->mutex);



	index = pd->index ^ 1;

	offset = pd->pg[pd->index].shift - shift;

	if (!offset)

		goto out;



	pd->pg[index].shift = shift;



	local_irq_save(flags);

	events = percpu_counter_sum(&pd->pg[pd->index].events);

	if (offset < 0)

		events <<= -offset;

	else

		events >>= offset;

	percpu_counter_set(&pd->pg[index].events, events);



	/*

	 * ensure the new pg is fully written before the switch

	 */

	smp_wmb();

	pd->index = index;

	local_irq_restore(flags);



	synchronize_rcu();



out:

	mutex_unlock(&pd->mutex);

}



/*

 * wrap the access to the data in an rcu_read_lock() section;

 * this is used to track the active references.

 */

static struct prop_global *prop_get_global(struct prop_descriptor *pd)

__acquires(RCU)

{

	int index;



	rcu_read_lock();

	index = pd->index;

	/*

	 * match the wmb from vcd_flip()

	 */

	smp_rmb();

	return &pd->pg[index];

}



static void prop_put_global(struct prop_descriptor *pd, struct prop_global *pg)

__releases(RCU)

{

	rcu_read_unlock();

}



static void

prop_adjust_shift(int *pl_shift, unsigned long *pl_period, int new_shift)

{

	int offset = *pl_shift - new_shift;



	if (!offset)

		return;



	if (offset < 0)

		*pl_period <<= -offset;

	else

		*pl_period >>= offset;



	*pl_shift = new_shift;

}



/*

 * PERCPU

 */



#define PROP_BATCH (8*(1+ilog2(nr_cpu_ids)))



int prop_local_init_percpu(struct prop_local_percpu *pl, gfp_t gfp)

{

	raw_spin_lock_init(&pl->lock);

	pl->shift = 0;

	pl->period = 0;

	return percpu_counter_init(&pl->events, 0, gfp);

}



void prop_local_destroy_percpu(struct prop_local_percpu *pl)

{

	percpu_counter_destroy(&pl->events);

}



/*

 * Catch up with missed period expirations.

 *

 *   until (c_{j} == c)

 *     x_{j} -= x_{j}/2;

 *     c_{j}++;

 */

static

void prop_norm_percpu(struct prop_global *pg, struct prop_local_percpu *pl)

{

	unsigned long period = 1UL << (pg->shift - 1);

	unsigned long period_mask = ~(period - 1);

	unsigned long global_period;

	unsigned long flags;



	global_period = percpu_counter_read(&pg->events);

	global_period &= period_mask;



	/*

	 * Fast path - check if the local and global period count still match

	 * outside of the lock.

	 */

	if (pl->period == global_period)

		return;



	raw_spin_lock_irqsave(&pl->lock, flags);

	prop_adjust_shift(&pl->shift, &pl->period, pg->shift);



	/*

	 * For each missed period, we half the local counter.

	 * basically:

	 *   pl->events >> (global_period - pl->period);

	 */

	period = (global_period - pl->period) >> (pg->shift - 1);

	if (period < BITS_PER_LONG) {

		s64 val = percpu_counter_read(&pl->events);



		if (val < (nr_cpu_ids * PROP_BATCH))

			val = percpu_counter_sum(&pl->events);



		__percpu_counter_add(&pl->events, -val + (val >> period),

					PROP_BATCH);

	} else

		percpu_counter_set(&pl->events, 0);



	pl->period = global_period;

	raw_spin_unlock_irqrestore(&pl->lock, flags);

}



/*

 *   ++x_{j}, ++t

 */

void __prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)

{

	struct prop_global *pg = prop_get_global(pd);



	prop_norm_percpu(pg, pl);

	__percpu_counter_add(&pl->events, 1, PROP_BATCH);

	percpu_counter_add(&pg->events, 1);

	prop_put_global(pd, pg);

}



/*

 * identical to __prop_inc_percpu, except that it limits this pl's fraction to

 * @frac/PROP_FRAC_BASE by ignoring events when this limit has been exceeded.

 */

void __prop_inc_percpu_max(struct prop_descriptor *pd,

			   struct prop_local_percpu *pl, long frac)

{

	struct prop_global *pg = prop_get_global(pd);



	prop_norm_percpu(pg, pl);



	if (unlikely(frac != PROP_FRAC_BASE)) {

		unsigned long period_2 = 1UL << (pg->shift - 1);

		unsigned long counter_mask = period_2 - 1;

		unsigned long global_count;

		long numerator, denominator;



		numerator = percpu_counter_read_positive(&pl->events);

		global_count = percpu_counter_read(&pg->events);

		denominator = period_2 + (global_count & counter_mask);



		if (numerator > ((denominator * frac) >> PROP_FRAC_SHIFT))

			goto out_put;

	}



	percpu_counter_add(&pl->events, 1);

	percpu_counter_add(&pg->events, 1);



out_put:

	prop_put_global(pd, pg);

}



/*

 * Obtain a fraction of this proportion

 *

 *   p_{j} = x_{j} / (period/2 + t % period/2)

 */

void prop_fraction_percpu(struct prop_descriptor *pd,

		struct prop_local_percpu *pl,

		long *numerator, long *denominator)

{

	struct prop_global *pg = prop_get_global(pd);

	unsigned long period_2 = 1UL << (pg->shift - 1);

	unsigned long counter_mask = period_2 - 1;

	unsigned long global_count;



	prop_norm_percpu(pg, pl);

	*numerator = percpu_counter_read_positive(&pl->events);



	global_count = percpu_counter_read(&pg->events);

	*denominator = period_2 + (global_count & counter_mask);



	prop_put_global(pd, pg);

}



/*

 * SINGLE

 */



int prop_local_init_single(struct prop_local_single *pl)

{

	raw_spin_lock_init(&pl->lock);

	pl->shift = 0;

	pl->period = 0;

	pl->events = 0;

	return 0;

}



void prop_local_destroy_single(struct prop_local_single *pl)

{

}



/*

 * Catch up with missed period expirations.

 */

static

void prop_norm_single(struct prop_global *pg, struct prop_local_single *pl)

{

	unsigned long period = 1UL << (pg->shift - 1);

	unsigned long period_mask = ~(period - 1);

	unsigned long global_period;

	unsigned long flags;



	global_period = percpu_counter_read(&pg->events);

	global_period &= period_mask;



	/*

	 * Fast path - check if the local and global period count still match

	 * outside of the lock.

	 */

	if (pl->period == global_period)

		return;



	raw_spin_lock_irqsave(&pl->lock, flags);

	prop_adjust_shift(&pl->shift, &pl->period, pg->shift);

	/*

	 * For each missed period, we half the local counter.

	 */

	period = (global_period - pl->period) >> (pg->shift - 1);

	if (likely(period < BITS_PER_LONG))

		pl->events >>= period;

	else

		pl->events = 0;

	pl->period = global_period;

	raw_spin_unlock_irqrestore(&pl->lock, flags);

}



/*

 *   ++x_{j}, ++t

 */

void __prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl)

{

	struct prop_global *pg = prop_get_global(pd);



	prop_norm_single(pg, pl);

	pl->events++;

	percpu_counter_add(&pg->events, 1);

	prop_put_global(pd, pg);

}



/*

 * Obtain a fraction of this proportion

 *

 *   p_{j} = x_{j} / (period/2 + t % period/2)

 */

void prop_fraction_single(struct prop_descriptor *pd,

	       	struct prop_local_single *pl,

		long *numerator, long *denominator)

{

	struct prop_global *pg = prop_get_global(pd);

	unsigned long period_2 = 1UL << (pg->shift - 1);

	unsigned long counter_mask = period_2 - 1;

	unsigned long global_count;



	prop_norm_single(pg, pl);

	*numerator = pl->events;



	global_count = percpu_counter_read(&pg->events);

	*denominator = period_2 + (global_count & counter_mask);



	prop_put_global(pd, pg);

}