首发地址个人博客
变量说明
数据类型
SystemC为C++的一个库，因此C++的特性在SystemC中均可以使用，数据类型同理，除了C++中的数据类型外，SystemC也有一些自己的数据类型，如下所示：
- 二值变量：
sc_bit和sc_bv（n为宽度）分别为二值（0、1）变量和任意位宽二值向量。 - 四值变量：
sc_logic和sc_lv（n为宽度）分别为四值（0、1、x、z）变量和任意位宽四值向量 - int型变量：
sc_int和sc_uint（n为宽度）分别为有符号和无符号的不超过64位宽的整型变量 - bigint变量：
sc_bigint和sc_bituing（n为宽度）分别为有符号和无符号任意位宽的整型变量
信号
信号使用sc_signal声明，一般用于连接端口和进程通信（功能进程之间连接信号）
端口
SystemC中端口类型主要有sc_in、sc_out和sc_inout，type中为端口的类型，可以使用C++自带的一些类型，也可以使用SystemC中的数据类型。
sc_out > vec_o;
例如上面为一个输出端口例子，该输出端口名称为vec_o，类型为SystemC的数据类型sc_int。
sc_in > vec1[VEC_WIDTH];
可以声明端口数组，如上所示，声明了一个宽度为VEC_WIDTH的端口数组，每个端口的类型是sc_int。
模块设计——矩阵-向量乘法器
设计一个矩阵-向量乘法器用于熟悉语法，需要注意的是若要使用SystemC特性，需要使用#include "systemc.h"
系统结构
该系统用于实现矩阵-向量乘法的行为级建模，包括以下几个部分：
- 乘法器：实现矩阵-向量乘法功能，由多个向量-向量乘法器构成
- 测试平台：激励生成器，用于产生指定尺寸的矩阵和向量以及时钟复位等控制信号
子模块设计
每个子模块在SystemC使用一个类描述，这个类使用宏SC_MODULE(声明，这里的子模块是向量-向量乘法器，这一部分代码如下所示：
SC_MODULE(vector_mul) {
sc_in clk,rst_n;
sc_in > vec1[VEC_WIDTH],vec2[VEC_WIDTH];
sc_out > vec_o;
void compute_vector_mul(void) {
int temp = 0;
if (rst_n.read() == false) {
vec_o.write(0);
return;
}
for (int i = 0; i < VEC_WIDTH; ++i) {
temp = temp + vec1[i].read() * vec2[i].read();
}
vec_o.write(temp);
};
SC_CTOR(vector_mul) {
SC_METHOD(compute_vector_mul);
sensitive_pos << clk;
sensitive_neg << rst_n;
};
};
一个子模块包括三个部分：端口定义、功能描述与构造函数。端口定义使用上述的端口定义，如下所示，该乘法器定义了两个类型为bool的控制端口：clk和rst_n。分别是时钟和复位端口；还定义了两个输入端口数组，分别是vec1和vec2，数组宽度为VEC_WIDTH（宏定义），类型为有符号整数类型sc_int；此外还定义了一个输出端口vec_o，类型为指定位宽的整数类型sc_int。定义端口后，该部分框图如下所示：
sc_in clk,rst_n;
sc_in > vec1[VEC_WIDTH],vec2[VEC_WIDTH];
sc_out > vec_o;
功能描述使用一个无输入参数无输出参数的方法描述，建议使用.read()读取输入端口的数据并使用.write()向输出端口写入数据。一个模块可以有多个功能描述，这里的功能描述功能类似于Verilog中的always块。SystemC中的赋值基本都是阻塞的，可以在这一函数中使用任意的C++特性和库等。定义了这一方法后，该部分框图如下所示：
void compute_vector_mul(void) {
int temp = 0;
if (rst_n.read() == false) {
vec_o.write(0);
return;
}
for (int i = 0; i < VEC_WIDTH; ++i) {
temp = temp + vec1[i].read() * vec2[i].read();
}
vec_o.write(temp);
};
最后一个部分是构造函数，这一部分是为了注册功能，描述连接关系和敏感列表等。无参数化的构造函数使用SC_CTOR(定义，这里的module name必须与这个类的名称一致。一个类可能有很多方法，只有如下所示的方式定义为METHOD（或THREAD等）的方法才作为模块的一个功能，定义后需要立刻定义敏感列表，只有敏感列表中的变量发生改变时，功能才运行：sensitive <<表示事件（电平）敏感，一般用于组合逻辑建模；sensitive_pos <<和sensitive_neg <<分别为正跳变敏感和负跳变敏感，一般用于时序逻辑建模。完成以上所有部分的定义后，完成对一个子模块的构建。
METHOD是一种阻塞式的功能进程，当这个进程被敏感列表触发之后，获取仿真控制权开始运行，直到运行完成，将控制权返回SystemC仿真内核。使用METHOD注册的功能函数不能含有无限循环，这会导致仿真卡死在这个任务中，控制权无法返回仿真内核。
SC_CTOR(vector_mul) {
SC_METHOD(compute_vector_mul); // 注册为METHOD
sensitive_pos << clk; // clk为正跳变敏感信号
sensitive_neg << rst_n; // rst_n为负跳变敏感信号
};
顶层模块
顶层模块用于实现子模块的连接，代码实现如下所示。除了声明端口以外，还需要在构造函数中定义连接关系。连接关系的定义分为三个部分：模块指针声明、模块实例化和端口连接。
SC_MODULE(matrix_vector_mul) {
sc_in clk,rst_n;
sc_in > matrix[VEC_NUM][VEC_WIDTH];
sc_in > vector_in[VEC_WIDTH];
sc_out > vector_out[VEC_NUM];
vector_mul *pe[VEC_NUM];
SC_CTOR(matrix_vector_mul) {
std::ostringstream pe_name;
for (int i = 0; i < VEC_NUM; ++i) {
pe_name << "pe" << i;
pe[i] = new vector_mul(pe_name.str().c_str());
pe[i]->clk(clk);
pe[i]->rst_n(rst_n);
for (int j = 0; j < VEC_WIDTH; ++j) {
pe[i]->vec1[j](matrix[i][j]);
pe[i]->vec2[j](vector_in[j]);
}
pe[i]->vec_o(vector_out[i]);
pe_name.str("");
}
};
};
模块指针声明如下所示，这里声明了VEC_NUM个子模块指针作为顶层模块的成员变量。
vector_mul *pe[VEC_NUM];
模块实例化如下所示，若使用SC_CTOR宏定义构造函数的子模块，需要使用一个唯一的字符串作为实例名。由于C++没有格式化字符串的功能，因此使用std::ostringstream生成唯一不重复的实例名，再用c_str()转为构造函数指定的类型。
pe[i] = new vector_mul(pe_name.str().c_str());
信号连接额部分使用如下所示的方式完成：
pe[i]->clk(clk); // clk端口与clk信号连接
pe[i]->rst_n(rst_n); // rst_n端口与rst_n信号连接
for (int j = 0; j < VEC_WIDTH; ++j) {
pe[i]->vec1[j](matrix[i][j]); // vec1[j]端口与matrix[i][j]信号连接
pe[i]->vec2[j](vector_in[j]); // vec2[j]端口与vector_in[j]信号连接
}
pe[i]->vec_o(vector_out[i]); // vec_o端口与vector_out[i]信号连接
测试平台设计
平台组件
这里实现的组件仅有激励生成器，该模块与上述模块没有太大的差别，该模块用于生成复位信号和数据信号。
SC_MODULE(driver)
{
sc_in clk;
sc_out rst_n;
sc_out > mat[VEC_NUM][VEC_WIDTH];
sc_out > vec[VEC_WIDTH];
void generate_input(void) {
for (int i = 0; i < VEC_WIDTH; ++i) {
for (int j = 0; j < VEC_NUM; ++j) {
mat[j][i].write(rand() % ((int)pow(2,WIDTH) - 1));
}
vec[i].write(rand() % ((int)pow(2,WIDTH) - 1));
}
while(1) {
wait();
for (int i = 0; i < VEC_WIDTH; ++i) {
for (int j = 0; j < VEC_NUM; ++j) {
mat[j][i].write(rand() % ((int)pow(2,WIDTH) - 1));
}
vec[i].write(rand() % ((int)pow(2,WIDTH) - 1));
}
}
};
void generate_reset(void) {
rst_n.write(1);
wait(1,SC_NS);
rst_n.write(0);
wait(1,SC_NS);
rst_n.write(1);
};
SC_CTOR(driver) {
SC_THREAD(generate_input);
sensitive_neg << clk;
SC_THREAD(generate_reset);
};
};
需要注意的是这里的功能描述和构造函数，如下所示。构造函数中功能成员generate_input和generate_reset均使用THREAD宏注册为功能，这一宏与METHOD的区别是这一种功能进程在仿真开始时运行，碰到wait()跳出，直到敏感列表中的信号再次触发这一进程，从上次跳出的wait()处继续运行，因此这种进程可以使用循环体包括wait()的无限循环。
SC_CTOR(driver) {
SC_THREAD(generate_input);
sensitive_neg << clk;
SC_THREAD(generate_reset);
};
除了使用wait()阻塞运行外，还可以使用wait(将执行延迟指定的时钟周期，如rst_n信号的实现，使用多个wait(延迟执行。
void generate_reset(void) {
rst_n.write(1);
wait(1,SC_NS); // 延迟1ns
rst_n.write(0);
wait(1,SC_NS); // 延迟1ns
rst_n.write(1);
};
平台运行
最终的平台运行集成在main函数中，如下所示，分为以下几个步骤：信号声明，模块声明和端口连接，波形追踪和仿真运行。
#include "systemc.h"
int sc_main(int argc,char* argv[])
{
sc_clock clk("clk",10,SC_NS);
sc_signal rst_n;
sc_signal > mat[VEC_NUM][VEC_WIDTH],vec[VEC_WIDTH];
sc_signal >vec_o[VEC_NUM];
sc_trace_file *fp; // Create VCD file
fp=sc_create_vcd_trace_file("wave");// open(fp), create wave.vcd file
fp->set_time_unit(1, SC_NS); // set tracing resolution to ns
matrix_vector_mul dut("dut");
dut.clk(clk);
dut.rst_n(rst_n);
for (int i = 0; i < VEC_NUM; ++i) {
for (int j = 0; j < VEC_WIDTH; ++j) {
dut.matrix[i][j](mat[i][j]);
}
}
for (int i = 0; i < VEC_WIDTH; ++i) {
dut.vector_in[i](vec[i]);
}
for (int i = 0; i < VEC_NUM; ++i) {
dut.vector_out[i](vec_o[i]);
}
driver d("dri");
d.clk(clk);
d.rst_n(rst_n);
for (int i = 0; i < VEC_WIDTH; ++i) {
for (int j = 0; j < VEC_NUM; ++j) {
d.mat[j][i](mat[j][i]);
}
d.vec[i](vec[i]);
}
sc_trace(fp,clk,"clk");
sc_trace(fp,rst_n,"rst_n");
for (int i = 0; i < VEC_NUM; ++i) {
for (int j = 0; j < VEC_WIDTH; ++j) {
std::ostringstream mat_name;
mat_name << "matrix(" << i << "," << j << ")";
sc_trace(fp,mat[i][j],mat_name.str());
mat_name.str("");
}
}
for (int i = 0; i < VEC_WIDTH; ++i) {
std::ostringstream stream1;
stream1 << "vec(" << i << ")";
sc_trace(fp,vec[i],stream1.str());
stream1.str("");
}
for (int i = 0; i < VEC_NUM; ++i) {
std::ostringstream out_name;
out_name << "dout(" << i << ")";
sc_trace(fp,vec_o[i],out_name.str());
out_name.str("");
}
sc_start(1000,SC_NS);
sc_close_vcd_trace_file(fp); // close(fp)
return 0;
};
第一个步骤是声明信号和模块，这一步用于声明连接需要的信号，这里的时钟信号使用SystemC的方法生成。用于连接的信号需要声明成sc_signal<>类型。
sc_clock clk("clk",10,SC_NS); // 时钟，周期为10ns
sc_signal rst_n;
sc_signal > mat[VEC_NUM][VEC_WIDTH],vec[VEC_WIDTH];
sc_signal >vec_o[VEC_NUM];
第二步是声明模块并连接信号，这里的连接和声明与顶层模块中类似，只是这里直接声明对象而不是指针。
matrix_vector_mul dut("dut");
dut.clk(clk);
dut.rst_n(rst_n);
for (int i = 0; i < VEC_NUM; ++i) {
for (int j = 0; j < VEC_WIDTH; ++j) {
dut.matrix[i][j](mat[i][j]);
}
}
for (int i = 0; i < VEC_WIDTH; ++i) {
dut.vector_in[i](vec[i]);
}
for (int i = 0; i < VEC_NUM; ++i) {
dut.vector_out[i](vec_o[i]);
}
第三步是实现波形跟踪与保存，首先定义一个sc_trace_file类型的指针，使用对应方法打开指定的文件类型和波形名称（fp=sc_create_vcd_trace_file("wave");保存vcd格式的波形）并进行配置。随后使用sc_trace(fp,signal,将需要观察的信号添加到波形跟踪中，其中sc_close_vcd_trace_file(fp);关闭仿真文件。
sc_trace_file *fp; // Create VCD file
fp=sc_create_vcd_trace_file("wave");// open(fp), create wave.vcd file
fp->set_time_unit(1, SC_NS); // set tracing resolution to ns
......
sc_trace(fp,clk,"clk");
sc_trace(fp,rst_n,"rst_n");
for (int i = 0; i < VEC_NUM; ++i) {
for (int j = 0; j < VEC_WIDTH; ++j) {
std::ostringstream mat_name;
mat_name << "matrix(" << i << "," << j << ")";
sc_trace(fp,mat[i][j],mat_name.str());
mat_name.str("");
}
}
for (int i = 0; i < VEC_WIDTH; ++i) {
std::ostringstream stream1;
stream1 << "vec(" << i << ")";
sc_trace(fp,vec[i],stream1.str());
stream1.str("");
}
for (int i = 0; i < VEC_NUM; ++i) {
std::ostringstream out_name;
out_name << "dout(" << i << ")";
sc_trace(fp,vec_o[i],out_name.str());
out_name.str("");
}
......
sc_close_vcd_trace_file(fp); // close(fp)
第四个部分是启动仿真，使用sc_start()运行指定的时间长度。
sc_start(1000,SC_NS); // 运行1000ns