当我们使用HDL代码在描述硬件功能时，主要有三种描述方式，即结构化描述方式、数据流描述方式、行为级描述方式。在平时编程时，可根据实际情况及个人喜好选择其中一种或者几种混合在一起进行自己的HDL代码编写。下面对三种描述方式进行介绍。
1.结构化描述方式
结构化描述方式时抽象级别最低的描述方式，但同时也是最接近于实际硬件的描述方式。采用结构化描述方式来编写HDL代码，其思路就跟在面包板上搭建数字电路是一样的,编程就是一个一个的器件相连。

但结构化描述不常用，原因有二：

1.使用结构化描述方式不宜描述功能复杂电路。因为我们大脑不仅要抽象出电路逻辑功能，还要抽象出具体实现形式。

2.不同FPGA厂商提供的软件集成开发环境中的原语使用名称是不一样的，代码编写起来不通用。

但结构化描述方式也有优势。父模块调用子模块的过程只能通过结构化的描述方式来实现。

言而总之，结构化描述方式的特征就是实例化语句。

一个例子

输入abcd分别为一比特逻辑，当ab不相等且cd不相等时输出o为1，否则输出o为0.要用结构化描述方式编写代码，必须先抽象出数字电路结构（即具体用到什么门电路）。

比如说采用下图的门电路（答案不唯一）



这里采用两个异或门和一个与门。

verilog实现
module aa（
input a,b,c,d,
output o
);
wire tmp0,tmp1;
XOR2 m0(.O(tmp0),.I0(a),.I1(b));
XOR2 m1(.O(tmp1),.I0(c),.I1(d));
AND m2(.O(o),.I0(tmp0),.I1(tmp1));
endmodule

2.数据流描述方式
数据流描述方式，又可称为寄存器传输级描述，他主要从数据的变换和传送角度来描述设计模块，并且使用的语句多为和硬件行为一致的并行语句。

数据流描述方式描述上例。
module aa(
input a,b,c,d,
output o
);
wire tmp0,tmp1;
assign tmp0 = a ^ b;
assign tmp1 = c ^ d;
assign o = tmp0 & tmp1;
endmodule

对比结构化描述方式，数据流描述方式清晰地阐明数据从输入到输出的传递情况。但是队医tmp0,tmp1,o却没有显式地规定一定要用什么具体电路去实现。比如，数据流的描述只说明tmp0可以=由ab异或产生，但并没有说明用什么门电路来实现异或操作。是直接一个异或门，还是使用与或非搭建）。这一部分工作交给编译器。

到这里，你可能想问前面结构化描述方式就说明异或操作就用一个异或门来实现了吗？况且FPGA基本单位也不是一个个的与或非异或门啊。其实前面结构化描述方式使用的原语。类似于一个IP核，核内描述就能够说明使用的是一个什么门电路。
3.行为级描述
行为级描述方式的主要载体就是串行语句，例如ifelse同时辅以并行语句用以描述各个算法之间的连接关系
module aa(
input a,b,c,d,
output o
);

always@(a,b,c,d)
if(a != b && c != d)
	o = 1'b1;
else 
	0 = 1'b0;
	
endmodule

行为级描述简直就是自然语言的直译啊。所以行为级描述抽象级别最高、概括能力也最强。
摘自《FPGA之道》

行为子类型是一个可复用的类所具备的重要性质，这篇文章主要介绍一下行为子类型和Java中关于泛型的子类型。


行为子类型

Java中一个非常重要的技术就是继承，子类可以通过继承父类获得父类的方法和字段。一般来说，通过继承关系得到的子类是父类的一个更加具体的描述，我想这就是子类型的由来。我们可以通过以访问父类型的方式来访问子类型而不会得到不一样的结果。行为子类型需要满足下面几个性质：

1.1子类型可以增加方法，但是不可删。

1.2子类型需要实现抽象方法。

1.3子类型不能具有更强的前置条件。

