[deliverable/linux.git] / net / ipv4 / ipvs / ip_vs_nq.c

/*
 * IPVS:        Never Queue scheduling module
 *
 * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Changes:
 *
 */

/*
 * The NQ algorithm adopts a two-speed model. When there is an idle server
 * available, the job will be sent to the idle server, instead of waiting
 * for a fast one. When there is no idle server available, the job will be
 * sent to the server that minimize its expected delay (The Shortest
 * Expected Delay scheduling algorithm).
 *
 * See the following paper for more information:
 * A. Weinrib and S. Shenker, Greed is not enough: Adaptive load sharing
 * in large heterogeneous systems. In Proceedings IEEE INFOCOM'88,
 * pages 986-994, 1988.
 *
 * Thanks must go to Marko Buuri <marko@buuri.name> for talking NQ to me.
 *
 * The difference between NQ and SED is that NQ can improve overall
 * system utilization.
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>

#include <net/ip_vs.h>


static inline unsigned int
ip_vs_nq_dest_overhead(struct ip_vs_dest *dest)
{
	/*
	 * We only use the active connection number in the cost
	 * calculation here.
	 */
	return atomic_read(&dest->activeconns) + 1;
}


/*
 *	Weighted Least Connection scheduling
 */
static struct ip_vs_dest *
ip_vs_nq_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)
{
	struct ip_vs_dest *dest, *least = NULL;
	unsigned int loh = 0, doh;

	IP_VS_DBG(6, "ip_vs_nq_schedule(): Scheduling...\n");

	/*
	 * We calculate the load of each dest server as follows:
	 *	(server expected overhead) / dest->weight
	 *
	 * Remember -- no floats in kernel mode!!!
	 * The comparison of h1*w2 > h2*w1 is equivalent to that of
	 *		  h1/w1 > h2/w2
	 * if every weight is larger than zero.
	 *
	 * The server with weight=0 is quiesced and will not receive any
	 * new connections.
	 */

	list_for_each_entry(dest, &svc->destinations, n_list) {

		if (dest->flags & IP_VS_DEST_F_OVERLOAD ||
		    !atomic_read(&dest->weight))
			continue;

		doh = ip_vs_nq_dest_overhead(dest);

		/* return the server directly if it is idle */
		if (atomic_read(&dest->activeconns) == 0) {
			least = dest;
			loh = doh;
			goto out;
		}

		if (!least ||
		    (loh * atomic_read(&dest->weight) >
		     doh * atomic_read(&least->weight))) {
			least = dest;
			loh = doh;
		}
	}

	if (!least)
		return NULL;

  out:
	IP_VS_DBG(6, "NQ: server %u.%u.%u.%u:%u "
		  "activeconns %d refcnt %d weight %d overhead %d\n",
		  NIPQUAD(least->addr.ip), ntohs(least->port),
		  atomic_read(&least->activeconns),
		  atomic_read(&least->refcnt),
		  atomic_read(&least->weight), loh);

	return least;
}


static struct ip_vs_scheduler ip_vs_nq_scheduler =
{
	.name =			"nq",
	.refcnt =		ATOMIC_INIT(0),
	.module =		THIS_MODULE,
	.n_list =		LIST_HEAD_INIT(ip_vs_nq_scheduler.n_list),
	.schedule =		ip_vs_nq_schedule,
};


static int __init ip_vs_nq_init(void)
{
	return register_ip_vs_scheduler(&ip_vs_nq_scheduler);
}

static void __exit ip_vs_nq_cleanup(void)
{
	unregister_ip_vs_scheduler(&ip_vs_nq_scheduler);
}

module_init(ip_vs_nq_init);
module_exit(ip_vs_nq_cleanup);
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* IPVS: Never Queue scheduling module
	3	*
