[21620] Fix load profiles TSAN issue (#3281)

include/fastdds/dds/domain/DomainParticipantFactory.hpp

@@ -314,6 +314,13 @@ class DomainParticipantFactory
     std::shared_ptr<fastrtps::rtps::RTPSDomainImpl> rtps_domain_;
 
     std::shared_ptr<detail::LogResources> log_resources_;
+
+    /**
+     * This mutex guards the access to load the profiles.
+     * Is used to lock every thread that is trying to load the profiles, so only the first one loads it and
+     * until it is not finished the rest of them does not leave function \c load_profiles .
+     */
+    mutable std::mutex default_xml_profiles_loaded_mtx_;
 };
 
 }  // namespace dds

src/cpp/fastdds/domain/DomainParticipantFactory.cpp

@@ -321,11 +321,17 @@ ReturnCode_t DomainParticipantFactory::get_participant_qos_from_profile(
 
 ReturnCode_t DomainParticipantFactory::load_profiles()
 {
-    if (false == default_xml_profiles_loaded)
+    // NOTE: This could be done with a bool atomic to avoid taking the mutex in most cases, however the use of
+    // atomic over mutex is not deterministically better, and this way is easier to read and understand.
+
+    // Only load profiles once, if not, wait for profiles to be loaded
+    std::lock_guard<std::mutex> _(default_xml_profiles_loaded_mtx_);
+    if (!default_xml_profiles_loaded)
     {
         SystemInfo::set_environment_file();
         XMLProfileManager::loadDefaultXMLFile();
-        // Only load profile once
+
+        // Change as already loaded
         default_xml_profiles_loaded = true;
 
         // Only change default participant qos when not explicitly set by the user

test/blackbox/common/BlackboxTestsDiscovery.cpp

@@ -2068,3 +2068,66 @@ TEST(Discovery, MulticastInitialPeer)
     writer.wait_discovery();
     reader.wait_discovery();
 }
+
+//! Regression test for redmine issue 17162
+TEST(Discovery, MultipleXMLProfileLoad)
+{
+    // These test may fail because one of the participants disappear before the other has found it.
+    // Thus, use condition variable so threads only finish once the discovery has taken place.
+    std::condition_variable cv;
+    std::mutex cv_mtx;
+    std::atomic<int> n_discoveries(0);
+
+    auto participant_creation_reader = [&]()
+            {
+                PubSubReader<HelloWorldPubSubType> participant(TEST_TOPIC_NAME);
+                participant.init();
+                participant.wait_discovery();
+
+                // Notify discovery has happen
+                {
+                    std::unique_lock<std::mutex> lock(cv_mtx);
+                    n_discoveries++;
+                }
+                cv.notify_all();
+
+                std::unique_lock<std::mutex> lock(cv_mtx);
+                cv.wait(
+                    lock,
+                    [&]()
+                    {
+                        return n_discoveries >= 2;
+                    }
+                    );
+            };
+
+    auto participant_creation_writer = [&]()
+            {
+                PubSubWriter<HelloWorldPubSubType> participant(TEST_TOPIC_NAME);
+                participant.init();
+                participant.wait_discovery();
+
+                // Notify discovery has happen
+                {
+                    std::unique_lock<std::mutex> lock(cv_mtx);
+                    n_discoveries++;
+                }
+                cv.notify_all();
+
+                std::unique_lock<std::mutex> lock(cv_mtx);
+                cv.wait(
+                    lock,
+                    [&]()
+                    {
+                        return n_discoveries >= 2;
+                    }
+                    );
+            };
+
+    // Start thread creating second participant
+    std::thread thr_reader(participant_creation_reader);
+    std::thread thr_writer(participant_creation_writer);
+
+    thr_reader.join();
+    thr_writer.join();
+}