Ticket #1707: rangeManagerOptimizations.patch

Users/lancelot/Desktop/0ad-svn/trunk/source/simulation2/components/CCmpRangeManager.cpp

@@ -129 +129 @@
 struct SerializeEntityData
 {
     template<typename S>
-    void operator()(S& serialize, const char* UNUSED(name), EntityData& value)
+    void operator()(S& serialize, const char* UNUSED(name), EntityData* value)
     {
-        serialize.NumberFixed_Unbounded("x", value.x);
-        serialize.NumberFixed_Unbounded("z", value.z);
-        serialize.NumberFixed_Unbounded("vision", value.visionRange);
-        serialize.NumberU8("retain in fog", value.retainInFog, 0, 1);
-        serialize.NumberI8_Unbounded("owner", value.owner);
-        serialize.NumberU8("in world", value.inWorld, 0, 1);
-        serialize.NumberU8_Unbounded("flags", value.flags);
+        serialize.NumberFixed_Unbounded("x", value->x);
+        serialize.NumberFixed_Unbounded("z", value->z);
+        serialize.NumberFixed_Unbounded("vision", value->visionRange);
+        serialize.NumberU8("retain in fog", value->retainInFog, 0, 1);
+        serialize.NumberI8_Unbounded("owner", value->owner);
+        serialize.NumberU8("in world", value->inWorld, 0, 1);
+        serialize.NumberU8_Unbounded("flags", value->flags);
     }
 };
 
@@ -149 +149 @@
  */
 struct EntityDistanceOrdering
 {
-    EntityDistanceOrdering(const std::map<entity_id_t, EntityData>& entities, const CFixedVector2D& source) :
+    EntityDistanceOrdering(const std::vector<EntityData*>& entities, const CFixedVector2D& source) :
         m_EntityData(entities), m_Source(source)
     {
     }
 
     bool operator()(entity_id_t a, entity_id_t b)
     {
-        const EntityData& da = m_EntityData.find(a)->second;
-        const EntityData& db = m_EntityData.find(b)->second;
-        CFixedVector2D vecA = CFixedVector2D(da.x, da.z) - m_Source;
-        CFixedVector2D vecB = CFixedVector2D(db.x, db.z) - m_Source;
+        const EntityData* da = m_EntityData[a];
+        const EntityData* db = m_EntityData[b];
+        if (da == NULL)
+            return false;
+        if (db == NULL)
+            return false;
+        CFixedVector2D vecA = CFixedVector2D(da->x, da->z) - m_Source;
+        CFixedVector2D vecB = CFixedVector2D(db->x, db->z) - m_Source;
         return (vecA.CompareLength(vecB) < 0);
     }
 
-    const std::map<entity_id_t, EntityData>& m_EntityData;
+    const std::vector<EntityData*>& m_EntityData;
     CFixedVector2D m_Source;
 
 private:
@@ -210 +214 @@
     // Range query state:
     tag_t m_QueryNext; // next allocated id
     std::map<tag_t, Query> m_Queries;
-    std::map<entity_id_t, EntityData> m_EntityData;
+    //std::map<entity_id_t, EntityData> m_EntityData;
+    std::vector<EntityData*> m_EntityData;
     SpatialSubdivision<entity_id_t> m_Subdivision; // spatial index of m_EntityData
 
     // LOS state:
@@ -284 +289 @@
 
         serialize.NumberU32_Unbounded("query next", m_QueryNext);
         SerializeMap<SerializeU32_Unbounded, SerializeQuery>()(serialize, "queries", m_Queries);
-        SerializeMap<SerializeU32_Unbounded, SerializeEntityData>()(serialize, "entity data", m_EntityData);
+        //SerializeVector<SerializeEntityData>()(serialize, "entity data array", m_EntityData);
 
         SerializeMap<SerializeI32_Unbounded, SerializeBool>()(serialize, "los reveal all", m_LosRevealAll);
         serialize.Bool("los circular", m_LosCircular);
@@ -335 +340 @@
             // The newly-created entity will have owner -1 and position out-of-world
             // (any initialisation of those values will happen later), so we can just
             // use the default-constructed EntityData here
-            EntityData entdata;
-
+            EntityData* entdata = new EntityData;
+            
             // Store the LOS data, if any
             CmpPtr<ICmpVision> cmpVision(GetSimContext(), ent);
             if (cmpVision)
             {
-                entdata.visionRange = cmpVision->GetRange();
-                entdata.retainInFog = (cmpVision->GetRetainInFog() ? 1 : 0);
+                entdata->visionRange = cmpVision->GetRange();
+                entdata->retainInFog = (cmpVision->GetRetainInFog() ? 1 : 0);
             }
 
             // Remember this entity
-            m_EntityData.insert(std::make_pair(ent, entdata));
+            if (ent >= m_EntityData.size()) {
+                m_EntityData.resize(ent+1);
+            }
+            m_EntityData[ent] = entdata;
 
             break;
         }
