FastDDS源码解析 六

最新推荐文章于 2024-09-20 11:49:02 发布
最新推荐文章于 2024-09-20 11:49:02 发布
阅读量523 收藏 1
点赞数 2
分类专栏： DDS 文章标签： 中间件 c++ 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzZhangYiLong/article/details/136536541
版权

writer数据发送过程分析

追踪代码：

void WriterHistory::notify_writer(CacheChange_t* a_change,
        const std::chrono::time_point<std::chrono::steady_clock>& max_blocking_time)
{
    //调用StatelessWriter发送
    mp_writer->unsent_change_added_to_history(a_change, max_blocking_time);
}

调用FlowController的接口:

void StatelessWriter::unsent_change_added_to_history(
        CacheChange_t* change,
        const std::chrono::time_point<std::chrono::steady_clock>& max_blocking_time)
{
    std::lock_guard<RecursiveTimedMutex> guard(mp_mutex);
    auto payload_length = change->serializedPayload.length;
    // Notify the datasharing readers
    // This also prepares the metadata for late-joiners
    if (is_datasharing_compatible())
    {
        datasharing_delivery(change);
    }
    // Now for the rest of readers
    if (!fixed_locators_.empty() || getMatchedReadersSize() > 0)
    {
        //真实发送接口
        flow_controller_->add_new_sample(this, change, max_blocking_time);
    }
    else
    {
    }
}

发送链路如下:

bool add_new_sample(
            fastrtps::rtps::RTPSWriter* writer,
            fastrtps::rtps::CacheChange_t* change,
            const std::chrono::time_point<std::chrono::steady_clock>& max_blocking_time) override
    {
        return add_new_sample_impl(writer, change, max_blocking_time);
    }

add_new_sample_impl:

    template<typename PubMode = PublishMode>
    typename std::enable_if<std::is_base_of<FlowControllerPureSyncPublishMode, PubMode>::value, bool>::type
    add_new_sample_impl(
            fastrtps::rtps::RTPSWriter* writer,
            fastrtps::rtps::CacheChange_t* change,
            const std::chrono::time_point<std::chrono::steady_clock>& max_blocking_time)
    {
        // This call should be made with writer's mutex locked.
        fastrtps::rtps::LocatorSelectorSender& locator_selector = writer->get_general_locator_selector();
        std::lock_guard<fastrtps::rtps::LocatorSelectorSender> lock(locator_selector);
        //构建消息组
        fastrtps::rtps::RTPSMessageGroup group(participant_, writer, &locator_selector);
        if (fastrtps::rtps::DeliveryRetCode::DELIVERED !=
                writer->deliver_sample_nts(change, group, locator_selector,max_blocking_time))
        {
        }

        return true;
    }

deliver_sample_nts:

DeliveryRetCode StatefulWriter::deliver_sample_nts(
        CacheChange_t* cache_change,
        RTPSMessageGroup& group,
        LocatorSelectorSender& locator_selector, // Object locked by FlowControllerImpl
        const std::chrono::time_point<std::chrono::steady_clock>& max_blocking_time)
{
    DeliveryRetCode ret_code = DeliveryRetCode::DELIVERED;
    if (there_are_remote_readers_)
    {
        //通过网络发送
        ret_code = deliver_sample_to_network(cache_change, group, locator_selector, max_blocking_time);
    }
    check_acked_status();
    return ret_code;
}

deliver_sample_nts:

