Apollo 10.0
自动驾驶开放平台
apollo::cyber::Component< M0, M1, M2, NullType > 模板类 参考abstract

#include <component.h>

类 apollo::cyber::Component< M0, M1, M2, NullType > 继承关系图:
apollo::cyber::Component< M0, M1, M2, NullType > 的协作图:

Public 成员函数

 Component ()
 
 ~Component () override
 
bool Initialize (const ComponentConfig &config) override
 
bool Process (const std::shared_ptr< M0 > &msg0, const std::shared_ptr< M1 > &msg1, const std::shared_ptr< M2 > &msg2)
 
- Public 成员函数 继承自 apollo::cyber::ComponentBase
virtual ~ComponentBase ()
 
virtual bool Initialize (const TimerComponentConfig &config)
 
virtual void Shutdown ()
 
template<typename T >
bool GetProtoConfig (T *config) const
 

额外继承的成员函数

- Public 类型 继承自 apollo::cyber::ComponentBase
template<typename M >
using Reader = cyber::Reader< M >
 
- Protected 成员函数 继承自 apollo::cyber::ComponentBase
virtual bool Init ()=0
 
virtual void Clear ()
 
const std::string & ConfigFilePath () const
 
void LoadConfigFiles (const ComponentConfig &config)
 
void LoadConfigFiles (const TimerComponentConfig &config)
 
- Protected 属性 继承自 apollo::cyber::ComponentBase
std::atomic< bool > is_shutdown_ = {false}
 
std::shared_ptr< Nodenode_ = nullptr
 
std::string config_file_path_ = ""
 
std::vector< std::shared_ptr< ReaderBase > > readers_
 

详细描述

template<typename M0, typename M1, typename M2>
class apollo::cyber::Component< M0, M1, M2, NullType >

在文件 component.h129 行定义.

构造及析构函数说明

◆ Component()

template<typename M0 , typename M1 , typename M2 >
apollo::cyber::Component< M0, M1, M2, NullType >::Component ( )
inline

在文件 component.h131 行定义.

131{}

◆ ~Component()

template<typename M0 , typename M1 , typename M2 >
apollo::cyber::Component< M0, M1, M2, NullType >::~Component ( )
inlineoverride

在文件 component.h132 行定义.

132{}

成员函数说明

◆ Initialize()

template<typename M0 , typename M1 , typename M2 >
bool apollo::cyber::Component< M0, M1, M2, NullType >::Initialize ( const ComponentConfig config)
overridevirtual

重载 apollo::cyber::ComponentBase .

在文件 component.h375 行定义.

