BVB Source Codes

CRYENGINE Show AIMemStats.cpp Source code

Return Download CRYENGINE: download AIMemStats.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include <CryMemory/CrySizer.h>
  5. #include "CAISystem.h"
  6. #include "Puppet.h"
  7. #include "AIVehicle.h"
  8. #include "AIPlayer.h"
  9. #include "GoalPipe.h"
  10. #include "GoalOp.h"
  11. #include "AStarSolver.h"
  12. #include "WorldOctree.h"
  13. #include "PerceptionManager.h"
  14. #include "ObjectContainer.h"
  15. #include "Navigation/NavigationSystem/NavigationSystem.h"
  16.  
  17. void CAISystem::GetMemoryStatistics(ICrySizer* pSizer)
  18. {
  19. #ifndef _LIB // Only when compiling as dynamic library
  20.         {
  21.                 //SIZER_COMPONENT_NAME(pSizer,"Strings");
  22.                 //pSizer->AddObject( (this+1),string::_usedMemory(0) );
  23.         }
  24.         {
  25.                 SIZER_COMPONENT_NAME(pSizer, "STL Allocator Waste");
  26.                 CryModuleMemoryInfo meminfo;
  27.                 ZeroStruct(meminfo);
  28.                 CryGetMemoryInfoForModule(&meminfo);
  29.                 pSizer->AddObject((this + 2), (size_t)meminfo.STL_wasted);
  30.         }
  31. #endif
  32.  
  33.         //sizeof(bool) + sizeof(void*)*3 + sizeof(MapType::value_type)
  34.         size_t size = 0;
  35.  
  36.         size = sizeof(*this);
  37.  
  38.         //  size+= (m_vWaitingToBeUpdated.size()+m_vAlreadyUpdated.size())*sizeof(CAIObject*);
  39.         size += m_disabledAIActorsSet.size() * sizeof(CAIActor*);
  40.         size += m_enabledAIActorsSet.size() * sizeof(CAIActor*);
  41.         pSizer->AddObject(this, size);
  42.  
  43.         {
  44.                 //    char str[255];
  45.                 //    cry_sprintf(str,"%d AIObjects",m_Objects.size());
  46.                 SIZER_SUBCOMPONENT_NAME(pSizer, "AIObjects");      // string is used to identify component, it should not be dynamic
  47.  
  48.                 // (MATT) TODO These and dummies etc should be included via the object container {2009/03/25}
  49.  
  50.                 /*
  51.                    AIObjects::iterator curObj = m_Objects.begin();
  52.  
  53.                    for(;curObj!=m_Objects.end();curObj++)
  54.                    {
  55.                    CAIObject *pObj = (CAIObject *) curObj->second;
  56.  
  57.                    size+=strlen(pObj->GetName());
  58.  
  59.                    if(CPuppet* pPuppet = pObj->CastToCPuppet())
  60.                    {
  61.                     size += pPuppet->MemStats();
  62.                    }
  63.                    else if(CAIPlayer* pPlayer = pObj->CastToCAIPlayer())
  64.                    {
  65.                     size += sizeof *pPlayer;
  66.                    }
  67.                    else if(CPuppet* pVehicle = pObj->CastToCAIVehicle())
  68.                    {
  69.                     size += sizeof *pVehicle;
  70.                    }
  71.                    else
  72.                    {
  73.                     size += sizeof *pObj;
  74.                    }
  75.                    }
  76.                    pSizer->AddObject( &m_Objects, size );
  77.                  */
  78.         }
  79.  
  80.         {
  81.                 SIZER_SUBCOMPONENT_NAME(pSizer, "NavGraph");
  82.  
  83.                 if (m_pGraph)
  84.                 {
  85.                         pSizer->AddObject(m_pGraph, sizeof(*m_pGraph));
  86.                         m_pGraph->GetMemoryStatistics(pSizer);
  87.                 }
  88.  
  89.                 if (m_pNavigation)
  90.                 {
  91.                         m_pNavigation->GetMemoryStatistics(pSizer);
  92.                 }
  93.         }
  94.  
  95.         size = 0;
  96.  
  97.         {
  98.                 char str[255];
  99.                 cry_sprintf(str, "%" PRISIZE_T " GoalPipes", m_PipeManager.m_mapGoals.size());
  100.                 SIZER_SUBCOMPONENT_NAME(pSizer, "Goals");
  101.                 GoalMap::iterator gItr = m_PipeManager.m_mapGoals.begin();
  102.                 for (; gItr != m_PipeManager.m_mapGoals.end(); ++gItr)
  103.                 {
  104.                         size += (gItr->first).capacity();
  105.                         size += (gItr->second)->MemStats() + sizeof(*(gItr->second));
  106.                 }
  107.                 pSizer->AddObject(&m_PipeManager.m_mapGoals, size);
  108.         }
  109.  
  110.         {
  111.                 SIZER_SUBCOMPONENT_NAME(pSizer, "PerceptionManager");
  112.                 pSizer->AddObject(gAIEnv.pPerceptionManager, sizeof(*gAIEnv.pPerceptionManager));
  113.         }
  114.  
  115.         {
  116.                 SIZER_SUBCOMPONENT_NAME(pSizer, "ObjectContainer");
  117.                 pSizer->AddObject(gAIEnv.pObjectContainer, sizeof(*gAIEnv.pObjectContainer));
  118.         }
  119.  
  120.         size = 0;
  121.         FormationDescriptorMap::iterator fItr = m_mapFormationDescriptors.begin();
  122.         for (; fItr != m_mapFormationDescriptors.end(); ++fItr)
  123.         {
  124.                 size += (fItr->first).capacity();
  125.                 size += sizeof((fItr->second));
  126.                 size += (fItr->second).m_sName.capacity();
  127.                 size += (fItr->second).m_Nodes.size() * sizeof(FormationNode);
  128.         }
  129.         pSizer->AddObject(&m_mapFormationDescriptors, size);
  130.  
  131.         size = m_mapGroups.size() * (sizeof(unsigned short) + sizeof(CAIObject*));
  132.         pSizer->AddObject(&m_mapGroups, size);
  133.  
  134.         {
  135.                 SIZER_SUBCOMPONENT_NAME(pSizer, "MNM Navigation System");
  136.                 if (gAIEnv.pNavigationSystem)
  137.                 {
  138.                         size = sizeof(NavigationSystem);
  139.                         pSizer->AddObject(gAIEnv.pNavigationSystem, size);
  140.                         gAIEnv.pNavigationSystem->GetMemoryStatistics(pSizer);
  141.                 }
  142.         }
  143. }
  144.  
  145. size_t GraphNode::MemStats()
  146. {
  147.         size_t size = 0;
  148.  
  149.         switch (navType)
  150.         {
  151.         case IAISystem::NAV_UNSET:
  152.                 size += sizeof(GraphNode_Unset);
  153.                 break;
  154.         case IAISystem::NAV_TRIANGULAR:
  155.                 size += sizeof(GraphNode_Triangular);
  156.                 size += (GetTriangularNavData()->vertices.capacity() ? GetTriangularNavData()->vertices.capacity() * sizeof(int) + 2 * sizeof(int) : 0);
  157.                 break;
  158.         case IAISystem::NAV_WAYPOINT_HUMAN:
  159.                 size += sizeof(GraphNode_WaypointHuman);
  160.                 break;
  161.         case IAISystem::NAV_WAYPOINT_3DSURFACE:
  162.                 size += sizeof(GraphNode_Waypoint3DSurface);
  163.                 break;
  164.         case IAISystem::NAV_FLIGHT:
  165.                 size += sizeof(GraphNode_Flight);
  166.                 break;
  167.         case IAISystem::NAV_VOLUME:
  168.                 size += sizeof(GraphNode_Volume);
  169.                 break;
  170.         case IAISystem::NAV_ROAD:
  171.                 size += sizeof(GraphNode_Road);
  172.                 break;
  173.         case IAISystem::NAV_SMARTOBJECT:
  174.                 size += sizeof(GraphNode_SmartObject);
  175.                 break;
  176.         case IAISystem::NAV_FREE_2D:
  177.                 size += sizeof(GraphNode_Free2D);
  178.                 break;
  179.         default:
  180.                 break;
  181.         }
  182.  
  183.         //size += links.capacity()*sizeof(unsigned);
  184.  
  185.         return size;
  186. }
  187.  
  188. //====================================================================
  189. // MemStats
  190. //====================================================================
  191. size_t CGraph::MemStats()
  192. {
  193.         size_t size = sizeof *this;
  194.         size += sizeof(GraphNode*) * m_taggedNodes.capacity();
  195.         size += sizeof(GraphNode*) * m_markedNodes.capacity();
  196.  
  197.         size += m_allNodes.MemStats();
  198.         //size += NodesPool.MemStats();
  199.         size += mBadGraphData.capacity() * sizeof(SBadGraphData);
  200.         size += m_mapEntrances.size() * sizeof(bool) + sizeof(void*) * 3 + sizeof(EntranceMap::value_type);
  201.         size += m_mapExits.size() * sizeof(bool) + sizeof(void*) * 3 + sizeof(EntranceMap::value_type);
  202.  
  203.         return size;
  204. }
  205.  
  206. void CGraph::GetMemoryStatistics(ICrySizer* pSizer)
  207. {
  208.         pSizer->AddContainer(m_taggedNodes);
  209.         pSizer->AddContainer(m_markedNodes);
  210.  
  211.         pSizer->AddContainer(mBadGraphData);
  212.  
  213.         pSizer->AddContainer(m_mapEntrances);
  214.         pSizer->AddContainer(m_mapExits);
  215.  
  216.         pSizer->AddObject(&m_allNodes, m_allNodes.MemStats());
  217.  
  218.         pSizer->AddObject(m_pGraphLinkManager, sizeof(*m_pGraphLinkManager));
  219.         m_pGraphLinkManager->GetMemoryStatistics(pSizer);
  220.  
  221.         pSizer->AddObject(m_pGraphNodeManager, sizeof(*m_pGraphNodeManager));
  222.         m_pGraphNodeManager->GetMemoryStatistics(pSizer);
  223. }
  224.  
  225. //====================================================================
  226. // NodeMemStats
  227. //====================================================================
  228. size_t CGraph::NodeMemStats(unsigned navTypeMask)
  229. {
  230.         size_t nodesSize = 0;
  231.         size_t linksSize = 0;
  232.  
  233.         CAllNodesContainer::Iterator it(m_allNodes, navTypeMask);
  234.         while (unsigned nodeIndex = it.Increment())
  235.         {
  236.                 GraphNode* pNode = GetNodeManager().GetNode(nodeIndex);
  237.  
  238.                 if (navTypeMask & pNode->navType)
  239.                 {
  240.                         nodesSize += pNode->MemStats();
  241.                         /*
  242.                               nodesSize += sizeof(GraphNode);
  243.                               linksSize += pNode->links.capacity() * sizeof(GraphLink);
  244.                               for (unsigned i = 0 ; i < pNode->links.size() ; ++i)
  245.                               {
  246.                                 if (pNode->links[i].GetCachedPassabilityResult())
  247.                                   linksSize += sizeof(GraphLink::SCachedPassabilityResult);
  248.                               }
  249.                               switch (pNode->navType)
  250.                               {
  251.                                 case IAISystem::NAV_TRIANGULAR:
  252.                                   nodesSize += sizeof(STriangularNavData);
  253.                                   nodesSize += pNode->GetTriangularNavData()->vertices.capacity() * sizeof(int);
  254.                                   break;
  255.                                 case IAISystem::NAV_WAYPOINT_3DSURFACE:
  256.                                 case IAISystem::NAV_WAYPOINT_HUMAN:
  257.                                   nodesSize += sizeof(SWaypointNavData);
  258.                                   break;
  259.                                 case IAISystem::NAV_SMARTOBJECT: nodesSize += sizeof(SSmartObjectNavData);
  260.                                   break;
  261.                                 default:
  262.                                   break;
  263.                               }
  264.                          */
  265.                 }
  266.         }
  267.         return nodesSize + linksSize;
  268. }
  269.  
  270. //====================================================================
  271. // MemStats
  272. //====================================================================
  273. size_t CGoalPipe::MemStats()
  274. {
  275.         size_t size = sizeof(*this);
  276.  
  277.         VectorOGoals::iterator itr = m_qGoalPipe.begin();
  278.  
  279.         for (; itr != m_qGoalPipe.end(); ++itr)
  280.         {
  281.                 size += sizeof(QGoal);
  282.                 size += itr->sPipeName.capacity();
  283.                 size += sizeof(*(itr->pGoalOp));
  284.                 if (!itr->params.str.empty())
  285.                         size += itr->params.str.capacity();
  286.  
  287.                 /*
  288.                    QGoal *curGoal = itr;
  289.                    size += sizeof *curGoal;
  290.                    size += curGoal->name.capacity();
  291.                    size += sizeof (*curGoal->pGoalOp);
  292.                    size += strlen(curGoal->params.szString);
  293.                  */
  294.         }
  295.         size += m_sName.capacity();
  296.         return size;
  297. }
  298.  
  299. size_t CPuppet::MemStats()
  300. {
  301.         size_t size = sizeof(*this);
  302.  
  303.         if (m_pCurrentGoalPipe)
  304.                 size += m_pCurrentGoalPipe->MemStats();
  305.  
  306.         /*
  307.            GoalMap::iterator itr=m_mapAttacks.begin();
  308.            for(; itr!=m_mapAttacks.end();itr++ )
  309.            {
  310.            size += (itr->first).capacity();
  311.            size += sizeof(CGoalPipe *);
  312.            }
  313.            itr=m_mapRetreats.begin();
  314.            for(; itr!=m_mapRetreats.end();itr++ )
  315.            {
  316.            size += (itr->first).capacity();
  317.            size += sizeof(CGoalPipe *);
  318.            }
  319.            itr=m_mapWanders.begin();
  320.            for(; itr!=m_mapWanders.end();itr++ )
  321.            {
  322.            size += (itr->first).capacity();
  323.            size += sizeof(CGoalPipe *);
  324.            }
  325.            itr=m_mapIdles.begin();
  326.            for(; itr!=m_mapIdles.end();itr++ )
  327.            {
  328.            size += (itr->first).capacity();
  329.            size += sizeof(CGoalPipe *);
  330.            }
  331.          */
  332.         //      if(m_mapVisibleAgents.size() < 1000)
  333.         //      size += (sizeof(CAIObject*)+sizeof(VisionSD))*m_mapVisibleAgents.size();
  334.         //      if(m_mapMemory.size()<1000)
  335.         //      size += (sizeof(CAIObject*)+sizeof(MemoryRecord))*m_mapMemory.size();
  336.         if (m_mapDevaluedPoints.size() < 1000)
  337.                 size += (sizeof(CAIObject*) + sizeof(float)) * m_mapDevaluedPoints.size();
  338.         //      if(m_mapPotentialTargets.size()<1000)
  339.         //      size += (sizeof(CAIObject*)+sizeof(float))*m_mapPotentialTargets.size();
  340.         //      if(m_mapSoundEvents.size()<1000)
  341.         //      size += (sizeof(CAIObject*)+sizeof(SoundSD))*m_mapSoundEvents.size();
  342.  
  343.         return size;
  344. }
  345. //
  346. //----------------------------------------------------------------------------------
  347.  
  348. //====================================================================
  349. // MemStats
  350. //====================================================================
  351. size_t CAStarSolver::MemStats()
  352. {
  353.         size_t size = sizeof(*this);
  354.  
  355.         size += (sizeof(GraphNode*) + 4) * m_pathNodes.size();
  356.         size += m_AStarNodeManager.MemStats();
  357.  
  358.         return size;
  359. }
  360.  
  361. //====================================================================
  362. // MemStats
  363. //====================================================================
  364. size_t CWorldOctree::MemStats()
  365. {
  366.         size_t size = sizeof(*this);
  367.  
  368.         size += m_cells.capacity() * sizeof(COctreeCell);
  369.         size += m_triangles.capacity() * sizeof(CTriangle);
  370.  
  371.         for (unsigned i = 0; i < m_cells.size(); ++i)
  372.         {
  373.                 const COctreeCell& cell = m_cells[i];
  374.                 size += sizeof(cell.m_aabb);
  375.                 size += sizeof(cell.m_childCellIndices);
  376.                 size += cell.m_triangleIndices.capacity() * sizeof(int);
  377.         }
  378.  
  379.         return size;
  380. }
  381.  
downloadAIMemStats.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top