DeliveryRetCode StatelessWriter::deliver_sample_nts(
        CacheChange_t* cache_change,
        RTPSMessageGroup& group,
        LocatorSelectorSender& locator_selector, // Object locked by FlowControllerImpl
        const std::chrono::time_point<std::chrono::steady_clock>& )
{
    uint64_t change_sequence_number = cache_change->sequenceNumber.to64long();
    NetworkFactory& network = mp_RTPSParticipant->network_factory();
    DeliveryRetCode ret_code = DeliveryRetCode::DELIVERED;
    //current_sequence_number_sent_ = 0  change_sequence_number = 1
    if (current_sequence_number_sent_ != change_sequence_number)
    {
        current_sequence_number_sent_ = change_sequence_number;
        current_fragment_sent_ = 0;
    }

    // Send the new sample to intra-process readers.
    if (0 == current_fragment_sent_)
    {
        // matched_local_readers_  为空，还没有匹配的reader
        for_matched_readers(matched_local_readers_, [&, cache_change](ReaderLocator& reader)
                {
                    intraprocess_delivery(cache_change, reader);
                    return false;
                });
    }

    try
    {
        // n_fragments = 0
        uint32_t n_fragments = cache_change->getFragmentCount();
        //m_separateSendingEnabled 默认 false 
        if (m_separateSendingEnabled)
        {
            if (0 < n_fragments)
            {
            }
            else
            {
                //matched_remote_readers_  此时也为空
                for (std::unique_ptr<ReaderLocator>& it : matched_remote_readers_)
                {
                    reader_data_filter_->is_relevant(*cache_change, it->remote_guid()))
                    {
                        group.sender(this, &*it);
                        size_t num_locators = it->locators_size();
                        if (group.add_data(*cache_change, is_inline_qos_expected_))
                        {
                            add_statistics_sent_submessage(cache_change, num_locators);
                        }
                        else
                        {
                            ret_code = DeliveryRetCode::NOT_DELIVERED;
                        }
                    }
                }
            }
        }
        else
        {
            // num_locators = 1
            size_t num_locators = locator_selector.locator_selector.selected_size() + fixed_locators_.size();
            if (0 < num_locators)
            {
                // n_fragments = 0
                if (0 < n_fragments)
                {
                    for (FragmentNumber_t frag = current_fragment_sent_ + 1;
                        DeliveryRetCode::DELIVERED == ret_code && frag <= n_fragments; ++frag)
                    {
                        if (group.add_data_frag(*cache_change, frag, is_inline_qos_expected_))
                        {
                            current_fragment_sent_ = frag;
                            add_statistics_sent_submessage(cache_change, num_locators);
                        }
                        else
                        {
                            ret_code = DeliveryRetCode::NOT_DELIVERED;
                        }
                    }
                }
                else
                {
                    //正式发送处
                    if (group.add_data(*cache_change, is_inline_qos_expected_))
                    {
                        add_statistics_sent_submessage(cache_change, num_locators);
                    }
                    else
                    {
                        ret_code = DeliveryRetCode::NOT_DELIVERED;
                    }
                }
            }
        }

        on_sample_datas(cache_change->write_params.sample_identity(),
                cache_change->writer_info.num_sent_submessages);
        on_data_sent();

    }
    //不走该处发送
    group.sender(this, &locator_selector);
    if (DeliveryRetCode::DELIVERED == ret_code &&
            change_sequence_number > last_sequence_number_sent_)
    {
        // This update must be done before calling the callback.
        last_sequence_number_sent_ = change_sequence_number;
        unsent_changes_cond_.notify_all();
        if (nullptr != mp_listener)
        {
            //释放掉 cache_change
            mp_listener->onWriterChangeReceivedByAll(this, cache_change);
        }
    }

    return ret_code;
}

下一层发送接口 RTPSMessageGroup::add_data ：

bool RTPSMessageGroup::add_data(
        const CacheChange_t& change,
        bool expectsInlineQos)
{
    assert(nullptr != sender_);

    CacheChangeInlineQoSWriter qos_writer(change);
    InlineQosWriter* inline_qos;
    inline_qos = (change.inline_qos.length > 0 && nullptr != change.inline_qos.data) ? &qos_writer : nullptr;

    //打包dst guid 0.1.0.c7
    const EntityId_t& readerId = get_entity_id(sender_->remote_guids());
    CacheChange_t change_to_add;
    change_to_add.copy_not_memcpy(&change);
    change_to_add.serializedPayload.data = change.serializedPayload.data;
    change_to_add.serializedPayload.length = change.serializedPayload.length;
    // 打包src guid 0.1.0.c2
    change_to_add.writerGUID = endpoint_->getGuid();

    bool is_big_submessage;
    //拷贝给 submessage_msg_
    if (!RTPSMessageCreator::addSubmessageData(submessage_msg_, &change_to_add, endpoint_->getAttributes().topicKind,
            readerId, expectsInlineQos, inline_qos, &is_big_submessage))
    {
        return false;
    }
    change_to_add.serializedPayload.data = nullptr;
    //下层发送接口
    return insert_submessage(is_big_submessage);
}

insert_submessage这一步未能发送。add_new_sample_impl结束后，会调用RTPSMessageGroup析构:实际发送动作在这里。

RTPSMessageGroup::~RTPSMessageGroup() noexcept(false)
{
    try
    {
        send();
    }
    catch (...)
    {
        throw;
    }
}

send()具体过程在后文分析,至此announceParticipantState分析完毕。这次发送实际发送给0.1.0.c7,因为自身存在0.1.0.c7的reader,因此也会接收到,但不会处理。
后面会进入writer.unsent_changes_reset()每隔一段时间广播一次,确保有其他新加入的参与者收到。

