libvma状态机代码阅读

# libvma状态机代码阅读

# 理论基础

## 状态转换关系表现形式

- 状态装换图


- 状态装换表


> * 这两种表现形式是等价的，对人类而言，显然状态转换图更为的直观，但对程序而言，状态装换表却更加的直接<br>

> * 程序的世界中，用“二维数组”来承载一个表结构

## 状态机的三要素

* state 状态

* event 事件

* action 转换

## 状态迁移

状态的迁移细分为下面三个步骤：

* 离开之前的状态

* 在执行action过程(状态装换的途中)

* 进入一个新的状态

在这三个步骤中，可以针对性的做不同的事情。


**如图所示**

* 每一个状态，在Enter、Leave这两个时机，可以有其对应的处理逻辑。

* 每一个状态，在状态不同的状态时候，分别有其对应的处理逻辑。

# 代码实现分析

基于上面的基础理论，我们来看一下具体的代码实现。

## 状态装换表的实现

// sparse (big) table event entry

typedef struct {

int next_state; // New state to move to

sm_action_cb_t trans_func; // Do-function

} sm_event_info_t;

@sm_event_info_t 用于描述一个事件event/action<br>

@next_state 下一个状态<br>

@trans_func 该事件下事件转换函数

// sparse (big) table state entry (including all events)

typedef struct sm_state_info{

sm_action_cb_t entry_func; // Entry function

sm_action_cb_t leave_func; // Leave function

sm_event_info_t* event_info; // Event -> Transition function

} sm_state_info_t;

@sm_state_info_t 用于描述一个状态 state<br>

@entry_func leave_func 该状态的Entry、Leave函数<br>

@event_info 该状态的事件列表，表识着处于该状态下，当不同event到来时，做何种action

sm_state_info_t*
m_p_sm_table; // pointer to full SM table

m_p_sm_table = (sm_state_info_t*)malloc(m_max_states * sizeof(sm_state_info_t));

for (st=0; st<m_max_states; st++) {

m_p_sm_table[st].event_info = (sm_event_info_t*)malloc(m_max_events * sizeof(sm_event_info_t));

}

以上代码中，创建了一个m_max_states * m_max_events的二维表。这个二维表就是状态装换表，用的是表驱动算法。

## 状态机的构建

用户看到的和理解的是上面显示的状态装换图，那么如何将这种状态装换图输入给程序，让程序解析并存储到转换表中呢？

** 首先 **

我们定义一种数据结构，让用户可以形象的表示出他看到和理解状态转换图。

// Short table line

typedef struct {

int state;
// State to handle event

int event;
// Event to handle

int next_state;
// New state to move to

sm_action_cb_t
action_func; // Do-function

} sm_short_table_line_t;

@sm_short_table_line_t 我们定义了一种“线”的结构，让用户可以表示出状态转换图中所看到的一条条转换路线

@state 线的一头，起始状态

@next_state 线的另外一头，终止状态

@event 事件

@action_func 动作

** 其次 **

为了让用户可以表示出Entry、Leave时的action，我们定义了两个特殊的event，一个特殊的状态来表示这个过程

#define SM_NO_ST
(-2)

#define SM_STATE_ENTRY
(-4)

#define SM_STATE_LEAVE
(-5)

@个人觉得这个SM_STATE_ENTRY 应该命名为SM_EVENT_ENTRY


这样用户就可以像上面描述状态路线一样来描述Entry、Leave

** 最终 **

用户是这么来描述一个状态装换图的：

sm_short_table_line_t sm_short_table[] = {

// {curr state,
event, next state,
action func }

{ SM_ST_A, SM_STATE_ENTRY, SM_NO_ST, sm_st_entry},

{ SM_ST_A, SM_EV_1, SM_ST_A, sm_st_A_ev_1},

{ SM_ST_A, SM_EV_2, SM_ST_B,sm_st_A_ev_2},