1.4子类型不能具有更弱的后置条件。

1.5参数类型逆变。

Java不支持这一条件，因为Java具有重载的技术，如果支持逆变，重载技术会很复杂。

1.6返回值、异常协变。

1.7不变量保持。

对于其中的协变和逆变，依然是通过行为子类型来确定的，如果一个类是另外一个类的行为子类型，那么可以通过返回这个子类型来代替父类，这就是协变（子类型代替父类型）；相反使用父类型来代替子类型就是逆变。


包含泛型的行为子类型

举个栗子，List<Number>和List<Integer>两个类型，Integer是Number的子类型，按理说一个存储Number的集合应该也能存储一个Integer的集合，但是Java中并不支持这点。同样List<List>和List<ArrayList>,即使是接口-实现类也不满足。

Java提供了通配符这项技术，List<? extend Number>表示Number以及继承Number的所有子类型。List<? super Integer>表示Integer以及Integer的所有父类型。通过这样的技术，我们就可以满足泛型的行为子类型了。

三、wait语句
wait语句是一种不可综合的电平触发事件控制语句，有如下两种形式：
 
wait(条件表达式) 语句/语句块;
wait(条件表达式);

对于第一种形式，语句块可以是串行块（begin…end）或并行块（fork…join）。当逻辑表达式为“真”时，语句块立即得到执行；否则，暂停进程并等待，直到逻辑表达式变为“真”，再开始执行。
对于第二种形式，当仿真执行到wait语句时，如果条件表达式为真，那么立即结束该语句的执行，仿真程序继续往下执行；否则，仿真程序进入等待状态，直到条件表达式为真。

 [设计模式]行为模式-状态模式(C++描述)
second60 20180509
1. 什么是状态模式
对于一些人或事特，会有不同状态，而一个状态会在不同的表现下转移到下一个状态。
通常情况下，我们可能写个if..else语句进行判断，或switch语句进行判断，但是当状态越来越多时，代码将变得不可维护，可读性和扩展性变得很差。同时，状态逻辑和动作逻辑没有分离。而状态模式正是解决这样的问题。

状态模式，使我们把状态逻辑和动作实现分离出来，每个状态封装到一个类中。
 
2. 状态模式结构图
 
 
2.1 分析
1. 环境类：定义客户感兴趣的接口。维护一个ConcreteState子类的实例，这个实例定义当前状态。
2. 状态抽象类：定义状态的抽象接口，封装与Context相关的接口
3. 具体状态类：每一个子类实现一个状态相关的行为。
2.2 代码实现
class  Context;
// 状态父类
class  State
{
public:
virtual ~State(){}
virtual void OperationInterface(Context* context) = 0;
virtual void OperationChangeState(Context* context) = 0;
protected:
bool ChangeState(Context* context,State* state)
{
context->ChangeState(st);
}
};
// 具体状态类
class  ConcreteStateA: public State
{
public:
void OperationInterface(Context* context)
{
//doing
}

void OperationChangeState(Context* context)
{
OperationInterface(context);
this->ChangeState(context, new ConcreteStateB());
}
};

// 具体状态类
class  ConcreteStateB: public State
{
public:
void OperationInterface(Context* context)
{
//doing
}

void OperationChangeState(Context* context)
{
OperationInterface(context);
this->ChangeState(context, new ConcreteStateA());
}

};

//环境类
class Context
{
public:
Context(State* state){_state = state;}
~Context(){delete _state;}
bool ChangeState(State* state)
{
this->_state = state;
return true;
}

void OperationInterface()
{
_state->OperationInterface(this);
}

void OperationChangeState()
{
_state->OperationChangeState(this);
}

private:
friend class State;
State* _state;
};

