2014-06-29 15:49:27 +00:00
|
|
|
/*
|
2009-10-21 01:19:17 +00:00
|
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
|
|
* names of its contributors may be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
using System;
|
2011-04-11 16:06:28 +00:00
|
|
|
using System.Collections;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Reflection;
|
2011-04-21 22:40:38 +00:00
|
|
|
using OpenSim.Framework;
|
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
using log4net;
|
2009-10-21 01:19:17 +00:00
|
|
|
|
|
|
|
namespace OpenSim.Region.ClientStack.LindenUDP
|
|
|
|
{
|
|
|
|
/// <summary>
|
|
|
|
/// A hierarchical token bucket for bandwidth throttling. See
|
|
|
|
/// http://en.wikipedia.org/wiki/Token_bucket for more information
|
|
|
|
/// </summary>
|
|
|
|
public class TokenBucket
|
|
|
|
{
|
2011-04-11 16:06:28 +00:00
|
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
2014-09-30 17:12:51 +00:00
|
|
|
|
|
|
|
public string Identifier { get; private set; }
|
|
|
|
|
|
|
|
public int DebugLevel { get; set; }
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Number of ticks (ms) per quantum, drip rate and max burst
|
|
|
|
/// are defined over this interval.
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected const Int32 m_ticksPerQuantum = 1000;
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// This is the number of quantums worth of packets that can
|
|
|
|
/// be accommodated during a burst
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected const Double m_quantumsPerBurst = 1.5;
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected const Int32 m_minimumDripRate = 1400;
|
2011-04-11 16:06:28 +00:00
|
|
|
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <summary>Time of the last drip, in system ticks</summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected Int32 m_lastDrip;
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// The number of bytes that can be sent at this moment. This is the
|
|
|
|
/// current number of tokens in the bucket
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected Int64 m_tokenCount;
|
2009-10-21 01:19:17 +00:00
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Map of children buckets and their requested maximum burst rate
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected Dictionary<TokenBucket,Int64> m_children = new Dictionary<TokenBucket,Int64>();
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
#region Properties
|
2009-10-21 01:19:17 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// The parent bucket of this bucket, or null if this bucket has no
|
|
|
|
/// parent. The parent bucket will limit the aggregate bandwidth of all
|
|
|
|
/// of its children buckets
|
|
|
|
/// </summary>
|
2014-10-10 17:38:54 +00:00
|
|
|
public TokenBucket Parent { get; protected set; }
|
2009-10-21 01:19:17 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Maximum burst rate in bytes per second. This is the maximum number
|
2011-04-11 16:06:28 +00:00
|
|
|
/// of tokens that can accumulate in the bucket at any one time. This
|
|
|
|
/// also sets the total request for leaf nodes
|
2009-10-21 01:19:17 +00:00
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected Int64 m_burstRate;
|
2011-04-11 16:06:28 +00:00
|
|
|
public Int64 RequestedBurstRate
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2011-04-11 16:06:28 +00:00
|
|
|
get { return m_burstRate; }
|
|
|
|
set { m_burstRate = (value < 0 ? 0 : value); }
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
public Int64 BurstRate
|
|
|
|
{
|
|
|
|
get {
|
|
|
|
double rate = RequestedBurstRate * BurstRateModifier();
|
|
|
|
if (rate < m_minimumDripRate * m_quantumsPerBurst)
|
|
|
|
rate = m_minimumDripRate * m_quantumsPerBurst;
|
|
|
|
|
|
|
|
return (Int64) rate;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <summary>
|
|
|
|
/// The speed limit of this bucket in bytes per second. This is the
|
2011-04-11 16:06:28 +00:00
|
|
|
/// number of tokens that are added to the bucket per quantum
|
2009-10-21 01:19:17 +00:00
|
|
|
/// </summary>
|
2014-10-10 22:36:50 +00:00
|
|
|
/// <remarks>
|
|
|
|
/// RequestedDripRate can never be above MaxDripRate.
|
|
|
|
/// Tokens are added to the bucket any time
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <seealso cref="RemoveTokens"/> is called, at the granularity of
|
|
|
|
/// the system tick interval (typically around 15-22ms)</remarks>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected Int64 m_dripRate;
|
|
|
|
public virtual Int64 RequestedDripRate
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2014-10-10 17:38:54 +00:00
|
|
|
get { return (m_dripRate == 0 ? TotalDripRequest : m_dripRate); }
|
2014-10-10 22:36:50 +00:00
|
|
|
set
|
|
|
|
{
|
|
|
|
if (value <= 0)
|
|
|
|
m_dripRate = 0;
|
|
|
|
else if (MaxDripRate > 0 && value > MaxDripRate)
|
|
|
|
m_dripRate = MaxDripRate;
|
|
|
|
else
|
|
|
|
m_dripRate = value;
|
|
|
|
|
2014-10-10 17:38:54 +00:00
|
|
|
TotalDripRequest = m_dripRate;
|
2014-10-10 22:36:50 +00:00
|
|
|
m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
|
|
|
|
|
2014-10-10 17:38:54 +00:00
|
|
|
if (Parent != null)
|
2014-10-10 22:36:50 +00:00
|
|
|
Parent.RegisterRequest(this, m_dripRate);
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-10 22:36:50 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the drip rate.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>DripRate can never be above max.</value>
|
2011-04-20 23:23:33 +00:00
|
|
|
public virtual Int64 DripRate
|
2009-10-21 07:18:35 +00:00
|
|
|
{
|
2014-10-10 22:36:50 +00:00
|
|
|
get
|
|
|
|
{
|
2014-10-10 17:38:54 +00:00
|
|
|
if (Parent == null)
|
|
|
|
return Math.Min(RequestedDripRate, TotalDripRequest);
|
2011-04-11 16:06:28 +00:00
|
|
|
|
2014-10-10 17:38:54 +00:00
|
|
|
double rate = (double)RequestedDripRate * Parent.DripRateModifier();
|
2011-04-11 16:06:28 +00:00
|
|
|
if (rate < m_minimumDripRate)
|
|
|
|
rate = m_minimumDripRate;
|
2014-10-10 22:36:50 +00:00
|
|
|
else if (MaxDripRate > 0 && rate > MaxDripRate)
|
|
|
|
rate = MaxDripRate;
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
return (Int64)rate;
|
|
|
|
}
|
2009-10-21 07:18:35 +00:00
|
|
|
}
|
|
|
|
|
2014-10-10 22:36:50 +00:00
|
|
|
// <summary>
|
|
|
|
// The maximum rate for flow control. Drip rate can never be greater than this.
|
|
|
|
// </summary>
|
|
|
|
// protected Int64 m_maxDripRate;
|
|
|
|
// public Int64 MaxDripRate
|
|
|
|
// {
|
|
|
|
// get { return m_maxDripRate; }
|
|
|
|
// //get { return (m_maxDripRate == 0 ? TotalDripRequest : m_maxDripRate); }
|
|
|
|
// set { m_maxDripRate = (value == 0 ? 0 : Math.Max(value, m_minimumFlow)); }
|
|
|
|
// }
|
|
|
|
public Int64 MaxDripRate { get; set; }
|
|
|
|
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <summary>
|
2011-04-11 16:06:28 +00:00
|
|
|
/// The current total of the requested maximum burst rates of
|
|
|
|
/// this bucket's children buckets.
|
2009-10-21 01:19:17 +00:00
|
|
|
/// </summary>
|
2014-10-10 17:38:54 +00:00
|
|
|
public Int64 TotalDripRequest { get; protected set; }
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
#endregion Properties
|
2009-10-21 01:19:17 +00:00
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
#region Constructor
|
2009-10-21 01:19:17 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Default constructor
|
|
|
|
/// </summary>
|
2014-09-30 17:12:51 +00:00
|
|
|
/// <param name="identifier">Identifier for this token bucket</param>
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <param name="parent">Parent bucket if this is a child bucket, or
|
|
|
|
/// null if this is a root bucket</param>
|
|
|
|
/// <param name="dripRate">Rate that the bucket fills, in bytes per
|
|
|
|
/// second. If zero, the bucket always remains full</param>
|
2014-10-10 22:36:50 +00:00
|
|
|
public TokenBucket(string identifier, TokenBucket parent, Int64 dripRate, Int64 maxDripRate)
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2014-09-30 17:12:51 +00:00
|
|
|
Identifier = identifier;
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
Parent = parent;
|
|
|
|
RequestedDripRate = dripRate;
|
2014-10-10 22:36:50 +00:00
|
|
|
MaxDripRate = maxDripRate;
|
2011-04-11 16:06:28 +00:00
|
|
|
// TotalDripRequest = dripRate; // this will be overwritten when a child node registers
|
|
|
|
// MaxBurst = (Int64)((double)dripRate * m_quantumsPerBurst);
|
2011-04-21 22:40:38 +00:00
|
|
|
m_lastDrip = Util.EnvironmentTickCount();
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
#endregion Constructor
|
|
|
|
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <summary>
|
2011-04-11 16:06:28 +00:00
|
|
|
/// Compute a modifier for the MaxBurst rate. This is 1.0, meaning
|
|
|
|
/// no modification if the requested bandwidth is less than the
|
|
|
|
/// max burst bandwidth all the way to the root of the throttle
|
|
|
|
/// hierarchy. However, if any of the parents is over-booked, then
|
|
|
|
/// the modifier will be less than 1.
|
2009-10-21 01:19:17 +00:00
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected double DripRateModifier()
|
2011-04-11 16:06:28 +00:00
|
|
|
{
|
|
|
|
Int64 driprate = DripRate;
|
2014-10-10 22:36:50 +00:00
|
|
|
double modifier = driprate >= TotalDripRequest ? 1.0 : (double)driprate / (double)TotalDripRequest;
|
|
|
|
|
|
|
|
// if (DebugLevel > 0)
|
|
|
|
// m_log.DebugFormat(
|
|
|
|
// "[TOKEN BUCKET]: Returning drip modifier {0}/{1} = {2} from {3}",
|
|
|
|
// driprate, TotalDripRequest, modifier, Identifier);
|
|
|
|
|
|
|
|
return modifier;
|
2011-04-11 16:06:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected double BurstRateModifier()
|
2011-04-11 16:06:28 +00:00
|
|
|
{
|
|
|
|
// for now... burst rate is always m_quantumsPerBurst (constant)
|
|
|
|
// larger than drip rate so the ratio of burst requests is the
|
|
|
|
// same as the drip ratio
|
|
|
|
return DripRateModifier();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Register drip rate requested by a child of this throttle. Pass the
|
|
|
|
/// changes up the hierarchy.
|
|
|
|
/// </summary>
|
|
|
|
public void RegisterRequest(TokenBucket child, Int64 request)
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2011-04-21 22:40:38 +00:00
|
|
|
lock (m_children)
|
|
|
|
{
|
|
|
|
m_children[child] = request;
|
2014-10-10 17:38:54 +00:00
|
|
|
// TotalDripRequest = m_children.Values.Sum();
|
2011-04-11 16:06:28 +00:00
|
|
|
|
2014-10-10 17:38:54 +00:00
|
|
|
TotalDripRequest = 0;
|
2011-04-21 22:40:38 +00:00
|
|
|
foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
|
2014-10-10 17:38:54 +00:00
|
|
|
TotalDripRequest += cref.Value;
|
2011-04-21 22:40:38 +00:00
|
|
|
}
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
// Pass the new values up to the parent
|
2014-10-10 17:38:54 +00:00
|
|
|
if (Parent != null)
|
2014-10-10 22:36:50 +00:00
|
|
|
{
|
|
|
|
Int64 effectiveDripRate;
|
|
|
|
|
|
|
|
if (MaxDripRate > 0)
|
|
|
|
effectiveDripRate = Math.Min(MaxDripRate, TotalDripRequest);
|
|
|
|
else
|
|
|
|
effectiveDripRate = TotalDripRequest;
|
|
|
|
|
|
|
|
//Parent.RegisterRequest(this, Math.Min(RequestedDripRate, TotalDripRequest));
|
|
|
|
Parent.RegisterRequest(this, effectiveDripRate);
|
|
|
|
}
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Remove the rate requested by a child of this throttle. Pass the
|
|
|
|
/// changes up the hierarchy.
|
|
|
|
/// </summary>
|
|
|
|
public void UnregisterRequest(TokenBucket child)
|
|
|
|
{
|
2011-04-21 22:40:38 +00:00
|
|
|
lock (m_children)
|
|
|
|
{
|
|
|
|
m_children.Remove(child);
|
|
|
|
// m_totalDripRequest = m_children.Values.Sum();
|
2011-04-11 16:06:28 +00:00
|
|
|
|
2014-10-10 17:38:54 +00:00
|
|
|
TotalDripRequest = 0;
|
2011-04-21 22:40:38 +00:00
|
|
|
foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
|
2014-10-10 17:38:54 +00:00
|
|
|
TotalDripRequest += cref.Value;
|
2011-04-21 22:40:38 +00:00
|
|
|
}
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
// Pass the new values up to the parent
|
2014-10-10 17:38:54 +00:00
|
|
|
if (Parent != null)
|
|
|
|
Parent.RegisterRequest(this,Math.Min(RequestedDripRate, TotalDripRequest));
|
2011-04-11 16:06:28 +00:00
|
|
|
}
|
|
|
|
|
2009-10-21 01:19:17 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Remove a given number of tokens from the bucket
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="amount">Number of tokens to remove from the bucket</param>
|
|
|
|
/// <returns>True if the requested number of tokens were removed from
|
|
|
|
/// the bucket, otherwise false</returns>
|
2011-04-11 16:06:28 +00:00
|
|
|
public bool RemoveTokens(Int64 amount)
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2011-04-11 16:06:28 +00:00
|
|
|
// Deposit tokens for this interval
|
|
|
|
Drip();
|
|
|
|
|
|
|
|
// If we have enough tokens then remove them and return
|
|
|
|
if (m_tokenCount - amount >= 0)
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2011-04-15 23:44:53 +00:00
|
|
|
// we don't have to remove from the parent, the drip rate is already
|
|
|
|
// reflective of the drip rate limits in the parent
|
|
|
|
m_tokenCount -= amount;
|
|
|
|
return true;
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
return false;
|
|
|
|
}
|
2009-10-21 01:19:17 +00:00
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Deposit tokens into the bucket from a child bucket that did
|
|
|
|
/// not use all of its available tokens
|
|
|
|
/// </summary>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected void Deposit(Int64 count)
|
2011-04-11 16:06:28 +00:00
|
|
|
{
|
|
|
|
m_tokenCount += count;
|
2009-10-21 01:19:17 +00:00
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
// Deposit the overflow in the parent bucket, this is how we share
|
|
|
|
// unused bandwidth
|
|
|
|
Int64 burstrate = BurstRate;
|
|
|
|
if (m_tokenCount > burstrate)
|
|
|
|
m_tokenCount = burstrate;
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Add tokens to the bucket over time. The number of tokens added each
|
|
|
|
/// call depends on the length of time that has passed since the last
|
|
|
|
/// call to Drip
|
|
|
|
/// </summary>
|
|
|
|
/// <returns>True if tokens were added to the bucket, otherwise false</returns>
|
2011-04-20 23:23:33 +00:00
|
|
|
protected void Drip()
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2011-04-11 16:06:28 +00:00
|
|
|
// This should never happen... means we are a leaf node and were created
|
|
|
|
// with no drip rate...
|
|
|
|
if (DripRate == 0)
|
2009-10-21 01:19:17 +00:00
|
|
|
{
|
2014-09-30 17:12:51 +00:00
|
|
|
m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0 for {0}", Identifier);
|
2011-04-11 16:06:28 +00:00
|
|
|
return;
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
2011-04-11 16:06:28 +00:00
|
|
|
|
|
|
|
// Determine the interval over which we are adding tokens, never add
|
|
|
|
// more than a single quantum of tokens
|
2011-04-21 22:40:38 +00:00
|
|
|
Int32 deltaMS = Math.Min(Util.EnvironmentTickCountSubtract(m_lastDrip), m_ticksPerQuantum);
|
|
|
|
m_lastDrip = Util.EnvironmentTickCount();
|
2009-10-21 01:19:17 +00:00
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
// This can be 0 in the very unusual case that the timer wrapped
|
|
|
|
// It can be 0 if we try add tokens at a sub-tick rate
|
|
|
|
if (deltaMS <= 0)
|
|
|
|
return;
|
2009-10-21 01:19:17 +00:00
|
|
|
|
2011-04-11 16:06:28 +00:00
|
|
|
Deposit(deltaMS * DripRate / m_ticksPerQuantum);
|
2009-10-21 01:19:17 +00:00
|
|
|
}
|
|
|
|
}
|
2011-04-20 23:23:33 +00:00
|
|
|
|
|
|
|
public class AdaptiveTokenBucket : TokenBucket
|
|
|
|
{
|
2014-10-10 22:36:50 +00:00
|
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
|
|
|
|
public bool AdaptiveEnabled { get; set; }
|
2011-04-20 23:23:33 +00:00
|
|
|
|
2011-04-22 21:02:34 +00:00
|
|
|
/// <summary>
|
2014-10-10 22:36:50 +00:00
|
|
|
/// Target drip rate for this bucket.
|
2011-04-22 21:02:34 +00:00
|
|
|
/// </summary>
|
2014-10-10 22:36:50 +00:00
|
|
|
/// <remarks>Usually set by the client. If adaptive is enabled then throttles will increase until we reach this.</remarks>
|
|
|
|
public Int64 TargetDripRate
|
|
|
|
{
|
|
|
|
get { return m_targetDripRate; }
|
|
|
|
set { m_targetDripRate = Math.Max(0, value); }
|
2011-04-20 23:23:33 +00:00
|
|
|
}
|
2014-10-10 22:36:50 +00:00
|
|
|
protected Int64 m_targetDripRate;
|
2014-06-29 15:49:27 +00:00
|
|
|
|
2011-04-20 23:23:33 +00:00
|
|
|
// <summary>
|
2014-10-10 22:36:50 +00:00
|
|
|
// Adjust drip rate in response to network conditions.
|
2011-04-20 23:23:33 +00:00
|
|
|
// </summary>
|
|
|
|
public virtual Int64 AdjustedDripRate
|
|
|
|
{
|
|
|
|
get { return m_dripRate; }
|
|
|
|
set {
|
2014-10-10 22:36:50 +00:00
|
|
|
m_dripRate = OpenSim.Framework.Util.Clamp<Int64>(value, m_minimumFlow, TargetDripRate);
|
2011-04-20 23:23:33 +00:00
|
|
|
m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
|
2014-10-10 17:38:54 +00:00
|
|
|
if (Parent != null)
|
|
|
|
Parent.RegisterRequest(this, m_dripRate);
|
2011-04-20 23:23:33 +00:00
|
|
|
}
|
|
|
|
}
|
2014-10-10 22:36:50 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// The minimum rate for flow control. Minimum drip rate is one
|
|
|
|
/// packet per second. Open the throttle to 15 packets per second
|
|
|
|
/// or about 160kbps.
|
|
|
|
/// </summary>
|
|
|
|
protected const Int64 m_minimumFlow = m_minimumDripRate * 15;
|
2011-04-20 23:23:33 +00:00
|
|
|
|
2014-10-10 22:36:50 +00:00
|
|
|
public AdaptiveTokenBucket(string identifier, TokenBucket parent, Int64 dripRate, Int64 maxDripRate, bool enabled)
|
|
|
|
: base(identifier, parent, dripRate, maxDripRate)
|
2011-04-20 23:23:33 +00:00
|
|
|
{
|
2014-10-10 22:36:50 +00:00
|
|
|
AdaptiveEnabled = enabled;
|
2011-04-25 17:44:41 +00:00
|
|
|
|
2014-10-10 22:36:50 +00:00
|
|
|
if (AdaptiveEnabled)
|
2011-04-25 17:44:41 +00:00
|
|
|
{
|
2014-09-30 17:12:51 +00:00
|
|
|
// m_log.DebugFormat("[TOKENBUCKET]: Adaptive throttle enabled");
|
2011-04-25 17:44:41 +00:00
|
|
|
AdjustedDripRate = m_minimumFlow;
|
|
|
|
}
|
2011-04-20 23:23:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// <summary>
|
2014-10-10 22:36:50 +00:00
|
|
|
// Reliable packets sent to the client for which we never received an ack adjust the drip rate down.
|
2011-04-20 23:23:33 +00:00
|
|
|
// </summary>
|
|
|
|
public void ExpirePackets(Int32 count)
|
|
|
|
{
|
2014-10-10 22:36:50 +00:00
|
|
|
if (AdaptiveEnabled)
|
2014-09-30 17:12:51 +00:00
|
|
|
{
|
|
|
|
if (DebugLevel > 0)
|
|
|
|
m_log.WarnFormat(
|
|
|
|
"[ADAPTIVEBUCKET] drop {0} by {1} expired packets for {2}",
|
|
|
|
AdjustedDripRate, count, Identifier);
|
|
|
|
|
2011-04-25 17:44:41 +00:00
|
|
|
AdjustedDripRate = (Int64) (AdjustedDripRate / Math.Pow(2,count));
|
2014-09-30 17:12:51 +00:00
|
|
|
}
|
2011-04-20 23:23:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// <summary>
|
2014-10-10 22:36:50 +00:00
|
|
|
// Reliable packets acked by the client adjust the drip rate up.
|
2011-04-20 23:23:33 +00:00
|
|
|
// </summary>
|
|
|
|
public void AcknowledgePackets(Int32 count)
|
|
|
|
{
|
2014-10-10 22:36:50 +00:00
|
|
|
if (AdaptiveEnabled)
|
2011-04-25 17:44:41 +00:00
|
|
|
AdjustedDripRate = AdjustedDripRate + count;
|
2011-04-20 23:23:33 +00:00
|
|
|
}
|
|
|
|
}
|
2014-10-10 22:36:50 +00:00
|
|
|
}
|