SystemC入门学习-第5章 同步逻辑建模

本章重点学习同步逻辑中的触发器，锁存器的一些建模规范：

• 触发器建模
• 带异步置位/复位
• 带同步置位/复位
• 锁存器建模

5.1 触发器建模

        触发器建模的关键是敏感列表的规范。SC_MODULE的规范写法中出现过sensitive 参数列表是事件敏感， 对触发器建模来讲，SC_MODULE的结构不变，只需要将事件敏感修改为沿敏感，写法如下, 这样的沿可用于指定bool或者sc_logic类型的信号或者端口。就sc_logic类型而言，非0到0的跳变被认为是负跳变沿，非1到1的跳变被认为是正跳变沿。

//规定用正跳变沿
sensitive_pos

//规定用负跳变沿
sensitive_neg

        下面是一个D触发器模型, 敏感列表包含了指定于端口clk的沿敏感sensitive_pos， 表明只有在端口clk的正跳变沿时刻，数据输入d才得以传送到输出q。

//file basic_ff.h
#include "systemc.h"

SC_MODULE(basic_ff){
    sc_in <bool> d, clk;
    sc_out <bool> q;

    void prc_basic_ff();
    
    SC_CTOR(basic_ff){
        SC_METHOD(prc_basic_ff);
        sensitive_pos << clk;
    }

};

//file basic_ff.cpp
#include "basic_ff.h"

void basic_ff::prc_basic_ff(){
    q = d;
}

        下面是一个包含多位端口的触发器示例，为prc_gang_ffs指定了负跳变沿敏感，所以这是一个由负跳变沿触发的触发器。

#include "systemc.h"

const int WIDTH =4;

SC_MODULE(gang_ffs){
    sc_in <sc_uint<WIDTH> > current_state;
    sc_in <bool> clock;
    sc_out <sc_uint<WIDTH> > next_state;

    void prc_gang_ffs();
    
    SC_CTOR(gang_ffs){
        SC_METHOD(prc_gang_ffs);
        sensitive_neg << clock;
    }

};

void gang_ffs::prc_gang_ffs(){
    next_state = current_state;
}

5.2 多进程

        一个模块可以具有多个SC_METHOD进程。每个进程可以模拟组合逻辑（使用事件敏感），也可以模拟同步逻辑（使用沿敏感）。进程之间的通信联系必须使用信号。

        一个进程不能既有沿敏感，又有事件敏感，并且在沿敏感的规范中只可以使用一个bool型的信号或者端口。

        下面是一个流水线的序列检测器。这个例子中，触发器用于生成信号。当输入数据流检测到‘101’序列时，检测器的输出为1。综合后的逻辑如下图。

#include "systemc.h"

SC_MODULE(seq_det){
    sc_in <bool> clk, data;
    sc_out <bool> seq_found;

    void prc_seq_det();//同步逻辑进程
    void prc_output();//组合逻辑进程

    sc_signal <bool> first, second, third;

    SC_CTOR(seq_det){
        SC_METHOD(prc_seq_det);
        sensitive_pos <<clk;

        SC_METHOD(prc_output);
        sensitive << first << second << third;

    }

};

void seq_det::prc_seq_det(){
    first = data;
    second = first; 
    third = second;
}

void seq_det::prc_output(){
    seq_found = first & !second & third;
}

        需要注意到是，信号和端口赋值的∆延迟。对信号和端口的赋值不是立即发生的，而是总发生在一个∆延迟之后。进程之间是可以同步执行的，即当时钟正跳变沿到来时候，进程prc_seq_det被调用，first被赋值，但是second = first, third = second没有执行时候，first的变化导致了进程prc_output的执行，所以此刻second是上个时刻的值，third是上上个时刻的值，所以如果序列中出现了101，就能被检测出来了。

5.3 带异步置位和清零端的触发器

        带异步置位和清零端的触发器编写时，清零输入的正或负跳变沿被指定为沿敏感列表的一部分。即若异步清零为低电平有效，则指定使用负跳变沿；若高电平有效，则使用正跳变沿。下面是一个带异步清零端的增/减计数器。

#include "systemc.h"

const int COUNT_SIZE = 4;
SC_MODULE(count4){
    sc_in <bool> mclk, clear, updown;
    sc_out <sc_uint <COUNT_SIZE> > data_out;

    void sync_block();

    SC_CTOR(count4){
        SC_METHOD(sync_block);
        sensitive_pos << mclk;
        sensitive_neg << clear;
    }

};

