SystemC入门笔记

变量说明

数据类型

SystemC为C++的一个库,因此C++的特性在SystemC中均可以使用,数据类型同理,除了C++中的数据类型外,SystemC也有一些自己的数据类型,如下所示:

  • 二值变量:sc_bitsc_bv<n>(n为宽度)分别为二值(0、1)变量和任意位宽二值向量。
  • 四值变量:sc_logicsc_lv<n>(n为宽度)分别为四值(0、1、x、z)变量和任意位宽四值向量
  • int型变量:sc_int<n>sc_uint<n>(n为宽度)分别为有符号和无符号的不超过64位宽的整型变量
  • bigint变量:sc_bigint<n>sc_bituing(n为宽度)分别为有符号和无符号任意位宽的整型变量

信号

信号使用sc_signal<type>声明,一般用于连接端口和进程通信(功能进程之间连接信号)

端口

SystemC中端口类型主要有sc_in<type>sc_out<type>sc_inout<type>,type中为端口的类型,可以使用C++自带的一些类型,也可以使用SystemC中的数据类型。

1
sc_out<sc_int<WIDTH * 2> > vec_o;

例如上面为一个输出端口例子,该输出端口名称为vec_o,类型为SystemC的数据类型sc_int<W>

1
sc_in<sc_int<WIDTH> > vec1[VEC_WIDTH];

可以声明端口数组,如上所示,声明了一个宽度为VEC_WIDTH的端口数组,每个端口的类型是sc_int<W>

模块设计——矩阵-向量乘法器

设计一个矩阵-向量乘法器用于熟悉语法,需要注意的是若要使用SystemC特性,需要使用#include "systemc.h"

系统结构

,.,.

该系统用于实现矩阵-向量乘法的行为级建模,包括以下几个部分:

  • 乘法器:实现矩阵-向量乘法功能,由多个向量-向量乘法器构成
  • 测试平台:激励生成器,用于产生指定尺寸的矩阵和向量以及时钟复位等控制信号

子模块设计

每个子模块在SystemC使用一个类描述,这个类使用宏SC_MODULE(<module name>)声明,这里的子模块是向量-向量乘法器,这一部分代码如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
SC_MODULE(vector_mul) {
sc_in<bool> clk,rst_n;
sc_in<sc_int<WIDTH> > vec1[VEC_WIDTH],vec2[VEC_WIDTH];
sc_out<sc_int<WIDTH * 2> > 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的控制端口:clkrst_n。分别是时钟和复位端口;还定义了两个输入端口数组,分别是vec1vec2,数组宽度为VEC_WIDTH(宏定义),类型为有符号整数类型sc_int<WIDTH>;此外还定义了一个输出端口vec_o,类型为指定位宽的整数类型sc_int<WIDTH * 2>。定义端口后,该部分框图如下所示:

1
2
3
sc_in<bool> clk,rst_n;
sc_in<sc_int<WIDTH> > vec1[VEC_WIDTH],vec2[VEC_WIDTH];
sc_out<sc_int<WIDTH * 2> > vec_o;

功能描述使用一个无输入参数无输出参数的方法描述,建议使用.read()读取输入端口的数据并使用.write()向输出端口写入数据。一个模块可以有多个功能描述,这里的功能描述功能类似于Verilog中的always块。SystemC中的赋值基本都是阻塞的,可以在这一函数中使用任意的C++特性和库等。定义了这一方法后,该部分框图如下所示:

1
2
3
4
5
6
7
8
9
10
11
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>)定义,这里的module name必须与这个类的名称一致。一个类可能有很多方法,只有如下所示的方式定义为METHOD(或THREAD等)的方法才作为模块的一个功能,定义后需要立刻定义敏感列表,只有敏感列表中的变量发生改变时,功能才运行:sensitive <<表示事件(电平)敏感,一般用于组合逻辑建模;sensitive_pos <<sensitive_neg <<分别为正跳变敏感和负跳变敏感,一般用于时序逻辑建模。完成以上所有部分的定义后,完成对一个子模块的构建。

