public LLPacketQueue(UUID agentId, ClientStackUserSettings userSettings)
{
// 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 OpenSim.Framework.BlockingQueue<LLQueItem>();
IncomingPacketQueue = new Queue<LLQueItem>();
OutgoingPacketQueue = new Queue<LLQueItem>();
ResendOutgoingPacketQueue = new Queue<LLQueItem>();
LandOutgoingPacketQueue = new Queue<LLQueItem>();
WindOutgoingPacketQueue = new Queue<LLQueItem>();
CloudOutgoingPacketQueue = new Queue<LLQueItem>();
TaskOutgoingPacketQueue = new Queue<LLQueItem>();
TaskLowpriorityPacketQueue = new Queue<LLQueItem>();
TextureOutgoingPacketQueue = new Queue<LLQueItem>();
AssetOutgoingPacketQueue = new Queue<LLQueItem>();
// Store the throttle multiplier for posterity.
throttleMultiplier = userSettings.ClientThrottleMultipler;
// Set up the throttle classes (min, max, current) in bits per second
ResendThrottle = new LLPacketThrottle(5000, 100000, 16000, userSettings.ClientThrottleMultipler);
LandThrottle = new LLPacketThrottle(1000, 100000, 2000, userSettings.ClientThrottleMultipler);
WindThrottle = new LLPacketThrottle(0, 100000, 0, userSettings.ClientThrottleMultipler);
CloudThrottle = new LLPacketThrottle(0, 100000, 0, userSettings.ClientThrottleMultipler);
TaskThrottle = new LLPacketThrottle(1000, 800000, 3000, userSettings.ClientThrottleMultipler);
AssetThrottle = new LLPacketThrottle(1000, 800000, 1000, userSettings.ClientThrottleMultipler);
TextureThrottle = new LLPacketThrottle(1000, 800000, 4000, userSettings.ClientThrottleMultipler);
// Total Throttle trumps all - it is the number of bits in total that are allowed to go out per second.
ThrottleSettings totalThrottleSettings = userSettings.TotalThrottleSettings;
if (null == totalThrottleSettings)
{
totalThrottleSettings = new ThrottleSettings(0, 1500000, 28000);
}
TotalThrottle
= new LLPacketThrottle(
totalThrottleSettings.Min, totalThrottleSettings.Max, totalThrottleSettings.Current,
userSettings.ClientThrottleMultipler);
throttleTimer = new Timer((int) (throttletimems/throttleTimeDivisor));
throttleTimer.Elapsed += ThrottleTimerElapsed;
throttleTimer.Start();
// TIMERS needed for this
// LastThrottle = DateTime.Now.Ticks;
// ThrottleInterval = (long)(throttletimems/throttleTimeDivisor);
m_agentId = agentId;
if (StatsManager.SimExtraStats != null)
{
StatsManager.SimExtraStats.RegisterPacketQueueStatsProvider(m_agentId, this);
}
}
public void OnMouseMoving(object sender, MouseEventArgs e)
{
if (_destroyed)
{
return;
}
// TODO: REVIEW THIS
// Per MSDN:
// if the system runs continuously, TickCount will increment from zero to Int32.MaxValue for approximately 24.9 days,
// then jump to Int32.MinValue, which is a negative number, then increment back to zero during the next 24.9 days.
long elapsed = Environment.TickCount - _lastMouseMoveMessageTick;
lock (_mouseEventLock)
{
_lastMouseMoveTick = Environment.TickCount;
try
{
CurrentMousePosition = e.GetPosition(TileImage);
}
catch (ArgumentException)
{
return; // Happens sometimes on layout changes
}
bool okToSend = false;
ThrottleSettings settings = ThrottleSettings.Default;
PerformanceMonitor p = PerformanceMonitor.CurrentInstance;
// TODO: Should maxPendingAllowed be adjusted based on FPS? Image Size? and the current operation?
// Experiment shows that 2 provides the smoothest experience for pan, zoom, w/l and 4 is best for stacking (in office).
// For big images (1x1 layout), pan and zoom work best when maxPendingAllowed=1.
int maxPendingAllowed = settings.MaxPendingMouseMoveMsgAllowed;
if (!ServerEntity.HasCapture)
{
if (IsSelected)
{
// Although we are not tracking the mouse movement,
// we still send mouse position to the server to obtain the new image
// when the mouse is hovering over the tools.
if (_timer == null)
{
//TODO (CR May 2010): should we just start handling the mouse globally through the helper? It might simplify the code.
//_lastMouseMoveMessageTick = Environment.TickCount;
//SendMouseMoveMessage();
StartMouseMoveTimer();
}
else
{
switch (settings.Strategy)
{
case ThrottleStrategy.WhenMouseMoveRspReceived:
okToSend = elapsed >=
p.AverageMouseMoveMsgRTTWithResponse /
settings.MaxPendingMouseMoveMsgAllowed && p.SendLag < maxPendingAllowed &&
p.RenderingLag < 5;
break;
}
if (okToSend)
{
// TODO: REVIEW THIS
// Per MSDN:
// if the system runs continuously, TickCount will increment from zero to Int32.MaxValue for approximately 24.9 days,
// then jump to Int32.MinValue, which is a negative number, then increment back to zero during the next 24.9 days.
_lastMouseMoveMessageTick = Environment.TickCount;
SendMouseMoveMessage();
}
}
}
return;
}
switch (settings.Strategy)
{
case ThrottleStrategy.WhenMouseMoveRspReceived:
okToSend = elapsed >=
p.AverageMouseMoveMsgRTTWithResponse / settings.MaxPendingMouseMoveMsgAllowed &&
p.SendLag < maxPendingAllowed && p.RenderingLag < 5;
break;
}
if (okToSend)
{
_lastMouseMoveMessageTick = Environment.TickCount;
SendMouseMoveMessage();
}
}
}