1da177e4 LT	4	* Authors: Wensong Zhang <wensong@linuxvirtualserver.org>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*
	11	* Changes:
	12	*
	13	*/
	14
	15	/*
	16	* The NQ algorithm adopts a two-speed model. When there is an idle server
	17	* available, the job will be sent to the idle server, instead of waiting
	18	* for a fast one. When there is no idle server available, the job will be
	19	* sent to the server that minimize its expected delay (The Shortest
	20	* Expected Delay scheduling algorithm).
	21	*
	22	* See the following paper for more information:
	23	* A. Weinrib and S. Shenker, Greed is not enough: Adaptive load sharing
	24	* in large heterogeneous systems. In Proceedings IEEE INFOCOM'88,
	25	* pages 986-994, 1988.
	26	*
	27	* Thanks must go to Marko Buuri <marko@buuri.name> for talking NQ to me.
	28	*
	29	* The difference between NQ and SED is that NQ can improve overall
	30	* system utilization.
	31	*
	32	*/
	33
	34	#include <linux/module.h>
	35	#include <linux/kernel.h>
	36
	37	#include <net/ip_vs.h>
	38
	39
1da177e4 LT	40	static inline unsigned int
	41	ip_vs_nq_dest_overhead(struct ip_vs_dest *dest)
	42	{
	43	/*
	44	* We only use the active connection number in the cost
	45	* calculation here.
	46	*/
	47	return atomic_read(&dest->activeconns) + 1;
	48	}
	49
	50
	51	/*
	52	* Weighted Least Connection scheduling
	53	*/
	54	static struct ip_vs_dest *
	55	ip_vs_nq_schedule(struct ip_vs_service svc, const struct sk_buff skb)
	56	{
	57	struct ip_vs_dest dest, least = NULL;
	58	unsigned int loh = 0, doh;
	59
	60	IP_VS_DBG(6, "ip_vs_nq_schedule(): Scheduling...\n");
	61
	62	/*
	63	* We calculate the load of each dest server as follows:
	64	* (server expected overhead) / dest->weight
	65	*
	66	* Remember -- no floats in kernel mode!!!
	67	* The comparison of h1w2 > h2w1 is equivalent to that of
	68	* h1/w1 > h2/w2
	69	* if every weight is larger than zero.
	70	*
	71	* The server with weight=0 is quiesced and will not receive any
	72	* new connections.
	73	*/
	74
	75	list_for_each_entry(dest, &svc->destinations, n_list) {
	76
	77	if (dest->flags & IP_VS_DEST_F_OVERLOAD \|\|
	78	!atomic_read(&dest->weight))
	79	continue;
	80
	81	doh = ip_vs_nq_dest_overhead(dest);
	82
	83	/* return the server directly if it is idle */
	84	if (atomic_read(&dest->activeconns) == 0) {
	85	least = dest;
	86	loh = doh;
	87	goto out;
	88	}
	89
	90	if (!least \|\|
	91	(loh * atomic_read(&dest->weight) >
	92	doh * atomic_read(&least->weight))) {
	93	least = dest;
	94	loh = doh;
	95	}
	96	}
	97
	98	if (!least)
	99	return NULL;
	100
	101	out:
	102	IP_VS_DBG(6, "NQ: server %u.%u.%u.%u:%u "
	103	"activeconns %d refcnt %d weight %d overhead %d\n",
e7ade46a	104	NIPQUAD(least->addr.ip), ntohs(least->port),
1da177e4 LT	105	atomic_read(&least->activeconns),
	106	atomic_read(&least->refcnt),
	107	atomic_read(&least->weight), loh);
	108
	109	return least;
	110	}
	111
	112
	113	static struct ip_vs_scheduler ip_vs_nq_scheduler =
	114	{
	115	.name = "nq",
	116	.refcnt = ATOMIC_INIT(0),
	117	.module = THIS_MODULE,
d149ccc9	118	.n_list = LIST_HEAD_INIT(ip_vs_nq_scheduler.n_list),
1da177e4 LT	119	.schedule = ip_vs_nq_schedule,
	120	};
	121
	122
	123	static int __init ip_vs_nq_init(void)
	124	{
1da177e4 LT	125	return register_ip_vs_scheduler(&ip_vs_nq_scheduler);
	126	}
	127
	128	static void __exit ip_vs_nq_cleanup(void)
	129	{
	130	unregister_ip_vs_scheduler(&ip_vs_nq_scheduler);
	131	}
	132
	133	module_init(ip_vs_nq_init);
	134	module_exit(ip_vs_nq_cleanup);
	135	MODULE_LICENSE("GPL");