Implemented thread synchronization for maps and set

Author: codenulls

Client/mods/deathmatch/logic/CClientGame.cpp

@@ -6845,8 +6845,15 @@ void CClientGame::RestreamModel ( unsigned short usModel )
 
 }
 
+void CClientGame::InsertIFPPointerToMap ( const unsigned int u32BlockNameHash, const std::shared_ptr < CClientIFP > & pIFP ) 
+{ 
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfIfpPointersMap );
+    m_mapOfIfpPointers [ u32BlockNameHash ] = pIFP; 
+}
+
 std::shared_ptr < CClientIFP > CClientGame::GetIFPPointerFromMap ( const unsigned int u32BlockNameHash )
 {
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfIfpPointersMap );
     auto it = m_mapOfIfpPointers.find ( u32BlockNameHash );
     if ( it != m_mapOfIfpPointers.end ( ) )
     {
@@ -6855,19 +6862,39 @@ std::shared_ptr < CClientIFP > CClientGame::GetIFPPointerFromMap ( const unsigne
     return nullptr;
 }
 
+void CClientGame::RemoveIFPPointerFromMap ( const unsigned int u32BlockNameHash ) 
+{ 
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfIfpPointersMap );
+    m_mapOfIfpPointers.erase ( u32BlockNameHash ); 
+}
+
+
+void  CClientGame::InsertPedPointerToSet ( CClientPed * pPed ) 
+{ 
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfPedPointersSet );
+    m_setOfPedPointers.insert ( pPed );
+}
+
+void  CClientGame::RemovePedPointerFromSet ( CClientPed * pPed ) 
+{ 
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfPedPointersSet );
+    m_setOfPedPointers.erase ( pPed ); 
+}
+
 CClientPed * CClientGame::GetClientPedByClump ( const RpClump & Clump )
 {
-    for ( auto it = m_mapOfPedPointers.begin(); it != m_mapOfPedPointers.end(); it++ )
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfPedPointersSet );
+    for ( auto it = m_setOfPedPointers.begin ( ); it != m_setOfPedPointers.end ( ); it++ )
     {
-        CEntity * pEntity = it->first->GetGameEntity();
+        CEntity * pEntity = (*it)->GetGameEntity();
         if ( pEntity != nullptr )
         { 
-            if ( pEntity->GetRpClump() != nullptr)
+            if ( pEntity->GetRpClump() != nullptr )
             { 
                 const RpClump & entityClump = *pEntity->GetRpClump();
                 if ( std::addressof ( entityClump ) == std::addressof ( Clump ) )
                 { 
-                    return it->first;
+                    return *it;
                 }
             }
         }
@@ -6877,38 +6904,41 @@ CClientPed * CClientGame::GetClientPedByClump ( const RpClump & Clump )
 
 void CClientGame::OnClientIFPUnload ( const std::shared_ptr < CClientIFP > & IFP )
 {   
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfPedPointersSet );
     IFP->MarkAsUnloading ( );
-    for ( auto it = m_mapOfPedPointers.begin(); it != m_mapOfPedPointers.end(); it++ )
+    for ( auto it = m_setOfPedPointers.begin ( ); it != m_setOfPedPointers.end ( ); it++ )
     {
         // Remove IFP animations from replaced animations of peds/players 
-        it->first->RestoreAnimations ( IFP );
+        (*it)->RestoreAnimations ( IFP );
 
         // Make sure that streamed in pulses or changing model does not accidently
         // play our custom animation. We can do that by making the custom animation 
         // untriggerable
-        if ( it->first->GetCustomAnimationBlockNameHash ( ) == IFP->GetBlockNameHash ( ) )
+        if ( (*it)->GetCustomAnimationBlockNameHash ( ) == IFP->GetBlockNameHash ( ) )
         {
-            if ( it->first->IsCustomAnimationPlaying ( ) )
+            if ( (*it)->IsCustomAnimationPlaying ( ) )
             {
-                it->first->SetCustomAnimationUntriggerable ( );
+                (*it)->SetCustomAnimationUntriggerable ( );
             }
 
             // Important! As we are using a shared_ptr, we need to decrement the reference counter 
             // by setting the shared_ptr to nullptr, this will avoid memory leak
-            if ( !it->first->IsNextAnimationCustom ( ) && it->first->IsCurrentAnimationCustom ( ) )
+            if ( !(*it)->IsNextAnimationCustom ( ) && (*it)->IsCurrentAnimationCustom ( ) )
             { 
-                it->first->DereferenceCustomAnimationBlock ();
+                (*it)->DereferenceCustomAnimationBlock ();
             }
         }
     }
 }
 
 void CClientGame::InsertAnimationAssociationToMap ( CAnimBlendAssociationSAInterface * pAnimAssociation, const std::shared_ptr < CIFPAnimations > & pIFPAnimations )
 {
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfAnimationAssociationsMap );
     m_mapOfCustomAnimationAssociations [ pAnimAssociation ] = pIFPAnimations;
 }
 
 void CClientGame::RemoveAnimationAssociationFromMap ( CAnimBlendAssociationSAInterface * pAnimAssociation )
 {
+    std::lock_guard < std::mutex > mutexGuardedLock ( m_MutexOfAnimationAssociationsMap );
     m_mapOfCustomAnimationAssociations.erase ( pAnimAssociation );
 }

