adds tlm::nw tracing

Author: eyck

src/interfaces/CMakeLists.txt

@@ -11,6 +11,7 @@ set(LIB_SOURCES
     axi/axi_target.cpp
 	ocp/ocp_tlm.cpp
     tilelink/tl_tlm.cpp
+    cxs/cxs_tlm.cpp
 )
 
 add_library(${PROJECT_NAME} ${LIB_SOURCES})

src/interfaces/cxs/cxs_tlm.cpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2020 Arteris IP
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cxs/cxs_tlm.h"
+#include <fmt/format.h>
+#include <tlm/scc/scv/tlm_extension_recording_registry.h>
+#include <tlm/scc/tlm_id.h>
+
+namespace cxs {
+
+class cxs_ext_recording : public tlm::scc::scv::tlm_extensions_recording_if<cxs_flit_types> {
+
+    void recordBeginTx(SCVNS scv_tr_handle& h, cxs_flit_types::tlm_payload_type& trans) override {
+        if(auto ext = trans.get_extension<orig_pkt_extension>()) { // CTRL, DATA, RESP
+            auto idx = 0U;
+            for(auto& pkt : ext->orig_ext) {
+                h.record_attribute(fmt::format("flit.packet{}.size", idx++).c_str(), pkt->get_data().size());
+                if(pkt->get_extension_count())
+                    for(auto& extensionRecording : tlm::scc::scv::tlm_extension_recording_registry<cxs_packet_types>::inst().get())
+                        if(extensionRecording)
+                            extensionRecording->recordBeginTx(h, *pkt);
+            }
+        }
+    }
+
+    void recordEndTx(SCVNS scv_tr_handle& handle, cxs_flit_types::tlm_payload_type& trans) override {}
+};
+#if defined(__GNUG__)
+__attribute__((constructor))
+#endif
+bool register_extensions() {
+    cxs::orig_pkt_extension ext; // NOLINT
+    if(!tlm::scc::scv::tlm_extension_recording_registry<cxs::cxs_flit_types>::inst().is_ext_registered(ext.ID))
+        tlm::scc::scv::tlm_extension_recording_registry<cxs::cxs_flit_types>::inst().register_ext_rec(
+            ext.ID,
+            new cxs::cxs_ext_recording()); // NOLINT
+    return true;                           // NOLINT
+}
+bool registered = register_extensions();
+} // namespace cxs

src/interfaces/cxs/cxs_tlm.h

