Apollo 10.0
自动驾驶开放平台
类 | 类型定义 | 枚举 | 函数 | 变量
apollo::cyber::croutine 命名空间参考

类

class  CRoutine
 
struct  RoutineContext
 
class  RoutineFactory
 

类型定义

using RoutineFunc = std::function< void()>
 
using Duration = std::chrono::microseconds
 
typedef void(* func) (void *)
 

枚举

enum class  RoutineState {
  READY , FINISHED , SLEEP , IO_WAIT ,
  DATA_WAIT
}
 

函数

void MakeContext (const func &f1, const void *arg, RoutineContext *ctx)
 
void SwapContext (char **src_sp, char **dest_sp)
 
template<typename M0 , typename F >
RoutineFactory CreateRoutineFactory (F &&f, const std::shared_ptr< data::DataVisitor< M0 > > &dv)
 
template<typename M0 , typename M1 , typename F >
RoutineFactory CreateRoutineFactory (F &&f, const std::shared_ptr< data::DataVisitor< M0, M1 > > &dv)
 
template<typename M0 , typename M1 , typename M2 , typename F >
RoutineFactory CreateRoutineFactory (F &&f, const std::shared_ptr< data::DataVisitor< M0, M1, M2 > > &dv)
 
template<typename M0 , typename M1 , typename M2 , typename M3 , typename F >
RoutineFactory CreateRoutineFactory (F &&f, const std::shared_ptr< data::DataVisitor< M0, M1, M2, M3 > > &dv)
 
template<typename Function >
RoutineFactory CreateRoutineFactory (Function &&f)
 

变量

constexpr size_t STACK_SIZE = 2 * 1024 * 1024
 
constexpr size_t REGISTERS_SIZE = 56
 

类型定义说明

◆ Duration

using apollo::cyber::croutine::Duration = typedef std::chrono::microseconds

在文件 croutine.h 第 36 行定义.

◆ func

typedef void(* apollo::cyber::croutine::func) (void *)

在文件 routine_context.h 第 41 行定义.

◆ RoutineFunc

using apollo::cyber::croutine::RoutineFunc = typedef std::function<void()>

在文件 croutine.h 第 35 行定义.

枚举类型说明

◆ RoutineState

enum class apollo::cyber::croutine::RoutineState
strong
枚举值
READY 
FINISHED 
SLEEP 
IO_WAIT 
DATA_WAIT 

在文件 croutine.h 第 38 行定义.

38{ READY, FINISHED, SLEEP, IO_WAIT, DATA_WAIT };

函数说明

◆ CreateRoutineFactory() [1/5]

template<typename M0 , typename F >
RoutineFactory apollo::cyber::croutine::CreateRoutineFactory ( F &&  f,
const std::shared_ptr< data::DataVisitor< M0 > > &  dv 
)

在文件 routine_factory.h 第 51 行定义.

52 {
53 RoutineFactory factory;
54 factory.SetDataVisitor(dv);
55 factory.create_routine = [=]() {
56 return [=]() {
57 std::shared_ptr<M0> msg;
58 for (;;) {
59 CRoutine::GetCurrentRoutine()->set_state(RoutineState::DATA_WAIT);
60 if (dv->TryFetch(msg)) {
61 f(msg);
62 CRoutine::Yield(RoutineState::READY);
63 } else {
64 CRoutine::Yield();
65 }
66 }
67 };
68 };
69 return factory;
70}
f
double f
Definition a_star_strategy.cc:33
apollo::cyber::croutine::RoutineFactory::SetDataVisitor
void SetDataVisitor(const std::shared_ptr< data::DataVisitorBase > &dv)
Definition routine_factory.h:42

◆ CreateRoutineFactory() [2/5]

template<typename M0 , typename M1 , typename F >
RoutineFactory apollo::cyber::croutine::CreateRoutineFactory ( F &&  f,
const std::shared_ptr< data::DataVisitor< M0, M1 > > &  dv 
)

在文件 routine_factory.h 第 73 行定义.

74 {
75 RoutineFactory factory;
76 factory.SetDataVisitor(dv);
77 factory.create_routine = [=]() {
78 return [=]() {
79 std::shared_ptr<M0> msg0;
80 std::shared_ptr<M1> msg1;
81 for (;;) {
82 CRoutine::GetCurrentRoutine()->set_state(RoutineState::DATA_WAIT);
83 if (dv->TryFetch(msg0, msg1)) {
84 f(msg0, msg1);
85 CRoutine::Yield(RoutineState::READY);
86 } else {
87 CRoutine::Yield();
88 }
89 }
90 };
91 };
92 return factory;
93}

