updates ace_pin_level testcase with snoop and updates scc

scc

@@ -1 +1 @@
-Subproject commit a21316a97fff4953a3c08d32f6b97cf6d11d441e
+Subproject commit b205dce627b36cc865c9da372a2e84e927a5e12a

tests/ace_pin_level/ace_narrow_burst_test.cpp

@@ -10,6 +10,21 @@ using namespace sc_core;
 
 factory::add<testbench> tb;
 
+struct {
+    unsigned int ResetCycles{4};
+    unsigned int BurstLengthByte{16};
+//       unsigned int BurstLengthByte{32};
+    unsigned int BurstSizeBytes{8};
+//        unsigned int NumberOfIterations{8};
+    unsigned int NumberOfIterations{2};
+    std::unordered_map<unsigned, std::pair<std::vector<tlm::scc::tlm_gp_shared_ptr>, std::vector<tlm::scc::tlm_gp_shared_ptr>>> read_tx;
+    std::unordered_map<unsigned, std::pair<std::vector<tlm::scc::tlm_gp_shared_ptr>, std::vector<tlm::scc::tlm_gp_shared_ptr>>> write_tx;
+    std::unordered_map<unsigned, std::pair<std::vector<tlm::scc::tlm_gp_shared_ptr>, std::vector<tlm::scc::tlm_gp_shared_ptr>>> snoop_tx;
+    unsigned resp_cnt{0};
+} state;
+
+int snoop_id=0;
+
 bool operator==(tlm::tlm_generic_payload const& a, tlm::tlm_generic_payload const& b){
     auto ret = true;
     ret &= a.get_command() == b.get_command();
@@ -78,6 +93,31 @@ inline void randomize(tlm::tlm_generic_payload& gp) {
     req_cnt++;
 }
 
+unsigned testbench::transport(tlm::tlm_generic_payload& trans) {
+    SCCDEBUG(__FUNCTION__)<<" update trans for snoop, with snoop_id = " << snoop_id;
+  //  SCCDEBUG(__FUNCTION__)<<" in transport with trans " << trans;
+    // extracting address and snoop_e from ac_trans and pack them into cache data trans
+    auto ac_address = trans.get_address();
+    auto ext = trans.get_extension<ace_extension>();
+    auto ac_snoop=ext->get_snoop();
+
+    for(size_t i = 0; i < trans.get_data_length(); ++i) {
+        *(trans.get_data_ptr() + i) = i % 2 ? 123 : 128;
+    }
+    SCCDEBUG(__FUNCTION__)<<" vector size " <<state.snoop_tx[snoop_id].second.size();
+    state.snoop_tx[snoop_id].second.emplace_back(&trans);
+
+    /*
+    ext->set_snoop_data_transfer(true);
+    ext->set_snoop_error(false);
+    ext->set_pass_dirty(false);
+    ext->set_shared(false);
+    ext->set_snoop_was_unique(false);
+    */
+    return 1;
+
+}
+
 template<typename STATE>
 unsigned run_scenario(STATE& state){
     auto& dut = factory::get<testbench>();
@@ -97,8 +137,6 @@ unsigned run_scenario(STATE& state){
         return 0;
     });
 
-
-
     dut.rst.write(false);
     sc_start(state.ResetCycles*dut.clk.period());
     dut.rst.write(true);
@@ -116,7 +154,7 @@ unsigned run_scenario(STATE& state){
             StartAddr += state.BurstSizeBytes;
         }
     });
-/*
+
     auto run2 = sc_spawn([&dut, &state](){
         unsigned int StartAddr{0x2000};
         for(int i = 0; i < state.NumberOfIterations; ++i) {
@@ -152,10 +190,26 @@ unsigned run_scenario(STATE& state){
             StartAddr += state.BurstSizeBytes;
         }
     });
-*/
+
+
+    auto run5 = sc_spawn([&dut, &state](){
+           unsigned int StartAddr{0x0};
+           for(int i = 0; i < state.NumberOfIterations; ++i) {
+               // tlm::scc::tlm_gp_shared_ptr trans = prepare_trans<testbench::bus_cfg>(StartAddr, 4, state.BurstLengthByte, state.BurstSizeBytes, 1);
+               tlm::scc::tlm_gp_shared_ptr trans = prepare_trans_ace<testbench::bus_cfg>(StartAddr, 4, state.BurstLengthByte, state.BurstSizeBytes, 1);
+               trans->set_command(tlm::TLM_READ_COMMAND);
+               SCCDEBUG(__FUNCTION__) << "run1, iteration " << i << "snoop_id = " << snoop_id <<"  TX: "<<*trans;
+               dut.ace_tgt_pe.snoop(*trans);
+               state.snoop_tx[snoop_id].first.emplace_back(trans);
+               snoop_id++;
+               StartAddr += state.BurstSizeBytes;
+           }
+       });
+
+
     unsigned cycles{0};