METHOD是一种阻塞式的功能进程,当这个进程被敏感列表触发之后,获取仿真控制权开始运行,直到运行完成,将控制权返回SystemC仿真内核。使用METHOD注册的功能函数不能含有无限循环,这会导致仿真卡死在这个任务中,控制权无法返回仿真内核。

1
2
3
4
5
SC_CTOR(vector_mul) {
SC_METHOD(compute_vector_mul); // 注册为METHOD
sensitive_pos << clk; // clk为正跳变敏感信号
sensitive_neg << rst_n; // rst_n为负跳变敏感信号
};

顶层模块

顶层模块用于实现子模块的连接,代码实现如下所示。除了声明端口以外,还需要在构造函数中定义连接关系。连接关系的定义分为三个部分:模块指针声明、模块实例化和端口连接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
SC_MODULE(matrix_vector_mul) {
sc_in<bool> clk,rst_n;
sc_in<sc_int<WIDTH> > matrix[VEC_NUM][VEC_WIDTH];
sc_in<sc_int<WIDTH> > vector_in[VEC_WIDTH];
sc_out<sc_int<WIDTH * 2> > 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个子模块指针作为顶层模块的成员变量。

1
vector_mul *pe[VEC_NUM];

模块实例化如下所示,若使用SC_CTOR宏定义构造函数的子模块,需要使用一个唯一的字符串作为实例名。由于C++没有格式化字符串的功能,因此使用std::ostringstream生成唯一不重复的实例名,再用c_str()转为构造函数指定的类型。

1
pe[i] = new vector_mul(pe_name.str().c_str());

信号连接额部分使用如下所示的方式完成:<point>-><port name>(<signal name>)。需要注意的是若声明的是端口数组,则需要将每个数组中的每个端口拆分出来依次连接。

1
2
3
4
5
6
7
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]信号连接

测试平台设计

平台组件

这里实现的组件仅有激励生成器,该模块与上述模块没有太大的差别,该模块用于生成复位信号和数据信号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
SC_MODULE(driver)
{
sc_in <bool> clk;
sc_out<bool> rst_n;
sc_out<sc_int<WIDTH> > mat[VEC_NUM][VEC_WIDTH];
sc_out<sc_int<WIDTH> > 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_inputgenerate_reset均使用THREAD宏注册为功能,这一宏与METHOD的区别是这一种功能进程在仿真开始时运行,碰到wait()跳出,直到敏感列表中的信号再次触发这一进程,从上次跳出的wait()处继续运行,因此这种进程可以使用循环体包括wait()的无限循环。

1
2
3
4
5
SC_CTOR(driver) {
SC_THREAD(generate_input);
sensitive_neg << clk;
SC_THREAD(generate_reset);
};

除了使用wait()阻塞运行外,还可以使用wait(<times>,SC_NS);将执行延迟指定的时钟周期,如rst_n信号的实现,使用多个wait(<times>,SC_NS)延迟执行。

1
2
3
4
5
6
7
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函数中,如下所示,分为以下几个步骤:信号声明,模块声明和端口连接,波形追踪和仿真运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include "systemc.h"
int sc_main(int argc,char* argv[])
{
sc_clock clk("clk",10,SC_NS);
sc_signal<bool> rst_n;
sc_signal<sc_int<WIDTH> > mat[VEC_NUM][VEC_WIDTH],vec[VEC_WIDTH];
sc_signal<sc_int<WIDTH * 2> >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<>类型。

1
2
3
4
sc_clock clk("clk",10,SC_NS); // 时钟,周期为10ns
sc_signal<bool> rst_n;
sc_signal<sc_int<WIDTH> > mat[VEC_NUM][VEC_WIDTH],vec[VEC_WIDTH];
sc_signal<sc_int<WIDTH * 2> >vec_o[VEC_NUM];

第二步是声明模块并连接信号,这里的连接和声明与顶层模块中类似,只是这里直接声明对象而不是指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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,<signal name>);将需要观察的信号添加到波形跟踪中,其中<signal name>为波形文件中这一信号的名称,因此需要保证对于每一个信号该名称唯一。当仿真完成后,需要使用sc_close_vcd_trace_file(fp);关闭仿真文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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()运行指定的时间长度。

1
sc_start(1000,SC_NS); // 运行1000ns