@@ -355 +363 @@
             const CMessagePositionChanged& msgData = static_cast<const CMessagePositionChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
-
             // Ignore if we're not already tracking this entity
-            if (it == m_EntityData.end())
+            if (ent >= m_EntityData.size())
                 break;
 
+            EntityData* entData = m_EntityData[ent];
+
             if (msgData.inWorld)
             {
-                if (it->second.inWorld)
+                if (entData->inWorld)
                 {
-                    CFixedVector2D from(it->second.x, it->second.z);
+                    CFixedVector2D from(entData->x, entData->z);
                     CFixedVector2D to(msgData.x, msgData.z);
                     m_Subdivision.Move(ent, from, to);
-                    LosMove(it->second.owner, it->second.visionRange, from, to);
+                    LosMove(entData->owner, entData->visionRange, from, to);
                 }
                 else
                 {
                     CFixedVector2D to(msgData.x, msgData.z);
                     m_Subdivision.Add(ent, to);
-                    LosAdd(it->second.owner, it->second.visionRange, to);
+                    LosAdd(entData->owner, entData->visionRange, to);
                 }
 
-                it->second.inWorld = 1;
-                it->second.x = msgData.x;
-                it->second.z = msgData.z;
+                entData->inWorld = 1;
+                entData->x = msgData.x;
+                entData->z = msgData.z;
             }
             else
             {
-                if (it->second.inWorld)
+                if (entData->inWorld)
                 {
-                    CFixedVector2D from(it->second.x, it->second.z);
+                    CFixedVector2D from(entData->x, entData->z);
                     m_Subdivision.Remove(ent, from);
-                    LosRemove(it->second.owner, it->second.visionRange, from);
+                    LosRemove(entData->owner, entData->visionRange, from);
                 }
 
-                it->second.inWorld = 0;
-                it->second.x = entity_pos_t::Zero();
-                it->second.z = entity_pos_t::Zero();
+                entData->inWorld = 0;
+                entData->x = entity_pos_t::Zero();
+                entData->z = entity_pos_t::Zero();
             }
 
             break;
@@ -402 +410 @@
             const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
-
             // Ignore if we're not already tracking this entity
-            if (it == m_EntityData.end())
+            if (ent >= m_EntityData.size())
                 break;
 
-            if (it->second.inWorld)
+            EntityData* entData = m_EntityData[ent];
+            
+            if (entData->inWorld)
             {
-                CFixedVector2D pos(it->second.x, it->second.z);
-                LosRemove(it->second.owner, it->second.visionRange, pos);
-                LosAdd(msgData.to, it->second.visionRange, pos);
+                CFixedVector2D pos(entData->x, entData->z);
+                LosRemove(entData->owner, entData->visionRange, pos);
+                LosAdd(msgData.to, entData->visionRange, pos);
             }
 
             ENSURE(-128 <= msgData.to && msgData.to <= 127);
-            it->second.owner = (i8)msgData.to;
-
+            entData->owner = (i8)msgData.to;
+            
             break;
         }
         case MT_Destroy:
@@ -425 +433 @@
             const CMessageDestroy& msgData = static_cast<const CMessageDestroy&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
-
             // Ignore if we're not already tracking this entity
-            if (it == m_EntityData.end())
+            if (ent >= m_EntityData.size())
                 break;
 
-            if (it->second.inWorld)
-                m_Subdivision.Remove(ent, CFixedVector2D(it->second.x, it->second.z));
+            EntityData* entData = m_EntityData[ent];
 
-            // This will be called after Ownership's OnDestroy, so ownership will be set
-            // to -1 already and we don't have to do a LosRemove here
-            ENSURE(it->second.owner == -1);
+            if (entData != NULL && entData->inWorld)
+                m_Subdivision.Remove(ent, CFixedVector2D(entData->x, entData->z));
 
-            m_EntityData.erase(it);
+            SAFE_DELETE(entData);
+            m_EntityData[ent] = NULL;
 
             break;
         }
@@ -447 +452 @@
             const CMessageVisionRangeChanged& msgData = static_cast<const CMessageVisionRangeChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
-
             // Ignore if we're not already tracking this entity
-            if (it == m_EntityData.end())
+            if (ent >= m_EntityData.size())
                 break;
-
+            
+            EntityData* entData = m_EntityData[ent];
+            
             CmpPtr<ICmpVision> cmpVision(GetSimContext(), ent);
             if (!cmpVision)
                 break;
 
-            entity_pos_t oldRange = it->second.visionRange;
+            entity_pos_t oldRange = entData->visionRange;
             entity_pos_t newRange = msgData.newRange;
 
             // If the range changed and the entity's in-world, we need to manually adjust it
             //  but if it's not in-world, we only need to set the new vision range
