ogb912/opensim
1
0
Fork 0
mirror of https://github.com/opensim/opensim.git synced 2026-08-10 11:33:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

seems to compile ( tests comented out)

Browse Source
This commit is contained in:
UbitUmarov
2015-09-02 19:54:53 +01:00
parent 371c9dd2af
commit a11edceb00
157 changed files with 1315 additions and 9792 deletions
Download Patch File Download Diff File Expand all files Collapse all files

271
OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
View File

@@ -42,24 +42,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
public class TokenBucket
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
<<<<<<< HEAD
public string Identifier { get; private set; }
public int DebugLevel { get; set; }
/// <summary>
/// Number of ticks (ms) per quantum, drip rate and max burst
/// are defined over this interval.
/// </summary>
protected const Int32 m_ticksPerQuantum = 1000;
=======
private static Int32 m_counter = 0;
// private Int32 m_identifier;
protected const float m_timeScale = 1e-3f;
>>>>>>> avn/ubitvar
/// <summary>
/// This is the number of m_minimumDripRate bytes
@@ -72,11 +60,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
/// <summary>
/// </summary>
<<<<<<< HEAD
protected const Int32 m_minimumDripRate = LLUDPServer.MTU;
=======
protected const float m_minimumDripRate = 1400;
>>>>>>> avn/ubitvar
/// <summary>Time of the last drip, in system ticks</summary>
protected Int32 m_lastDrip;
@@ -90,27 +74,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
/// <summary>
/// Map of children buckets and their requested maximum burst rate
/// </summary>
<<<<<<< HEAD
protected Dictionary<TokenBucket,Int64> m_children = new Dictionary<TokenBucket,Int64>();
=======
protected Dictionary<TokenBucket, float> m_children = new Dictionary<TokenBucket, float>();
#region Properties
>>>>>>> avn/ubitvar
/// <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>
public TokenBucket Parent { get; protected set; }
protected TokenBucket m_parent;
public TokenBucket Parent
{
get { return m_parent; }
set { m_parent = value; }
}
/// <summary>
/// This is the maximum number
/// of tokens that can accumulate in the bucket at any one time. This
/// also sets the total request for leaf nodes
/// </summary>
protected float m_burst;
//not in use
public float MaxDripRate { get; set; }
public float RequestedBurst
{
get { return m_burst; }
@@ -143,63 +131,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
/// Can never be above MaxDripRate.
/// Tokens are added to the bucket at any time
/// <seealso cref="RemoveTokens"/> is called, at the granularity of
<<<<<<< HEAD
/// the system tick interval (typically around 15-22ms)
/// FIXME: It is extremely confusing to be able to set a RequestedDripRate of 0 and then receive a positive
/// number on get if TotalDripRequest is set. This also stops us being able to retrieve the fact that
/// RequestedDripRate is set to 0. Really, this should always return m_dripRate and then we can get
/// (m_dripRate == 0 ? TotalDripRequest : m_dripRate) on some other properties.
/// </remarks>
public virtual Int64 RequestedDripRate
{
get { return (m_dripRate == 0 ? TotalDripRequest : m_dripRate); }
set
{
if (value <= 0)
m_dripRate = 0;
else if (MaxDripRate > 0 && value > MaxDripRate)
m_dripRate = MaxDripRate;
else
m_dripRate = value;
m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
if (Parent != null)
Parent.RegisterRequest(this, m_dripRate);
}
}
/// <summary>
/// Gets the drip rate.
/// </summary>
/// <value>
/// DripRate can never be above max drip rate or below min drip rate.
/// If we are a child bucket then the drip rate return is modifed by the total load on the capacity of the
/// parent bucket.
/// </value>
public virtual Int64 DripRate
{
get
{
double rate;
// FIXME: This doesn't properly work if we have a parent and children and a requested drip rate set
// on ourselves which is not equal to the child drip rates.
if (Parent == null)
{
if (TotalDripRequest > 0)
rate = Math.Min(RequestedDripRate, TotalDripRequest);
else
rate = RequestedDripRate;
}
else
{
rate = (double)RequestedDripRate * Parent.DripRateModifier();
}
=======
/// the system tick interval (typically around 15-22ms)</remarks>
protected float m_dripRate;
public virtual float RequestedDripRate
{
get { return (m_dripRate == 0 ? m_totalDripRequest : m_dripRate); }
@@ -212,7 +146,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
}
}
public virtual float DripRate
public virtual float DripRate
{
get {
float rate = Math.Min(RequestedDripRate,TotalDripRequest);
@@ -220,28 +154,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
return rate;
rate *= m_parent.DripRateModifier();
>>>>>>> avn/ubitvar
if (rate < m_minimumDripRate)
rate = m_minimumDripRate;
else if (MaxDripRate > 0 && rate > MaxDripRate)
rate = MaxDripRate;
return (float)rate;
}
}
protected Int64 m_dripRate;
// <summary>
// The maximum rate for flow control. Drip rate can never be greater than this.
// </summary>
public Int64 MaxDripRate { get; set; }
/// <summary>
/// The current total of the requested maximum burst rates of children buckets.
/// </summary>
<<<<<<< HEAD
public Int64 TotalDripRequest { get; protected set; }
=======
protected float m_totalDripRequest;
public float TotalDripRequest
{
@@ -252,7 +174,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
#endregion Properties
#region Constructor
>>>>>>> avn/ubitvar
/// <summary>
/// Default constructor
@@ -260,36 +182,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
/// <param name="identifier">Identifier for this token bucket</param>
/// <param name="parent">Parent bucket if this is a child bucket, or
/// null if this is a root bucket</param>
<<<<<<< HEAD
/// <param name="requestedDripRate">
/// Requested rate that the bucket fills, in bytes per
/// second. If zero, the bucket always remains full.
/// </param>
public TokenBucket(string identifier, TokenBucket parent, Int64 requestedDripRate, Int64 maxDripRate)
=======
/// <param name="maxBurst">Maximum size of the bucket in bytes, or
/// zero if this bucket has no maximum capacity</param>
/// <param name="dripRate">Rate that the bucket fills, in bytes per
/// second. If zero, the bucket always remains full</param>
public TokenBucket(TokenBucket parent, float dripRate, float MaxBurst)
>>>>>>> avn/ubitvar
{
Identifier = identifier;
m_counter++;
Parent = parent;
<<<<<<< HEAD
RequestedDripRate = requestedDripRate;
MaxDripRate = maxDripRate;
m_lastDrip = Util.EnvironmentTickCount();
=======
RequestedDripRate = dripRate;
RequestedBurst = MaxBurst;
// TotalDripRequest = dripRate; // this will be overwritten when a child node registers
// MaxBurst = (Int64)((double)dripRate * m_quantumsPerBurst);
m_lastDrip = Util.EnvironmentTickCount() + 100000;
>>>>>>> avn/ubitvar
}
#endregion Constructor
/// <summary>
/// Compute a modifier for the MaxBurst rate. This is 1.0, meaning
/// no modification if the requested bandwidth is less than the
@@ -299,20 +209,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
/// </summary>
protected float DripRateModifier()
{
<<<<<<< HEAD
Int64 driprate = DripRate;
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;
=======
float driprate = DripRate;
return driprate >= TotalDripRequest ? 1.0f : driprate / TotalDripRequest;
>>>>>>> avn/ubitvar
}
/// <summary>
@@ -335,29 +233,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
{
m_children[child] = request;
<<<<<<< HEAD
TotalDripRequest = 0;
foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
TotalDripRequest += cref.Value;
=======
m_totalDripRequest = 0;
foreach (KeyValuePair<TokenBucket, float> cref in m_children)
m_totalDripRequest += cref.Value;
>>>>>>> avn/ubitvar
}
// Pass the new values up to the parent
if (Parent != null)
{
Int64 effectiveDripRate;
if (RequestedDripRate > 0)
effectiveDripRate = Math.Min(RequestedDripRate, TotalDripRequest);
else
effectiveDripRate = TotalDripRequest;
Parent.RegisterRequest(this, effectiveDripRate);
}
if (m_parent != null)
m_parent.RegisterRequest(this, Math.Min(RequestedDripRate, TotalDripRequest));
}
/// <summary>
@@ -370,15 +253,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
{
m_children.Remove(child);
<<<<<<< HEAD
TotalDripRequest = 0;
foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
TotalDripRequest += cref.Value;
=======
m_totalDripRequest = 0;
foreach (KeyValuePair<TokenBucket, float> cref in m_children)
m_totalDripRequest += cref.Value;
>>>>>>> avn/ubitvar
}
// Pass the new values up to the parent
@@ -427,7 +304,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
// with no drip rate...
if (DripRate == 0)
{
m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0 for {0}", Identifier);
m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0 for {0}", m_counter);
return;
}
@@ -453,17 +330,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
public bool AdaptiveEnabled { get; set; }
/// <summary>
<<<<<<< HEAD
/// Target drip rate for this bucket.
/// </summary>
/// <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(value, m_minimumFlow);
=======
/// The minimum rate for flow control. Minimum drip rate is one
/// packet per second.
/// </summary>
@@ -479,13 +345,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
public float MaxDripRate
{
get { return (m_maxDripRate == 0 ? m_totalDripRequest : m_maxDripRate); }
set
set
{
m_maxDripRate = (value == 0 ? m_totalDripRequest : Math.Max(value, m_minimumFlow));
>>>>>>> avn/ubitvar
}
}
protected Int64 m_targetDripRate;
private bool m_enabled = false;
// <summary>
// Adjust drip rate in response to network conditions.
@@ -493,109 +359,50 @@ namespace OpenSim.Region.ClientStack.LindenUDP
public virtual float AdjustedDripRate
{
get { return m_dripRate; }
<<<<<<< HEAD
set
set
{
m_dripRate = OpenSim.Framework.Util.Clamp<Int64>(value, m_minimumFlow, TargetDripRate);
m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
if (Parent != null)
Parent.RegisterRequest(this, m_dripRate);
=======
set {
m_dripRate = OpenSim.Framework.Util.Clamp<float>(value,m_minimumFlow,MaxDripRate);
m_dripRate = OpenSim.Framework.Util.Clamp<float>(value, m_minimumFlow, MaxDripRate);
if (m_parent != null)
m_parent.RegisterRequest(this,m_dripRate);
>>>>>>> avn/ubitvar
m_parent.RegisterRequest(this, m_dripRate);
}
}
/// <summary>
/// The minimum rate for adaptive flow control.
/// </summary>
protected Int64 m_minimumFlow = 32000;
<<<<<<< HEAD
/// <summary>
/// Constructor for the AdaptiveTokenBucket class
/// <param name="identifier">Unique identifier for the client</param>
/// <param name="parent">Parent bucket in the hierarchy</param>
/// <param name="requestedDripRate"></param>
/// <param name="maxDripRate">The ceiling rate for adaptation</param>
/// <param name="minDripRate">The floor rate for adaptation</param>
/// </summary>
public AdaptiveTokenBucket(string identifier, TokenBucket parent, Int64 requestedDripRate, Int64 maxDripRate, Int64 minDripRate, bool enabled)
: base(identifier, parent, requestedDripRate, maxDripRate)
{
AdaptiveEnabled = enabled;
if (AdaptiveEnabled)
{
// m_log.DebugFormat("[TOKENBUCKET]: Adaptive throttle enabled");
m_minimumFlow = minDripRate;
TargetDripRate = m_minimumFlow;
AdjustedDripRate = m_minimumFlow;
}
=======
// <summary>
//
// </summary>
public AdaptiveTokenBucket(TokenBucket parent, float maxDripRate,float maxBurst, bool enabled)
: base(parent, maxDripRate,maxBurst)
public AdaptiveTokenBucket(TokenBucket parent, float maxDripRate, float maxBurst, bool enabled)
: base(parent, maxDripRate, maxBurst)
{
m_enabled = enabled;
MaxDripRate = maxDripRate;
if (enabled)
AdjustedDripRate = m_maxDripRate * .5f;
else
AdjustedDripRate = m_maxDripRate;
>>>>>>> avn/ubitvar
}
/// <summary>
/// Reliable packets sent to the client for which we never received an ack adjust the drip rate down.
/// <param name="packets">Number of packets that expired without successful delivery</param>
/// </summary>
public void ExpirePackets(Int32 packets)
public void ExpirePackets(Int32 count)
{
if (AdaptiveEnabled)
{
if (DebugLevel > 0)
m_log.WarnFormat(
"[ADAPTIVEBUCKET] drop {0} by {1} expired packets for {2}",
AdjustedDripRate, packets, Identifier);
// AdjustedDripRate = (Int64) (AdjustedDripRate / Math.Pow(2,packets));
// Compute the fallback solely on the rate allocated beyond the minimum, this
// should smooth out the fallback to the minimum rate
AdjustedDripRate = m_minimumFlow + (Int64) ((AdjustedDripRate - m_minimumFlow) / Math.Pow(2, packets));
}
// m_log.WarnFormat("[ADAPTIVEBUCKET] drop {0} by {1} expired packets",AdjustedDripRate,count);
if (m_enabled)
AdjustedDripRate = (Int64)(AdjustedDripRate / Math.Pow(2, count));
}
/// <summary>
/// Reliable packets acked by the client adjust the drip rate up.
/// <param name="packets">Number of packets successfully acknowledged</param>
/// </summary>
public void AcknowledgePackets(Int32 packets)
// <summary>
//
// </summary>
public void AcknowledgePackets(Int32 count)
{
if (AdaptiveEnabled)
AdjustedDripRate = AdjustedDripRate + packets * LLUDPServer.MTU;
}
/// <summary>
/// Adjust the minimum flow level for the adaptive throttle, this will drop adjusted
/// throttles back to the minimum levels
/// <param>minDripRate--the new minimum flow</param>
/// </summary>
public void ResetMinimumAdaptiveFlow(Int64 minDripRate)
{
m_minimumFlow = minDripRate;
TargetDripRate = m_minimumFlow;
AdjustedDripRate = m_minimumFlow;
if (m_enabled)
AdjustedDripRate = AdjustedDripRate + count;
}
}
}