FastDDSSharedParticipant.cpp

Go to the documentation of this file.

// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma de Barcelona (UAB).
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#ifndef CARLA_ROS2_MIDDLEWARE_TESTING
 
#include "carla/ros2/middleware/fastdds/FastDDSSharedParticipant.h"
#include "carla/ros2/middleware/MiddlewareConfig.h"
#include "carla/Logging.h"
 
#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
#include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
 
#include <cstdlib>
 
namespace carla {
namespace ros2 {
 
namespace efd = eprosima::fastdds::dds;
 
// Static member definitions
std::mutex                                      FastDDSSharedParticipant::_mutex;
efd::DomainParticipant*                         FastDDSSharedParticipant::_participant { nullptr };
uint32_t                                        FastDDSSharedParticipant::_refcount { 0u };
std::unordered_map<std::string, uint32_t>       FastDDSSharedParticipant::_type_refcounts;
 
efd::DomainParticipant* FastDDSSharedParticipant::acquire() {
  std::lock_guard<std::mutex> lock(_mutex);
  if (_refcount == 0u) {
    // Load XML profiles (FASTRTPS_DEFAULT_PROFILES_FILE) before reading the
    // factory default QoS, so a profile marked is_default_profile is already
    // folded in. load_profiles() is idempotent. The default MUST be read via
    // get_default_participant_qos(): PARTICIPANT_QOS_DEFAULT is a static
    // constant that XML profiles never modify -- copying it silently discards
    // any user-provided profile (transports included).
    auto* factory = efd::DomainParticipantFactory::get_instance();
    factory->load_profiles();
    efd::DomainParticipantQos pqos = factory->get_default_participant_qos();
    // Fast-DDS's builtin default is UDPv4 + shared memory, and SHM is
    // preferred for any peer that looks same-host. SHM delivery silently
    // drops every sample across a container, uid, or Fast-DDS-version
    // boundary (discovery is UDP multicast, so topics stay visible while no
    // data arrives), and Fast-DDS never falls back to the reader's UDP
    // locator when the SHM path is unreachable. Default to UDPv4-only so any
    // subscriber works out of the box; setting the standard
    // FASTDDS_BUILTIN_TRANSPORTS environment variable (e.g. to DEFAULT)
    // skips this override and restores SHM for same-host, same-uid setups.
    //
    // The override must also yield to an XML default profile that configured
    // its own transports (user transports, or builtin transports disabled):
    // setup_transports() would silently REPLACE a whitelisted transport with
    // an unrestricted UDPv4 one bound to every interface, so e.g. camera
    // multicast then leaks out physical NICs -- a saturated WiFi multicast
    // queue backpressures the writers and collapses the tick rate.
    const bool xml_configured_transports =
        !pqos.transport().user_transports.empty() ||
        !pqos.transport().use_builtin_transports;
    if (std::getenv("FASTDDS_BUILTIN_TRANSPORTS") == nullptr &&
        !xml_configured_transports) {
      pqos.setup_transports(eprosima::fastdds::rtps::BuiltinTransports::UDPv4);
    }
    // Use the effective domain id resolved by the abstraction layer
    // (--ros-domain-id, else ROS_DOMAIN_ID, else the default domain 0).
    const uint32_t domain_id =
        static_cast<uint32_t>(MiddlewareConfig::GetEffectiveDomainId());
    _participant =
        efd::DomainParticipantFactory::get_instance()->create_participant(domain_id, pqos);
    if (_participant == nullptr) {
      log_error("FastDDSSharedParticipant: Failed to create DomainParticipant");
      return nullptr;
    }
  }
  ++_refcount;
  return _participant;
}
 
void FastDDSSharedParticipant::release() {
  std::lock_guard<std::mutex> lock(_mutex);
  if (_refcount == 0u) {
    log_error("FastDDSSharedParticipant::release() called with refcount already 0");
    return;
  }
  --_refcount;
  if (_refcount == 0u && _participant != nullptr) {
    // delete_contained_entities() drains all Topics and TypeSupports still
    // owned by the participant before the participant itself is deleted.
    // Without this call, TypeSupport objects registered with register_type()
    // but not explicitly unregistered could be leaked or double-freed.
    _participant->delete_contained_entities();
    efd::DomainParticipantFactory::get_instance()->delete_participant(_participant);
    _participant = nullptr;
    _type_refcounts.clear();
  }
}
 
void FastDDSSharedParticipant::retain_type(const std::string& type_name) {
  std::lock_guard<std::mutex> lock(_mutex);
  ++_type_refcounts[type_name];
}
 
void FastDDSSharedParticipant::release_type(const std::string& type_name) {
  std::lock_guard<std::mutex> lock(_mutex);
  auto it = _type_refcounts.find(type_name);
  if (it == _type_refcounts.end() || it->second == 0u) {
    return;
  }
  --it->second;
  if (it->second == 0u) {
    // Unregister the type from the shared participant so the TypeSupport
    // refcount inside FastDDS reaches zero cleanly.
    if (_participant != nullptr) {
      _participant->unregister_type(type_name);
    }
    _type_refcounts.erase(it);
  }
}
 
} // namespace ros2
} // namespace carla
 
#endif // !CARLA_ROS2_MIDDLEWARE_TESTING