SC_HAS_PROCESS

SC_HAS_PROCESS从systemC v2.0开始引入。它只接受一个参数，即模块类的名称。它经常与SC_CTOR进行比较。让我们看看这两个宏是如何定义的:

SC_SCOR: #define SC_CTOR(user_module_name) typedef user_module_name SC_CURRENT_USER_MODULEUser_module_name (::sc_core::sc_module_name)
SC_HAS_PROCESS: #define SC_HAS_PROCESS(user_module_name) typedef user_module_name SC_CURRENT_USER_MODULE

当提供时;"module"作为SC_CTOR和SC_HAS_PROCESS的输入参数，它们展开为:

SC_CTOR(module): typedef module SC_CURRENT_USER_MODULE;Module (::sc_core::sc_module_name)
SC_HAS_PROCESS(module):类型定义模块SC_CURRENT_USER_MODULE;

从这里可以看到:

两者都将“模块”定义为“SC_CURRENT_USER_MODULE”，这是在通过SC_METHOD/SC_THREAD/SC_CTHREAD注册成员函数到模拟内核时使用的。
SC_CTOR还声明了一个默认构造函数，其模块名作为唯一的输入参数。其影响是:

a) SC_CTOR保存一行代码来编写构造函数文件，而如果使用SC_HAS_PROCESS，则必须声明构造函数:

Module_class_name (sc_module_name名称，附加参数…);

b)由于SC_CTOR有构造函数声明，它只能放在类头文件中。

建议:

如果模块没有模拟进程，不要使用SC_CTOR或SC_HAS_PROCESS(通过SC_METHOD/SC_THREAD/SC_CTHREAD注册到模拟内核的成员函数)
如果模块不需要额外的参数(除了模块名)来实例化，则使用SC_CTOR
当实例化过程中需要额外的参数时，使用SC_HAS_PROCESS

SC_HAS_PROCESS.cpp

c++
#include <systemc>
using namespace sc_core;

SC_MODULE(MODULE_A) { // 没有仿真过程的模块不需要SC_CTOR或SC_HAS_PROCESS
  MODULE_A(sc_module_name name) { // C++ 样式构造函数，基类使用模块名称隐式实例化。
    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() { //定义函数
    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); // 注册成员函数
  }
  void func_b() { // 定义函数
    std::cout << name() << ", SC_HAS_PROCESS" << std::endl;
  }
};

SC_MODULE(MODULE_C) { // 传递其他输入参数
  const int i;
  SC_HAS_PROCESS(MODULE_C); // 可以使用 SC_CTOR，它还将定义一个未使用的构造函数：MODULE_A（sc_module_name）;
  MODULE_C(sc_module_name name, int i) : i(i) { // 定义构造函数
    SC_METHOD(func_c); // 注册成员函数
  }
  void func_c() { // 定义函数
    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); // 声明生成器
  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_CURRENT_USER_MODULE和构造函数
  MODULE_E(sc_module_name name); // C++ 样式构造函数声明
  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) { // 构造函数定义
  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;
}

结果

shell

        SystemC 2.3.3-Accellera --- Oct  4 2020 22:59:38
        Copyright (c) 1996-2018 by all Contributors,
        ALL RIGHTS RESERVED
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

目录

SC_HAS_PROCESS

SC_HAS_PROCESS.cpp

结果