-            CFixedVector2D pos(it->second.x, it->second.z);
-            if (it->second.inWorld)
-                LosRemove(it->second.owner, oldRange, pos);
+            CFixedVector2D pos(entData->x, entData->z);
+            if (entData->inWorld)
+                LosRemove(entData->owner, oldRange, pos);
 
-            it->second.visionRange = newRange;
+            entData->visionRange = newRange;
 
-            if (it->second.inWorld)
-                LosAdd(it->second.owner, newRange, pos);
+            if (entData->inWorld)
+                LosAdd(entData->owner, newRange, pos);
 
             break;
         }
@@ -555 +560 @@
         m_LosStateRevealed.clear();
         m_LosStateRevealed.resize(m_TerrainVerticesPerSide*m_TerrainVerticesPerSide);
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (size_t i = 0; i < m_EntityData.size(); ++i)
         {
-            if (it->second.inWorld)
-                LosAdd(it->second.owner, it->second.visionRange, CFixedVector2D(it->second.x, it->second.z));
+            if (m_EntityData[i] != NULL && m_EntityData[i]->inWorld)
+                LosAdd(m_EntityData[i]->owner, m_EntityData[i]->visionRange, CFixedVector2D(m_EntityData[i]->x, m_EntityData[i]->z));
         }
 
         for (ssize_t j = 0; j < m_TerrainVerticesPerSide; ++j)
@@ -572 +577 @@
         // (TODO: find the optimal number instead of blindly guessing)
         m_Subdivision.Reset(x1, z1, entity_pos_t::FromInt(8*TERRAIN_TILE_SIZE));
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (size_t i = 0; i < m_EntityData.size(); ++i)
         {
-            if (it->second.inWorld)
-                m_Subdivision.Add(it->first, CFixedVector2D(it->second.x, it->second.z));
+            if (m_EntityData[i] != NULL && m_EntityData[i]->inWorld)
+                m_Subdivision.Add(i, CFixedVector2D(m_EntityData[i]->x, m_EntityData[i]->z));
         }
     }
 
@@ -643 +648 @@
             return r;
         }
 
+        PROFILE_START("perform");
         PerformQuery(q, r);
+        PROFILE_END("perform");
 
         // Return the list sorted by distance from the entity
         CFixedVector2D pos = cmpSourcePosition->GetPosition2D();
@@ -693 +700 @@
 
         u32 ownerMask = CalcOwnerMask(player);
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (size_t i = 0; i < m_EntityData.size(); ++i)
         {
             // Check owner and add to list if it matches
-            if (CalcOwnerMask(it->second.owner) & ownerMask)
-                entities.push_back(it->first);
+            if (m_EntityData[i] != NULL && CalcOwnerMask(m_EntityData[i]->owner) & ownerMask)
+                entities.push_back(i);
         }
 
         return entities;
@@ -766 +773 @@
     /**
      * Returns whether the given entity matches the given query (ignoring maxRange)
      */
-    bool TestEntityQuery(const Query& q, entity_id_t id, const EntityData& entity)
+    bool TestEntityQuery(const Query& q, entity_id_t id, const EntityData* entity)
     {
         // Quick filter to ignore entities with the wrong owner
-        if (!(CalcOwnerMask(entity.owner) & q.ownersMask))
+        if (!(CalcOwnerMask(entity->owner) & q.ownersMask))
             return false;
 
         // Ignore entities not present in the world
-        if (!entity.inWorld)
+        if (!entity->inWorld)
             return false;
 
         // Ignore entities that don't match the current flags
-        if (!(entity.flags & q.flagsMask))
+        if (!(entity->flags & q.flagsMask))
             return false;
 
         // Ignore self
@@ -804 +811 @@
         // Special case: range -1.0 means check all entities ignoring distance
         if (q.maxRange == entity_pos_t::FromInt(-1))
         {
-            for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+            for (size_t i = 0; i < m_EntityData.size(); ++i)
             {
-                if (!TestEntityQuery(q, it->first, it->second))
+                if (m_EntityData[i] == NULL || !TestEntityQuery(q, i, m_EntityData[i]))
                     continue;
 
-                r.push_back(it->first);
+                r.push_back(i);
             }
         }
         else
         {
             // Get a quick list of entities that are potentially in range
-            std::vector<entity_id_t> ents = m_Subdivision.GetNear(pos, q.maxRange);
+            std::vector<entity_id_t> ents;
+            PROFILE_START("GetNear");
+            //ents = m_Subdivision.GetNear(pos, q.maxRange);
+            ents = m_Subdivision.GetNearUnsorted(pos, q.maxRange);
+            PROFILE_END("GetNear");
 
             for (size_t i = 0; i < ents.size(); ++i)
             {
-                std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.find(ents[i]);
-                ENSURE(it != m_EntityData.end());
-
-                if (!TestEntityQuery(q, it->first, it->second))
+                const EntityData* entData = m_EntityData[ents[i]];
+                
+                if (!TestEntityQuery(q, ents[i], entData))
                     continue;
 
                 // Restrict based on precise distance
-                int distVsMax = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.maxRange);
+                int distVsMax = (CFixedVector2D(entData->x, entData->z) - pos).CompareLength(q.maxRange);
                 if (distVsMax > 0)
                     continue;
 
                 if (!q.minRange.IsZero())
                 {
-                    int distVsMin = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.minRange);
+                    int distVsMin = (CFixedVector2D(entData->x, entData->z) - pos).CompareLength(q.minRange);
                     if (distVsMin < 0)
                         continue;
                 }
 
-                r.push_back(it->first);
+                r.push_back(ents[i]);
             }
         }
     }
