实习——————_holo::createholologsubdirectory-CSDN博客

本文链接：https://blog.csdn.net/loveyourz1/article/details/131687611

main

holo::CreateHoloLogSubdirectory("holovis");
holo::log::LogLevel level_set[] = {holo::log::LogLevel::DEBUG, holo::log::LogLevel::INFO, holo::log::LogLevel::WARNING,
                                   holo::log::LogLevel::ERROR, holo::log::LogLevel::FATAL};

std::string log_file_name = holo::GetLogFileAbsolutePath("holovis/" + node_name + ".log");

holo::log::HoloLogger::Initialize(node_name);
if (storage == "on")
{
    holo::log::HoloLogger::SetLogFilePath(log_file_name);
    holo::log::HoloLogger::SetFileRolling(1024 * 1024 * 50, ((single > 0) ? 0 : 5));
}
holo::log::HoloLogger::SetAsynchronousMode(((sync > 0) ? false : true));
holo::log::HoloLogger::SetLogLevel(level_set[log_level]);
if (verbose)
{
    holo::log::HoloLogger::EnableStdout();
}
else
{
    holo::log::HoloLogger::DisableStdout();
}

mallopt(M_MMAP_MAX, 0);
mallopt(M_TRIM_THRESHOLD, -1);

这段代码包含了一系列关于日志记录和内存管理的设置和配置。

首先，在 holo 命名空间下调用了 CreateHoloLogSubdirectory 函数，该函数用于创建名为 “holovis” 的子目录，用于存储日志文件。

然后，定义了一个 holo::log::LogLevel 枚举类型的数组 level_set，其中包含了不同日志级别的枚举值。

接下来，根据给定的 node_name 和文件扩展名，构造了一个日志文件的完整路径 log_file_name。

然后，调用 HoloLogger::Initialize 函数对日志记录器进行初始化，传入了 node_name 作为参数。

接下来的 if 语句检查了变量 storage 是否等于字符串 “on”，如果满足条件，执行其中的代码块。

在该代码块中，使用 HoloLogger::SetLogFilePath 设置日志文件路径为 log_file_name，并调用 HoloLogger::SetFileRolling 设置日志文件的滚动策略，其中第一个参数是日志文件的最大大小（50MB），第二个参数是文件保留的个数。根据 single 变量的值，滚动策略的基准索引可能为 0 或 5。

然后，根据 sync 变量的值，调用 HoloLogger::SetAsynchronousMode 设置日志记录的同步或异步模式。

根据 log_level 变量的值，调用 HoloLogger::SetLogLevel 设置日志记录的级别。log_level 作为索引用于选择 level_set 数组中对应的日志级别。

接下来的 if-else 语句根据 verbose 变量的值，选择是否启用标准输出。

最后，调用了 mallopt 函数来设置内存分配的一些选项。具体来说，M_MMAP_MAX 设置为 0，M_TRIM_THRESHOLD 设置为 -1。这些选项设置了内存管理的相关行为，例如禁用内存映射和修剪操作。

这些代码组合起来完成了对日志记录和内存管理的配置和初始化。具体实现的含义和效果可能需要结合整个程序的上下文来进行更准确的解释。

总线

总线对象（Bus Object）是一种用于进行组件间通信的抽象概念。在软件系统中，不同的组件或模块可能需要相互交换信息、共享数据或进行协调。总线对象提供了一种通信机制，使这些组件能够进行相互之间的通信。

总线对象通常用于实现发布-订阅（Publish-Subscribe）或观察者模式（Observer Pattern），其中一个组件（发布者）将消息发布到总线上，而其他组件（订阅者）则从总线中订阅感兴趣的消息。总线对象充当了消息传递的媒介，使发布者和订阅者之间解耦，并提供了一种松散耦合的通信机制。

总线对象可以是应用程序内部的虚拟对象，也可以是物理硬件上的实际总线，如数据总线、地址总线、控制总线等。具体实现总线对象的方式可以是使用消息队列、事件系统、观察者模式等。

在给定的代码片段中，总线对象通过调用 bus_ptr_->Enable() 方法进行启用，然后使用 BusType::AsyncSpin(1) 函数进行事件的异步处理。这样，允许程序通过总线对象与其他组件进行交互和通信。具体总线对象的实现可能需要参考代码的其他部分或相关文档来确定

message_queue

void StartQueue() 
{
    if (message_queue_is_running_)
    {
        return;
    }
    message_queue_is_running_ = true;
    message_queue_handle_thread_ = std::thread([this] {
        while (this->message_queue_is_running_)
        {
            std::vector<T> received_msgs;
            {
                std::unique_lock<std::mutex> lck(this->message_queue_mutex_);
                if (!this->message_queue_cv_.wait_for(lck, std::chrono::milliseconds(this->message_queue_wait_idle_time_),
                                            [this] { return !this->message_queue_.empty(); }))
                {
                    continue;
                }

                received_msgs.reserve(this->message_queue_.size());
                received_msgs.swap(this->message_queue_);
            }

            this->Consume(received_msgs);
        }

        // liujia: in case some msg left...  
        std::lock_guard<std::mutex> lck(this->message_queue_mutex_);
        std::vector<T> received_msgs;
        received_msgs.reserve(this->message_queue_.size());
        received_msgs.swap(this->message_queue_);
        this->Consume(received_msgs);
    });
}

这段代码是一个名为 “StartQueue” 的函数实现。根据代码逻辑，我可以解释其功能如下：

首先，它检查变量 message_queue_is_running_ 是否为真。如果是真，表示消息队列已经在运行，那么函数会立即返回，不进行任何操作。
如果 message_queue_is_running_ 是假（即消息队列没有在运行），则将其设置为真以表示消息队列正在运行。
接下来，通过创建一个匿名的 std::thread 对象，启动一个线程来执行后续的操作。
在这个线程中，使用一个循环来连续运行，直到 message_queue_is_running_ 变为假。
在每次循环中，首先创建一个 std::vector 类型的变量 received_msgs，用于存储接收到的消息。
然后，使用 std::unique_lockstd::mutex 对象 lck 来锁定 message_queue_mutex_ 互斥量，以确保在访问消息队列时的线程安全。
使用 message_queue_cv_ 条件变量的 wait_for() 函数等待一段时间，直到消息队列不为空，或者超时等待时间耗尽。
如果等待时间耗尽（即没有消息到达），则继续下一次循环。
如果消息队列不为空，将其内容拷贝到 received_msgs 变量中，并清空原来的消息队列。
然后，调用 this->Consume(received_msgs) 函数来处理接收到的消息。
循环会不断重复这个过程，直到 message_queue_is_running_ 变为假。
在循环结束后，为了确保处理所有剩余的消息，再次锁定互斥量，将剩余的消息拷贝到 received_msgs 中，并清空原来的消息队列。
最后，再次调用 this->Consume(received_msgs) 函数来处理剩余的消息。
根据代码的命名和上下文，这段代码实现了一个消息队列的处理逻辑，它从队列中获取消息并通过 Consume 函数进行处理。具体的消息处理逻辑需要查看 Consume 函数的实现或者检查代码的其他部分来确定。