{ SM_ST_A, SM_EV_3, SM_ST_C, sm_st_A_ev_3},

{ SM_ST_A, SM_STATE_LEAVE, SM_NO_ST, sm_st_leave},

{ SM_ST_B, SM_STATE_ENTRY, SM_NO_ST, sm_st_entry},

{ SM_ST_B, SM_EV_1, SM_ST_B, sm_st_B_ev_1},

{ SM_ST_B, SM_EV_2, SM_ST_C, sm_st_B_ev_2},

{ SM_ST_B, SM_EV_3, SM_ST_A, sm_st_B_ev_3},

{ SM_ST_B, SM_STATE_LEAVE, SM_NO_ST, sm_st_leave},

{ SM_ST_C, SM_STATE_ENTRY, SM_NO_ST, sm_st_entry},

{ SM_ST_C, SM_EV_1, SM_ST_C, sm_st_C_ev_1},

{ SM_ST_C, SM_EV_2, SM_ST_A, sm_st_C_ev_2},

{ SM_ST_C, SM_EV_3, SM_ST_B, sm_st_C_ev_3},

{ SM_ST_C, SM_STATE_LEAVE, SM_NO_ST, sm_st_leave},

SM_TABLE_END

};

@SM_TABLE_END 是预先定义的一个宏，来标识数组结束

** 接口 **

state_machine(void*
app_hndl,

int start_state,

int
max_states,

int
max_events,

sm_short_table_line_t*
short_table,

sm_action_cb_t
default_entry_func,

sm_action_cb_t
default_leave_func,

sm_action_cb_t
default_trans_func,

sm_new_event_notify_cb_t
new_event_notify_func

);

@app_hndl 应用句柄

@start_state 初始化起始的状态

@max_states 最大状态个数

@max_events 最大事件个数

@short_table 状态机路线图

@default_entry_func

@default_leave_func

@default_trans_func 默认的处理函数

@new_event_notify_func 通知函数，有新事件过来后被调用

g_sm = new state_machine(NULL,

SM_ST_A,

SM_ST_LAST,

SM_EV_LAST,

sm_short_table,

sm_default_trans_func,

NULL,

NULL,

print_event_info);

## 事件触发

int process_event(int event, void* ev_data);

@event 事件

@ev_data 自定义事件数据

一个新事件的到来，会引起状态发生变换，并产生一系列的动作：

1. new_event_notify_func

2. leave_func

3. trans_func

4. entry_func

按照上面的顺序，会调用这么4个回调函数。

## 竞争

* 当一个事件正在处理，另一个事件到来，如何应对？

* process_event() 接口线程安全吗？

状态机的实现采用先来先服务的原则，理论上不存在同时到达的概念，所以引入了一个FIFO队列：

sm_fifo*
m_sm_fifo; // fifo queue for the events

int state_machine::lock_in_process(int event, void* ev_data)

{

if (!m_b_is_in_process) {

m_b_is_in_process = 1;

sm_logfunc("lock_in_process: critical section free. Locking it");

}

else {

m_sm_fifo->push_back(event, ev_data);

sm_logfunc("lock_in_process: critical section is in use");

return -1;

}

return 0;

}

void state_machine::unlock_in_process()

{

m_b_is_in_process = 0;

if (m_sm_fifo->is_empty()) {

sm_logfunc("unlock_in_process: there are no pending events");

}

else {

sm_logfunc("unlock_in_process: there are pending events");

sm_fifo_entry_t ret = m_sm_fifo->pop_front();

process_event(ret.event, ret.ev_data);

}

}

以上代码描述了状态机单事件处理的过程：

1. 当当前状态空闲时，直接处理事件

2. 当当前状态非空闲时，推入FIFO队列，留着后续处理

3. 处理完当前事件后，从FIFO队列取后续事件继续处理

** 问题 **

该接口通过`m_b_is_in_process`变量来标识状态，并非线程安全。