376 {
377 node_.reset(new Node(config.name()));
378 LoadConfigFiles(config);
379
380 if (config.readers_size() < 3) {
381 AERROR << "Invalid config file: too few readers.";
382 return false;
383 }
384
385 if (!Init()) {
386 AERROR << "Component Init() failed.";
387 return false;
388 }
389
390 bool is_reality_mode = GlobalData::Instance()->IsRealityMode();
391
392 ReaderConfig reader_cfg;
393 reader_cfg.channel_name = config.readers(1).channel();
394 reader_cfg.qos_profile.CopyFrom(config.readers(1).qos_profile());
395 reader_cfg.pending_queue_size = config.readers(1).pending_queue_size();
396
397 auto reader1 = node_->template CreateReader<M1>(reader_cfg);
398
399 reader_cfg.channel_name = config.readers(2).channel();
400 reader_cfg.qos_profile.CopyFrom(config.readers(2).qos_profile());
401 reader_cfg.pending_queue_size = config.readers(2).pending_queue_size();
402
403 auto reader2 = node_->template CreateReader<M2>(reader_cfg);
404
405 reader_cfg.channel_name = config.readers(0).channel();
406 reader_cfg.qos_profile.CopyFrom(config.readers(0).qos_profile());
407 reader_cfg.pending_queue_size = config.readers(0).pending_queue_size();
408
409 auto role_attr = std::make_shared<proto::RoleAttributes>();
410 role_attr->set_node_name(config.name());
411 role_attr->set_channel_name(config.readers(0).channel());
412
413 std::shared_ptr<Reader<M0>> reader0 = nullptr;
414 if (cyber_likely(is_reality_mode)) {
415 reader0 = node_->template CreateReader<M0>(reader_cfg);
416 } else {
417 std::weak_ptr<Component<M0, M1, M2, NullType>> self =
418 std::dynamic_pointer_cast<Component<M0, M1, M2, NullType>>(
419 shared_from_this());
420
421 auto blocker1 = blocker::BlockerManager::Instance()->GetBlocker<M1>(
422 config.readers(1).channel());
423 auto blocker2 = blocker::BlockerManager::Instance()->GetBlocker<M2>(
424 config.readers(2).channel());
425
426 auto func = [self, blocker1, blocker2,
427 role_attr](const std::shared_ptr<M0>& msg0) {
428 auto start_time = Time::Now().ToMicrosecond();
429 auto ptr = self.lock();
430 if (ptr) {
431 if (!blocker1->IsPublishedEmpty() && !blocker2->IsPublishedEmpty()) {
432 auto msg1 = blocker1->GetLatestPublishedPtr();
433 auto msg2 = blocker2->GetLatestPublishedPtr();
434 ptr->Process(msg0, msg1, msg2);
435 auto end_time = Time::Now().ToMicrosecond();
436 // sampling proc latency and cyber latency in microsecond
437 uint64_t process_start_time;
438 statistics::Statistics::Instance()->SamplingProcLatency<uint64_t>(
439 *role_attr, end_time - start_time);
440 if (statistics::Statistics::Instance()->GetProcStatus(
441 *role_attr, &process_start_time) &&
442 (start_time - process_start_time) > 0) {
443 statistics::Statistics::Instance()->SamplingCyberLatency(
444 *role_attr, start_time - process_start_time);
445 }
446 }
447 } else {
448 AERROR << "Component object has been destroyed.";
449 }
450 };
451
452 reader0 = node_->template CreateReader<M0>(reader_cfg, func);
453 }
454
455 if (reader0 == nullptr || reader1 == nullptr || reader2 == nullptr) {
456 AERROR << "Component create reader failed.";
457 return false;
458 }
459 readers_.push_back(std::move(reader0));
460 readers_.push_back(std::move(reader1));
461 readers_.push_back(std::move(reader2));
462
463 if (cyber_unlikely(!is_reality_mode)) {
464 return true;
465 }
466
467 auto sched = scheduler::Instance();
468 std::weak_ptr<Component<M0, M1, M2, NullType>> self =
469 std::dynamic_pointer_cast<Component<M0, M1, M2, NullType>>(
470 shared_from_this());
471 auto func = [self, role_attr](const std::shared_ptr<M0>& msg0,
472 const std::shared_ptr<M1>& msg1,
473 const std::shared_ptr<M2>& msg2) {
474 auto start_time = Time::Now().ToMicrosecond();
475 auto ptr = self.lock();
476 if (ptr) {
477 ptr->Process(msg0, msg1, msg2);
478 auto end_time = Time::Now().ToMicrosecond();
479 // sampling proc latency and cyber latency in microsecond
480 uint64_t process_start_time;
481 statistics::Statistics::Instance()->SamplingProcLatency<uint64_t>(
482 *role_attr, end_time - start_time);
483 if (statistics::Statistics::Instance()->GetProcStatus(
484 *role_attr, &process_start_time) &&
485 (start_time - process_start_time) > 0) {
486 statistics::Statistics::Instance()->SamplingCyberLatency(
487 *role_attr, start_time - process_start_time);
488 }
489 } else {
490 AERROR << "Component object has been destroyed.";
491 }
492 };
493
494 std::vector<data::VisitorConfig> config_list;
495 for (auto& reader : readers_) {
496 config_list.emplace_back(reader->ChannelId(), reader->PendingQueueSize());
497 }
498 auto dv = std::make_shared<data::DataVisitor<M0, M1, M2>>(config_list);
499 croutine::RoutineFactory factory =
500 croutine::CreateRoutineFactory<M0, M1, M2>(func, dv);
501 return sched->CreateTask(factory, node_->Name());
502}
Definition node.h:31
std::vector< std::shared_ptr< ReaderBase > > readers_
std::shared_ptr< Node > node_
void LoadConfigFiles(const ComponentConfig &config)
uint64_t ToMicrosecond() const
convert time to microsecond (us).
Definition time.cc:85
static Time Now()
get the current time.
Definition time.cc:57
static const std::shared_ptr< BlockerManager > & Instance()
#define cyber_likely(x)
Definition macros.h:29
#define cyber_unlikely(x)
Definition macros.h:30
#define AERROR
Definition log.h:44

◆ Process()

template<typename M0 , typename M1 , typename M2 >
bool apollo::cyber::Component< M0, M1, M2, NullType >::Process ( const std::shared_ptr< M0 > &  msg0,
const std::shared_ptr< M1 > &  msg1,
const std::shared_ptr< M2 > &  msg2 
)

在文件 component.h365 行定义.

367 {
368 if (is_shutdown_.load()) {
369 return true;
370 }
371 return Proc(msg0, msg1, msg2);
372}
std::atomic< bool > is_shutdown_

该类的文档由以下文件生成: