Fix AXI4 write strobe handling and optimize byte enable

.github/workflows/ci-transaction_recording.yml

@@ -0,0 +1,44 @@
+name: CI Transaction Recording
+
+on:
+  push:
+    paths:
+      - '**.cpp'
+      - '**.h'
+      - '**CMakeLists.txt'
+      - '.github/workflows/**'
+  pull_request:
+    paths:
+      - '**.cpp'
+      - '**.h'
+      - '**CMakeLists.txt'
+      - '.github/workflows/**'
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        cpp_std: [11, 14, 17, 20]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Update submodules
+        run: git submodule update --init --recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake g++ python3-pip
+          pip3 install "conan<2.0"
+
+      - name: Configure
+        run: >
+          cmake -S . -B build
+          -DCMAKE_CXX_STANDARD=${{ matrix.cpp_std }}
+
+      - name: Build
+        run: cmake --build build -j
+
+      - name: Run transaction_recording
+        run: ./build/examples/transaction_recording/transaction_recording

src/interfaces/axi/pin/axi4_target.h

@@ -431,10 +431,14 @@ template <typename CFG> inline void axi::pin::axi4_target<CFG>::wdata_t() {
             // TODO: assuming consecutive write (not scattered)
             auto strobe = strb.to_uint();
             if(last) {
-                auto act_data_len = CFG::IS_LITE ? util::bit_count(strobe) : fsm_hndl->aux.i32.i0;
+                auto act_data_len = CFG::IS_LITE ? util::bit_count(strobe) : (beat_count + 1) * size;
                 gp->set_data_length(act_data_len);
-                gp->set_byte_enable_length(act_data_len);
                 gp->set_streaming_width(act_data_len);
+                if (fsm_hndl->aux.i32.i0 == act_data_len) {
+                    gp->set_byte_enable_length(0);
+                } else {
+                    gp->set_byte_enable_length(act_data_len);
+                }
             }
             auto tp = CFG::IS_LITE || this->w_last->read() ? axi::fsm::protocol_time_point_e::BegReqE
                                                            : axi::fsm::protocol_time_point_e::BegPartReqE;

third_party/cci-1.0.1/cci/cfg/cci_param_typed.h

@@ -31,6 +31,14 @@
  * @author Enrico Galli, Intel
  * @author Guillaume Delbergue, GreenSocs / Ericsson
  */
+
+#if defined(__clang__) || \
+   (defined(__GNUC__) && ((__GNUC__ * 1000 + __GNUC_MINOR__) >= 4006))
+// ignore warning about hidden "register_post_read_callback()" overloads
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
+#endif
+
 CCI_OPEN_NAMESPACE_
 
 // Forward declaration
@@ -988,4 +996,10 @@ template <typename T, cci_param_mutable_type TM = CCI_MUTABLE_PARAM>
 using cci_param = cci_param_typed<T,TM>;
 
 CCI_CLOSE_NAMESPACE_
+
+#if defined(__clang__) || \
+   (defined(__GNUC__) && ((__GNUC__ * 1000 + __GNUC_MINOR__) >= 4006))
+#pragma GCC diagnostic pop
+#endif
+
 #endif //CCI_CFG_CCI_PARAM_TYPED_H_INCLUDED_

third_party/cci-1.0.1/cci/core/cci_value.h

@@ -764,7 +764,7 @@ class cci_value_map_elem_cref
   template<typename U> friend class cci_impl::value_iterator_impl;
   typedef cci_impl::value_ptr<cci_value_map_elem_cref> proxy_ptr;
 
-  typedef void value_type; // TODO: add  explicit value_type 
+  using value_type = cci_value_map_elem_cref;
 public:
   typedef cci_value_map_elem_cref const_reference;
   typedef cci_value_map_elem_ref  reference;
@@ -791,7 +791,7 @@ class cci_value_map_elem_ref
 {
   template<typename U> friend class cci_impl::value_iterator_impl;
   typedef cci_impl::value_ptr<cci_value_map_elem_ref> proxy_ptr;
-  typedef void value_type; // TODO: add  explicit value_type
+  using value_type = cci_value_map_elem_ref;
 public:
   typedef cci_value_map_elem_cref const_reference;
   typedef cci_value_map_elem_ref  reference;

third_party/cci-1.0.1/cci/core/cci_value_iterator.h

@@ -71,11 +71,11 @@ template<typename T> class value_iterator_impl
 {
 public:
   // std::iterator_traits types
-  typedef T reference;  // return by value!
-  typedef value_ptr<T> pointer;    // return proxy pointer
-  typedef typename T::value_type value_type; // "real" value type
-  typedef std::ptrdiff_t difference_type;
-  typedef std::random_access_iterator_tag iterator_category;
+  using reference           = T;    // return by value!
+  using pointer             = value_ptr<T>; // return proxy pointer
+  using value_type          = typename T::value_type;   // "real" value type
+  using difference_type     = std::ptrdiff_t;
+  using iterator_category   = std::random_access_iterator_tag;
 
 protected:
   typedef void* impl_type; //  type-punned pointer for now
@@ -130,11 +130,11 @@ class cci_value_iterator
 public:
   /// @name C++ standard iterator types
   ///@{
-  typedef typename impl::value_type        value_type;
-  typedef typename impl::pointer           pointer;
-  typedef typename impl::reference         reference;
-  typedef typename impl::difference_type   difference_type;
-  typedef typename impl::iterator_category iterator_category;
+  using value_type          = typename impl::value_type;
+  using pointer             = typename impl::pointer;
+  using reference           = typename impl::reference;
+  using difference_type     = typename impl::difference_type;
+  using iterator_category   = typename impl::iterator_category;
   ///@}
 
   /// constructs an invalid iterator (non-dereferencable, non-incrementable)

third_party/scv-tr/src/scv-tr/scv_introspection.h

@@ -3252,8 +3252,8 @@ template <int W> class scv_extensions<sc_lv<W>> : public scv_extensions_base<sc_
 // ----------------------------------------
 template <typename T> class scv_extensions<scv_extensions<T>> : public scv_extensions<T> {
 public:
-    scv_extensions<scv_extensions<T>>() {}
-    scv_extensions<scv_extensions<T>>(const scv_extensions<T>& rhs)
+    scv_extensions() {}
+    scv_extensions(const scv_extensions<T>& rhs)
     : scv_extensions<T>(rhs) {}
     virtual ~scv_extensions() {}
     scv_extensions& operator=(const scv_extensions<T>& rhs) { return scv_extensions<T>::operator=(rhs); }