- //   while(cycles<1000 && !(run1.terminated() && run2.terminated() && run3.terminated() && run4.terminated())){
+   while(cycles<1000 && !(run1.terminated() && run2.terminated() && run3.terminated() && run4.terminated())){
-   while(cycles<1000 && !(run1.terminated())){
+ //  while(cycles<1000 && !(run1.terminated())){
         sc_start(10 * dut.clk.period());
         cycles+=10;
     }
@@ -163,18 +217,8 @@ unsigned run_scenario(STATE& state){
 }
 
 TEST_CASE("ace_burst_alignment", "[AXI][pin-level]") {
-    struct {
-        unsigned int ResetCycles{4};
- //       unsigned int BurstLengthByte{16};
-        unsigned int BurstLengthByte{32};
-        unsigned int BurstSizeBytes{8};
-//        unsigned int NumberOfIterations{8};
-        unsigned int NumberOfIterations{1};
-        std::unordered_map<unsigned, std::pair<std::vector<tlm::scc::tlm_gp_shared_ptr>, std::vector<tlm::scc::tlm_gp_shared_ptr>>> read_tx;
-        std::unordered_map<unsigned, std::pair<std::vector<tlm::scc::tlm_gp_shared_ptr>, std::vector<tlm::scc::tlm_gp_shared_ptr>>> write_tx;
-        unsigned resp_cnt{0};
-    } state;
 
+    state.resp_cnt=0;
     auto cycles = run_scenario(state);
 
     REQUIRE(cycles<1000);
@@ -182,6 +226,7 @@ TEST_CASE("ace_burst_alignment", "[AXI][pin-level]") {
     REQUIRE(sc_report_handler::get_count(SC_WARNING) == 0);
 
    REQUIRE(state.resp_cnt==4*state.NumberOfIterations);
+   // REQUIRE(state.resp_cnt==1*state.NumberOfIterations);
     for(auto& e: state.write_tx) {
         auto const& send_tx = e.second.first;
         auto const& recv_tx = e.second.second;
@@ -192,22 +237,40 @@ TEST_CASE("ace_burst_alignment", "[AXI][pin-level]") {
         }
 
     }
+
     for(auto& e: state.read_tx) {
         auto const& send_tx = e.second.first;
         auto const& recv_tx = e.second.second;
         REQUIRE(send_tx.size() == recv_tx.size());
         for(auto i = 0; i<send_tx.size(); ++i){
             REQUIRE(send_tx[i]->get_response_status() == tlm::TLM_OK_RESPONSE);
+            SCCDEBUG(__FUNCTION__) << " index = " << i ;
+ //           SCCDEBUG(__FUNCTION__) <<" send     value = "<<*send_tx[i];
+ //           SCCDEBUG(__FUNCTION__) <<" received value = "<<*recv_tx[i];
             CHECK(*send_tx[i] == *recv_tx[i]);
         }
     }
+
+    for(auto& e: state.snoop_tx) {
+        auto const& snoop_tx = e.second.first;
+        auto const& recv_tx = e.second.second;
+        REQUIRE(snoop_tx.size() == recv_tx.size());
+        for(auto i = 0; i<snoop_tx.size(); ++i){
+            REQUIRE(snoop_tx[i]->get_response_status() == tlm::TLM_OK_RESPONSE);
+            SCCDEBUG(__FUNCTION__) << " index = " << i ;
+            SCCDEBUG(__FUNCTION__) <<" send snoop value = "<<*snoop_tx[i];
+            SCCDEBUG(__FUNCTION__) <<" received   value = "<<*recv_tx[i];
+  //          CHECK(*snoop_tx[i] == *recv_tx[i]);
+        }
+    }
+
 }
 
 TEST_CASE("axi4_narrow_burst", "[AXI][pin-level]") {
-    struct {
+ /*   struct {
         unsigned int ResetCycles{4};
-        unsigned int BurstLengthByte{32};
+   //     unsigned int BurstLengthByte{32};
-  //      unsigned int BurstLengthByte{16};
+        unsigned int BurstLengthByte{16};
         unsigned int BurstSizeBytes{4};
  //       unsigned int NumberOfIterations{8};
         unsigned int NumberOfIterations{1};
@@ -215,7 +278,8 @@ TEST_CASE("axi4_narrow_burst", "[AXI][pin-level]") {
         std::unordered_map<unsigned, std::pair<std::vector<tlm::scc::tlm_gp_shared_ptr>, std::vector<tlm::scc::tlm_gp_shared_ptr>>> write_tx;
         unsigned resp_cnt{0};
     } state;
-
+*/
+    state.resp_cnt=0;
     auto cycles = run_scenario(state);
 
     REQUIRE(cycles<1000);
@@ -240,3 +304,5 @@ TEST_CASE("axi4_narrow_burst", "[AXI][pin-level]") {
 
     }
 }
+
+

tests/ace_pin_level/testbench.h

@@ -13,16 +13,18 @@ using namespace sc_core;
 using namespace axi;
 using namespace axi::pe;
 
-class testbench : public sc_core::sc_module {
+class testbench : public sc_core::sc_module
+                 ,public tlm::scc::pe::intor_bw_b {
 public:
     using bus_cfg = axi::ace_cfg</*BUSWIDTH=*/64, /*ADDRWIDTH=*/32, /*IDWIDTH=*/4, /*USERWIDTH=*/1>;
 
     sc_core::sc_time clk_period{10, sc_core::SC_NS};
     sc_core::sc_clock clk{"clk", clk_period, 0.5, sc_core::SC_ZERO_TIME, true};
     sc_core::sc_signal<bool> rst{"rst"};
+    // test interface, which is bound to initiator bw_o
+    sc_core::sc_export<tlm::scc::pe::intor_bw_b> bw_i{"bw_i"};
     // initiator side
     axi::ace_initiator_socket<bus_cfg::BUSWIDTH> intor{"ace_intor"};
-
     axi::pin::ace_initiator<bus_cfg> intor_bfm{"ace_intor_bfm"};
     // signal accurate bus
     axi::aw_ch_ace<bus_cfg, axi::signal_types> aw;
@@ -30,6 +32,9 @@ public:
     axi::b_ch_ace<bus_cfg, axi::signal_types> b;
     axi::ar_ch_ace<bus_cfg, axi::signal_types> ar;
     axi::rresp_ch_ace<bus_cfg, axi::signal_types> rresp;
+    axi::ac_ch_ace<bus_cfg, axi::signal_types> ac;
+    axi::cr_ch_ace<bus_cfg, axi::signal_types> cr;
+    axi::cd_ch_ace<bus_cfg, axi::signal_types> cd;
 
     axi::pin::ace_target<bus_cfg> tgt_bfm{"ace_tgt_bfm"};
     // target side
@@ -48,6 +53,8 @@ public:
     , intor_pe("ace_intor_pe", intor)
     , ace_tgt_pe("ace_tgt_pe", tgt_ace)
     , axi_tgt_pe("axi_tgt_pe", tgt_axi) {
+
+        bw_i.bind(*this);
         intor_pe.clk_i(clk);
         intor_bfm.clk_i(clk);
         tgt_bfm.clk_i(clk);
@@ -62,20 +69,31 @@ public:
         intor_bfm.bind_b(b);
         intor_bfm.bind_ar(ar);
         intor_bfm.bind_r(rresp);
+
+        intor_bfm.bind_ac(ac);
+        intor_bfm.bind_cr(cr);
+        intor_bfm.bind_cd(cd);
+
         // signals to bfm
         tgt_bfm.bind_aw(aw);
         tgt_bfm.bind_w(wdata);
         tgt_bfm.bind_b(b);
         tgt_bfm.bind_ar(ar);
         tgt_bfm.bind_r(rresp);
-        // bfm to recorder
-        tgt_bfm.isckt(tgt_ace);
 
+        tgt_bfm.bind_ac(ac);
+        tgt_bfm.bind_cr(cr);
+        tgt_bfm.bind_cd(cd);
+
+        // bfm to ace target
+        tgt_bfm.isckt(tgt_ace);
         ace_tgt_pe.isckt_axi(tgt_axi);
+        // for updating snooop transaction
+        intor_pe.bw_o(bw_i);
 
     }
 
-
+    unsigned transport(tlm::tlm_generic_payload& trans) override ;
     void run1() {
     }
 };