void count4::sync_block(){
    if(!clear)  //符合异步条件
        data_out = 0;
    else          //不符合，使用时钟的正跳变沿，即mclk
        if(updown)
            data_out = data_out.read() + 1;
        else
            data_out = data_out.read() - 1;
}

        下面是一个包含异步置位和清零位的触发器建模。置位和清零的输入沿必须指定为敏感列表的一部分。

#include "systemc.h"

const int STATE_BITS = 4;

SC_MODULE(async_states){
    sc_in <bool> clk, reset, set;
    sc_in <sc_uint <STATE_BITS> > current_state;
    sc_out<sc_uint <STATE_BITS> > next_state;

    void prc_async_state();

    SC_CTOR(async_states){
        SC_METHOD(prc_async_state);
        sensitive_neg << clk <<reset;
        sensitive_pos <<set;
    }

};

void async_states::prc_async_state(){
    if (!reset)   //第一个异步条件
        next_state = 0;
    else if(set)  //第二个异步条件
        next_state = 5;
    else          //（隐含的）负跳变沿
        next_state = current_state;
}

        通常情况下，一个进程可以有多个被指定为其敏感列表的跳变沿。并且使用一条这样形式的if语句来描述该进程的行为，在该形式的语句中首先检查的不是时钟条件，而在最后那个else分支中才隐含了时钟条件。若指定使用负跳变沿敏感列表，则还需要使用非时钟条件的逻辑“非”；否则就要使用非时钟条件的正值。如下是这种条件语句的样板程序。

SC_METHOD(my_process);
sensitive_pos << a << b << clk;
sensitive_net << d << e << f;

void my_module::my_process(){
    if(a)
        <异步行为>
    else if (b)
        <异步行为>
    else if (!d) //因为指定了负跳变沿，所以使用逻辑“非”
        <异步行为>
    else if (!f)
        <异步行为>
    else        //时钟的正跳变沿
        <按时钟节拍的行为>
}

5.4 带同步置位和清零端的触发器

        在未带同步置位和清零端得触发器建模时，在敏感列表中只需指定一个时钟跳变沿即可。其置位和清零条件被清晰明确地编写在SC_METHOD进程的代码里。

        如下是一个带低电平有效同步置位端的计数器。（prc_counter代码，书上写了未出现过的变量名：preset，不知道是写错了还是自己哪里没理解清）

#include "systemc.h"

const int COUNT_BITS = 4;

SC_MODULE(sync_count4){
    sc_in <bool> mclk, clear, updown;
    sc_in <sc_uint<COUNT_BITS> > data_in;
    sc_out<sc_uint<COUNT_BITS> > data_out;

    void  prc_counter();
    
    SC_CTOR(sync_count4){
        SC_METHOD(prc_counter);
        sensitive_pos << mclk;
    }
};

void sync_count4::prc_counter(){
    if(!preset)
        data_out = data_in;
    else
        if(updown)
            data_out = data_out.read()+1;
        else
            data_out = data_out.read()-1;
}

同步逻辑如下图：

5.5 多时钟和多相位时钟

        在一个模块中，可以编写任意多个SC_METHOD进程，每个这样的进程都可以是同步或组合的进程。当出现多个同步进程时，可以在不同进程中使用不同的时钟来为设计的逻辑建模。

        下面示例，进程prc_vt15ck在时钟vt15ck的负跳变沿触发，而进程prc_ds1ck则在时钟dslck的正跳变沿触发。

#include "systemc.h"

SC_MODULE(mult_clks){
    sc_in <bool> vt15ck, addclk, adn, resetn, subclr, subn, ds1ck;
    sc_out <bool> ds1_add, ds1_sub;

    void prc_vt15ck();
    void prc_ds1ck();
    sc_signal <bool> add_state, sub_state;

    SC_CTOR(mult_clks){
        SC_METHOD(prc_vt15ck);
        sensitive_neg << vt15ck;
        SC_METHOD(prc_ds1ck);
        sensitive_pos << ds1ck;
    }

};

void mult_clks::prc_vt15ck(){
    add_state = !(addclk | (adn | resetn));
    sub_state = subclr ^ (subn & resetn);
}

void mult_clks::prc_ds1ck(){
    ds1_add = add_state;
    ds1_sub = sub_state;
}

        如下是综合后生成的逻辑。信号add_state和信号sub_state在时钟vt15ck的负跳变沿时刻被赋值，并且它们的值在另外一个时钟ds1ck的正跳变沿时刻被赋予ds1_add和ds1_sub。在RTL建模时，通常规定不允许使用不同时钟沿对同一个信号或端口赋值。

        

        在设计模块中可以使用同一个时钟的不同相位。下面举例说明。进程prc_rising由时钟zclk的正跳变沿触发，进程prc_falling则由时钟zclk的负跳变沿触发。一个进程的输出是另一个进程的输入，用信号d在进程之间通信实现。