int main()
{
State* st = new ConcreteStateA();
Context* con = new Context(st);
con->OperationChangeState();
con->OperationChangeState();
con->OperationChangeState();
//释放
return 0;
}
2.3 优点
1. 对象的状态逻辑和动作实现分离，状态分布在不同子类中
2. 封装了转换规则
3. 枚举了可能的状态，确定了状态的种类
4. 将所有与某个状态有关的行为放到了一个类中，方便增加新的状态
5. 多个环境对象可共享一个状态对象，减少对象的个数
2.4 缺点
1. 因为状态分布在不同子类中，所以整体状态图的理解成本大
2. 会增加系统类和对象的个数
3. 状态模式结构与实现都较为复杂，如果使用不当，导致结构和代码混乱
4. 新增状态，可能会修改相互转换的其他状态
 
2.5 状态模式和策略模式
状态模式和策略模式结构图很相似，但两者的用途不同。
状态模式主要适应对象状态改变时的不同处理策略
策略模式为具体算法和实现接口的解耦
 
 
3 适用场景
1、行为随状态改变而改变的场景。 
2、条件、分支语句的代替者。
 
4 例子
1： 电梯的状态：开门，关门，停，运行
代码：
// 四种状态
enum ELiftState
{
ELiftState_Open		= 1,
ELiftState_Close	= 2,
ELiftState_Stop		= 3,
ELiftState_Run		= 4,
};

//电梯状态抽象类
class LiftState
{
public:
LiftState(){}
void setContext(Context* context){_context = context;}
virtual ~LiftState(){}
virtual void open() = 0;
virtual void close() = 0;
virtual void stop() = 0;
virutal void run() = 0;
private:
Context* _context;
};
// 具体状态类
class OpenningState:public LiftState
{
public:
OpenningState(Context* context):LiftState(context){}
void close()
{
this->_context->setLiftState(ELiftState_Close);
this->_context->getLiftState()->close();
}
void open()
{
 	cout << “continue openning” << endl;
}
void run(){}
void stop(){}
};
// 具体状态类
class ClosingState:public LiftState
{
public:
ClosingState(Context* context):LiftState(context){}
void close()
{
cout << “continue closing” << endl;
}
void open()
{
this->_context->setLiftState(ELiftState_Open);
this->_context->getLiftState()->open();
}
void run()
{
this->_context->setLiftState(ELiftState_Run);
this->_context->getLiftState()->run();
}
void stop()
{
this->_context->setLiftState(ELiftState_Stop);
this->_context->getLiftState()->stop();
}
};

// 具体状态类
class RunningState:public LiftState
{
public:
RunningState(Context* context):LiftState(context){}
void close(){}
void open(){}
void run()
{
cout << “keep running” << endl;
}
void stop()
{
this->_context->setLiftState(ELiftState_Stop);
this->_context->getLiftState()->stop();
}
};
class StoppingState:public LiftState
{
public:
StoppingState(Context* context):LiftState(context){}
void close(){}
void open()
{
this->_context->setLiftState(ELiftState_Open);
this->_context->getLiftState()->open();
}
void run()
{
this->_context->setLiftState(ELiftState_Run);
this->_context->getLiftState()->run();
}
void stop()
{
cout << “keep stop”<< endl;
}
};

class Context
{
public:
Context(){}
void setLiftState(LiftState* state)
{
_now_state = state;
state->setContext(this);
}
void open(){_now_state->open();}
void close(){_now_state->close();}
void run(){_now_state->run();}
void stop(){_now_state->stop();}
private:
LiftState * _now_state;
};

int main()
{
Context* context = new Context();
context->setLiftState(new ClosingState());
context->open();
context->close();
context->run();
context->stop();
}
5 总结
状态模式，把状态逻辑和动作分离，状态在状态子类中，动作在Context中.两者互相变化独立即，改变状态逻辑可以很容易复用Context的动作，也可以在不影响State派生类的前提下创建Context子类来更改或替换动作。
状态模式使用比较广泛，凡是涉及到状态转换，或分支判断的，都可以采用状态模式，但在有适用的情况下使用。
 
下节预告：观察都模式