@@ -945 +955 @@
     
     virtual void SetEntityFlag(entity_id_t ent, std::string identifier, bool value)
     {
-        std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
-
         // We don't have this entity
-        if (it == m_EntityData.end())
+        if (ent >= m_EntityData.size())
             return;
 
+        EntityData* entData = m_EntityData[ent];
+        
         u8 flag = GetEntityFlagMask(identifier);
 
         // We don't have a flag set
@@ -961 +971 @@
         }
 
         if (value)
-            it->second.flags |= flag;
+            entData->flags |= flag;
         else
-            it->second.flags &= ~flag;
+            entData->flags &= ~flag;
     }
 
     // ****************************************************************

Users/lancelot/Desktop/0ad-svn/trunk/source/simulation2/components/CCmpObstructionManager.cpp

@@ -544 +544 @@
     CFixedVector2D posMin (std::min(x0, x1) - r, std::min(z0, z1) - r);
     CFixedVector2D posMax (std::max(x0, x1) + r, std::max(z0, z1) + r);
 
-    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(posMin, posMax);
+    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRangeUnsorted(posMin, posMax);
     for (size_t i = 0; i < unitShapes.size(); ++i)
     {
         std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
@@ -559 +559 @@
             return true;
     }
 
-    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(posMin, posMax);
+    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRangeUnsorted(posMin, posMax);
     for (size_t i = 0; i < staticShapes.size(); ++i)
     {
         std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
@@ -880 +880 @@
 
     ENSURE(x0 <= x1 && z0 <= z1);
 
-    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
+    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRangeUnsorted(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
     for (size_t i = 0; i < unitShapes.size(); ++i)
     {
         std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
@@ -901 +901 @@
         squares.push_back(s);
     }
 
-    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
+    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRangeUnsorted(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
     for (size_t i = 0; i < staticShapes.size(); ++i)
     {
         std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);

Users/lancelot/Desktop/0ad-svn/trunk/source/simulation2/helpers/Spatial.h

@@ -203 +203 @@
 
         return ret;
     }
+    
+    /**
+     * Returns a sorted list of unique items that includes all items
+     * within the given axis-aligned square range.
+     */
+    std::vector<T> GetInRangeUnsorted(CFixedVector2D posMin, CFixedVector2D posMax)
+    {
+        std::vector<T> ret;
+        
+        ENSURE(posMin.X <= posMax.X && posMin.Y <= posMax.Y);
+        
+        u32 i0 = GetI0(posMin.X);
+        u32 j0 = GetJ0(posMin.Y);
+        u32 i1 = GetI1(posMax.X);
+        u32 j1 = GetJ1(posMax.Y);
+        for (u32 j = j0; j <= j1; ++j)
+        {
+            for (u32 i = i0; i <= i1; ++i)
+            {
+                std::vector<T>& div = m_Divisions[i + j*m_DivisionsW];
+                ret.insert(ret.end(), div.begin(), div.end());
+            }
+        }
+        
+        // Remove duplicates
+        //std::sort(ret.begin(), ret.end());
+        //ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
+        
+        return ret;
+    }
 
     /**
      * Returns a sorted list of unique items that includes all items
@@ -216 +246 @@
         return GetInRange(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range));
     }
 
+    /**
+     * Returns a sorted list of unique items that includes all items
+     * within the given circular distance of the given point.
+     */
+    std::vector<T> GetNearUnsorted(CFixedVector2D pos, entity_pos_t range)
+    {
+        // TODO: be cleverer and return a circular pattern of divisions,
+        // not this square over-approximation
+        
+        return GetInRangeUnsorted(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range));
+    }
+    
 private:
     // Helper functions for translating coordinates into division indexes
     // (avoiding out-of-bounds accesses, and rounding correctly so that