From 395637acddca473380d09ba23acc3b6db0814e75 Mon Sep 17 00:00:00 2001 From: lbsa71 Date: Thu, 6 Dec 2007 14:08:22 +0000 Subject: * now the throttle timer is stopped whilst processing Queue so that it won't fire twice * started to refactored throttling method * some code convention refactorings --- OpenSim/Region/ClientStack/ClientView.cs | 572 ++++++++++++++++--------------- 1 file changed, 301 insertions(+), 271 deletions(-) (limited to 'OpenSim/Region/ClientStack/ClientView.cs') diff --git a/OpenSim/Region/ClientStack/ClientView.cs b/OpenSim/Region/ClientStack/ClientView.cs index 724fccc..415b04e 100644 --- a/OpenSim/Region/ClientStack/ClientView.cs +++ b/OpenSim/Region/ClientStack/ClientView.cs @@ -91,62 +91,62 @@ namespace OpenSim.Region.ClientStack protected AgentCircuitManager m_authenticateSessionsHandler; private Encoding enc = Encoding.ASCII; // Dead client detection vars - private Timer clientPingTimer; - private int packetsReceived = 0; - private int probesWithNoIngressPackets = 0; - private int lastPacketsReceived = 0; + private Timer m_clientPingTimer; + private int m_packetsReceived = 0; + private int m_probesWithNoIngressPackets = 0; + private int m_lastPacketsReceived = 0; // 1536000 - private int throttleOutboundMax = 1536000; // Number of bytes allowed to go out per second. (256kbps per client) + private int m_throttleOutboundMax = 1536000; // Number of bytes allowed to go out per second. (256kbps per client) // TODO: Make this variable. Lower throttle on un-ack. Raise over time? - private int bytesSent = 0; // Number of bytes sent this period + private int m_bytesSent = 0; // Number of bytes sent this period - private int throttleOutbound = 162144; // Number of bytes allowed to go out per second. (256kbps per client) + private int m_throttleOutbound = 162144; // Number of bytes allowed to go out per second. (256kbps per client) // TODO: Make this variable. Lower throttle on un-ack. Raise over time // All throttle times and number of bytes are calculated by dividing by this value // This value also determines how many times per throttletimems the timer will run // If throttleimems is 1000 ms, then the timer will fire every 1000/7 milliseconds - private int throttleTimeDivisor = 7; + private int m_throttleTimeDivisor = 7; - private int throttletimems = 1000; + private int m_throttletimems = 1000; // Maximum -per type- throttle - private int ResendthrottleMAX = 100000; - private int LandthrottleMax = 100000; - private int WindthrottleMax = 100000; - private int CloudthrottleMax = 100000; - private int TaskthrottleMax = 800000; - private int AssetthrottleMax = 800000; - private int TexturethrottleMax = 800000; + private int m_resendthrottleMAX = 100000; + private int m_landthrottleMax = 100000; + private int m_windthrottleMax = 100000; + private int m_cloudthrottleMax = 100000; + private int m_taskthrottleMax = 800000; + private int m_assetthrottleMax = 800000; + private int m_texturethrottleMax = 800000; // Minimum -per type- throttle - private int ResendthrottleMin = 5000; // setting resendmin to 0 results in mostly dropped packets - private int LandthrottleMin = 1000; - private int WindthrottleMin = 1000; - private int CloudthrottleMin = 1000; - private int TaskthrottleMin = 1000; - private int AssetthrottleMin = 1000; - private int TexturethrottleMin = 1000; + private int m_resendthrottleMin = 5000; // setting resendmin to 0 results in mostly dropped packets + private int m_landthrottleMin = 1000; + private int m_windthrottleMin = 1000; + private int m_cloudthrottleMin = 1000; + private int m_taskthrottleMin = 1000; + private int m_assetthrottleMin = 1000; + private int m_texturethrottleMin = 1000; // Sim default per-client settings. - private int ResendthrottleOutbound = 50000; - private int ResendBytesSent = 0; - private int LandthrottleOutbound = 100000; - private int LandBytesSent = 0; - private int WindthrottleOutbound = 10000; - private int WindBytesSent = 0; - private int CloudthrottleOutbound = 5000; - private int CloudBytesSent = 0; - private int TaskthrottleOutbound = 100000; - private int TaskBytesSent = 0; - private int AssetthrottleOutbound = 80000; - private int AssetBytesSent = 0; - private int TexturethrottleOutbound = 100000; - private int TextureBytesSent = 0; - - private Timer throttleTimer; + private int m_resendthrottleOutbound = 50000; + private int m_resendBytesSent = 0; + private int m_landthrottleOutbound = 100000; + private int m_landBytesSent = 0; + private int m_windthrottleOutbound = 10000; + private int m_windBytesSent = 0; + private int m_cloudthrottleOutbound = 5000; + private int m_cloudBytesSent = 0; + private int m_taskthrottleOutbound = 100000; + private int m_taskBytesSent = 0; + private int m_assetthrottleOutbound = 80000; + private int m_assetBytesSent = 0; + private int m_texturethrottleOutbound = 100000; + private int m_textureBytesSent = 0; + + private Timer m_throttleTimer; public ClientView(EndPoint remoteEP, UseCircuitCodePacket initialcirpack, ClientManager clientManager, IScene scene, AssetCache assetCache, PacketServer packServer, @@ -174,17 +174,17 @@ namespace OpenSim.Region.ClientStack // in it to process. it's an on-purpose threadlock though because // without it, the clientloop will suck up all sim resources. - PacketQueue = new BlockingQueue(); + m_packetQueue = new BlockingQueue(); - IncomingPacketQueue = new Queue(); - OutgoingPacketQueue = new Queue(); - ResendOutgoingPacketQueue = new Queue(); - LandOutgoingPacketQueue = new Queue(); - WindOutgoingPacketQueue = new Queue(); - CloudOutgoingPacketQueue = new Queue(); - TaskOutgoingPacketQueue = new Queue(); - TextureOutgoingPacketQueue = new Queue(); - AssetOutgoingPacketQueue = new Queue(); + m_incomingPacketQueue = new Queue(); + m_outgoingPacketQueue = new Queue(); + m_resendOutgoingPacketQueue = new Queue(); + m_landOutgoingPacketQueue = new Queue(); + m_windOutgoingPacketQueue = new Queue(); + m_cloudOutgoingPacketQueue = new Queue(); + m_taskOutgoingPacketQueue = new Queue(); + m_textureOutgoingPacketQueue = new Queue(); + m_assetOutgoingPacketQueue = new Queue(); //this.UploadAssets = new AgentAssetUpload(this, m_assetCache, m_inventoryCache); @@ -192,9 +192,9 @@ namespace OpenSim.Region.ClientStack AckTimer.Elapsed += new ElapsedEventHandler(AckTimer_Elapsed); AckTimer.Start(); - throttleTimer = new Timer((int)(throttletimems/throttleTimeDivisor)); - throttleTimer.Elapsed += new ElapsedEventHandler(throttleTimer_Elapsed); - throttleTimer.Start(); + m_throttleTimer = new Timer((int)(m_throttletimems/m_throttleTimeDivisor)); + m_throttleTimer.Elapsed += throttleTimer_Elapsed; + m_throttleTimer.Start(); RegisterLocalPacketHandlers(); @@ -205,14 +205,24 @@ namespace OpenSim.Region.ClientStack void throttleTimer_Elapsed(object sender, ElapsedEventArgs e) { - bytesSent = 0; - ResendBytesSent = 0; - LandBytesSent = 0; - WindBytesSent = 0; - CloudBytesSent = 0; - TaskBytesSent = 0; - AssetBytesSent = 0; - TextureBytesSent = 0; + // We need to stop the timer so that another timer event won't cause queue races. + m_throttleTimer.Stop(); + + ProcessThrottleQueues(); + + m_throttleTimer.Start(); + } + + private void ProcessThrottleQueues() + { + m_bytesSent = 0; + m_resendBytesSent = 0; + m_landBytesSent = 0; + m_windBytesSent = 0; + m_cloudBytesSent = 0; + m_taskBytesSent = 0; + m_assetBytesSent = 0; + m_textureBytesSent = 0; // I was considering this.. Will an event fire if the thread it's on is blocked? @@ -225,76 +235,96 @@ namespace OpenSim.Region.ClientStack // 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 - while ((bytesSent <= ((int)(throttleOutbound/throttleTimeDivisor)) && - (ResendOutgoingPacketQueue.Count > 0 || - LandOutgoingPacketQueue.Count > 0 || - WindOutgoingPacketQueue.Count > 0 || - CloudOutgoingPacketQueue.Count > 0 || - TaskOutgoingPacketQueue.Count > 0 || - AssetOutgoingPacketQueue.Count > 0 || - TextureOutgoingPacketQueue.Count > 0)) && throttleLoops <= MaxThrottleLoops) + + + + while (TimeToDequeue( m_bytesSent, m_throttleOutbound ) && + (m_resendOutgoingPacketQueue.Count > 0 || + m_landOutgoingPacketQueue.Count > 0 || + m_windOutgoingPacketQueue.Count > 0 || + m_cloudOutgoingPacketQueue.Count > 0 || + m_taskOutgoingPacketQueue.Count > 0 || + m_assetOutgoingPacketQueue.Count > 0 || + m_textureOutgoingPacketQueue.Count > 0) && ( throttleLoops <= MaxThrottleLoops)) { throttleLoops++; //Now comes the fun part.. we dump all our elements into PacketQueue that we've saved up. - if (ResendBytesSent <= ((int)(ResendthrottleOutbound/throttleTimeDivisor)) && ResendOutgoingPacketQueue.Count > 0) - { - QueItem qpack = ResendOutgoingPacketQueue.Dequeue(); - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - ResendBytesSent += qpack.Packet.ToBytes().Length; - } - if (LandBytesSent <= ((int)(LandthrottleOutbound/throttleTimeDivisor)) && LandOutgoingPacketQueue.Count > 0) + if (TimeToDequeue(m_resendBytesSent, m_resendthrottleOutbound)) { - QueItem qpack = LandOutgoingPacketQueue.Dequeue(); + m_resendBytesSent += ProcessQueue(m_resendOutgoingPacketQueue); + } - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - LandBytesSent += qpack.Packet.ToBytes().Length; + if (TimeToDequeue(m_landBytesSent, m_landthrottleOutbound)) + { + m_landBytesSent += ProcessQueue(m_landOutgoingPacketQueue); } - if (WindBytesSent <= ((int)(WindthrottleOutbound/throttleTimeDivisor)) && WindOutgoingPacketQueue.Count > 0) + + // -- TODO: Well, do the same for the rest of them + + if (m_windBytesSent <= ((int)(m_windthrottleOutbound/m_throttleTimeDivisor)) && m_windOutgoingPacketQueue.Count > 0) { - QueItem qpack = WindOutgoingPacketQueue.Dequeue(); + QueItem qpack = m_windOutgoingPacketQueue.Dequeue(); - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - WindBytesSent += qpack.Packet.ToBytes().Length; + m_packetQueue.Enqueue(qpack); + m_bytesSent += qpack.Packet.ToBytes().Length; + m_windBytesSent += qpack.Packet.ToBytes().Length; } - if (CloudBytesSent <= ((int)(CloudthrottleOutbound/throttleTimeDivisor)) && CloudOutgoingPacketQueue.Count > 0) + if (m_cloudBytesSent <= ((int)(m_cloudthrottleOutbound/m_throttleTimeDivisor)) && m_cloudOutgoingPacketQueue.Count > 0) { - QueItem qpack = CloudOutgoingPacketQueue.Dequeue(); + QueItem qpack = m_cloudOutgoingPacketQueue.Dequeue(); - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - CloudBytesSent += qpack.Packet.ToBytes().Length; + m_packetQueue.Enqueue(qpack); + m_bytesSent += qpack.Packet.ToBytes().Length; + m_cloudBytesSent += qpack.Packet.ToBytes().Length; } - if (TaskBytesSent <= ((int)(TaskthrottleOutbound/throttleTimeDivisor)) && TaskOutgoingPacketQueue.Count > 0) + if (m_taskBytesSent <= ((int)(m_taskthrottleOutbound/m_throttleTimeDivisor)) && m_taskOutgoingPacketQueue.Count > 0) { - QueItem qpack = TaskOutgoingPacketQueue.Dequeue(); + QueItem qpack = m_taskOutgoingPacketQueue.Dequeue(); - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - TaskBytesSent += qpack.Packet.ToBytes().Length; + m_packetQueue.Enqueue(qpack); + m_bytesSent += qpack.Packet.ToBytes().Length; + m_taskBytesSent += qpack.Packet.ToBytes().Length; } - if (TextureBytesSent <= ((int)(TexturethrottleOutbound/throttleTimeDivisor)) && TextureOutgoingPacketQueue.Count > 0) + if (m_textureBytesSent <= ((int)(m_texturethrottleOutbound/m_throttleTimeDivisor)) && m_textureOutgoingPacketQueue.Count > 0) { - QueItem qpack = TextureOutgoingPacketQueue.Dequeue(); + QueItem qpack = m_textureOutgoingPacketQueue.Dequeue(); - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - TextureBytesSent += qpack.Packet.ToBytes().Length; + m_packetQueue.Enqueue(qpack); + m_bytesSent += qpack.Packet.ToBytes().Length; + m_textureBytesSent += qpack.Packet.ToBytes().Length; } - if (AssetBytesSent <= ((int)(AssetthrottleOutbound/throttleTimeDivisor)) && AssetOutgoingPacketQueue.Count > 0) + if (m_assetBytesSent <= ((int)(m_assetthrottleOutbound/m_throttleTimeDivisor)) && m_assetOutgoingPacketQueue.Count > 0) { - QueItem qpack = AssetOutgoingPacketQueue.Dequeue(); + QueItem qpack = m_assetOutgoingPacketQueue.Dequeue(); - PacketQueue.Enqueue(qpack); - bytesSent += qpack.Packet.ToBytes().Length; - AssetBytesSent += qpack.Packet.ToBytes().Length; + m_packetQueue.Enqueue(qpack); + m_bytesSent += qpack.Packet.ToBytes().Length; + m_assetBytesSent += qpack.Packet.ToBytes().Length; } } + } + + private int ProcessQueue(Queue queue) + { + if (queue.Count > 0) + { + QueItem qpack = queue.Dequeue(); + + m_packetQueue.Enqueue(qpack); + int packLength = qpack.Packet.ToBytes().Length; + + m_bytesSent += packLength; + return packLength; + } + return 0; + } + + private bool TimeToDequeue(int bytesSent, int outboundThrottle) + { + return bytesSent <= ((int)(outboundThrottle / m_throttleTimeDivisor)); } public LLUUID SessionId @@ -311,7 +341,7 @@ namespace OpenSim.Region.ClientStack public void Close() { - clientPingTimer.Stop(); + m_clientPingTimer.Stop(); m_scene.RemoveClient(AgentId); @@ -333,7 +363,7 @@ namespace OpenSim.Region.ClientStack } public void Stop() { - clientPingTimer.Stop(); + m_clientPingTimer.Stop(); libsecondlife.Packets.DisableSimulatorPacket disable = new libsecondlife.Packets.DisableSimulatorPacket(); OutPacket(disable, ThrottleOutPacketType.Task); @@ -434,7 +464,7 @@ namespace OpenSim.Region.ClientStack MainLog.Instance.Verbose("CLIENT", "Entered loop"); while (true) { - QueItem nextPacket = PacketQueue.Dequeue(); + QueItem nextPacket = m_packetQueue.Dequeue(); if (nextPacket.Incoming) { queuedLast = false; @@ -442,7 +472,7 @@ namespace OpenSim.Region.ClientStack //is a incoming packet if (nextPacket.Packet.Type != PacketType.AgentUpdate) { - packetsReceived++; + m_packetsReceived++; } DebugPacket("IN", nextPacket.Packet); ProcessInPacket(nextPacket.Packet); @@ -450,9 +480,9 @@ namespace OpenSim.Region.ClientStack else { // Throw it back on the queue if it's going to cause us to flood the client - if (bytesSent > throttleOutboundMax) + if (m_bytesSent > m_throttleOutboundMax) { - PacketQueue.Enqueue(nextPacket); + m_packetQueue.Enqueue(nextPacket); MainLog.Instance.Verbose("THROTTLE", "Client over throttle limit, requeuing packet"); if (queuedLast) @@ -471,7 +501,7 @@ namespace OpenSim.Region.ClientStack //Don't throttle AvatarPickerReplies!, they return a null .ToBytes()! if (nextPacket.Packet.Type != PacketType.AvatarPickerReply) - bytesSent += nextPacket.Packet.ToBytes().Length; + m_bytesSent += nextPacket.Packet.ToBytes().Length; //is a out going packet @@ -487,10 +517,10 @@ namespace OpenSim.Region.ClientStack protected void CheckClientConnectivity(object sender, ElapsedEventArgs e) { - if (packetsReceived == lastPacketsReceived) + if (m_packetsReceived == m_lastPacketsReceived) { - probesWithNoIngressPackets++; - if (probesWithNoIngressPackets > 30) + m_probesWithNoIngressPackets++; + if (m_probesWithNoIngressPackets > 30) { if (OnConnectionClosed != null) { @@ -506,8 +536,8 @@ namespace OpenSim.Region.ClientStack else { // Something received in the meantime - we can reset the counters - probesWithNoIngressPackets = 0; - lastPacketsReceived = packetsReceived; + m_probesWithNoIngressPackets = 0; + m_lastPacketsReceived = m_packetsReceived; } } @@ -515,9 +545,9 @@ namespace OpenSim.Region.ClientStack protected virtual void InitNewClient() { - clientPingTimer = new Timer(5000); - clientPingTimer.Elapsed += new ElapsedEventHandler(CheckClientConnectivity); - clientPingTimer.Enabled = true; + m_clientPingTimer = new Timer(5000); + m_clientPingTimer.Elapsed += new ElapsedEventHandler(CheckClientConnectivity); + m_clientPingTimer.Enabled = true; MainLog.Instance.Verbose("CLIENT", "Adding viewer agent to scene"); m_scene.AddNewClient(this, true); @@ -2203,20 +2233,20 @@ namespace OpenSim.Region.ClientStack } // Previously ClientView.PacketQueue - protected BlockingQueue PacketQueue; + protected BlockingQueue m_packetQueue; - protected Queue IncomingPacketQueue; - protected Queue OutgoingPacketQueue; - protected Queue ResendOutgoingPacketQueue; - protected Queue LandOutgoingPacketQueue; - protected Queue WindOutgoingPacketQueue; - protected Queue CloudOutgoingPacketQueue; - protected Queue TaskOutgoingPacketQueue; - protected Queue TextureOutgoingPacketQueue; - protected Queue AssetOutgoingPacketQueue; + protected Queue m_incomingPacketQueue; + protected Queue m_outgoingPacketQueue; + protected Queue m_resendOutgoingPacketQueue; + protected Queue m_landOutgoingPacketQueue; + protected Queue m_windOutgoingPacketQueue; + protected Queue m_cloudOutgoingPacketQueue; + protected Queue m_taskOutgoingPacketQueue; + protected Queue m_textureOutgoingPacketQueue; + protected Queue m_assetOutgoingPacketQueue; - protected Dictionary PendingAcks = new Dictionary(); - protected Dictionary NeedAck = new Dictionary(); + protected Dictionary m_pendingAcks = new Dictionary(); + protected Dictionary m_needAck = new Dictionary(); protected Timer AckTimer; protected uint Sequence = 0; @@ -2258,13 +2288,13 @@ namespace OpenSim.Region.ClientStack protected void AddAck(Packet Pack) { - lock (NeedAck) + lock (m_needAck) { - if (!NeedAck.ContainsKey(Pack.Header.Sequence)) + if (!m_needAck.ContainsKey(Pack.Header.Sequence)) { try { - NeedAck.Add(Pack.Header.Sequence, Pack); + m_needAck.Add(Pack.Header.Sequence, Pack); } catch (Exception e) // HACKY { @@ -2278,7 +2308,7 @@ namespace OpenSim.Region.ClientStack else { // Client.Log("Attempted to add a duplicate sequence number (" + - // packet.Header.Sequence + ") to the NeedAck dictionary for packet type " + + // packet.Header.Sequence + ") to the m_needAck dictionary for packet type " + // packet.Type.ToString(), Helpers.LogLevel.Warning); } } @@ -2287,21 +2317,21 @@ namespace OpenSim.Region.ClientStack protected virtual void SetPendingAcks(ref Packet Pack) { // Append any ACKs that need to be sent out to this packet - lock (PendingAcks) + lock (m_pendingAcks) { // TODO: If we are over MAX_APPENDED_ACKS we should drain off some of these - if (PendingAcks.Count > 0 && PendingAcks.Count < MAX_APPENDED_ACKS) + if (m_pendingAcks.Count > 0 && m_pendingAcks.Count < MAX_APPENDED_ACKS) { - Pack.Header.AckList = new uint[PendingAcks.Count]; + Pack.Header.AckList = new uint[m_pendingAcks.Count]; int i = 0; - foreach (uint ack in PendingAcks.Values) + foreach (uint ack in m_pendingAcks.Values) { Pack.Header.AckList[i] = ack; i++; } - PendingAcks.Clear(); + m_pendingAcks.Clear(); Pack.Header.AppendedAcks = true; } } @@ -2357,11 +2387,11 @@ namespace OpenSim.Region.ClientStack // Handle appended ACKs if (NewPack.Header.AppendedAcks) { - lock (NeedAck) + lock (m_needAck) { foreach (uint ack in NewPack.Header.AckList) { - NeedAck.Remove(ack); + m_needAck.Remove(ack); } } } @@ -2371,11 +2401,11 @@ namespace OpenSim.Region.ClientStack { PacketAckPacket ackPacket = (PacketAckPacket) NewPack; - lock (NeedAck) + lock (m_needAck) { foreach (PacketAckPacket.PacketsBlock block in ackPacket.Packets) { - NeedAck.Remove(block.ID); + m_needAck.Remove(block.ID); } } } @@ -2392,7 +2422,7 @@ namespace OpenSim.Region.ClientStack QueItem item = new QueItem(); item.Packet = NewPack; item.Incoming = true; - PacketQueue.Enqueue(item); + m_packetQueue.Enqueue(item); } } @@ -2404,11 +2434,11 @@ namespace OpenSim.Region.ClientStack // wait for the timer to fire to put things into the // output queue - if((q.Count == 0) && (TypeBytesSent <= ((int)(Throttle / throttleTimeDivisor)))) + if((q.Count == 0) && (TypeBytesSent <= ((int)(Throttle / m_throttleTimeDivisor)))) { - bytesSent += item.Packet.ToBytes().Length; + m_bytesSent += item.Packet.ToBytes().Length; TypeBytesSent += item.Packet.ToBytes().Length; - PacketQueue.Enqueue(item); + m_packetQueue.Enqueue(item); } else { @@ -2428,34 +2458,34 @@ namespace OpenSim.Region.ClientStack switch (throttlePacketType) { case ThrottleOutPacketType.Resend: - ThrottleCheck(ref ResendBytesSent, ResendthrottleOutbound, ref ResendOutgoingPacketQueue, item); + ThrottleCheck(ref m_resendBytesSent, m_resendthrottleOutbound, ref m_resendOutgoingPacketQueue, item); break; case ThrottleOutPacketType.Texture: - ThrottleCheck(ref TextureBytesSent, TexturethrottleOutbound, ref TextureOutgoingPacketQueue, item); + ThrottleCheck(ref m_textureBytesSent, m_texturethrottleOutbound, ref m_textureOutgoingPacketQueue, item); break; case ThrottleOutPacketType.Task: - ThrottleCheck(ref TaskBytesSent, TaskthrottleOutbound, ref TaskOutgoingPacketQueue, item); + ThrottleCheck(ref m_taskBytesSent, m_taskthrottleOutbound, ref m_taskOutgoingPacketQueue, item); break; case ThrottleOutPacketType.Land: - ThrottleCheck(ref LandBytesSent, LandthrottleOutbound, ref LandOutgoingPacketQueue, item); + ThrottleCheck(ref m_landBytesSent, m_landthrottleOutbound, ref m_landOutgoingPacketQueue, item); break; case ThrottleOutPacketType.Asset: - ThrottleCheck(ref AssetBytesSent, AssetthrottleOutbound, ref AssetOutgoingPacketQueue, item); + ThrottleCheck(ref m_assetBytesSent, m_assetthrottleOutbound, ref m_assetOutgoingPacketQueue, item); break; case ThrottleOutPacketType.Cloud: - ThrottleCheck(ref CloudBytesSent, CloudthrottleOutbound, ref CloudOutgoingPacketQueue, item); + ThrottleCheck(ref m_cloudBytesSent, m_cloudthrottleOutbound, ref m_cloudOutgoingPacketQueue, item); break; case ThrottleOutPacketType.Wind: - ThrottleCheck(ref WindBytesSent, WindthrottleOutbound, ref WindOutgoingPacketQueue, item); + ThrottleCheck(ref m_windBytesSent, m_windthrottleOutbound, ref m_windOutgoingPacketQueue, item); break; default: // Acknowledgements and other such stuff should go directly to the blocking Queue // Throttling them may and likely 'will' be problematic - PacketQueue.Enqueue(item); + m_packetQueue.Enqueue(item); break; } - //OutgoingPacketQueue.Enqueue(item); + //m_outgoingPacketQueue.Enqueue(item); } # region Low Level Packet Methods @@ -2475,10 +2505,10 @@ namespace OpenSim.Region.ClientStack /* if (Pack.Header.Reliable) { - lock (PendingAcks) + lock (m_pendingAcks) { uint sequence = (uint)Pack.Header.Sequence; - if (!PendingAcks.ContainsKey(sequence)) { PendingAcks[sequence] = sequence; } + if (!m_pendingAcks.ContainsKey(sequence)) { m_pendingAcks[sequence] = sequence; } } }*/ } @@ -2487,9 +2517,9 @@ namespace OpenSim.Region.ClientStack { int now = System.Environment.TickCount; - lock (NeedAck) + lock (m_needAck) { - foreach (Packet packet in NeedAck.Values) + foreach (Packet packet in m_needAck.Values) { if ((now - packet.TickCount > RESEND_TIMEOUT) && (!packet.Header.Resent)) { @@ -2505,11 +2535,11 @@ namespace OpenSim.Region.ClientStack protected void SendAcks() { - lock (PendingAcks) + lock (m_pendingAcks) { - if (PendingAcks.Count > 0) + if (m_pendingAcks.Count > 0) { - if (PendingAcks.Count > 250) + if (m_pendingAcks.Count > 250) { // FIXME: Handle the odd case where we have too many pending ACKs queued up MainLog.Instance.Verbose("NETWORK", "Too many ACKs queued up!"); @@ -2520,9 +2550,9 @@ namespace OpenSim.Region.ClientStack int i = 0; PacketAckPacket acks = new PacketAckPacket(); - acks.Packets = new PacketAckPacket.PacketsBlock[PendingAcks.Count]; + acks.Packets = new PacketAckPacket.PacketsBlock[m_pendingAcks.Count]; - foreach (uint ack in PendingAcks.Values) + foreach (uint ack in m_pendingAcks.Values) { acks.Packets[i] = new PacketAckPacket.PacketsBlock(); acks.Packets[i].ID = ack; @@ -2532,7 +2562,7 @@ namespace OpenSim.Region.ClientStack acks.Header.Reliable = false; OutPacket(acks, ThrottleOutPacketType.Unknown); - PendingAcks.Clear(); + m_pendingAcks.Clear(); } } } @@ -3388,7 +3418,7 @@ namespace OpenSim.Region.ClientStack // If the client didn't send acceptable values.... // Scale the clients values down until they are acceptable. - if (tall <= throttleOutboundMax) + if (tall <= m_throttleOutboundMax) { // Sanity // Making sure the client sends sane values @@ -3397,61 +3427,61 @@ namespace OpenSim.Region.ClientStack // Then Check Min of type // Resend throttle - if (tResend <= ResendthrottleMAX) - ResendthrottleOutbound = tResend; + if (tResend <= m_resendthrottleMAX) + m_resendthrottleOutbound = tResend; - if (tResend < ResendthrottleMin) - ResendthrottleOutbound = ResendthrottleMin; + if (tResend < m_resendthrottleMin) + m_resendthrottleOutbound = m_resendthrottleMin; // Land throttle - if (tLand <= LandthrottleMax) - LandthrottleOutbound = tLand; + if (tLand <= m_landthrottleMax) + m_landthrottleOutbound = tLand; - if (tLand < LandthrottleMin) - LandthrottleOutbound = LandthrottleMin; + if (tLand < m_landthrottleMin) + m_landthrottleOutbound = m_landthrottleMin; // Wind throttle - if (tWind <= WindthrottleMax) - WindthrottleOutbound = tWind; + if (tWind <= m_windthrottleMax) + m_windthrottleOutbound = tWind; - if (tWind < WindthrottleMin) - WindthrottleOutbound = WindthrottleMin; + if (tWind < m_windthrottleMin) + m_windthrottleOutbound = m_windthrottleMin; // Cloud throttle - if (tCloud <= CloudthrottleMax) - CloudthrottleOutbound = tCloud; + if (tCloud <= m_cloudthrottleMax) + m_cloudthrottleOutbound = tCloud; - if (tCloud < CloudthrottleMin) - CloudthrottleOutbound = CloudthrottleMin; + if (tCloud < m_cloudthrottleMin) + m_cloudthrottleOutbound = m_cloudthrottleMin; // Task throttle - if (tTask <= TaskthrottleMax) - TaskthrottleOutbound = tTask; + if (tTask <= m_taskthrottleMax) + m_taskthrottleOutbound = tTask; - if (tTask < TaskthrottleMin) - TaskthrottleOutbound = TaskthrottleMin; + if (tTask < m_taskthrottleMin) + m_taskthrottleOutbound = m_taskthrottleMin; // Texture throttle - if (tTexture <= TexturethrottleMax) - TexturethrottleOutbound = tTexture; + if (tTexture <= m_texturethrottleMax) + m_texturethrottleOutbound = tTexture; - if (tTexture < TexturethrottleMin) - TexturethrottleOutbound = TexturethrottleMin; + if (tTexture < m_texturethrottleMin) + m_texturethrottleOutbound = m_texturethrottleMin; //Asset throttle - if (tAsset <= AssetthrottleMax) - AssetthrottleOutbound = tAsset; - - if (tAsset < AssetthrottleMin) - AssetthrottleOutbound = AssetthrottleMin; - - /* MainLog.Instance.Verbose("THROTTLE", "Using:resendbytes=" + ResendthrottleOutbound + - " landbytes=" + LandthrottleOutbound + - " windbytes=" + WindthrottleOutbound + - " cloudbytes=" + CloudthrottleOutbound + - " taskbytes=" + TaskthrottleOutbound + - " texturebytes=" + TexturethrottleOutbound + - " Assetbytes=" + AssetthrottleOutbound + + if (tAsset <= m_assetthrottleMax) + m_assetthrottleOutbound = tAsset; + + if (tAsset < m_assetthrottleMin) + m_assetthrottleOutbound = m_assetthrottleMin; + + /* MainLog.Instance.Verbose("THROTTLE", "Using:resendbytes=" + m_resendthrottleOutbound + + " landbytes=" + m_landthrottleOutbound + + " windbytes=" + m_windthrottleOutbound + + " cloudbytes=" + m_cloudthrottleOutbound + + " taskbytes=" + m_taskthrottleOutbound + + " texturebytes=" + m_texturethrottleOutbound + + " Assetbytes=" + m_assetthrottleOutbound + " Allbytes=" + tall); */ } @@ -3471,23 +3501,23 @@ namespace OpenSim.Region.ClientStack // it's client recommended level (won't scale it down) // unless it's beyond sane values itself. - if (tResend <= ResendthrottleMAX) + if (tResend <= m_resendthrottleMAX) { // This is nexted because we only want to re-set the values // the packet throttler uses once. - if (tResend >= ResendthrottleMin) + if (tResend >= m_resendthrottleMin) { - ResendthrottleOutbound = tResend; + m_resendthrottleOutbound = tResend; } else { - ResendthrottleOutbound = ResendthrottleMin; + m_resendthrottleOutbound = m_resendthrottleMin; } } else { - ResendthrottleOutbound = ResendthrottleMAX; + m_resendthrottleOutbound = m_resendthrottleMAX; } @@ -3502,12 +3532,12 @@ namespace OpenSim.Region.ClientStack // Okay.. now we've got the percentages of total communication. // Apply them to a new max total - int tLandResult = (int)(LandPercent * throttleOutboundMax); - int tWindResult = (int)(WindPercent * throttleOutboundMax); - int tCloudResult = (int)(CloudPercent * throttleOutboundMax); - int tTaskResult = (int)(TaskPercent * throttleOutboundMax); - int tTextureResult = (int)(TexturePercent * throttleOutboundMax); - int tAssetResult = (int)(AssetPercent * throttleOutboundMax); + int tLandResult = (int)(LandPercent * m_throttleOutboundMax); + int tWindResult = (int)(WindPercent * m_throttleOutboundMax); + int tCloudResult = (int)(CloudPercent * m_throttleOutboundMax); + int tTaskResult = (int)(TaskPercent * m_throttleOutboundMax); + int tTextureResult = (int)(TexturePercent * m_throttleOutboundMax); + int tAssetResult = (int)(AssetPercent * m_throttleOutboundMax); // Now we have to check our scaled values for sanity @@ -3515,54 +3545,54 @@ namespace OpenSim.Region.ClientStack // Then Check Min of type // Land throttle - if (tLandResult <= LandthrottleMax) - LandthrottleOutbound = tLandResult; + if (tLandResult <= m_landthrottleMax) + m_landthrottleOutbound = tLandResult; - if (tLandResult < LandthrottleMin) - LandthrottleOutbound = LandthrottleMin; + if (tLandResult < m_landthrottleMin) + m_landthrottleOutbound = m_landthrottleMin; // Wind throttle - if (tWindResult <= WindthrottleMax) - WindthrottleOutbound = tWindResult; + if (tWindResult <= m_windthrottleMax) + m_windthrottleOutbound = tWindResult; - if (tWindResult < WindthrottleMin) - WindthrottleOutbound = WindthrottleMin; + if (tWindResult < m_windthrottleMin) + m_windthrottleOutbound = m_windthrottleMin; // Cloud throttle - if (tCloudResult <= CloudthrottleMax) - CloudthrottleOutbound = tCloudResult; + if (tCloudResult <= m_cloudthrottleMax) + m_cloudthrottleOutbound = tCloudResult; - if (tCloudResult < CloudthrottleMin) - CloudthrottleOutbound = CloudthrottleMin; + if (tCloudResult < m_cloudthrottleMin) + m_cloudthrottleOutbound = m_cloudthrottleMin; // Task throttle - if (tTaskResult <= TaskthrottleMax) - TaskthrottleOutbound = tTaskResult; + if (tTaskResult <= m_taskthrottleMax) + m_taskthrottleOutbound = tTaskResult; - if (tTaskResult < TaskthrottleMin) - TaskthrottleOutbound = TaskthrottleMin; + if (tTaskResult < m_taskthrottleMin) + m_taskthrottleOutbound = m_taskthrottleMin; // Texture throttle - if (tTextureResult <= TexturethrottleMax) - TexturethrottleOutbound = tTextureResult; + if (tTextureResult <= m_texturethrottleMax) + m_texturethrottleOutbound = tTextureResult; - if (tTextureResult < TexturethrottleMin) - TexturethrottleOutbound = TexturethrottleMin; + if (tTextureResult < m_texturethrottleMin) + m_texturethrottleOutbound = m_texturethrottleMin; //Asset throttle - if (tAssetResult <= AssetthrottleMax) - AssetthrottleOutbound = tAssetResult; - - if (tAssetResult < AssetthrottleMin) - AssetthrottleOutbound = AssetthrottleMin; - - /* MainLog.Instance.Verbose("THROTTLE", "Using:resendbytes=" + ResendthrottleOutbound + - " landbytes=" + LandthrottleOutbound + - " windbytes=" + WindthrottleOutbound + - " cloudbytes=" + CloudthrottleOutbound + - " taskbytes=" + TaskthrottleOutbound + - " texturebytes=" + TexturethrottleOutbound + - " Assetbytes=" + AssetthrottleOutbound + + if (tAssetResult <= m_assetthrottleMax) + m_assetthrottleOutbound = tAssetResult; + + if (tAssetResult < m_assetthrottleMin) + m_assetthrottleOutbound = m_assetthrottleMin; + + /* MainLog.Instance.Verbose("THROTTLE", "Using:resendbytes=" + m_resendthrottleOutbound + + " landbytes=" + m_landthrottleOutbound + + " windbytes=" + m_windthrottleOutbound + + " cloudbytes=" + m_cloudthrottleOutbound + + " taskbytes=" + m_taskthrottleOutbound + + " texturebytes=" + m_texturethrottleOutbound + + " Assetbytes=" + m_assetthrottleOutbound + " Allbytes=" + tall); */ } @@ -3570,20 +3600,20 @@ namespace OpenSim.Region.ClientStack { // The client sent a stupid value.. // We're going to set the throttles to the minimum possible - ResendthrottleOutbound = ResendthrottleMin; - LandthrottleOutbound = LandthrottleMin; - WindthrottleOutbound = WindthrottleMin; - CloudthrottleOutbound = CloudthrottleMin; - TaskthrottleOutbound = TaskthrottleMin; - TexturethrottleOutbound = TexturethrottleMin; - AssetthrottleOutbound = AssetthrottleMin; - MainLog.Instance.Verbose("THROTTLE", "ClientSentBadThrottle Using:resendbytes=" + ResendthrottleOutbound + - " landbytes=" + LandthrottleOutbound + - " windbytes=" + WindthrottleOutbound + - " cloudbytes=" + CloudthrottleOutbound + - " taskbytes=" + TaskthrottleOutbound + - " texturebytes=" + TexturethrottleOutbound + - " Assetbytes=" + AssetthrottleOutbound + + m_resendthrottleOutbound = m_resendthrottleMin; + m_landthrottleOutbound = m_landthrottleMin; + m_windthrottleOutbound = m_windthrottleMin; + m_cloudthrottleOutbound = m_cloudthrottleMin; + m_taskthrottleOutbound = m_taskthrottleMin; + m_texturethrottleOutbound = m_texturethrottleMin; + m_assetthrottleOutbound = m_assetthrottleMin; + MainLog.Instance.Verbose("THROTTLE", "ClientSentBadThrottle Using:resendbytes=" + m_resendthrottleOutbound + + " landbytes=" + m_landthrottleOutbound + + " windbytes=" + m_windthrottleOutbound + + " cloudbytes=" + m_cloudthrottleOutbound + + " taskbytes=" + m_taskthrottleOutbound + + " texturebytes=" + m_texturethrottleOutbound + + " Assetbytes=" + m_assetthrottleOutbound + " Allbytes=" + tall); } } @@ -3591,13 +3621,13 @@ namespace OpenSim.Region.ClientStack // This has the effect of 'wiggling the slider // causes prim and stuck textures that didn't download to download - ResendBytesSent = 0; - LandBytesSent = 0; - WindBytesSent = 0; - CloudBytesSent = 0; - TaskBytesSent = 0; - AssetBytesSent = 0; - TextureBytesSent = 0; + m_resendBytesSent = 0; + m_landBytesSent = 0; + m_windBytesSent = 0; + m_cloudBytesSent = 0; + m_taskBytesSent = 0; + m_assetBytesSent = 0; + m_textureBytesSent = 0; //Yay, we've finally handled the agent Throttle packet! break; -- cgit v1.1