A few more tweaks on position updates and create child agents. Mono hates concurrent uses of the same TCP connection, and even of the connections to the same server. So let's stop doing it. This patch makes movement much smoother when there are lots of neighbours.

OpenSim/Framework/Servers/VersionInfo.cs

@@ -30,7 +30,7 @@ namespace OpenSim
     public class VersionInfo
     {
         private const string VERSION_NUMBER = "0.7.3";
-        private const Flavour VERSION_FLAVOUR = Flavour.Dev;
+        private const Flavour VERSION_FLAVOUR = Flavour.RC2;
 
         public enum Flavour
         {

OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs

@@ -1258,12 +1258,16 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 if (neighbour.RegionHandle != sp.Scene.RegionInfo.RegionHandle)
                 {
-                    InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
                     try
                     {
-                        d.BeginInvoke(sp, cagents[count], neighbour, neighbour.ExternalEndPoint, newAgent,
-                                      InformClientOfNeighbourCompleted,
-                                      d);
+                        // Let's put this back at sync, so that it doesn't clog 
+                        // the network, especially for regions in the same physical server.
+                        // We're really not in a hurry here.
+                        InformClientOfNeighbourAsync(sp, cagents[count], neighbour, neighbour.ExternalEndPoint, newAgent);
+                        //InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
+                        //d.BeginInvoke(sp, cagents[count], neighbour, neighbour.ExternalEndPoint, newAgent,
+                        //              InformClientOfNeighbourCompleted,
+                        //              d);
                     }
 
                     catch (ArgumentOutOfRangeException)

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RegionInfoCache.cs

@@ -65,13 +65,26 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             }
         }
 
+        internal struct ScopedRegionPosition
+        {
+            public UUID m_scopeID;
+            public ulong m_regionHandle;
+            public ScopedRegionPosition(UUID scopeID, ulong handle)
+            {
+                m_scopeID = scopeID;
+                m_regionHandle = handle;
+            }
+        }
+
         private ExpiringCache<ScopedRegionUUID, GridRegion> m_UUIDCache;
         private ExpiringCache<ScopedRegionName, ScopedRegionUUID> m_NameCache;
+        private ExpiringCache<ScopedRegionPosition, GridRegion> m_PositionCache;
 
         public RegionInfoCache()
         {
             m_UUIDCache = new ExpiringCache<ScopedRegionUUID, GridRegion>();
-            m_NameCache = new ExpiringCache<ScopedRegionName, ScopedRegionUUID>(); 
+            m_NameCache = new ExpiringCache<ScopedRegionName, ScopedRegionUUID>();
+            m_PositionCache = new ExpiringCache<ScopedRegionPosition, GridRegion>();
         }
 
         public void Cache(GridRegion rinfo)
@@ -96,6 +109,9 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             {
                 ScopedRegionName name = new ScopedRegionName(scopeID,rinfo.RegionName);
                 m_NameCache.AddOrUpdate(name, id, CACHE_EXPIRATION_SECONDS);
+
+                ScopedRegionPosition pos = new ScopedRegionPosition(scopeID, rinfo.RegionHandle);
+                m_PositionCache.AddOrUpdate(pos, rinfo, CACHE_EXPIRATION_SECONDS);
             }
         }
 
@@ -114,6 +130,22 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             return null;
         }
 
+        public GridRegion Get(UUID scopeID, ulong handle, out bool inCache)
+        {
+            inCache = false;
+
+            GridRegion rinfo = null;
+            ScopedRegionPosition pos = new ScopedRegionPosition(scopeID, handle);
+            if (m_PositionCache.TryGetValue(pos, out rinfo))
+            {
+                inCache = true;
+                return rinfo;
+            }
+
+            return null;
+        }
+
+
         public GridRegion Get(UUID scopeID, string name, out bool inCache)
         {
             inCache = false;

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RemoteGridServiceConnector.cs

@@ -186,10 +186,16 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
         {
-            GridRegion rinfo = m_LocalGridService.GetRegionByPosition(scopeID, x, y);
+            bool inCache = false;
+            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, Util.UIntsToLong((uint)x, (uint)y), out inCache);
+            if (inCache)
+                return rinfo;
+
+            rinfo = m_LocalGridService.GetRegionByPosition(scopeID, x, y);
             if (rinfo == null)
                 rinfo = m_RemoteGridService.GetRegionByPosition(scopeID, x, y);
 
+            m_RegionInfoCache.Cache(rinfo);
             return rinfo;
         }
 

OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs

@@ -140,6 +140,7 @@ namespace OpenSim.Region.Framework.Scenes
             icon.EndInvoke(iar);
         }
 
+        ExpiringCache<string, bool> _failedSims = new ExpiringCache<string, bool>();
         public void SendChildAgentDataUpdate(AgentPosition cAgentData, ScenePresence presence)
         {
             // This assumes that we know what our neighbors are.
@@ -156,16 +157,22 @@ namespace OpenSim.Region.Framework.Scenes
                         // that the region position is cached or performance will degrade
                         Utils.LongToUInts(regionHandle, out x, out y);
                         GridRegion dest = m_scene.GridService.GetRegionByPosition(UUID.Zero, (int)x, (int)y);
-                        if (! simulatorList.Contains(dest.ServerURI))
+                        bool v = true;
+                        if (! simulatorList.Contains(dest.ServerURI) && !_failedSims.TryGetValue(dest.ServerURI, out v))
                         {
                             // we havent seen this simulator before, add it to the list
                             // and send it an update
                             simulatorList.Add(dest.ServerURI);
+                            // Let move this to sync. Mono definitely does not like async networking.
+                            if (!m_scene.SimulationService.UpdateAgent(dest, cAgentData))
+                                // Also if it fails, get it out of the loop for a bit
+                                _failedSims.Add(dest.ServerURI, true, 120);
 
-                            SendChildAgentDataUpdateDelegate d = SendChildAgentDataUpdateAsync;
-                            d.BeginInvoke(cAgentData, m_regionInfo.ScopeID, dest,
-                                          SendChildAgentDataUpdateCompleted,
-                                          d);
+                            // Leaving this here as a reminder that we tried, and it sucks.
+                            //SendChildAgentDataUpdateDelegate d = SendChildAgentDataUpdateAsync;
+                            //d.BeginInvoke(cAgentData, m_regionInfo.ScopeID, dest,
+                            //              SendChildAgentDataUpdateCompleted,
+                            //              d);
                         }
                     }
                 }

OpenSim/Region/Framework/Scenes/ScenePresence.cs

@@ -2738,7 +2738,8 @@ namespace OpenSim.Region.Framework.Scenes
                 AgentPosition agentpos = new AgentPosition();
                 agentpos.CopyFrom(cadu);
 
-                m_scene.SendOutChildAgentUpdates(agentpos, this);
+                // Let's get this out of the update loop
+                Util.FireAndForget(delegate { m_scene.SendOutChildAgentUpdates(agentpos, this); });
             }
         }