task_fsm.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <etl/fsm.h>
 
#include "kernel_log.hpp"
#include "task_messages.hpp"
 
namespace TaskStatusId {
inline constexpr etl::fsm_state_id_t kUnInit = 0;
inline constexpr etl::fsm_state_id_t kReady = 1;
inline constexpr etl::fsm_state_id_t kRunning = 2;
inline constexpr etl::fsm_state_id_t kSleeping = 3;
inline constexpr etl::fsm_state_id_t kBlocked = 4;
inline constexpr etl::fsm_state_id_t kExited = 5;
inline constexpr etl::fsm_state_id_t kZombie = 6;
}  // namespace TaskStatusId
 
// 前向声明所有状态类，以便在转换表中相互引用
struct StateUnInit;
struct StateReady;
struct StateRunning;
struct StateSleeping;
struct StateBlocked;
struct StateExited;
struct StateZombie;
 
struct StateUnInit : public etl::fsm_state<etl::fsm, StateUnInit,
                                           TaskStatusId::kUnInit, MsgSchedule> {
  auto on_event(const MsgSchedule&) -> etl::fsm_state_id_t {
    return TaskStatusId::kReady;
  }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: UnInit received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
struct StateReady : public etl::fsm_state<etl::fsm, StateReady,
                                          TaskStatusId::kReady, MsgSchedule> {
  auto on_event(const MsgSchedule&) -> etl::fsm_state_id_t {
    return TaskStatusId::kRunning;
  }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: Ready received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
struct StateRunning
    : public etl::fsm_state<etl::fsm, StateRunning, TaskStatusId::kRunning,
                            MsgYield, MsgSleep, MsgBlock, MsgExit> {
  auto on_event(const MsgYield&) -> etl::fsm_state_id_t {
    return TaskStatusId::kReady;
  }
  auto on_event(const MsgSleep&) -> etl::fsm_state_id_t {
    return TaskStatusId::kSleeping;
  }
  auto on_event(const MsgBlock&) -> etl::fsm_state_id_t {
    return TaskStatusId::kBlocked;
  }
  auto on_event(const MsgExit& msg) -> etl::fsm_state_id_t {
    if (msg.has_parent) {
      return TaskStatusId::kZombie;
    }
    return TaskStatusId::kExited;
  }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: Running received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
struct StateSleeping
    : public etl::fsm_state<etl::fsm, StateSleeping, TaskStatusId::kSleeping,
                            MsgWakeup> {
  auto on_event(const MsgWakeup&) -> etl::fsm_state_id_t {
    return TaskStatusId::kReady;
  }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: Sleeping received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
struct StateBlocked : public etl::fsm_state<etl::fsm, StateBlocked,
                                            TaskStatusId::kBlocked, MsgWakeup> {
  auto on_event(const MsgWakeup&) -> etl::fsm_state_id_t {
    return TaskStatusId::kReady;
  }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: Blocked received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
struct StateExited : public etl::fsm_state<etl::fsm, StateExited,
                                           TaskStatusId::kExited, MsgReap> {
  auto on_event(const MsgReap&) -> etl::fsm_state_id_t { return STATE_ID; }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: Exited received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
struct StateZombie : public etl::fsm_state<etl::fsm, StateZombie,
                                           TaskStatusId::kZombie, MsgReap> {
  auto on_event(const MsgReap&) -> etl::fsm_state_id_t {
    return TaskStatusId::kExited;
  }
  auto on_event_unknown(const etl::imessage& msg) -> etl::fsm_state_id_t {
    klog::Warn("TaskFsm: Zombie received unexpected message id={}",
               static_cast<int>(msg.get_message_id()));
    return STATE_ID;
  }
};
 
class TaskFsm {
 public:
  auto Start() -> void { fsm_.start(); }
 
  auto Receive(const etl::imessage& msg) -> void { fsm_.receive(msg); }
 
  [[nodiscard]] auto GetStateId() const -> etl::fsm_state_id_t {
    return fsm_.get_state_id();
  }
 
  TaskFsm() : fsm_(router_id::kTaskFsm) {
    state_list_[0] = &state_uninit_;
    state_list_[1] = &state_ready_;
    state_list_[2] = &state_running_;
    state_list_[3] = &state_sleeping_;
    state_list_[4] = &state_blocked_;
    state_list_[5] = &state_exited_;
    state_list_[6] = &state_zombie_;
    fsm_.set_states(state_list_, 7);
  }
 
  TaskFsm(const TaskFsm&) = delete;
  TaskFsm(TaskFsm&&) = delete;
  auto operator=(const TaskFsm&) -> TaskFsm& = delete;
  auto operator=(TaskFsm&&) -> TaskFsm& = delete;
  ~TaskFsm() = default;
 
 private:
  StateUnInit state_uninit_;
  StateReady state_ready_;
  StateRunning state_running_;
  StateSleeping state_sleeping_;
  StateBlocked state_blocked_;
  StateExited state_exited_;
  StateZombie state_zombie_;
 
  etl::ifsm_state* state_list_[7];
 
  etl::fsm fsm_;
};