5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

enter/exit moved outside of the states, into the fsm. Now i just use the type_name function to get a state name

Browse Source
master
Francisco Paisana 5 years ago committed by Francisco Paisana
parent 4a4827a603
commit b699e0e490
2 changed files with 139 additions and 132 deletions
Show Stats Download Patch File Download Diff File

156
lib/include/srslte/common/fsm.h
Unescape Escape View File

@ -31,7 +31,7 @@
#include <memory> #include <memory>
#include <tuple> #include <tuple>
// Helper to print a type name for logging //! Helper to print the name of a type for logging
#if defined(__GNUC__) && !defined(__clang__) #if defined(__GNUC__) && !defined(__clang__)
template <typename T> template <typename T>
std::string get_type_name() std::string get_type_name()
@ -48,8 +48,16 @@ std::string get_type_name()
} }
#endif #endif
//! This version leverages type deduction. (e.g. get_type_name(var))
template <typename T>
std::string get_type_name(const T& t)
{
return get_type_name<T>();
}
namespace srslte { namespace srslte {
//! When there is no state transition
struct same_state { struct same_state {
}; };
@ -60,26 +68,9 @@ struct state_name_visitor {
template <typename State> template <typename State>
void operator()(State&& s) void operator()(State&& s)
{ {
name = s.name(); name = get_type_name(s);
}
const char* name = "invalid state";
};
template <typename TargetVariant, typename PrevState>
struct variant_convert {
template <typename State>
void operator()(State& s)
{
static_assert(not std::is_same<typename std::decay<State>::type, typename std::decay<PrevState>::type>::value,
"State cannot transition to itself.\n");
if (p != nullptr) {
srslte::get<PrevState>(*v).exit();
} }
v->transit(std::move(s)); std::string name = "invalid state";
srslte::get<State>(*v).enter();
}
TargetVariant* v;
PrevState* p;
}; };
struct fsm_helper { struct fsm_helper {
@ -91,12 +82,51 @@ struct fsm_helper {
template <typename FSM, typename State> template <typename FSM, typename State>
using disable_if_fsm_state = typename get_fsm_state_list<FSM>::template disable_if_can_hold<State>; using disable_if_fsm_state = typename get_fsm_state_list<FSM>::template disable_if_can_hold<State>;
template <typename FSM>
static auto call_init(FSM* f) -> decltype(f->derived()->do_init())
{
f->derived()->do_init();
}
static void call_init(...) {}
template <typename FSM, typename State>
static auto call_enter(FSM* f, State* s) -> decltype(f->enter(*s))
{
f->enter(*s);
call_init(s);
}
static void call_enter(...) {}
template <typename FSM, typename State>
static auto call_exit(FSM* f, State* s) -> decltype(f->exit(*s))
{
f->exit(*s);
}
static void call_exit(...) {}
template <typename FSM, typename PrevState>
struct variant_convert {
variant_convert(FSM* f_, PrevState* p_) : f(f_), p(p_) {}
template <typename State>
void operator()(State& s)
{
static_assert(not std::is_same<typename std::decay<State>::type, typename std::decay<PrevState>::type>::value,
"State cannot transition to itself.\n");
call_exit(f, &srslte::get<PrevState>(f->states));
f->states.transit(std::move(s));
call_enter(f, &srslte::get<State>(f->states));
}
FSM* f;
PrevState* p;
};
template <typename FSM>
struct enter_visitor { struct enter_visitor {
enter_visitor(FSM* f_) : f(f_) {}
template <typename State> template <typename State>
void operator()(State&& s) void operator()(State&& s)
{ {
s.do_enter(); call_enter(f, &s);
} }
FSM* f;
}; };
//! Stayed in same state //! Stayed in same state
@ -109,7 +139,7 @@ struct fsm_helper {
template <typename FSM, typename... Args, typename PrevState> template <typename FSM, typename... Args, typename PrevState>
static void handle_state_change(FSM* f, choice_t<Args...>* s, PrevState* p) static void handle_state_change(FSM* f, choice_t<Args...>* s, PrevState* p)
{ {
fsm_details::variant_convert<decltype(f->states), PrevState> visitor{.v = &f->states, .p = p}; fsm_details::fsm_helper::variant_convert<FSM, PrevState> visitor{f, p};
s->visit(visitor); s->visit(visitor);
} }
//! Simple state transition in FSM //! Simple state transition in FSM
@ -117,11 +147,9 @@ struct fsm_helper {
static enable_if_fsm_state<FSM, State> handle_state_change(FSM* f, State* s, PrevState* p) static enable_if_fsm_state<FSM, State> handle_state_change(FSM* f, State* s, PrevState* p)
{ {
static_assert(not std::is_same<State, PrevState>::value, "State cannot transition to itself.\n"); static_assert(not std::is_same<State, PrevState>::value, "State cannot transition to itself.\n");
if (p != nullptr) { call_exit(f, &srslte::get<PrevState>(f->states));
srslte::get<PrevState>(f->states).do_exit();
}
f->states.transit(std::move(*s)); f->states.transit(std::move(*s));
srslte::get<State>(f->states).do_enter(); call_enter(f, &srslte::get<State>(f->states));
} }
//! State not present in current FSM. Attempt state transition in parent FSM in the case of NestedFSM //! State not present in current FSM. Attempt state transition in parent FSM in the case of NestedFSM
template <typename FSM, typename State, typename PrevState> template <typename FSM, typename State, typename PrevState>
@ -129,7 +157,8 @@ struct fsm_helper {
{ {
static_assert(FSM::is_nested, "State is not present in the FSM list of valid states"); static_assert(FSM::is_nested, "State is not present in the FSM list of valid states");
if (p != nullptr) { if (p != nullptr) {
srslte::get<PrevState>(f->states).do_exit(); // srslte::get<PrevState>(f->states).do_exit();
call_exit(f, &srslte::get<PrevState>(f->states));
} }
handle_state_change(f->parent_fsm()->derived(), s, static_cast<typename FSM::derived_t*>(f)); handle_state_change(f->parent_fsm()->derived(), s, static_cast<typename FSM::derived_t*>(f));
} }
@ -181,23 +210,9 @@ struct fsm_helper {
} // namespace fsm_details } // namespace fsm_details
//! Base class for states and FSMs
class state_t
{
public:
state_t() = default;
virtual const char* name() const = 0;
void do_enter() { enter(); }
void do_exit() { exit(); }
protected:
virtual void enter() {}
virtual void exit() {}
};
//! CRTP Class for all non-nested FSMs //! CRTP Class for all non-nested FSMs
template <typename Derived> template <typename Derived>
class fsm_t : public state_t class fsm_t
{ {
protected: protected:
using base_t = fsm_t<Derived>; using base_t = fsm_t<Derived>;
@ -206,6 +221,9 @@ protected:
{ {
public: public:
using derived_t = Derived; using derived_t = Derived;
using Derived::do_init;
using Derived::enter;
using Derived::exit;
using Derived::react; using Derived::react;
using Derived::states; using Derived::states;
using Derived::unhandled_event; using Derived::unhandled_event;
@ -219,10 +237,10 @@ public:
struct state_list : public choice_t<States...> { struct state_list : public choice_t<States...> {
using base_t = choice_t<States...>; using base_t = choice_t<States...>;
template <typename... Args> template <typename... Args>
state_list(Args&&... args) : base_t(std::forward<Args>(args)...) state_list(fsm_t<Derived>* f, Args&&... args) : base_t(std::forward<Args>(args)...)
{ {
if (not Derived::is_nested) { if (not Derived::is_nested) {
fsm_details::fsm_helper::enter_visitor visitor{}; fsm_details::fsm_helper::enter_visitor<derived_view> visitor{f->derived()};
this->visit(visitor); this->visit(visitor);
} }
} }
@ -255,7 +273,7 @@ public:
return srslte::get_if<State>(derived()->states); return srslte::get_if<State>(derived()->states);
} }
const char* get_state_name() const std::string get_state_name() const
{ {
fsm_details::state_name_visitor visitor{}; fsm_details::state_name_visitor visitor{};
derived()->states.visit(visitor); derived()->states.visit(visitor);
@ -279,13 +297,15 @@ protected:
derived_view* derived() { return static_cast<derived_view*>(this); } derived_view* derived() { return static_cast<derived_view*>(this); }
const derived_view* derived() const { return static_cast<const derived_view*>(this); } const derived_view* derived() const { return static_cast<const derived_view*>(this); }
void do_enter() void do_init()
{ {
enter(); fsm_details::fsm_helper::enter_visitor<derived_view> visitor{derived()};
fsm_details::fsm_helper::enter_visitor visitor{};
derived()->states.visit(visitor); derived()->states.visit(visitor);
} }
void enter() {}
void exit() {}
template <typename Event> template <typename Event>
void unhandled_event(Event&& e) void unhandled_event(Event&& e)
{ {
@ -327,6 +347,8 @@ public:
protected: protected:
using parent_fsm_t = ParentFSM; using parent_fsm_t = ParentFSM;
using fsm_t<Derived>::enter;
using fsm_t<Derived>::do_init;
ParentFSM* fsm_ptr = nullptr; ParentFSM* fsm_ptr = nullptr;
}; };
@ -364,21 +386,10 @@ public:
using fsm_t<Derived>::trigger; using fsm_t<Derived>::trigger;
// states // states
struct idle_st : public state_t { struct idle_st {
const char* name() const final { return "idle"; }
idle_st(Derived* f_) : fsm(f_) {}
void exit()
{
fsm->launch_counter++;
fsm->log_h->info("Proc %s: Starting run no. %d\n", fsm->derived()->name(), fsm->launch_counter);
}
Derived* fsm;
}; };
struct complete_st : public srslte::state_t { struct complete_st {
complete_st(Derived* fsm_, bool success_) : fsm(fsm_), success(success_) {} complete_st(bool success_) : success(success_) {}
const char* name() const final { return "complete"; }
void enter() { fsm->trigger(srslte::proc_complete_ev<bool>{success}); }
Derived* fsm;
bool success; bool success;
}; };
@ -392,20 +403,13 @@ public:
trigger(proc_launch_ev<Args...>(std::forward<Args>(args)...)); trigger(proc_launch_ev<Args...>(std::forward<Args>(args)...));
} }
// template <typename... Args> protected:
// void trigger(proc_launch_ev<Args...> e) void exit(idle_st& s)
// { {
// if (not base_t::template is_in_state<idle_st>()) { launch_counter++;
// log_h->error("Proc %s: Ignoring launch because procedure is already running\n", base_t::derived()->name()); log_h->info("Starting run no. %d\n", launch_counter);
// return; }
// } void enter(complete_st& s) { trigger(srslte::proc_complete_ev<bool>{s.success}); }
// base_t::trigger(std::move(e));
// }
// template <typename T>
// void trigger(T&& t)
// {
// base_t::trigger(std::forward<T>(t));
// }
private: private:
int launch_counter = 0; int launch_counter = 0;

113
lib/test/common/fsm_test.cc
Unescape Escape View File

@ -36,48 +36,29 @@ public:
uint32_t idle_enter_counter = 0, state1_enter_counter = 0; uint32_t idle_enter_counter = 0, state1_enter_counter = 0;
uint32_t foo_counter = 0; uint32_t foo_counter = 0;
const char* name() const override { return "fsm1"; } // states
fsm1(srslte::log_ref log_) : srslte::fsm_t<fsm1>(log_) {} struct idle_st {
// idle state
struct idle_st : public srslte::state_t {
idle_st(fsm1* f_) : f(f_) { f->idle_enter_counter++; }
void enter() final { f->log_h->info("fsm1::%s::enter called\n", name()); }
void exit() final { f->log_h->info("fsm1::%s::exit called\n", name()); }
const char* name() const final { return "idle"; }
fsm1* f;
}; };
struct state1 {
// simple state
class state1 : public srslte::state_t
{
public:
state1(fsm1* f_) : f(f_) { f->state1_enter_counter++; }
void enter() final { f->log_h->info("fsm1::%s::enter called\n", name()); }
void exit() final { f->log_h->info("fsm1::%s::exit called\n", name()); }
const char* name() const final { return "state1"; }
fsm1* f;
}; };
fsm1(srslte::log_ref log_) : srslte::fsm_t<fsm1>(log_) {}
// this state is another FSM // this state is another FSM
class fsm2 : public srslte::nested_fsm_t<fsm2, fsm1> class fsm2 : public srslte::nested_fsm_t<fsm2, fsm1>
{ {
public: public:
struct state_inner : public srslte::state_t { // states
const char* name() const final { return "state_inner"; } struct state_inner {
state_inner(fsm2* f_) : f(f_) {}
void enter() { f->log_h->info("fsm2::%s::enter called\n", name()); }
// void exit() final { f->log_h->info("fsm2::%s::exit called\n", name()); }
fsm2* f;
}; };
fsm2(fsm1* f_) : nested_fsm_t(f_) {} fsm2(fsm1* f_) : nested_fsm_t(f_) {}
~fsm2() { log_h->info("%s being destroyed!", name()); } ~fsm2() { log_h->info("%s being destroyed!", get_type_name(*this).c_str()); }
void enter() final { log_h->info("%s::enter called\n", name()); }
void exit() { log_h->info("%s::exit called\n", name()); }
const char* name() const final { return "fsm2"; }
protected: protected:
void enter(state_inner& s) { log_h->info("fsm1::%s::enter called\n", get_type_name<state_inner>().c_str()); }
void exit(state_inner& s) { log_h->info("fsm1::%s::exit called\n", get_type_name<state_inner>().c_str()); }
// FSM2 transitions // FSM2 transitions
auto react(state_inner& s, ev1 e) -> srslte::same_state; auto react(state_inner& s, ev1 e) -> srslte::same_state;
auto react(state_inner& s, ev2 e) -> state1; auto react(state_inner& s, ev2 e) -> state1;
@ -87,6 +68,20 @@ public:
}; };
protected: protected:
// enter/exit
template <typename State>
void enter(State& s)
{
log_h->info("%s::enter called\n", get_type_name<State>().c_str());
}
template <typename State>
void exit(State& s)
{
log_h->info("%s::exit called\n", get_type_name<State>().c_str());
}
void enter(idle_st& s);
void enter(state1& s);
// transitions // transitions
auto react(idle_st& s, ev1 e) -> state1; auto react(idle_st& s, ev1 e) -> state1;
auto react(state1& s, ev1 e) -> fsm2; auto react(state1& s, ev1 e) -> fsm2;
@ -95,9 +90,20 @@ protected:
void foo(ev1 e) { foo_counter++; } void foo(ev1 e) { foo_counter++; }
// list of states // list of states
state_list<idle_st, state1, fsm2> states{idle_st{this}}; state_list<idle_st, state1, fsm2> states{this, idle_st{}};
}; };
void fsm1::enter(idle_st& s)
{
log_h->info("%s::enter custom called\n", get_type_name(s).c_str());
idle_enter_counter++;
}
void fsm1::enter(state1& s)
{
log_h->info("%s::enter custom called\n", get_type_name(s).c_str());
state1_enter_counter++;
}
// FSM event handlers // FSM event handlers
auto fsm1::fsm2::react(state_inner& s, ev1 e) -> srslte::same_state auto fsm1::fsm2::react(state_inner& s, ev1 e) -> srslte::same_state
{ {
@ -108,24 +114,24 @@ auto fsm1::fsm2::react(state_inner& s, ev1 e) -> srslte::same_state
auto fsm1::fsm2::react(state_inner& s, ev2 e) -> state1 auto fsm1::fsm2::react(state_inner& s, ev2 e) -> state1
{ {
log_h->info("fsm2::state_inner::react called\n"); log_h->info("fsm2::state_inner::react called\n");
return state1{parent_fsm()}; return {};
} }
auto fsm1::react(idle_st& s, ev1 e) -> state1 auto fsm1::react(idle_st& s, ev1 e) -> state1
{ {
log_h->info("fsm1::%s::react called\n", s.name()); log_h->info("%s::react called\n", get_type_name(s).c_str());
foo(e); foo(e);
return state1{this}; return {};
} }
auto fsm1::react(state1& s, ev1 e) -> fsm2 auto fsm1::react(state1& s, ev1 e) -> fsm2
{ {
log_h->info("fsm1::%s::react called\n", s.name()); log_h->info("%s::react called\n", get_type_name(s).c_str());
return fsm2{this}; return {this};
} }
auto fsm1::react(state1& s, ev2 e) -> srslte::choice_t<idle_st, fsm2> auto fsm1::react(state1& s, ev2 e) -> srslte::choice_t<idle_st, fsm2>
{ {
log_h->info("fsm1::%s::react called\n", s.name()); log_h->info("%s::react called\n", get_type_name(s).c_str());
return idle_st{this}; return idle_st{};
} }
// Static Checks // Static Checks
@ -154,39 +160,39 @@ int test_hsm()
log_h->set_level(srslte::LOG_LEVEL_INFO); log_h->set_level(srslte::LOG_LEVEL_INFO);
fsm1 f{log_h}; fsm1 f{log_h};
TESTASSERT(std::string{f.name()} == "fsm1"); TESTASSERT(f.idle_enter_counter == 1);
TESTASSERT(std::string{f.get_state_name()} == "idle"); TESTASSERT(get_type_name(f) == "fsm1");
TESTASSERT(f.get_state_name() == "fsm1::idle_st");
TESTASSERT(f.is_in_state<fsm1::idle_st>()); TESTASSERT(f.is_in_state<fsm1::idle_st>());
TESTASSERT(f.foo_counter == 0); TESTASSERT(f.foo_counter == 0);
TESTASSERT(f.idle_enter_counter == 1);
// Moving Idle -> State1 // Moving Idle -> State1
ev1 e; ev1 e;
f.trigger(e); f.trigger(e);
TESTASSERT(std::string{f.get_state_name()} == "state1"); TESTASSERT(f.get_state_name() == "fsm1::state1");
TESTASSERT(f.is_in_state<fsm1::state1>()); TESTASSERT(f.is_in_state<fsm1::state1>());
// Moving State1 -> fsm2 // Moving State1 -> fsm2
f.trigger(e); f.trigger(e);
TESTASSERT(std::string{f.get_state_name()} == "fsm2"); TESTASSERT(f.get_state_name() == "fsm1::fsm2");
TESTASSERT(f.is_in_state<fsm1::fsm2>()); TESTASSERT(f.is_in_state<fsm1::fsm2>());
TESTASSERT(std::string{f.get_state<fsm1::fsm2>()->get_state_name()} == "state_inner"); TESTASSERT(f.get_state<fsm1::fsm2>()->get_state_name() == "fsm1::fsm2::state_inner");
// Fsm2 does not listen to ev1 // Fsm2 does not listen to ev1
f.trigger(e); f.trigger(e);
TESTASSERT(std::string{f.get_state_name()} == "fsm2"); TESTASSERT(std::string{f.get_state_name()} == "fsm1::fsm2");
TESTASSERT(f.is_in_state<fsm1::fsm2>()); TESTASSERT(f.is_in_state<fsm1::fsm2>());
TESTASSERT(std::string{f.get_state<fsm1::fsm2>()->get_state_name()} == "state_inner"); TESTASSERT(f.get_state<fsm1::fsm2>()->get_state_name() == "fsm1::fsm2::state_inner");
// Moving fsm2 -> state1 // Moving fsm2 -> state1
f.trigger(ev2{}); f.trigger(ev2{});
TESTASSERT(std::string{f.get_state_name()} == "state1"); TESTASSERT(std::string{f.get_state_name()} == "fsm1::state1");
TESTASSERT(f.is_in_state<fsm1::state1>()); TESTASSERT(f.is_in_state<fsm1::state1>());
TESTASSERT(f.state1_enter_counter == 2); TESTASSERT(f.state1_enter_counter == 2);
// Moving state1 -> idle // Moving state1 -> idle
f.trigger(ev2{}); f.trigger(ev2{});
TESTASSERT(std::string{f.get_state_name()} == "idle"); TESTASSERT(std::string{f.get_state_name()} == "fsm1::idle_st");
TESTASSERT(f.is_in_state<fsm1::idle_st>()); TESTASSERT(f.is_in_state<fsm1::idle_st>());
TESTASSERT(f.foo_counter == 1); TESTASSERT(f.foo_counter == 1);
TESTASSERT(f.idle_enter_counter == 2); TESTASSERT(f.idle_enter_counter == 2);
@ -203,14 +209,11 @@ struct procevent2 {
struct proc1 : public srslte::proc_fsm_t<proc1, int> { struct proc1 : public srslte::proc_fsm_t<proc1, int> {
public: public:
struct procstate1 : public srslte::state_t { struct procstate1 {
const char* name() const final { return "procstate1"; }
}; };
proc1(srslte::log_ref log_) : base_t(log_) {} proc1(srslte::log_ref log_) : base_t(log_) {}
const char* name() const final { return "proc1"; }
protected: protected:
// Transitions // Transitions
auto react(idle_st& s, srslte::proc_launch_ev<int*> ev) -> procstate1; auto react(idle_st& s, srslte::proc_launch_ev<int*> ev) -> procstate1;
@ -232,17 +235,17 @@ auto proc1::react(idle_st& s, srslte::proc_launch_ev<int*> ev) -> procstate1
auto proc1::react(procstate1& s, procevent1 ev) -> complete_st auto proc1::react(procstate1& s, procevent1 ev) -> complete_st
{ {
log_h->info("success!\n"); log_h->info("success!\n");
return {this, true}; return {true};
} }
auto proc1::react(procstate1& s, procevent2 ev) -> complete_st auto proc1::react(procstate1& s, procevent2 ev) -> complete_st
{ {
log_h->info("failure!\n"); log_h->info("failure!\n");
return {this, false}; return {false};
} }
auto proc1::react(complete_st& s, srslte::proc_complete_ev<bool> ev) -> idle_st auto proc1::react(complete_st& s, srslte::proc_complete_ev<bool> ev) -> idle_st
{ {
log_h->info("propagate results %s\n", s.success ? "success" : "failure"); log_h->info("propagate results %s\n", s.success ? "success" : "failure");
return {this}; return {}; //{this};
} }
int test_fsm_proc() int test_fsm_proc()

Write Preview
Loading…
Cancel
Save