From efd90b56b761219af6425b1c7a2cdd3b6ffb4de2 Mon Sep 17 00:00:00 2001 From: lbsa71 Date: Thu, 27 Dec 2007 21:41:48 +0000 Subject: * Optimized usings * shortened references * Removed redundant 'this' * Normalized EOF --- OpenSim/Region/ClientStack/PacketQueue.cs | 198 +++++++++++++++--------------- 1 file changed, 101 insertions(+), 97 deletions(-) (limited to 'OpenSim/Region/ClientStack/PacketQueue.cs') diff --git a/OpenSim/Region/ClientStack/PacketQueue.cs b/OpenSim/Region/ClientStack/PacketQueue.cs index 4c9295e..1065f63 100644 --- a/OpenSim/Region/ClientStack/PacketQueue.cs +++ b/OpenSim/Region/ClientStack/PacketQueue.cs @@ -27,17 +27,10 @@ */ using System; using System.Collections.Generic; -using System.Net; -using System.Net.Sockets; -using System.Text; using System.Threading; using System.Timers; -using Axiom.Math; -using libsecondlife; using libsecondlife.Packets; using OpenSim.Framework; -using OpenSim.Framework.Communications.Cache; -using OpenSim.Framework.Console; using Timer=System.Timers.Timer; namespace OpenSim.Region.ClientStack @@ -47,7 +40,7 @@ namespace OpenSim.Region.ClientStack private bool m_enabled = true; private BlockingQueue SendQueue; - + private Queue IncomingPacketQueue; private Queue OutgoingPacketQueue; private Queue ResendOutgoingPacketQueue; @@ -57,7 +50,7 @@ namespace OpenSim.Region.ClientStack private Queue TaskOutgoingPacketQueue; private Queue TextureOutgoingPacketQueue; private Queue AssetOutgoingPacketQueue; - + private Dictionary PendingAcks = new Dictionary(); private Dictionary NeedAck = new Dictionary(); @@ -82,15 +75,15 @@ namespace OpenSim.Region.ClientStack // private long ThrottleInterval; private Timer throttleTimer; - public PacketQueue() + public PacketQueue() { // While working on this, the BlockingQueue had me fooled for a bit. // The Blocking queue causes the thread to stop until there's something // in it to process. it's an on-purpose threadlock though because // without it, the clientloop will suck up all sim resources. - + SendQueue = new BlockingQueue(); - + IncomingPacketQueue = new Queue(); OutgoingPacketQueue = new Queue(); ResendOutgoingPacketQueue = new Queue(); @@ -100,7 +93,7 @@ namespace OpenSim.Region.ClientStack TaskOutgoingPacketQueue = new Queue(); TextureOutgoingPacketQueue = new Queue(); AssetOutgoingPacketQueue = new Queue(); - + // Set up the throttle classes (min, max, current) in bytes ResendThrottle = new PacketThrottle(5000, 100000, 50000); @@ -114,14 +107,13 @@ namespace OpenSim.Region.ClientStack // Number of bytes allowed to go out per second. (256kbps per client) TotalThrottle = new PacketThrottle(0, 162144, 1536000); - throttleTimer = new Timer((int)(throttletimems/throttleTimeDivisor)); + throttleTimer = new Timer((int) (throttletimems/throttleTimeDivisor)); throttleTimer.Elapsed += new ElapsedEventHandler(ThrottleTimerElapsed); throttleTimer.Start(); - + // TIMERS needed for this // LastThrottle = DateTime.Now.Ticks; // ThrottleInterval = (long)(throttletimems/throttleTimeDivisor); - } /* STANDARD QUEUE MANIPULATION INTERFACES */ @@ -129,44 +121,48 @@ namespace OpenSim.Region.ClientStack public void Enqueue(QueItem item) { - if (!m_enabled) {return;} + if (!m_enabled) + { + return; + } // We could micro lock, but that will tend to actually // probably be worse than just synchronizing on SendQueue - lock (this) { + lock (this) + { switch (item.throttleType) { - case ThrottleOutPacketType.Resend: - ThrottleCheck(ref ResendThrottle, ref ResendOutgoingPacketQueue, item); - break; - case ThrottleOutPacketType.Texture: - ThrottleCheck(ref TextureThrottle, ref TextureOutgoingPacketQueue, item); - break; - case ThrottleOutPacketType.Task: - ThrottleCheck(ref TaskThrottle, ref TaskOutgoingPacketQueue, item); - break; - case ThrottleOutPacketType.Land: - ThrottleCheck(ref LandThrottle, ref LandOutgoingPacketQueue, item); - break; - case ThrottleOutPacketType.Asset: - ThrottleCheck(ref AssetThrottle, ref AssetOutgoingPacketQueue, item); - break; - case ThrottleOutPacketType.Cloud: - ThrottleCheck(ref CloudThrottle, ref CloudOutgoingPacketQueue, item); - break; - case ThrottleOutPacketType.Wind: - ThrottleCheck(ref WindThrottle, ref WindOutgoingPacketQueue, item); - break; - - default: - // Acknowledgements and other such stuff should go directly to the blocking Queue - // Throttling them may and likely 'will' be problematic - SendQueue.Enqueue(item); - break; + case ThrottleOutPacketType.Resend: + ThrottleCheck(ref ResendThrottle, ref ResendOutgoingPacketQueue, item); + break; + case ThrottleOutPacketType.Texture: + ThrottleCheck(ref TextureThrottle, ref TextureOutgoingPacketQueue, item); + break; + case ThrottleOutPacketType.Task: + ThrottleCheck(ref TaskThrottle, ref TaskOutgoingPacketQueue, item); + break; + case ThrottleOutPacketType.Land: + ThrottleCheck(ref LandThrottle, ref LandOutgoingPacketQueue, item); + break; + case ThrottleOutPacketType.Asset: + ThrottleCheck(ref AssetThrottle, ref AssetOutgoingPacketQueue, item); + break; + case ThrottleOutPacketType.Cloud: + ThrottleCheck(ref CloudThrottle, ref CloudOutgoingPacketQueue, item); + break; + case ThrottleOutPacketType.Wind: + ThrottleCheck(ref WindThrottle, ref WindOutgoingPacketQueue, item); + break; + + default: + // Acknowledgements and other such stuff should go directly to the blocking Queue + // Throttling them may and likely 'will' be problematic + SendQueue.Enqueue(item); + break; } } } - + public QueItem Dequeue() { return SendQueue.Dequeue(); @@ -174,7 +170,8 @@ namespace OpenSim.Region.ClientStack public void Flush() { - lock(this) { + lock (this) + { while (PacketsWaiting()) { //Now comes the fun part.. we dump all our elements into m_packetQueue that we've saved up. @@ -211,7 +208,7 @@ namespace OpenSim.Region.ClientStack } } - public void Close() + public void Close() { m_enabled = false; throttleTimer.Stop(); @@ -242,22 +239,22 @@ namespace OpenSim.Region.ClientStack public void ProcessThrottle() { - // I was considering this.. Will an event fire if the thread it's on is blocked? - + // Then I figured out.. it doesn't really matter.. because this thread won't be blocked for long // The General overhead of the UDP protocol gets sent to the queue un-throttled by this // so This'll pick up about around the right time. - + int MaxThrottleLoops = 4550; // 50*7 packets can be dequeued at once. int throttleLoops = 0; - + // We're going to dequeue all of the saved up packets until // we've hit the throttle limit or there's no more packets to send - lock (this) { + lock (this) + { ResetCounters(); // MainLog.Instance.Verbose("THROTTLE", "Entering Throttle"); - while (TotalThrottle.UnderLimit() && PacketsWaiting() && + while (TotalThrottle.UnderLimit() && PacketsWaiting() && (throttleLoops <= MaxThrottleLoops)) { throttleLoops++; @@ -265,7 +262,7 @@ namespace OpenSim.Region.ClientStack if (ResendThrottle.UnderLimit() && ResendOutgoingPacketQueue.Count > 0) { QueItem qpack = ResendOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); ResendThrottle.Add(qpack.Packet.ToBytes().Length); @@ -273,7 +270,7 @@ namespace OpenSim.Region.ClientStack if (LandThrottle.UnderLimit() && LandOutgoingPacketQueue.Count > 0) { QueItem qpack = LandOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); LandThrottle.Add(qpack.Packet.ToBytes().Length); @@ -281,7 +278,7 @@ namespace OpenSim.Region.ClientStack if (WindThrottle.UnderLimit() && WindOutgoingPacketQueue.Count > 0) { QueItem qpack = WindOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); WindThrottle.Add(qpack.Packet.ToBytes().Length); @@ -289,7 +286,7 @@ namespace OpenSim.Region.ClientStack if (CloudThrottle.UnderLimit() && CloudOutgoingPacketQueue.Count > 0) { QueItem qpack = CloudOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); CloudThrottle.Add(qpack.Packet.ToBytes().Length); @@ -297,7 +294,7 @@ namespace OpenSim.Region.ClientStack if (TaskThrottle.UnderLimit() && TaskOutgoingPacketQueue.Count > 0) { QueItem qpack = TaskOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); TaskThrottle.Add(qpack.Packet.ToBytes().Length); @@ -305,7 +302,7 @@ namespace OpenSim.Region.ClientStack if (TextureThrottle.UnderLimit() && TextureOutgoingPacketQueue.Count > 0) { QueItem qpack = TextureOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); TextureThrottle.Add(qpack.Packet.ToBytes().Length); @@ -313,19 +310,18 @@ namespace OpenSim.Region.ClientStack if (AssetThrottle.UnderLimit() && AssetOutgoingPacketQueue.Count > 0) { QueItem qpack = AssetOutgoingPacketQueue.Dequeue(); - + SendQueue.Enqueue(qpack); TotalThrottle.Add(qpack.Packet.ToBytes().Length); AssetThrottle.Add(qpack.Packet.ToBytes().Length); } } // MainLog.Instance.Verbose("THROTTLE", "Processed " + throttleLoops + " packets"); - } } - + private void ThrottleTimerElapsed(object sender, ElapsedEventArgs e) - { + { // just to change the signature, and that ProcessThrottle // will be used elsewhere possibly ProcessThrottle(); @@ -339,7 +335,7 @@ namespace OpenSim.Region.ClientStack // wait for the timer to fire to put things into the // output queue - if((q.Count == 0) && (throttle.UnderLimit())) + if ((q.Count == 0) && (throttle.UnderLimit())) { Monitor.Enter(this); throttle.Add(item.Packet.ToBytes().Length); @@ -357,31 +353,39 @@ namespace OpenSim.Region.ClientStack private int ScaleThrottle(int value, int curmax, int newmax) { - return (int)(((float)value/(float)curmax) * newmax); + return (int) (((float) value/(float) curmax)*newmax); } + private byte[] GetThrottlesPacked(float multiplier) { int singlefloat = 4; - float tResend = ResendThrottle.Throttle * multiplier; - float tLand = LandThrottle.Throttle * multiplier; - float tWind = WindThrottle.Throttle * multiplier; - float tCloud = CloudThrottle.Throttle * multiplier; - float tTask = TaskThrottle.Throttle * multiplier; - float tTexture = TextureThrottle.Throttle * multiplier; - float tAsset = AssetThrottle.Throttle * multiplier; - - byte[] throttles = new byte[singlefloat * 7]; + float tResend = ResendThrottle.Throttle*multiplier; + float tLand = LandThrottle.Throttle*multiplier; + float tWind = WindThrottle.Throttle*multiplier; + float tCloud = CloudThrottle.Throttle*multiplier; + float tTask = TaskThrottle.Throttle*multiplier; + float tTexture = TextureThrottle.Throttle*multiplier; + float tAsset = AssetThrottle.Throttle*multiplier; + + byte[] throttles = new byte[singlefloat*7]; int i = 0; - Buffer.BlockCopy(BitConverter.GetBytes(tResend), 0, throttles, singlefloat * i, singlefloat); i++; - Buffer.BlockCopy(BitConverter.GetBytes(tLand), 0, throttles, singlefloat * i, singlefloat); i++; - Buffer.BlockCopy(BitConverter.GetBytes(tWind), 0, throttles, singlefloat * i, singlefloat); i++; - Buffer.BlockCopy(BitConverter.GetBytes(tCloud), 0, throttles, singlefloat * i, singlefloat); i++; - Buffer.BlockCopy(BitConverter.GetBytes(tTask), 0, throttles, singlefloat * i, singlefloat); i++; - Buffer.BlockCopy(BitConverter.GetBytes(tTexture), 0, throttles, singlefloat * i, singlefloat); i++; - Buffer.BlockCopy(BitConverter.GetBytes(tAsset), 0, throttles, singlefloat * i, singlefloat); + Buffer.BlockCopy(BitConverter.GetBytes(tResend), 0, throttles, singlefloat*i, singlefloat); + i++; + Buffer.BlockCopy(BitConverter.GetBytes(tLand), 0, throttles, singlefloat*i, singlefloat); + i++; + Buffer.BlockCopy(BitConverter.GetBytes(tWind), 0, throttles, singlefloat*i, singlefloat); + i++; + Buffer.BlockCopy(BitConverter.GetBytes(tCloud), 0, throttles, singlefloat*i, singlefloat); + i++; + Buffer.BlockCopy(BitConverter.GetBytes(tTask), 0, throttles, singlefloat*i, singlefloat); + i++; + Buffer.BlockCopy(BitConverter.GetBytes(tTexture), 0, throttles, singlefloat*i, singlefloat); + i++; + Buffer.BlockCopy(BitConverter.GetBytes(tAsset), 0, throttles, singlefloat*i, singlefloat); return throttles; } + public void SetThrottleFromClient(byte[] throttle) { int tResend = -1; @@ -401,25 +405,25 @@ namespace OpenSim.Region.ClientStack // it might be smart to do this check more often... if (!BitConverter.IsLittleEndian) for (int i = 0; i < 7; i++) - Array.Reverse(throttle, j + i * singlefloat, singlefloat); - + Array.Reverse(throttle, j + i*singlefloat, singlefloat); + // values gotten from libsecondlife.org/wiki/Throttle. Thanks MW_ // bytes // Convert to integer, since.. the full fp space isn't used. - tResend = (int)BitConverter.ToSingle(throttle, j); + tResend = (int) BitConverter.ToSingle(throttle, j); j += singlefloat; - tLand = (int)BitConverter.ToSingle(throttle, j); + tLand = (int) BitConverter.ToSingle(throttle, j); j += singlefloat; - tWind = (int)BitConverter.ToSingle(throttle, j); + tWind = (int) BitConverter.ToSingle(throttle, j); j += singlefloat; - tCloud = (int)BitConverter.ToSingle(throttle, j); + tCloud = (int) BitConverter.ToSingle(throttle, j); j += singlefloat; - tTask = (int)BitConverter.ToSingle(throttle, j); + tTask = (int) BitConverter.ToSingle(throttle, j); j += singlefloat; - tTexture = (int)BitConverter.ToSingle(throttle, j); + tTexture = (int) BitConverter.ToSingle(throttle, j); j += singlefloat; - tAsset = (int)BitConverter.ToSingle(throttle, j); - + tAsset = (int) BitConverter.ToSingle(throttle, j); + tall = tResend + tLand + tWind + tCloud + tTask + tTexture + tAsset; /* MainLog.Instance.Verbose("CLIENT", "Client AgentThrottle - Got throttle:resendbytes=" + tResend + @@ -431,13 +435,13 @@ namespace OpenSim.Region.ClientStack " Assetbytes=" + tAsset + " Allbytes=" + tall); */ - + // Total Sanity // Make sure that the client sent sane total values. - + // If the client didn't send acceptable values.... // Scale the clients values down until they are acceptable. - + if (tall <= TotalThrottle.Max) { ResendThrottle.Throttle = tResend; @@ -448,7 +452,7 @@ namespace OpenSim.Region.ClientStack TextureThrottle.Throttle = tTexture; AssetThrottle.Throttle = tAsset; TotalThrottle.Throttle = tall; - } + } else if (tall < 1) { // client is stupid, penalize him by minning everything @@ -478,4 +482,4 @@ namespace OpenSim.Region.ClientStack ResetCounters(); } } -} +} \ No newline at end of file -- cgit v1.1