Learn SystemC - Simulation Stages

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

Phases/Stages（阶段）

systemC应用程序仿真操作包含三个阶段：

Elaboration（阐述）:

在调用sc_start()之前执行的语句内容。
该阶段主要目的是创建用于支持仿真语义的内部数据及结构。
在阐述阶段，会创建模型层级的各部分（modules,ports,primitive channels, and processes），ports和exports会绑定到channels。

Execution（执行）:

可以再分为两个阶段：

Initialization（初始化）

  仿真内核标记所有的仿真过程，并存入可运行或等待(ruannabl or waiting)过程集中。
  所有的仿真过程默认会处于可运行集中，除非设置了无需初始化(no initialization)。

Simulation（仿真）

  通常可描述为状态机，该状态机负责调度仿真过程及推进仿真时间，包含两个内部阶段：
    1) evaluate: 
    在一个时间点(仿真时间)运行所有的可运行仿真过程。每个仿真过程保持运行直到遇到wait或return语句。如果没有可运行仿真过程则停止。
    2) advance-time: 
    当所有可运行仿真过程执行完成后，仿真进入该阶段，并执行以下操作：
      a) 推进仿真时间到时间最近的已调度事件
      b) 标记等待该特定时间的仿真过程为可运行
      c) 再次执行evaluation阶段
    evaluate和advance-time持续执行，直到以下事件之一发生 ，然后会进入cleanup阶段。
      a) 所有的仿真过程yielded
      b) 有仿真过程调用了`sc_stop()`
      c) 到达仿真的最大时间

Cleanup or post-processing（清除及后处理）

销毁对象，释放内存，关闭已打开的文件等等。

在阐述及仿真的各个阶段，有四个回调函数会被内核调用，分别如下：

1. virtual void before_end_of_elaboration():
   在模型层级构建完成后调用
2. virtual void end_of_elaboration():
   a.在所有的before_end_of_elaboration调用后
   b.在任意模型实例化或绑定端口后
   c.在开始仿真前
3. virtual void start_of_simulation():
   a) 在应用第一次调用sc_start时或仿真开始时，并且仿真由内核直接控制
   b) 如果应用多次调用sc_start，start_of_simulation只在第一次调用sc_start时回调
   c) 在end_of_elaboration回调之后并且在初始化阶段之前
4. virtual void end_of_simulation():
   a) 调用sc_stop停止仿真调度时，或者仿真结束时
   b) 即使调用多次sc_stop，该回调只调用一次

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

SC_MODULE(STAGE) {
  SC_CTOR(STAGE) { // elaboration
    std::cout << sc_time_stamp() << ": Elaboration: constructor" << std::endl;
    SC_THREAD(thread); // initialization + simulation
  }
  ~STAGE() { // cleanup
    std::cout << sc_time_stamp() << ": Cleanup: desctructor" << std::endl;
  }
  void thread() {
    std::cout << sc_time_stamp() << ": Execution.initialization" << std::endl;
    int i = 0;
    while(true) {
      wait(1, SC_SEC); // advance-time
      std::cout << sc_time_stamp() << ": Execution.simulation" << std::endl; // evaluation
      if (++i >= 2) {
        sc_stop(); // stop simulation after 2 iterations
      }
    }
  }
  void before_end_of_elaboration() {
    std::cout << "before end of elaboration" << std::endl;
  }
  void end_of_elaboration() {
    std::cout << "end of elaboration" << std::endl;
  }
  void start_of_simulation() {
    std::cout << "start of simulation" << std::endl;
  }
  void end_of_simulation() {
    std::cout << "end of simulation" << std::endl;
  }
};

int sc_main(int, char*[]) {
  STAGE stage("stage"); // Elaboration
  sc_start(); // Execution till sc_stop
  return 0; // Cleanup
}

运行结果：

0 s: Elaboration: constructor 
before end of elaboration # callback: before_end_of_elaboration()
end of elaboration # callback: end_of_elaboration()
start of simulation # callback: start_of_simulation()
0 s: Execution.initialization # initialization
1 s: Execution.simulation # iteration #1
2 s: Execution.simulation # iteration #2
Info: /OSCI/SystemC: Simulation stopped by user. # sc_stop triggered
end of simulation # callback: end_of_simulation
2 s: Cleanup: desctructor