Learn SystemC - SC_HAS_PROCESS

本文为英文版本翻译，原文地址：SC_HAS_PROCESS

SC_HAS_PROCESS

宏SC_HAS_PROCESS在systemC v2.0版本中引入，该宏只有一个参数：模型类的名称。它与SC_CTOR的定义分别如下：

#define SC_CTOR(user_module_name)  \
	typedef user_module_name SC_CURRENT_USER_MODULE; \
	user_module_name( ::sc_core::sc_module_name )

#define SC_HAS_PROCESS(user_module_name)  \
	typedef user_module_name SC_CURRENT_USER_MODULE

由以上两个宏定义可以发现：

1. 两者都将输入的模型名称定义为SC_CURRENT_USER_MODULE，该定义在注册成员函数到仿真内核时会使用到。注册成员函数到仿真内核使用以下的宏：
   SC_METHOD/SC_THREAD/SC_CTHREAD
2. SC_CTOR同时声明了一个默认的构造函数，该构造函数只有一个参数：模型名称
   a) SC_CTOR减少使用者一行代码去声明构造函数，当使用SC_HAS_PROCESS时，使用者不得不声明一个类似如下的构造函数
   module_class_name(sc_module_name name, 其它参数...)
   b) 英文SC_CTOR声明了默认构造函数，所以它只能出现在类的定义中

建议

1. 如果模型类中没有仿真进程（通过SC_METHOD/SC_THREAD/SC_CTHREAD注册到仿真内核的成员函数），那么就不使用SC_CTOR和SC_HAS_PROCESS
2. 若实例化时不需要额外的参数（即除了模型名称），就使用SC_CTOR
3. 若需要额外的参数，就使用SC_HAS_PROCESS

下面看下具体示例：

// Learn with Examples, 2020, MIT license
#include <systemc>
using namespace sc_core;

SC_MODULE(MODULE_A) { // 没有仿真过程的模型，不需要SC_CTOR，SC_HAS_PROCESS
  MODULE_A(sc_module_name name) { // c++ style constructor, the base class is implicitly instantiated with module name.
    std::cout << this->name() << ", no SC_CTOR or SC_HAS_PROCESS" << std::endl;
  }
};

SC_MODULE(MODULE_B1) { // 只有模型名称参数的构造函数
  SC_CTOR(MODULE_B1) { // 声明构造函数：MODULE_B1(sc_module_name)
    SC_METHOD(func_b); // 注册成员函数到仿真内核
  }
  void func_b() { // define function
    std::cout << name() << ", SC_CTOR" << std::endl;
  }
};

SC_MODULE(MODULE_B2) { // 只有模型名称参数的构造函数
  SC_HAS_PROCESS(MODULE_B2); // 没有声明构造函数
  MODULE_B2(sc_module_name name) { // 显示声明构造函数，同样通过sc_module_name实例化基类
    SC_METHOD(func_b); // register member function
  }
  void func_b() { // define function
    std::cout << name() << ", SC_HAS_PROCESS" << std::endl;
  }
};

SC_MODULE(MODULE_C) { // 多个参数模型
  const int i;
  SC_HAS_PROCESS(MODULE_C); // 其实也可以使用SC_CTOR, SC_CTOR会定义一个可能不会使用的构造函数：MODULE_A(sc_module_name);
  MODULE_C(sc_module_name name, int i) : i(i) { // 定义构造函数
    SC_METHOD(func_c); // register member function
  }
  void func_c() { // define function
    std::cout << name() << ", additional input argument" << std::endl;
  }
};

SC_MODULE(MODULE_D1) { // SC_CTOR在类头，构造函数实现在类头外
  SC_CTOR(MODULE_D1);
  void func_d() {
    std::cout << this->name() << ", SC_CTOR inside header, constructor defined outside header" << std::endl;
  }
};
MODULE_D1::MODULE_D1(sc_module_name name) : sc_module(name) { // 构造函数. "sc_module(name)" 可选
  SC_METHOD(func_d);
}

SC_MODULE(MODULE_D2) { // SC_HAS_PROCESS在类头
  SC_HAS_PROCESS(MODULE_D2);
  MODULE_D2(sc_module_name); // 声明constructor
  void func_d() {
    std::cout << this->name() << ", SC_CTOR inside header, constructor defined outside header" << std::endl;
  }
};
MODULE_D2::MODULE_D2(sc_module_name name) : sc_module(name) { // 构造函数. "sc_module(name)"可选
  SC_METHOD(func_d);
}

SC_MODULE(MODULE_E) { // SC_HAS_PROCESS和构造函数定义在类头外
  MODULE_E(sc_module_name name); // c++ style constructor declaration
  void func_e() {
    std::cout << this->name() << ", SC_HAS_PROCESS outside header, CANNOT use SC_CTOR" << std::endl;
  }
};
MODULE_E::MODULE_E(sc_module_name name) { // constructor definition
  SC_HAS_PROCESS(MODULE_E); // 这里不可使用SC_CTOR
  SC_METHOD(func_e);
}

int sc_main(int, char*[]) {
  MODULE_A module_a("module_a");
  MODULE_B1 module_b1("module_b1");
  MODULE_B2 module_b2("module_b2");
  MODULE_C module_c("module_c", 1);
  MODULE_D1 module_d1("module_d1");
  MODULE_D2 module_d2("module_d2");
  MODULE_E module_e("module_e");
  sc_start();
  return 0;
}

运行结果：

module_a, no SC_CTOR or SC_HAS_PROCESS
module_b1, SC_CTOR
module_b2, SC_HAS_PROCESS
module_c, additional input argument
module_d1, SC_CTOR inside header, constructor defined outside header
module_d2, SC_CTOR inside header, constructor defined outside header
module_e, SC_HAS_PROCESS outside header, CANNOT use SC_CTOR