diff options
Diffstat (limited to 'src/systemc/tests/systemc/compliance_1666/test00/test00.cpp')
| -rw-r--r-- | src/systemc/tests/systemc/compliance_1666/test00/test00.cpp | 384 |
1 files changed, 384 insertions, 0 deletions
diff --git a/src/systemc/tests/systemc/compliance_1666/test00/test00.cpp b/src/systemc/tests/systemc/compliance_1666/test00/test00.cpp new file mode 100644 index 000000000..6541e9e0d --- /dev/null +++ b/src/systemc/tests/systemc/compliance_1666/test00/test00.cpp @@ -0,0 +1,384 @@ +
+// General tests combining features of SystemC 2.1 and 1666
+
+
+#define SC_INCLUDE_DYNAMIC_PROCESSES
+
+#include <systemc>
+using sc_core::sc_interface;
+using sc_core::sc_object;
+using sc_core::sc_port;
+using sc_core::sc_export;
+using sc_core::sc_module;
+using sc_core::sc_module_name;
+using sc_core::sc_in;
+using sc_core::sc_in_clk;
+using sc_core::sc_signal;
+using sc_core::sc_prim_channel;
+using sc_core::sc_event;
+using sc_core::sc_delta_count;
+using sc_core::sc_is_running;
+using sc_core::sc_get_top_level_objects;
+using sc_core::sc_find_object;
+using sc_core::sc_report;
+using sc_core::sc_report_handler;
+using sc_core::sc_actions;
+using sc_core::SC_INFO;
+using sc_core::SC_UNSPECIFIED;
+using sc_core::SC_THROW;
+using sc_core::sc_spawn;
+using sc_core::sc_process_handle;
+using sc_core::sc_get_current_process_handle;
+using sc_core::sc_time;
+using sc_core::sc_time_stamp;
+using sc_core::SC_ZERO_TIME;
+using sc_core::SC_PS;
+using sc_core::SC_NS;
+using sc_core::SC_US;
+using sc_core::sc_start_of_simulation_invoked;
+using sc_core::sc_end_of_simulation_invoked;
+using sc_core::sc_start;
+using sc_core::sc_stop;
+using sc_core::sc_copyright;
+using sc_core::sc_version;
+using sc_core::sc_release;
+using sc_dt::sc_abs;
+using sc_dt::sc_max;
+using sc_dt::sc_min;
+using sc_dt::sc_int;
+using sc_dt::sc_bigint;
+using std::cout;
+using std::endl;
+
+#if defined(IEEE_1666_CPLUSPLUS) && IEEE_1666_CPLUSPLUS >= 201103L
+// dynamic process macros have been moved to functions on C++11
+using sc_core::sc_bind;
+using sc_core::sc_ref;
+using sc_core::sc_cref;
+#endif // IEEE_1666_CPLUSPLUS
+
+struct i_f: virtual sc_interface
+{
+ virtual void write() = 0;
+};
+
+void check_form_of_suffix(std::string s)
+{
+ std::string charset = "0123456789";
+ while (!s.empty())
+ {
+ sc_assert(s[0] == '_');
+ s = s.substr(1);
+ sc_assert(!s.empty());
+ do
+ {
+ sc_assert(charset.find(s[0]) < charset.size());
+ s = s.substr(1);
+ } while (!s.empty() && (s[0] != '_'));
+ }
+}
+
+struct Chan: i_f, sc_object
+{
+ virtual void write()
+ {
+ sc_assert(std::string(name()).substr(0,17) == "top.m_dest.object");
+ check_form_of_suffix(std::string(name()).substr(17));
+ }
+};
+
+struct M_src: sc_core::sc_behavior
+{
+ sc_port<i_f>* p;
+ SC_HAS_PROCESS(M_src);
+
+ M_src(sc_module_name _name)
+ {
+ p = new sc_port<i_f>;
+
+ SC_THREAD(T);
+ }
+ void T()
+ {
+ (*p)->write();
+ }
+};
+
+struct M_dest: sc_core::sc_channel
+{
+ sc_export<i_f>* xp;
+ SC_HAS_PROCESS(M_dest);
+
+ M_dest(sc_module_name _name)
+ {
+ xp = new sc_export<i_f>;
+ Chan* ch = new Chan;
+ xp->bind(*ch);
+ }
+};
+
+void f()
+{
+ ::sc_core::wait(33, SC_PS);
+}
+
+struct Prim: sc_prim_channel
+{
+ Prim() : cref_arg(1) {}
+
+ void write() { request_update(); }
+
+ void update()
+ {
+ sc_spawn(sc_bind(&Prim::proc, this));
+ }
+
+ void proc()
+ {
+ ev.notify(SC_ZERO_TIME);
+ wait(ev);
+ cout << "Prim::Proc spawned and resumed" << endl;
+ SC_FORK
+ sc_spawn(sc_bind(&Prim::Th, this, 1)),
+ sc_spawn(sc_bind(&Prim::Th, this, 2))
+ SC_JOIN
+ sc_spawn(sc_bind(&Prim::Th_ref, this, sc_ref(ref_arg)));
+ sc_spawn(sc_bind(&Prim::Th_cref, this, sc_cref(cref_arg)));
+ wait(1, SC_NS);
+ sc_assert(ref_arg == 99);
+ }
+ sc_event ev;
+ void Th(int i)
+ {
+ cout << "Th::i=" << i << endl;
+ }
+ void Th_ref(int& arg)
+ {
+ arg = 99;
+ sc_time t(sc_time_stamp());
+ sc_process_handle h = sc_spawn(&f);
+ wait(h.terminated_event());
+ sc_assert(sc_time_stamp() == t + sc_time(33, SC_PS));
+ }
+ void Th_cref(const int& arg)
+ {
+ }
+ int ref_arg;
+ const int cref_arg;
+};
+
+SC_MODULE(M)
+{
+ Prim prim;
+ SC_CTOR(M)
+ {
+ SC_THREAD(T);
+ }
+
+ void T()
+ {
+ wait(10, SC_NS);
+ try {
+ sc_report_handler::set_actions("msg_type", SC_INFO, SC_THROW);
+ SC_REPORT_INFO("msg_type", "msg");
+ }
+ catch (sc_report& rpt) {
+ cout << "Caught rpt " << rpt.what() << endl;
+ sc_assert(rpt.get_severity() == SC_INFO);
+ sc_assert(std::string(rpt.get_msg_type()) == "msg_type");
+ sc_assert(std::string(rpt.get_msg()) == "msg");
+ sc_assert(rpt.get_time() == sc_time(10, SC_NS));
+ sc_assert(std::string(rpt.get_process_name()) == "top.m.T");
+
+ sc_assert(sc_report_handler::get_count(SC_INFO) == 1);
+ sc_report rpt2 = rpt; // Copy constructor
+
+ prim.write();
+
+ sc_spawn(sc_bind(&M::proc, this, &rpt2));
+ wait(100, SC_NS);
+ }
+ }
+ void proc(sc_report* rpt)
+ {
+ sc_assert(rpt->get_severity() == SC_INFO);
+ sc_assert(std::string(rpt->get_msg_type()) == "msg_type");
+ sc_assert(std::string(rpt->get_msg()) == "msg");
+ sc_assert(rpt->get_time() == sc_time(10, SC_NS));
+ sc_assert(std::string(rpt->get_process_name()) == "top.m.T");
+ rpt->get_file_name();
+ rpt->get_line_number();
+ }
+};
+
+struct CM: sc_module
+{
+ sc_in_clk clk;
+ sc_in<bool> reset;
+
+ SC_HAS_PROCESS(CM);
+
+ CM(sc_module_name _name)
+ : first(true)
+ {
+ SC_CTHREAD(CT, clk.pos());
+ reset_signal_is(reset, true);
+
+ sc_assert(sc_start_of_simulation_invoked() == false);
+ sc_assert(sc_end_of_simulation_invoked() == false);
+ sc_assert(sc_is_running() == false);
+ }
+
+ bool first;
+
+ void CT()
+ {
+ if (first)
+ sc_assert(sc_time_stamp() == sc_time(5, SC_US));
+ else
+ sc_assert(sc_time_stamp() == sc_time(30, SC_US));
+ first = false;
+
+ sc_assert(sc_start_of_simulation_invoked() == true);
+ sc_assert(sc_end_of_simulation_invoked() == false);
+ sc_assert(sc_is_running() == true);
+
+ while(1)
+ {
+ wait();
+ sc_assert(sc_time_stamp() == sc_time(15, SC_US));
+ wait();
+ sc_assert(sc_time_stamp() == sc_time(25, SC_US));
+ wait();
+ sc_assert(false);
+ }
+ }
+
+ void start_of_simulation()
+ {
+ sc_assert(sc_start_of_simulation_invoked() == false);
+ sc_assert(sc_end_of_simulation_invoked() == false);
+ sc_assert(sc_is_running() == false);
+ }
+
+ void end_of_simulation()
+ {
+ sc_assert(sc_start_of_simulation_invoked() == true);
+ sc_assert(sc_end_of_simulation_invoked() == false);
+ sc_assert(sc_is_running() == false);
+ }
+};
+
+SC_MODULE(Top)
+{
+ M *m;
+ CM *cm;
+
+ M_src m_src;
+ M_dest m_dest;
+
+ sc_signal<bool> clk, reset;
+
+ SC_CTOR(Top)
+ : m_src("m_src"), m_dest("m_dest")
+ {
+ m = new M("m");
+ cm = new CM("cm");
+ cm->clk(clk);
+ cm->reset(reset);
+
+ m_src.p->bind( *(m_dest.xp) ); // Port-export binding
+
+ SC_THREAD(T);
+ SC_THREAD(T2);
+ }
+ void T()
+ {
+ clk = false;
+ reset = true;
+ wait(5, SC_US);
+ clk = true;
+ wait(5, SC_US);
+ clk = false;
+ reset = false;
+ wait(5, SC_US);
+ clk = true;
+ wait(5, SC_US);
+ clk = false;
+ wait(5, SC_US);
+ clk = true;
+ wait(5, SC_US);
+ clk = false;
+ reset = true;
+ wait(10, SC_US);
+ }
+ void T2()
+ {
+ sc_assert(sc_min(-1,1) == -1);
+ sc_assert(sc_max(-1,1) == 1);
+ sc_assert(sc_abs(-1) == 1);
+
+ sc_assert(sc_min(sc_int<8>(-1),sc_int<8>(1)) == sc_int<8>(-1));
+ sc_assert(sc_max(sc_int<8>(-1),sc_int<8>(1)) == sc_int<8>(1));
+ sc_assert(sc_abs(sc_int<8>(-1)) == sc_int<8>(1));
+
+ sc_assert(sc_min(sc_bigint<256>(-1),sc_bigint<256>(1)) == sc_bigint<256>(-1));
+ sc_assert(sc_max(sc_bigint<256>(-1),sc_bigint<256>(1)) == sc_bigint<256>(1));
+ sc_assert(sc_abs(sc_bigint<256>(-1)) == sc_bigint<256>(1));
+ }
+};
+
+int sc_main(int argc, char* argv[])
+{
+ sc_assert(sc_delta_count() == 0);
+ sc_assert(sc_is_running() == 0);
+ sc_assert(sc_time_stamp() == sc_time(SC_ZERO_TIME));
+ sc_assert(sc_report_handler::get_count(SC_INFO) == 0);
+ sc_assert(sc_report_handler::get_count("foo") == 0);
+
+ sc_actions act1 = sc_report_handler::get_new_action_id();
+ sc_actions act2 = sc_report_handler::get_new_action_id();
+ while (act2 != SC_UNSPECIFIED)
+ {
+ sc_assert(act2 != act1);
+ act2 = sc_report_handler::get_new_action_id();
+ }
+ sc_assert(sc_report_handler::get_log_file_name() == 0);
+ sc_assert(sc_get_top_level_objects().size() == 0);
+ sc_assert(sc_find_object("foo") == 0);
+ sc_assert(!sc_get_current_process_handle().valid());
+
+ sc_copyright();
+ sc_version();
+ std::string release = sc_release();
+ int n = release.find('.');
+ std::string major = release.substr(0,n);
+ release = release.substr(n+1,release.size()-1);
+ n = release.find('.');
+ std::string minor = release.substr(0,n);
+ release = release.substr(n+1,release.size()-1);
+ n = release.find('-');
+ std::string patch = release.substr(0,n);
+ std::string originator = release.substr(n+1,release.size());
+
+ std::string charset =
+ "abcdefghijklmnopqrstuvwxyzABSCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-";
+
+ for (unsigned int i = 0; i < major.size(); i++)
+ sc_assert(charset.find(major[i]) < charset.size());
+ for (unsigned int i = 0; i < minor.size(); i++)
+ sc_assert(charset.find(minor[i]) < charset.size());
+ for (unsigned int i = 0; i < patch.size(); i++)
+ sc_assert(charset.find(patch[i]) < charset.size());
+ for (unsigned int i = 0; i < originator.size(); i++)
+ sc_assert(charset.find(originator[i]) < charset.size());
+
+ Top top("top");
+ sc_start();
+
+ sc_stop();
+ sc_assert(sc_end_of_simulation_invoked() == true);
+
+ cout << endl << "Success" << endl;
+ return 0;
+}
|