#include "systemc.h"

SC_MODULE(multiphase)
{
    sc_in <bool> zclk, a, b, c;
    sc_out <bool> e;

    void prc_rising();
    void prc_falling();

    sc_signal <bool> d;

    SC_CTOR(multiphase){
        SC_METHOD(prc_rising);
        sensitive_pos << zclk;

        SC_METHOD(prc_falling);
        sensitive_neg << zclk;
    }

};

void multiphase::prc_rising(){
    e = d & c;
}

void multiphase::prc_falling(){
    d = a & b;
}

5.6 锁存器建模

        如果没有对进程的所有路径赋值，则在该进程综合后的逻辑中有可能为信号或端口生成锁存器。条件语句如if , switch，是可能在进程内生成多条执行路径的两条语句。

        if语句生成锁存器的例子1：

        当clk为0时候，输出端口z没有被赋值。因此根据该模型的定义，综合后将为端口z生成一个锁存器。

#include "systemc.h"

SC_MODULE(latched_alu){
    sc_in <bool> clk, a,b;
    sc_out <bool> z;

    void prc_alu();

    SC_CTOR(latched_alu){
        SC_METHOD(prc_alu);
        sensitive_pos << clk << a << b;
    }

};

void latched_alu::prc_alu(){
    if(clk)
        z = !( a | b);

}

        switch语句生成锁存器的一个例子2：

#include "systemc.h"

enum states{s0, s1, s2, s3};
const int Z_SIZE = 2;

SC_MODULE(state_update){
    sc_in <states> current_state;
    sc_out <sc_uint<Z_SIZE> > z;

    void prc_state_update();

    SC_CTOR(state_update){
        SC_METHOD(prc_state_update);
        sensitive << current_state;
    }

};

void state_update::prc_state_update(){
    switch(current_state)
    {
        case s0:
        case s3: z=0; break;
        case s1: z = 3; break;
    }

}

避免生成锁存器

        在大多数情况下，生成锁存器是不需要的。所以避免生成锁存器的关键是：若信号或端口在条件语句中被赋值，则必须确认条件语句的所有可能分支中，该信号或端口都被赋予一个值。

也就是，代码覆盖所有的条件分支，或者给端口或信号赋初值。

比如上面示例2，给prc_state_update函数修改如下：

//修改方案1
void state_update::prc_state_update(){
    switch(current_state)
    {
        case s0:
        case s3: z = 0; break;
        case s1: z = 3; break;
        default: z = 1; break;
    }

}

//修改方案2
void state_update::prc_state_update(){
    z = 1; 
    switch(current_state)
    {
        case s0:
        case s3: z = 0; break;
        case s1: z = 3; break;
    }

}

         另一个完整示例：

        下面示例的prc_compute1, prc_compute是生成锁存器和不生成锁存器的写法，以及其综合后的逻辑图对比：

#include "systemc.h"
const int BITS = 2;
enum grade_type { fail, pass, excellent};

SC_MODULE(compute){
    sc_in <sc_uint<BITS> >marks;
    sc_out <grade_type> grade;

    void prc_compute();

    SC_CTOR(compute){
        SC_METHOD(prc_compute);
        sensitive << marks;
    }

};

void compute::prc_compute(){
    if(marks.read() < 5)
        grade = fail;
    else if (marks.read()<7)
        grade = pass;
    else
        grade = excellent;

}

void compute::prc_compute1(){
    if(marks.read() < 5)
        grade = fail;
    else if (marks.read()<7)
        grade = pass;

}

 

5.7 小结

• 同步逻辑建模使用跳变沿敏感的SC_METHOD进程
• 一个模块可以包含任意多个进程，每个进程可以是表示组合逻辑的进程，或者是表示同步逻辑的进程
• 若在一个对时钟跳变沿敏感的进程中对信号或者端口进行赋值，则综合后生成的逻辑为触发器
• 同步逻辑中的异步置位和复位可以使用特定形式的if语句建模
• 必须在if语句或开关语句的所有分支中对信号或端口赋值，否则综合后将生成锁存器
• 若在if语句或开关语句前对信号或端口进行初始化，或者确保在条件语句的所有分支中都对其进行赋值，则综合后可以避免生成锁存器。