[net-next-2.6.git] / net / sunrpc / timer.c

/*
 * linux/net/sunrpc/timer.c
 *
 * Estimate RPC request round trip time.
 *
 * Based on packet round-trip and variance estimator algorithms described
 * in appendix A of "Congestion Avoidance and Control" by Van Jacobson
 * and Michael J. Karels (ACM Computer Communication Review; Proceedings
 * of the Sigcomm '88 Symposium in Stanford, CA, August, 1988).
 *
 * This RTT estimator is used only for RPC over datagram protocols.
 *
 * Copyright (C) 2002 Trond Myklebust <trond.myklebust@fys.uio.no>
 */

#include <asm/param.h>

#include <linux/types.h>
#include <linux/unistd.h>
#include <linux/module.h>

#include <linux/sunrpc/clnt.h>

#define RPC_RTO_MAX (60*HZ)
#define RPC_RTO_INIT (HZ/5)
#define RPC_RTO_MIN (HZ/10)

void
rpc_init_rtt(struct rpc_rtt *rt, unsigned long timeo)
{
	unsigned long init = 0;
	unsigned i;

	rt->timeo = timeo;

	if (timeo > RPC_RTO_INIT)
		init = (timeo - RPC_RTO_INIT) << 3;
	for (i = 0; i < 5; i++) {
		rt->srtt[i] = init;
		rt->sdrtt[i] = RPC_RTO_INIT;
		rt->ntimeouts[i] = 0;
	}
}
EXPORT_SYMBOL_GPL(rpc_init_rtt);

/*
 * NB: When computing the smoothed RTT and standard deviation,
 *     be careful not to produce negative intermediate results.
 */
void
rpc_update_rtt(struct rpc_rtt *rt, unsigned timer, long m)
{
	long *srtt, *sdrtt;

	if (timer-- == 0)
		return;

	/* jiffies wrapped; ignore this one */
	if (m < 0)
		return;

	if (m == 0)
		m = 1L;

	srtt = (long *)&rt->srtt[timer];
	m -= *srtt >> 3;
	*srtt += m;

	if (m < 0)
		m = -m;

	sdrtt = (long *)&rt->sdrtt[timer];
	m -= *sdrtt >> 2;
	*sdrtt += m;

	/* Set lower bound on the variance */
	if (*sdrtt < RPC_RTO_MIN)
		*sdrtt = RPC_RTO_MIN;
}
EXPORT_SYMBOL_GPL(rpc_update_rtt);

/*
 * Estimate rto for an nfs rpc sent via. an unreliable datagram.
 * Use the mean and mean deviation of rtt for the appropriate type of rpc
 * for the frequent rpcs and a default for the others.
 * The justification for doing "other" this way is that these rpcs
 * happen so infrequently that timer est. would probably be stale.
 * Also, since many of these rpcs are
 * non-idempotent, a conservative timeout is desired.
 * getattr, lookup,
 * read, write, commit     - A+4D
 * other                   - timeo
 */

unsigned long
rpc_calc_rto(struct rpc_rtt *rt, unsigned timer)
{
	unsigned long res;

	if (timer-- == 0)
		return rt->timeo;

	res = ((rt->srtt[timer] + 7) >> 3) + rt->sdrtt[timer];
	if (res > RPC_RTO_MAX)
		res = RPC_RTO_MAX;

	return res;
}
EXPORT_SYMBOL_GPL(rpc_calc_rto);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/net/sunrpc/timer.c
	3	*
	4	* Estimate RPC request round trip time.
	5	*
	6	* Based on packet round-trip and variance estimator algorithms described
	7	* in appendix A of "Congestion Avoidance and Control" by Van Jacobson
	8	* and Michael J. Karels (ACM Computer Communication Review; Proceedings
	9	* of the Sigcomm '88 Symposium in Stanford, CA, August, 1988).
	10	*
	11	* This RTT estimator is used only for RPC over datagram protocols.
	12	*
	13	* Copyright (C) 2002 Trond Myklebust <trond.myklebust@fys.uio.no>
	14	*/
	15
	16	#include <asm/param.h>
	17
	18	#include <linux/types.h>
	19	#include <linux/unistd.h>
12444809	20	#include <linux/module.h>
1da177e4 LT	21
1da177e4 LT	22	#include <linux/sunrpc/clnt.h>
1da177e4 LT	23
	24	#define RPC_RTO_MAX (60*HZ)
	25	#define RPC_RTO_INIT (HZ/5)
	26	#define RPC_RTO_MIN (HZ/10)
	27
	28	void
	29	rpc_init_rtt(struct rpc_rtt *rt, unsigned long timeo)
	30	{
	31	unsigned long init = 0;
	32	unsigned i;
	33
	34	rt->timeo = timeo;
	35
	36	if (timeo > RPC_RTO_INIT)
	37	init = (timeo - RPC_RTO_INIT) << 3;
	38	for (i = 0; i < 5; i++) {
	39	rt->srtt[i] = init;
	40	rt->sdrtt[i] = RPC_RTO_INIT;
	41	rt->ntimeouts[i] = 0;
	42	}
	43	}
12444809	44	EXPORT_SYMBOL_GPL(rpc_init_rtt);
1da177e4 LT	45
	46	/*
	47	* NB: When computing the smoothed RTT and standard deviation,
	48	* be careful not to produce negative intermediate results.
	49	*/
	50	void
	51	rpc_update_rtt(struct rpc_rtt *rt, unsigned timer, long m)
	52	{
	53	long srtt, sdrtt;
	54
	55	if (timer-- == 0)
	56	return;
	57
	58	/* jiffies wrapped; ignore this one */
	59	if (m < 0)
	60	return;
	61
	62	if (m == 0)
	63	m = 1L;
	64
	65	srtt = (long *)&rt->srtt[timer];
	66	m -= *srtt >> 3;
	67	*srtt += m;
	68
	69	if (m < 0)
	70	m = -m;
	71
	72	sdrtt = (long *)&rt->sdrtt[timer];
	73	m -= *sdrtt >> 2;
	74	*sdrtt += m;
	75
	76	/* Set lower bound on the variance */
	77	if (*sdrtt < RPC_RTO_MIN)
	78	*sdrtt = RPC_RTO_MIN;
	79	}
12444809	80	EXPORT_SYMBOL_GPL(rpc_update_rtt);
1da177e4 LT	81
	82	/*
	83	* Estimate rto for an nfs rpc sent via. an unreliable datagram.
	84	* Use the mean and mean deviation of rtt for the appropriate type of rpc
	85	* for the frequent rpcs and a default for the others.
	86	* The justification for doing "other" this way is that these rpcs
	87	* happen so infrequently that timer est. would probably be stale.
	88	* Also, since many of these rpcs are
	89	* non-idempotent, a conservative timeout is desired.
	90	* getattr, lookup,
	91	* read, write, commit - A+4D
	92	* other - timeo
	93	*/
	94
	95	unsigned long
	96	rpc_calc_rto(struct rpc_rtt *rt, unsigned timer)
	97	{
	98	unsigned long res;
	99
	100	if (timer-- == 0)
	101	return rt->timeo;
	102
	103	res = ((rt->srtt[timer] + 7) >> 3) + rt->sdrtt[timer];
	104	if (res > RPC_RTO_MAX)
	105	res = RPC_RTO_MAX;
	106
	107	return res;
	108	}
12444809	109	EXPORT_SYMBOL_GPL(rpc_calc_rto);