test: add first lt_bus tests

1 files changed, 337 insertions, 0 deletions

diff --git a/test/lt_bus.cc b/test/lt_bus.cc
new file mode 100644
index 0000000..ffbad9d
--- /dev/null
+++ b/test/lt_bus.cc
@@ -0,0 +1,337 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <models/lt_bus.h>
+
+#include <tlm_utils/simple_initiator_socket.h>
+#include <tlm_utils/simple_target_socket.h>
+
+#include <sstream>
+#include "gmock/gmock.h"
+
+using testing::_;
+
+// -- STRONG TYPES -------------------------------------------------------------
+
+namespace detail {
+template <typename Tag, typename T>
+struct [[nodiscard]] phantom {
+  explicit constexpr phantom(T val) : val{val} {}
+  constexpr T cast() const {
+    return val;
+  }
+
+ private:
+  T val;
+};
+
+namespace tag {
+struct addr;
+struct len;
+}  // namespace tag
+}  // namespace detail
+
+using addr_t = detail::phantom<detail::tag::addr, sc_dt::uint64>;
+using len_t = detail::phantom<detail::tag::len, u32>;
+
+// -- TLM TARGET MOCK ----------------------------------------------------------
+
+struct target : public sc_core::sc_module {
+  explicit target(sc_core::sc_module_name nm) : sc_module(std::move(nm)) {
+    p_sock.register_b_transport(this, &target::b_transport_int);
+    p_sock.register_get_direct_mem_ptr(this, &target::get_direct_mem_ptr);
+  }
+
+  tlm_utils::simple_target_socket<target> p_sock{"sock"};
+
+  MOCK_METHOD(void,
+              b_transport,
+              (tlm::tlm_generic_payload&, sc_core::sc_time&));
+  MOCK_METHOD(bool,
+              get_direct_mem_ptr,
+              (tlm::tlm_generic_payload&, tlm::tlm_dmi&));
+
+  void inv_dmi(sc_dt::uint64 start, sc_dt::uint64 end) {
+    p_sock->invalidate_direct_mem_ptr(start, end);
+  }
+
+ private:
+  void b_transport_int(tlm::tlm_generic_payload& tx, sc_core::sc_time& t) {
+    // Set a default response status, mocked method can overwrite it.
+    tx.set_response_status(tlm::TLM_OK_RESPONSE);
+    b_transport(tx, t);
+  }
+};
+
+// -- TLM INITIATOR UTIL -------------------------------------------------------
+
+struct initiator : public sc_core::sc_module {
+  explicit initiator(sc_core::sc_module_name nm) : sc_module(std::move(nm)) {
+    p_sock.register_invalidate_direct_mem_ptr(
+        this, &initiator::invalidate_direct_mem_ptr);
+  }
+
+  tlm_utils::simple_initiator_socket<initiator> p_sock{"sock"};
+
+  MOCK_METHOD(void, invalidate_direct_mem_ptr, (sc_dt::uint64, sc_dt::uint64));
+
+  bool transport(addr_t a, len_t l) {
+    tlm::tlm_generic_payload tx;
+    setup_tx(tx, a, l);
+
+    sc_core::sc_time t;
+    p_sock->b_transport(tx, t);
+    // Check bus restored correct original address.
+    auto is_original_addr = [&](auto addr) { return addr == a.cast(); };
+    EXPECT_PRED1(is_original_addr, tx.get_address());
+
+    return tx.is_response_ok();
+  }
+
+  struct dmi_result {
+    bool ok;
+    range addr;
+
+    explicit constexpr operator bool() const {
+      return ok;
+    }
+  };
+
+  dmi_result get_dmi(addr_t a, len_t l) {
+    tlm::tlm_generic_payload tx;
+    setup_tx(tx, a, l);
+
+    tlm::tlm_dmi dmi;
+    const bool ok = p_sock->get_direct_mem_ptr(tx, dmi);
+    // Check bus restored correct original address.
+    auto is_original_addr = [&](auto addr) { return addr == a.cast(); };
+    EXPECT_PRED1(is_original_addr, tx.get_address());
+
+    return {ok, range{dmi.get_start_address(), dmi.get_end_address()}};
+  }
+
+ private:
+  void setup_tx(tlm::tlm_generic_payload& tx, addr_t a, len_t l) const {
+    tx.set_command(tlm::TLM_WRITE_COMMAND);
+    tx.set_address(a.cast());
+    // NOTE: Since the tests dont require data, we set a nullptr (invalid gp,
+    // but okay here).
+    tx.set_data_ptr(nullptr);
+    tx.set_data_length(l.cast());
+    tx.set_byte_enable_ptr(nullptr);
+    tx.set_byte_enable_length(0);
+    tx.set_response_status(tlm::TLM_INCOMPLETE_RESPONSE);
+    tx.set_dmi_allowed(false);
+  }
+};
+
+// -- TEST UTILS ---------------------------------------------------------------
+
+static std::string tx_to_str(const tlm::tlm_generic_payload& tx) {
+  std::ostringstream oss;
+  // Only print values we are interested in in the tests.
+  oss << "tx.addr=0x" << std::hex << tx.get_address() << std::dec << ',';
+  oss << "tx.len=" << tx.get_data_length();
+  return oss.str();
+};
+
+MATCHER_P(gp_addr,
+          /* arg0 */ arg_addr,
+          /* desc */ [](addr_t a) {
+            tlm::tlm_generic_payload tx;
+            tx.set_address(a.cast());
+            return tx_to_str(tx);
+          }(arg_addr /* ign negation arg */)) {
+  return arg.get_address() == arg_addr.cast();
+}
+
+// Custom generic payload (gp) address and length matcher.
+MATCHER_P2(gp_addr_len,
+           /* arg0 */ arg_addr,
+           /* arg1 */ arg_len,
+           /* desc */ [](addr_t a, len_t l) {
+             tlm::tlm_generic_payload tx;
+             tx.set_address(a.cast());
+             tx.set_data_length(l.cast());
+             return tx_to_str(tx);
+           }(arg_addr, arg_len /* ign negation arg */)) {
+  return arg.get_address() == arg_addr.cast() &&
+         arg.get_data_length() == arg_len.cast();
+}
+
+// Define operator<< for tlm generic payloads in the tlm namespace. Used
+// by gtest/gmock when printing payload objects.
+// It is not a good practice to add functions to non-owned namespaced but for
+// this test this is okay, just close the eyes :^)
+namespace tlm {
+std::ostream& operator<<(std::ostream& os, const tlm::tlm_generic_payload& tx) {
+  return os << tx_to_str(tx);
+}
+}  // namespace tlm
+
+// -- TESTS --------------------------------------------------------------------
+
+struct bus_test : testing::Test {
+  void SetUp() override {
+    bus.attach_initiator(i1.p_sock);
+    bus.attach_initiator(i2.p_sock);
+  }
+
+  testing::StrictMock<target> t1{"target1"};
+  testing::StrictMock<target> t2{"target2"};
+  initiator i1{"initiator1"};
+  initiator i2{"initiator2"};
+
+  lt_bus bus{"bus-testling"};
+};
+
+TEST_F(bus_test, zero_based_mapping) {
+  bus.attach_target(t1.p_sock, 0, 0xff);
+
+  // Enforce EXPECT_CALLs in sequence.
+  testing::InSequence seq;
+
+  // Relative addressing (zero mapped: relative -> absolute).
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x0), len_t(16)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x0), len_t(16)));
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x10), len_t(4)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x10), len_t(4)));
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0xff), len_t(1)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0xff), len_t(1)));
+
+  // Full mapped range.
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x0), len_t(0x100)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x0), len_t(0x100)));
+
+  // Out of bound.
+  ASSERT_FALSE(i1.transport(addr_t(0x0), len_t(0x101)));  // oob
+  ASSERT_FALSE(i1.transport(addr_t(0xff), len_t(2)));     // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x100), len_t(1)));    // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x800), len_t(4)));    // oob
+}
+
+TEST_F(bus_test, non_zero_based_mapping) {
+  bus.attach_target(t1.p_sock, 0x100, 0x1ff);
+
+  // Enforce EXPECT_CALLs in sequence.
+  testing::InSequence seq;
+
+  // Check relative addressing.
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x0), len_t(16)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x100), len_t(16)));
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x10), len_t(4)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x110), len_t(4)));
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0xff), len_t(1)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x1ff), len_t(1)));
+
+  // Full mapped range.
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x0), len_t(0x100)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x100), len_t(0x100)));
+
+  // Out of bound.
+  ASSERT_FALSE(i1.transport(addr_t(0x0), len_t(4)));        // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x100), len_t(0x101)));  // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x1ff), len_t(2)));      // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x200), len_t(1)));      // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x800), len_t(4)));      // oob
+}
+
+TEST_F(bus_test, multiple_targets) {
+  bus.attach_target(t1.p_sock, 0x100, 0x1ff);
+  bus.attach_target(t2.p_sock, 0x200, 0x7ff);
+
+  // Enforce EXPECT_CALLs in sequence.
+  testing::InSequence seq;
+
+  // Check relative addressing (t1).
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x0), len_t(16)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x100), len_t(16)));
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0x10), len_t(4)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x110), len_t(4)));
+  EXPECT_CALL(t1, b_transport(gp_addr_len(addr_t(0xff), len_t(1)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x1ff), len_t(1)));
+  // Check relative addressing (t2).
+  EXPECT_CALL(t2, b_transport(gp_addr_len(addr_t(0x0), len_t(16)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x200), len_t(16)));
+  EXPECT_CALL(t2, b_transport(gp_addr_len(addr_t(0x10), len_t(4)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x210), len_t(4)));
+  EXPECT_CALL(t2, b_transport(gp_addr_len(addr_t(0xff), len_t(1)), _));
+  ASSERT_TRUE(i1.transport(addr_t(0x2ff), len_t(1)));
+
+  // Overlapping t1 & t2.
+  ASSERT_FALSE(i1.transport(addr_t(0x0), len_t(2)));        // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x1ff), len_t(2)));      // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x100), len_t(0x200)));  // oob
+  ASSERT_FALSE(i1.transport(addr_t(0x800), len_t(1)));      // oob
+}
+
+TEST_F(bus_test, get_dmi_ptr) {
+  bus.attach_target(t1.p_sock, 0x100, 0x1ff);
+
+  EXPECT_CALL(t1, get_direct_mem_ptr(gp_addr_len(addr_t(0x0), len_t(16)), _))
+      .WillOnce([](tlm::tlm_generic_payload&, tlm::tlm_dmi& dmi) -> bool {
+        dmi.set_start_address(0x0);
+        dmi.set_end_address(0x1f);
+        return true;
+      });
+  auto dmi = i1.get_dmi(addr_t(0x100), len_t(16));
+  ASSERT_TRUE(dmi);
+  // DMI address must also be fixed up by the bus on the bw path.
+  ASSERT_EQ((range{0x100, 0x11f}), dmi.addr);
+}
+
+TEST_F(bus_test, get_dmi_ptr_larger_than_mapping) {
+  bus.attach_target(t1.p_sock, 0x100, 0x1ff);
+
+  // Returned DMI range from target exceeds bus mapping. Bus must limit returned
+  // DMI range on the bw path.
+  EXPECT_CALL(t1, get_direct_mem_ptr(gp_addr_len(addr_t(0x0), len_t(16)), _))
+      .WillOnce([](tlm::tlm_generic_payload&, tlm::tlm_dmi& dmi) -> bool {
+        dmi.set_start_address(0x0);
+        dmi.set_end_address(0x200);
+        return true;
+      });
+  auto dmi = i1.get_dmi(addr_t(0x100), len_t(16));
+  ASSERT_TRUE(dmi);
+  // DMI address must be truncated by the bus on the bw path.
+  ASSERT_EQ((range{0x100, 0x1ff}), dmi.addr);
+}
+
+TEST_F(bus_test, invalidate_dmi) {
+  bus.attach_target(t1.p_sock, 0x400, 0x7ff);
+  bus.attach_target(t2.p_sock, 0xa00, 0xaff);
+
+  testing::InSequence seq;
+
+  // Target 1.
+
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0x400, 0x410));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0x400, 0x410));
+  t1.inv_dmi(0x0, 0x10);
+
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0x500, 0x7ff));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0x500, 0x7ff));
+  t1.inv_dmi(0x100, 0x3ff);
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0x500, 0x7ff));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0x500, 0x7ff));
+  t1.inv_dmi(0x100, 0x400);
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0x500, 0x7ff));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0x500, 0x7ff));
+  t1.inv_dmi(0x100, 0x401);
+
+  // Target 2.
+
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0xa00, 0xa10));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0xa00, 0xa10));
+  t2.inv_dmi(0x0, 0x10);
+
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0xa80, 0xaff));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0xa80, 0xaff));
+  t2.inv_dmi(0x80, 0xff);
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0xa80, 0xaff));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0xa80, 0xaff));
+  t2.inv_dmi(0x80, 0x100);
+  EXPECT_CALL(i1, invalidate_direct_mem_ptr(0xa80, 0xaff));
+  EXPECT_CALL(i2, invalidate_direct_mem_ptr(0xa80, 0xaff));
+  t2.inv_dmi(0x80, 0x101);
+}