@@ -44,6 +44,16 @@ struct cxs_flit_payload : public tlm::nw::tlm_network_payload<CXS_CMD> {
     uint8_t end{0};
     uint8_t end_error{0};
     bool last{false};
+
+    cxs_flit_payload& operator=(const cxs_flit_payload& x) {
+        tlm::nw::tlm_network_payload<CXS_CMD>::operator=(x);
+        start_ptr = x.start_ptr;
+        end_ptr = x.end_ptr;
+        end = x.end;
+        end_error = x.end_error;
+        last = x.last;
+        return (*this);
+    }
 };
 
 struct cxs_flit_types {
@@ -64,6 +74,9 @@ struct cxs_packet_types {
     using tlm_phase_type = ::tlm::tlm_phase;
 };
 
+bool register_extensions();
+extern bool registered;
+
 } // namespace cxs
 
 namespace tlm {
@@ -132,6 +145,7 @@ struct cxs_transmitter : public sc_core::sc_module,
 
     cxs_transmitter(sc_core::sc_module_name const& nm)
     : sc_core::sc_module(nm) {
+        register_extensions();
         tsck(*this);
         isck(*this);
         SC_HAS_PROCESS(cxs_transmitter);
@@ -158,9 +172,11 @@ struct cxs_transmitter : public sc_core::sc_module,
     }
 
     tlm::tlm_sync_enum nb_transport_fw(pkt_tx_type& trans, pkt_phase_type& phase, sc_core::sc_time& t) override {
-        SCCTRACE(SCMOD) << "Forwarding CXS packet with size " << trans.get_data().size() << "bytes";
+        SCCTRACEALL(SCMOD) << "Forwarding CXS packet with size " << trans.get_data().size() << "bytes";
         if(phase == tlm::nw::REQUEST) {
             pkt_peq.notify(cxs_pkt_shared_ptr(&trans), t);
+            if(clock_period.get_value() != sc_core::SC_ZERO_TIME)
+                t += clock_period.get_value() - 1_ps;
             phase = tlm::nw::CONFIRM;
             return tlm::TLM_UPDATED;
         }
@@ -170,11 +186,13 @@ struct cxs_transmitter : public sc_core::sc_module,
     unsigned int transport_dbg(pkt_tx_type& trans) override { return 0; }
 
     tlm::tlm_sync_enum nb_transport_bw(flit_tx_type& trans, flit_phase_type& phase, sc_core::sc_time& t) override {
-        SCCTRACE(SCMOD) << "Received non-blocking transaction in bw path with phase " << phase.get_name();
-        if(phase == tlm::nw::REQUEST) {
+        SCCTRACEALL(SCMOD) << "Received non-blocking transaction in bw path with phase " << phase.get_name();
+        if(phase == tlm::nw::REQUEST && trans.get_command() == cxs::CXS_CMD::CREDIT) {
             received_credits += trans.get_data()[0];
-            SCCDEBUG(SCMOD) << "Received " << static_cast<unsigned>(trans.get_data()[0]) << " credit(s), " << received_credits.get()
+            SCCTRACE(SCMOD) << "Received " << static_cast<unsigned>(trans.get_data()[0]) << " credit(s), " << received_credits.get()
                             << " credit(s) in total";
+            if(clock_period.get_value() > sc_core::SC_ZERO_TIME)
+                t += clock_period - 1_ps;
             phase = tlm::nw::CONFIRM;
             return tlm::TLM_UPDATED;
         }
@@ -228,6 +246,7 @@ struct cxs_transmitter : public sc_core::sc_module,
             received_credits -= burst_credits;
         }
         burst_credits--;
+        SCCTRACE(SCMOD) << "Transmitted one flit, " << received_credits.get() << " credit(s) in total";
     }
 
     void reset() {
@@ -273,6 +292,7 @@ struct cxs_receiver : public sc_core::sc_module,
 
     cxs_receiver(sc_core::sc_module_name const& nm)
     : sc_core::sc_module(nm) {
+        register_extensions();
         tsck(*this);
         isck(*this);
         SC_HAS_PROCESS(cxs_receiver);
@@ -302,28 +322,28 @@ struct cxs_receiver : public sc_core::sc_module,
     }
 
     tlm::tlm_sync_enum nb_transport_fw(flit_tx_type& trans, flit_phase_type& phase, sc_core::sc_time& t) override {
-        SCCTRACE(SCMOD) << "Received non-blocking transaction in fw path with phase " << phase.get_name();
+        SCCTRACEALL(SCMOD) << "Received non-blocking transaction in fw path with phase " << phase.get_name();
         credit_returned.push_back(1);
         if(trans.end) {
             auto ext = trans.get_extension<cxs::orig_pkt_extension>();
             for(auto& orig_ptr : ext->orig_ext) {
                 auto ph = tlm::nw::REQUEST;
                 auto d = sc_core::SC_ZERO_TIME;
-                SCCTRACE(SCMOD) << "Forwarding CXS pkt with size " << orig_ptr->get_data().size() << "bytes";
+                SCCDEBUG(SCMOD) << "Forwarding CXS pkt with size " << orig_ptr->get_data().size() << "bytes";
                 auto status = isck->nb_transport_fw(*orig_ptr, ph, t);
                 sc_assert(status == tlm::TLM_UPDATED);
             }
         }
-        phase = tlm::nw::RESPONSE;
         if(clock_period.get_value() != sc_core::SC_ZERO_TIME)
             t += clock_period.get_value() - 1_ps;
+        phase = tlm::nw::RESPONSE;
         return tlm::TLM_UPDATED;
     }
 
     unsigned int transport_dbg(flit_tx_type& trans) override { return 0; }
 
     tlm::tlm_sync_enum nb_transport_bw(pkt_tx_type& trans, flit_phase_type& phase, sc_core::sc_time& t) override {
-        SCCTRACE(SCMOD) << "Received non-blocking transaction in bw path with phase " << phase.get_name();
+        SCCTRACEALL(SCMOD) << "Received non-blocking transaction in bw path with phase " << phase.get_name();
         if(phase == tlm::nw::CONFIRM)
             return tlm::TLM_ACCEPTED;
         throw std::runtime_error("illegal request in backward path");
@@ -367,8 +387,12 @@ struct cxs_channel : public sc_core::sc_module,
     using transaction_type = cxs_flit_types::tlm_payload_type;
     using phase_type = cxs_flit_types::tlm_phase_type;
 
+    sc_core::sc_in<bool> tx_clk_i{"tx_clk_i"};
+
     cxs_flit_target_socket<PHITWIDTH> tsck{"tsck"};
 
+    sc_core::sc_in<bool> rx_clk_i{"rx_clk_i"};
+
     cxs_flit_initiator_socket<PHITWIDTH> isck{"isck"};
 
     cci::cci_param<sc_core::sc_time> channel_delay{"channel_delay", sc_core::SC_ZERO_TIME, "delay of the CXS channel"};
@@ -394,7 +418,7 @@ struct cxs_channel : public sc_core::sc_module,
     }
 
     tlm::tlm_sync_enum nb_transport_fw(transaction_type& trans, phase_type& phase, sc_core::sc_time& t) override {
-        SCCTRACE(SCMOD) << "Received non-blocking transaction in fw path with phase " << phase.get_name();
+        SCCTRACEALL(SCMOD) << "Received non-blocking transaction in fw path with phase " << phase.get_name();
         if(phase == tlm::nw::REQUEST) {
             if(trans.get_data().size() > PHITWIDTH / 8) {
                 SCCERR(SCMOD) << "A CXS flit can be maximal " << PHITWIDTH / 8 << " bytes long, current data length is "
@@ -413,9 +437,9 @@ struct cxs_channel : public sc_core::sc_module,
     }
 
     tlm::tlm_sync_enum nb_transport_bw(transaction_type& trans, phase_type& phase, sc_core::sc_time& t) override {
-        SCCTRACE(SCMOD) << "Received non-blocking transaction in bw path with phase " << phase.get_name();
+        SCCTRACEALL(SCMOD) << "Received non-blocking transaction in bw path with phase " << phase.get_name();
         if(phase == tlm::nw::REQUEST) { // this is a credit
-            SCCDEBUG(SCMOD) << "Forwarding " << static_cast<unsigned>(trans.get_data()[0]) << " credit(s)";
+            SCCTRACE(SCMOD) << "Forwarding " << static_cast<unsigned>(trans.get_data()[0]) << " credit(s)";
             bw_peq.notify(cxs_flit_shared_ptr(&trans), channel_delay.get_value());
             if(tx_clock_period.get_value() > sc_core::SC_ZERO_TIME)
                 t += tx_clock_period - 1_ps;
@@ -431,6 +455,15 @@ struct cxs_channel : public sc_core::sc_module,
     unsigned int transport_dbg(transaction_type& trans) override { return isck->transport_dbg(trans); }
 
 private:
+    void start_of_simulation() override {
+        if(tx_clock_period.get_value() == sc_core::SC_ZERO_TIME)
+            if(auto clk_if = dynamic_cast<sc_core::sc_clock*>(tx_clk_i.get_interface()))
+                tx_clock_period.set_value(clk_if->period());
+        if(rx_clock_period.get_value() == sc_core::SC_ZERO_TIME)
+            if(auto clk_if = dynamic_cast<sc_core::sc_clock*>(rx_clk_i.get_interface()))
+                rx_clock_period.set_value(clk_if->period());
+    }
+
     void fw() {
         while(fw_peq.has_next()) {
             auto ptr = fw_peq.get();
@@ -467,5 +500,6 @@ struct cxs_channel : public sc_core::sc_module,
     scc::peq<cxs_flit_shared_ptr> bw_peq;
     sc_core::sc_event fw_resp, bw_resp;
 };
+
 } // namespace cxs
 #endif // _CXS_CXS_TLM_H_

src/interfaces/cxs/scv/tlm_recording.h

@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright 2016-2022 MINRES Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+
+#ifndef TLM_CXS_RECORDER_H_
+#define TLM_CXS_RECORDER_H_
+
+#include <cxs/cxs_tlm.h>
+#include <tlm/nw/scv/tlm_recorder.h>
+#include <tlm/nw/scv/tlm_recorder_module.h>
+#ifdef HAS_SCV
+#include <scv.h>
+#else
+#include <scv-tr.h>
+#ifndef SCVNS
+#define SCVNS ::scv_tr::
+#endif
+#endif
+
+//! @brief SystemC TLM
+namespace tlm {
+//! @brief SCC TLM utilities
+namespace nw {
+//! @brief SCC SCV4TLM classes and functions
+namespace scv {
+
+template <> void record(SCVNS scv_tr_handle& handle, cxs::cxs_flit_payload const& o) {
+    static const std::array<std::string, 3> cmd2char{{"FLIT", "CREDIT", "CRDRTN"}};
+    handle.record_attribute("flit.ptr", reinterpret_cast<uintptr_t>(&o));
+    handle.record_attribute("flit.type", cmd2char.at(static_cast<unsigned>(o.get_command())));
+    // std::array<uint8_t, 8> start_ptr;
+    // std::array<uint8_t, 8> end_ptr;
+    handle.record_attribute("flit.start", static_cast<unsigned>(o.start));
+    handle.record_attribute("flit.end", static_cast<unsigned>(o.end));
+    handle.record_attribute("flit.end_error", o.end_error);
+    handle.record_attribute("flit.last", o.last);
+}
+} // namespace scv
+} // namespace nw
+} // namespace tlm
+
+#endif /* TLM2_RECORDER_H_ */

src/sysc/CMakeLists.txt

@@ -38,14 +38,14 @@ set(LIB_SOURCES
     scc/scv/scv_tr_ftr.cpp
     scc/vcd_pull_trace.cpp
     scc/vcd_push_trace.cpp
-    tlm/scc/scv/tlm_recorder.cpp
-    tlm/scc/pe/parallel_pe.cpp
     scc/hierarchy_dumper.cpp
     scc/cci_broker.cpp
     scc/configurer.cpp
     scc/configurable_tracer.cpp
     scc/sc_thread_pool.cpp
     scc/signal_opt_ports.cpp
+    tlm/scc/scv/tlm_recorder.cpp
+    tlm/scc/pe/parallel_pe.cpp
     tlm/scc/lwtr/tlm2_lwtr.cpp
 )
 

src/sysc/tlm/nw/scv/tlm_recorder.cpp

@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright 2016-2022 MINRES Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+
+#ifndef SC_INCLUDE_DYNAMIC_PROCESSES
+#define SC_INCLUDE_DYNAMIC_PROCESSES
+#include "tlm/nw/tlm_network_sockets.h"
+#endif
+#include "tlm_recorder.h"
+#include <tlm/scc/scv/tlm_extension_recording_registry.h>
+#include <tlm/scc/tlm_id.h>
+
+namespace tlm {
+namespace nw {
+namespace scv {
+namespace {
+const std::array<std::string, 3> cmd2char{{"READ", "WRITE", "IGNORE"}};
+const std::array<std::string, 7> resp2char{
+    {"OK", "INCOMPLETE", "GENERIC_ERROR", "ADDRESS_ERROR", "COMMAND_ERROR", "BURST_ERROR", "BYTE_ENABLE_ERROR"}};
+const std::array<std::string, 3> gp_option2char{{"MIN_PAYLOAD", "FULL_PAYLOAD", "FULL_PAYLOAD_ACCEPTED"}};
+const std::array<std::string, 5> phase2char{{"UNINITIALIZED_PHASE", "BEGIN_REQ", "END_REQ", "BEGIN_RESP", "END_RESP"}};
+const std::array<std::string, 4> dmi2char{{"DMI_ACCESS_NONE", "DMI_ACCESS_READ", "DMI_ACCESS_WRITE", "DMI_ACCESS_READ_WRITE"}};
+const std::array<std::string, 3> sync2char{{"ACCEPTED", "UPDATED", "COMPLETED"}};
+
+} // namespace
+void record(SCVNS scv_tr_handle& handle, tlm::nw::tlm_network_payload_base& o) {
+    // handle.record_attribute("trans.ptr", reinterpret_cast<uintptr_t>(&o));
+    // handle.record_attribute("trans.address", o.get_address());
+    // handle.record_attribute("trans.cmd", cmd2char.at(o.get_command()));
+    // handle.record_attribute("trans.data_ptr", o.get_data_ptr());
+    // handle.record_attribute("trans.data_length", o.get_data_length());
+    // handle.record_attribute("trans.response", resp2char.at(1 - o.get_response_status()));
+    // handle.record_attribute("trans.dmi_allowed", o.is_dmi_allowed());
+    // handle.record_attribute("trans.byte_enable", o.get_byte_enable_ptr());
+    // handle.record_attribute("trans.byte_enable_length", o.get_byte_enable_length());
+    // handle.record_attribute("trans.streaming_width", o.get_streaming_width());
+    // handle.record_attribute("trans.gp_option", gp_option2char.at(o.get_gp_option()));
+    // if(o.get_data_length() && o.get_data_length() < 9 && o.get_data_ptr()) {
+    //     uint64_t buf = 0;
+    //     memcpy(&buf, o.get_data_ptr(), o.get_data_length());
+    //     handle.record_attribute("trans.data_value", buf);
+    // }
+}
+void record(SCVNS scv_tr_handle& handle, tlm::tlm_phase& o) {
+    unsigned id = o;
+    if(id < phase2char.size())
+        handle.record_attribute("phase", phase2char[id]);
+    else
+        handle.record_attribute("phase_id", id);
+}
+void record(SCVNS scv_tr_handle& handle, tlm::tlm_sync_enum o) { handle.record_attribute("tlm_sync", sync2char.at(o)); }
+
+} // namespace scv
+} // namespace nw
+} // namespace tlm