Client/mods/deathmatch/logic/CClientGame.h

@@ -593,12 +593,12 @@ class CClientGame
     void                                      SetFileCacheRoot                ( void );
     const char*                               GetFileCacheRoot                ( void )                                    { return m_strFileCacheRoot; }
 
-    inline void                               InsertIFPPointerToMap           ( const unsigned int u32BlockNameHash, const std::shared_ptr < CClientIFP > & pIFP ) { m_mapOfIfpPointers [ u32BlockNameHash ] = pIFP; }
-    inline void                               RemoveIFPPointerFromMap         ( const unsigned int u32BlockNameHash ) { m_mapOfIfpPointers.erase ( u32BlockNameHash ); }
+    void                                      InsertIFPPointerToMap           ( const unsigned int u32BlockNameHash, const std::shared_ptr < CClientIFP > & pIFP );
+    void                                      RemoveIFPPointerFromMap         ( const unsigned int u32BlockNameHash );
     std::shared_ptr < CClientIFP >            GetIFPPointerFromMap            ( const unsigned int u32BlockNameHash );
 
-    void                                      InsertPedPointerToMap           ( CClientPed * pPed ) { m_mapOfPedPointers [ pPed ] = true; }
-    void                                      RemovePedPointerFromMap         ( CClientPed * pPed ) { m_mapOfPedPointers.erase ( pPed ); }
+    void                                      InsertPedPointerToSet           ( CClientPed * pPed );
+    void                                      RemovePedPointerFromSet         ( CClientPed * pPed );
     CClientPed *                              GetClientPedByClump             ( const RpClump & Clump );
 
     void                                      OnClientIFPUnload               ( const std::shared_ptr < CClientIFP > & IFP );
@@ -821,9 +821,13 @@ class CClientGame
 
     // (unsigned int) Key is the hash of custom block name that is supplied to engineLoadIFP
     std::map < unsigned int, std::shared_ptr < CClientIFP > > m_mapOfIfpPointers; 
+    mutable std::mutex m_MutexOfIfpPointersMap;
 
-    std::map < CClientPed *, bool > m_mapOfPedPointers;
-    AnimAssociations_type           m_mapOfCustomAnimationAssociations;
+    std::set < CClientPed * > m_setOfPedPointers;
+    mutable std::mutex m_MutexOfPedPointersSet;
+
+    AnimAssociations_type m_mapOfCustomAnimationAssociations;
+    mutable std::mutex m_MutexOfAnimationAssociationsMap;
 };
 
 extern CClientGame* g_pClientGame;

Client/mods/deathmatch/logic/CClientPed.cpp

@@ -247,13 +247,13 @@ void CClientPed::Init ( CClientManager* pManager, unsigned long ulModelID, bool
         SetArmor ( 0.0f );
     }
 
-    g_pClientGame->InsertPedPointerToMap ( this );
+    g_pClientGame->InsertPedPointerToSet ( this );
 }
 
 
 CClientPed::~CClientPed ( void )
 { 
-    g_pClientGame->RemovePedPointerFromMap ( this );
+    g_pClientGame->RemovePedPointerFromSet ( this );
 
     // Remove from the ped manager
     m_pManager->GetPedManager ()->RemoveFromList ( this );
@@ -6210,7 +6210,6 @@ void CClientPed::ReplaceAnimation ( CAnimBlendHierarchy * pInternalAnimHierarchy
     SReplacedAnimation replacedAnimation;
     replacedAnimation.pIFP = pIFP;
     replacedAnimation.pAnimationHierarchy = pCustomAnimHierarchy;
-
     m_mapOfReplacedAnimations [ pInternalAnimHierarchy->GetInterface () ] = replacedAnimation;
 }
 
@@ -6228,7 +6227,7 @@ void CClientPed::RestoreAnimations ( const std::shared_ptr < CClientIFP > & IFP
 void CClientPed::RestoreAnimations ( CAnimBlock & animationBlock )
 {
     const size_t cAnimations = animationBlock.GetAnimationCount ( );
-    for ( size_t i = 0; i < cAnimations; i++)
+    for ( size_t i = 0; i < cAnimations; i++ )
     {
         auto pAnimHierarchyInterface = animationBlock.GetAnimationHierarchyInterface ( i );
         m_mapOfReplacedAnimations.erase ( pAnimHierarchyInterface );