◆ CreateRoutineFactory() [3/5]

template<typename M0 , typename M1 , typename M2 , typename F >
RoutineFactory apollo::cyber::croutine::CreateRoutineFactory ( F &&  f,
const std::shared_ptr< data::DataVisitor< M0, M1, M2 > > &  dv 
)

在文件 routine_factory.h 第 96 行定义.

97 {
98 RoutineFactory factory;
99 factory.SetDataVisitor(dv);
100 factory.create_routine = [=]() {
101 return [=]() {
102 std::shared_ptr<M0> msg0;
103 std::shared_ptr<M1> msg1;
104 std::shared_ptr<M2> msg2;
105 for (;;) {
106 CRoutine::GetCurrentRoutine()->set_state(RoutineState::DATA_WAIT);
107 if (dv->TryFetch(msg0, msg1, msg2)) {
108 f(msg0, msg1, msg2);
109 CRoutine::Yield(RoutineState::READY);
110 } else {
111 CRoutine::Yield();
112 }
113 }
114 };
115 };
116 return factory;
117}

◆ CreateRoutineFactory() [4/5]

template<typename M0 , typename M1 , typename M2 , typename M3 , typename F >
RoutineFactory apollo::cyber::croutine::CreateRoutineFactory ( F &&  f,
const std::shared_ptr< data::DataVisitor< M0, M1, M2, M3 > > &  dv 
)

在文件 routine_factory.h 第 120 行定义.

121 {
122 RoutineFactory factory;
123 factory.SetDataVisitor(dv);
124 factory.create_routine = [=]() {
125 return [=]() {
126 std::shared_ptr<M0> msg0;
127 std::shared_ptr<M1> msg1;
128 std::shared_ptr<M2> msg2;
129 std::shared_ptr<M3> msg3;
130 for (;;) {
131 CRoutine::GetCurrentRoutine()->set_state(RoutineState::DATA_WAIT);
132 if (dv->TryFetch(msg0, msg1, msg2, msg3)) {
133 f(msg0, msg1, msg2, msg3);
134 CRoutine::Yield(RoutineState::READY);
135 } else {
136 CRoutine::Yield();
137 }
138 }
139 };
140 };
141 return factory;
142}

◆ CreateRoutineFactory() [5/5]

template<typename Function >
RoutineFactory apollo::cyber::croutine::CreateRoutineFactory ( Function &&  f)

在文件 routine_factory.h 第 145 行定义.

145 {
146 RoutineFactory factory;
147 factory.create_routine = [f = std::forward<Function&&>(f)]() { return f; };
148 return factory;
149}

◆ MakeContext()

void apollo::cyber::croutine::MakeContext ( const func &  f1,
const void *  arg,
RoutineContext *  ctx 
)

在文件 routine_context.cc 第 40 行定义.

40 {
41 ctx->sp = ctx->stack + STACK_SIZE - 2 * sizeof(void *) - REGISTERS_SIZE;
42 std::memset(ctx->sp, 0, REGISTERS_SIZE);
43#ifdef __aarch64__
44 char *sp = ctx->stack + STACK_SIZE - sizeof(void *);
45#else
46 char *sp = ctx->stack + STACK_SIZE - 2 * sizeof(void *);
47#endif
48 *reinterpret_cast<void **>(sp) = reinterpret_cast<void *>(f1);
49 sp -= sizeof(void *);
50 *reinterpret_cast<void **>(sp) = const_cast<void *>(arg);
51}
apollo::cyber::croutine::STACK_SIZE
constexpr size_t STACK_SIZE
Definition routine_context.h:34

◆ SwapContext()

void apollo::cyber::croutine::SwapContext ( char **  src_sp,
char **  dest_sp 
)
inline

在文件 routine_context.h 第 53 行定义.

53 {
54 ctx_swap(reinterpret_cast<void**>(src_sp), reinterpret_cast<void**>(dest_sp));
55}
ctx_swap
void ctx_swap(void **, void **) asm("ctx_swap")

变量说明

◆ REGISTERS_SIZE

constexpr size_t apollo::cyber::croutine::REGISTERS_SIZE = 56
constexpr

在文件 routine_context.h 第 38 行定义.

◆ STACK_SIZE

constexpr size_t apollo::cyber::croutine::STACK_SIZE = 2 * 1024 * 1024
constexpr

在文件 routine_context.h 第 34 行定义.