adds some testing for CXS TLM implementation

CMakePresets.json

@@ -18,6 +18,15 @@
                 "CMAKE_PROJECT_TOP_LEVEL_INCLUDES":"cmake-conan/conan_provider.cmake"
             }
         },
+        {
+            "name": "DebugCXX11",
+            "cacheVariables": {
+                "CMAKE_POLICY_DEFAULT_CMP0091": "NEW",
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_CXX_STANDARD": "11",
+                "CMAKE_PROJECT_TOP_LEVEL_INCLUDES":"cmake-conan/conan_provider.cmake"
+            }
+        },
         {
             "name": "RelWithDebInfo",
             "cacheVariables": {

scc

@@ -1 +1 @@
-Subproject commit 66d3b8f9ee209d7343448bf259b93cc4ab85218b
+Subproject commit 8b9784da1cd849e86df6a22b55bdaeec3572d762

tests/CMakeLists.txt

@@ -8,6 +8,7 @@ add_subdirectory(ace_pin_level)
 add_subdirectory(configuration)
 add_subdirectory(configurer)
 add_subdirectory(sc_fixed_tracing)
+add_subdirectory(cxs_tlm)
 if(FULL_TEST_SUITE)
 	add_subdirectory(sim_performance)
 endif()

tests/cxs_tlm/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable (cxs_tlm sc_main.cpp)
+target_link_libraries (cxs_tlm LINK_PUBLIC busses scc-sysc)
+add_test(NAME cxs_tlm COMMAND cxs_tlm )

tests/cxs_tlm/sc_main.cpp

@@ -0,0 +1,92 @@
+#define SC_INCLUDE_FX
+#include <scc/cci_util.h>
+#include <scc/configurer.h>
+#include <scc/observer.h>
+#include <scc/sc_variable.h>
+#include <scc/tracer.h>
+#include <cxs/tlm_network_cxs.h>
+#include <string>
+#include <systemc>
+
+using namespace sc_dt;
+using namespace std;
+using namespace cxs;
+
+enum {PHIT_WIDTH=664};
+struct testbench : public sc_core::sc_module,
+public tlm::nw::tlm_network_fw_transport_if<tlm_network_cxs_types>,
+public tlm::nw::tlm_network_bw_transport_if<tlm_network_cxs_types> {
+
+    using transaction_type = tlm_network_cxs_types::tlm_payload_type;
+    using phase_type = tlm_network_cxs_types::tlm_phase_type;
+
+    sc_core::sc_clock clk{"clk", 1_ns};
+    tlm_network_cxs_initiator_socket<PHIT_WIDTH> isck{"isck"};
+    cxs_channel<PHIT_WIDTH> cxs_chan{"cxs_chan"};
+    tlm_network_cxs_target_socket<PHIT_WIDTH> tsck{"tsck"};
+
+    testbench(sc_core::sc_module_name const& nm)
+    : sc_module(nm) {
+        isck(*this);
+        tsck(*this);
+        cxs_chan.rcv_clk_i(clk);
+        isck(cxs_chan.tsck);
+        cxs_chan.isck(tsck);
+        SC_HAS_PROCESS(testbench);
+        SC_THREAD(run);
+        cxs_chan.channel_delay.set_value(100_ns);
+    }
+
+    void run() {
+        cxs::tlm_network_cxs_payload trans;
+        trans.set_command(cxs::CXS_CMD::DATA);
+        sc_core::sc_time t = sc_core::SC_ZERO_TIME;
+        isck->b_transport(trans, t);
+        tlm_cxs_shared_ptr trans_ptr = tlm_mm_cxs::get().allocate();
+        auto phase{tlm::nw::REQUEST};
+        auto status = isck->nb_transport_fw(*trans_ptr, phase, t);
+        if(status == tlm::TLM_UPDATED) {
+            sc_assert(phase==tlm::nw::CONFIRM);
+        }
+        wait(target_received_evt);
+        sc_core::sc_stop();
+    }
+
+    void b_transport(transaction_type& trans, sc_core::sc_time& t) override {
+        SCCINFO(SCMOD)<<"Received blocking transaction";
+    }
+
+    tlm::tlm_sync_enum nb_transport_fw(transaction_type& trans, phase_type& phase, sc_core::sc_time& t) override {
+        if(phase==tlm::nw::INDICATION) {
+            SCCINFO(SCMOD)<<"Received non-blocking transaction with phase " << phase.get_name();
+            target_received_evt.notify(sc_core::SC_ZERO_TIME);
+            phase = tlm::nw::RESPONSE;
+            return tlm::TLM_UPDATED;
+        }
+        throw std::runtime_error("illegal request in forward path");
+    }
+
+    tlm::tlm_sync_enum nb_transport_bw(transaction_type& trans, phase_type& phase, sc_core::sc_time& t) override {
+        if(phase==tlm::nw::CONFIRM) {
+            return tlm::TLM_ACCEPTED;
+        }
+        throw std::runtime_error("illegal response in backward path");
+    }
+
+    unsigned int transport_dbg(transaction_type& trans) override {
+        return 0;
+    }
+
+    sc_core::sc_event target_received_evt;
+};
+
+int sc_main(int sc_argc, char* sc_argv[]) {
+    scc::init_logging(scc::log::INFO);
+    scc::configurer cfg("");
+    scc::tracer trc("cxs_tlm");
+    testbench tb("tb");
+    sc_core::sc_start();
+    SCCINFO("sc_main") << "End Simulation.";
+
+    return sc_core::sc_report_handler::get_count(sc_core::SC_ERROR) + sc_core::sc_report_handler::get_count(sc_core::SC_WARNING);
+} // End of 'sc_main'