RegisterReceiver 分析

    //从列表中取出receiver
    for (auto& receiver : m_receiverResourcelist)
    {
        //进行注册
        receiver.Receiver->RegisterReceiver(receiver.mp_receiver);
    }

这里在前面分析中共create了3个receiver。注册过程:

void ReceiverResource::RegisterReceiver(
        MessageReceiver* rcv)
{
    std::lock_guard<std::mutex> _(mtx);

    if (receiver == nullptr)
    {
        receiver = rcv;
    }
}

至此RTPSParticipantImpl->enable()分析完毕。

zzZhangYiLong
关注
专栏目录
Fast DDS（1）
pony12的专栏
12-13 689
eProsima Fast DDS是DDS（数据分发服务）规范的C++实现，DDS是由对象管理组（OMG）定义的协议。eProsima Fast DDS库提供应用程序编程接口（API）和通信协议，用于部署以数据为中心的发布者-用户（DCPS）模型，目的是在实时系统之间建立高效可靠的信息分发。eProsima Fast DDS在资源处理方面具有可预测性、可扩展性、灵活性和高效性。https://fast-dds.docs.eprosima.com/en/latest/
【FastDDS源码剖析】CacheChange_t
桃花朵朵的博客
01-15 310
CacheChange_t在Fast DDS中扮演着重要的角色，并且对于实时通信和数据发布-订阅模型的实现具有关键意义。它是Fast DDS中用于管理数据变化的关键组件之一，用于表示在数据发布者和订阅者之间交换的数据单元，并在DDS中的发布-订阅过程中起到关键的作用。CacheChange_t结构中并没有包含实际的数据，而是包含了数据的指针(参考)，以及与数据相关的元数据，如时间戳、序列号等。通过CacheChange_t，Fast DDS能够有效地跟踪和传输数据更新，以保证可靠的通信和数据一致性。
FASTDDS和ZeroMQ
最新发布
远方雪的专栏
09-20 715
（原名Fast-RTPS）是一种基于DDS（Data Distribution Service）标准的实现，由eProsima开发。它是一个开源的中间件，专为高性能分布式系统设计，广泛应用于机器人、航空航天、医疗等领域。FastDDS支持多种通信模式，包括发布/订阅、点对点等，并提供了灵活的QoS（Quality of Service）策略来满足不同应用的需求。
Fast DDS 介绍
Captain--Jack
04-12 1969
前面已经简要介绍过DDS协议规范了，接下来我们来看一个它的C++实现----Fast DDS。eProsima Fast-DDS是eprosima对于DDS的C++实现，这是一个免费开源软件，遵循Apache License 2.0。eProsima Fast DDS在性能，功能和对最新版本RTPS标准（RTPS 2.2）的遵守方面均处于领先地位。它最为被大家知道的可能是因为被ROS2设定为默认的消息中间件。Fast DDS由以下几部分组成：1.DDS API接口实现；
机器人开发--Fast DDS
天道酬勤
06-20 2260
数据分发服务DDS，Fast DDS是实现该协议厂商之一。
FastDDS-源码编译&安装&测试
生活不止眼前的苟且
02-07 7153
大家好，我是小鱼，今天被群友在群里催了DDS相关的文章里，说好的来源码体验一下DDS来着，小鱼不能再咕咕咕了，所以今天就分享一下，FastDDS的安装和体验。 FastDDS和普通ROS包一样，有二进制安装、源码编译、Docker三种安装方式。 因为官方把二进制和Docker放到了官网 而且要填写个人信息才能下载 而且下载速度超级超级慢 而且不方便观摩源码 所以小鱼带你一起从源码进行安装。 本来想做成一键安装的，省的大家敲脚本了！！ 但是绝对不能惯着，让大家多复制粘贴一下（其实是为了凑文章字数），小鱼就带大
快速DDS：最完善的DDS-已证明：大量成功案例
01-30
eProsima快速DDS eprosima Fast DDS （以前称为Fast RTPS）是OMG（对象管理组）的DDS（数据分发服务）标准的C ++实现。 eProsima Fast DDS实现了RTPS（实时发布订阅）协议，该协议通过对象管理组（OMG）联盟定义和维护的不可靠传输（例如UDP）提供发布者与订阅者的通信。 RTPS还是为数据分发服务（DDS）标准定义的有线互操作性协议。 eProsima Fast DDS公开了一个API，可以直接访问RTPS协议，从而使用户可以完全访问协议内部。 该库的一些主要功能是： 用于实时应用程序的可配置的最大努力和可靠的发布-订阅通信策略。 即插即用的连接性，以便网络的任何其他成员自动发现任何新的应用程序。 模块化和可扩展性允许网络中复杂而简单的设备不断增长。 可配置的网络行为和可互换的传输层：为每个部署选择最佳协议和系统输入/输出通道组合。 两个API层：一个高级的发布者-订阅者层（专注于可用性（DDS））和一个较低的Writer-Reader层，该层提供对RTPS协议内部工作的更好访问。 eProsima Fas
fastdds源码解析
05-30
FastDDS源码解析可以从以下几个方面入手： 1. 架构设计：FastDDS的架构非常复杂，涉及到多线程、网络通信、协议解析等多个方面。源码解析需要从整体上理解其架构设计，包括各个模块之间的关系、数据流动、状态转换...
【FastDDS源码剖析】EDP/EDPListener/EDPSimple
桃花朵朵的博客
06-10 223
前一篇文章介绍了PDP(Participant Discovery Phase )，Participant发现之后需要EDP。EDP的代码看起来比较绕，我们分一下几个方面介绍EDP。一是要做什么，二是为了达到这个目的需要发送什么，三是具体如何实现的。
【FastDDS源码剖析】PDP/PDPListener/PDPSimple
桃花朵朵的博客
05-25 204
我们用三篇文章来介绍FastDDS的Simple Discovery机制。发现分为两个阶段，一是Participant Discovery Phase (PDP)，同一个DomainID下的DomainParticipants 相互发现，二是Endpoint Discovery Phase (EDP)，DomainParticipants之间交换DataWriters 和 DataReaders的信息，从而使DataWriters 和 DataReaders相互匹配。
【FastDDS源码剖析】GUID_T
桃花朵朵的博客
01-12 352
本文将对Fast DDS中的GUID_T进行分析，并探讨GUID_T在Fast DDS内部的关键作用。GUID_T是Fast DDS中一种重要的标识符类型，用于唯一标识实体。在分布式系统中，实体的唯一标识对于数据交换和通信的正确性至关重要。GUID_T作为全局唯一标识符，在Fast DDS中扮演着关键的角色。它用于标识DDS实体（如主题、订阅者、发布者）。GUID_T的生成和管理机制保证了在Fast DDS中的实体的唯一性。本文将深入研究Fast DDS中GUID_T的实现细节和关键功能。
FastDDS-1.开始
zhangzl419
02-27 1802
FastDDS的快速开始，通过本文能够快速了解fastdds的使用方法。
优雅的玩转Fast-DDS
yiyu20180729的博客
04-20 777
Fast-DDS
一篇文章搞懂FastDfs(全是干货，建议收藏）
热门推荐
BUG
05-23 3万+
这里写目录标题1. 什么是分布式文件系统2. 为什么要使用分布式文件系统3. FastDFS 与 HDFS比较4. 什么是FastDFS5. 常见术语6. FastDFS架构7. FastDFS上传过程8. FastDFS下载过程9. Linux上FastDFS安装注：一定要先启动Tracker，在启动Storage9.1 基础环境安装1.下载安装包：2. 安装基础环境3. 安装libfatscommon函数库4. 进入libfastcommon文件夹，编译并且安装5. 安装fastdfs主程序文件6. 安
Fast DDS 介绍与使用
usstmiracle的博客
09-01 1335
在上一篇中，我们介绍了DDS，eProsima的Fast DDS是DDS规范的C++实现，Fast DDS的前称是Fast RTPS，目前ROS2将Fast DDS作为默认的DDS中间件实现。Fast DDS主要包括以下内容：DDS APIDDS采用的通信模型是一种多对多单向数据交换，其中产生数据的应用程序将数据发布到属于使用数据的应用程序的订阅者的本地缓存。信息流由负责数据交换的实体之间建立的服务质量(QoS)策略来控制。作为一个以数据为中心的模型，DDS建立在所有感兴趣的应用程序都可以访问的“全局数据空
Fast DDS入门一、Fast DDS介绍
咸鱼爱幻想的博客
02-11 8399
Fast DDS是DDS（数据分发服务）规范的C++实现，DDS是由对象管理组（OMG）定义的协议。Fast DDS库提供应用程序编程接口（API）和通信协议，用于部署以数据为中心的发布-订阅（DCPS）模型，目的是在实时系统之间建立高效可靠的信息分发。Fast DDS在资源处理方面具有可预测性、可扩展性、灵活性和高效性。为了满足这些要求，它使用了类型化接口，并依赖于一个多对多的分布式网络范例，该范例巧妙地允许将通信的发布方和订阅方分离。Fast DDS包括：DDS API实现。
fastdds的快速使用
neuzhangno的博客
11-09 3037
fastdds的入门级用例并使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值