path: root/test/lt_bus.cc

#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);
}