aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/CMakeLists.txt44
-rw-r--r--test/lt_bus.cc66
-rw-r--r--test/lt_bus_locked.cc168
3 files changed, 254 insertions, 24 deletions
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b67735a..714e18a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,8 +1,10 @@
-# Fetch googletest.
+# Fetch googletest (latest greatest, okay in this repo).
# https://google.github.io/googletest/quickstart-cmake.html#set-up-a-project
include(FetchContent)
FetchContent_Declare(
- googletest URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+ googletest
+ GIT_REPOSITORY https://github.com/google/googletest.git
+ GIT_TAG main
)
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)
@@ -12,11 +14,33 @@ enable_testing()
# Include gtest_discover_tests macro.
include(GoogleTest)
-foreach(T IN ITEMS lt_bus)
- set(TGT test-${T})
- add_executable(${TGT} ${T}.cc)
- target_include_directories(${TGT} PRIVATE ${SRC})
- target_compile_options(${TGT} PRIVATE -Wall -Wextra)
- target_link_libraries(${TGT} GTest::gmock_main SystemC::systemc)
- gtest_discover_tests(${TGT})
-endforeach()
+macro(test_int name kind)
+ set(target test-${name})
+ add_executable(${target} ${name}.cc)
+ target_include_directories(${target} PRIVATE ${SRC})
+ target_compile_options(${target} PRIVATE -Wall -Wextra)
+ if(${kind} STREQUAL "gtest")
+ target_link_libraries(${target} GTest::gmock_main)
+ target_link_libraries(${target} SystemC::systemc)
+ gtest_discover_tests(${target})
+ elseif(${kind} STREQUAL "sim")
+ target_link_libraries(${target} SystemC::systemc)
+ add_test(NAME ${target} COMMAND ${target})
+ else()
+ message(FATAL_ERROR "unknown test kind '${kind}'")
+ endif()
+endmacro()
+
+macro(sim_test name)
+ test_int(${name} "sim")
+endmacro()
+
+macro(gtest_test name)
+ test_int(${name} "gtest")
+endmacro()
+
+# Google tests.
+gtest_test("lt_bus")
+
+# Simulation tests.
+sim_test("lt_bus_locked")
diff --git a/test/lt_bus.cc b/test/lt_bus.cc
index ffbad9d..4f7fcf7 100644
--- a/test/lt_bus.cc
+++ b/test/lt_bus.cc
@@ -7,7 +7,6 @@
#include <tlm_utils/simple_target_socket.h>
#include <sstream>
-#include "gmock/gmock.h"
using testing::_;
@@ -28,11 +27,13 @@ struct [[nodiscard]] phantom {
namespace tag {
struct addr;
struct len;
+struct lock;
} // namespace tag
} // namespace detail
using addr_t = detail::phantom<detail::tag::addr, sc_dt::uint64>;
using len_t = detail::phantom<detail::tag::len, u32>;
+using lock_t = detail::phantom<detail::tag::len, bool>;
// -- TLM TARGET MOCK ----------------------------------------------------------
@@ -75,10 +76,15 @@ struct initiator : public sc_core::sc_module {
MOCK_METHOD(void, invalidate_direct_mem_ptr, (sc_dt::uint64, sc_dt::uint64));
- bool transport(addr_t a, len_t l) {
+ bool transport(addr_t a, len_t l, lock_t lk = lock_t{false}) {
tlm::tlm_generic_payload tx;
setup_tx(tx, a, l);
+ // Set bus lock extension (will be owned by gp).
+ auto* bl = new bus_lock;
+ bl->is_lock = lk.cast();
+ tx.set_extension(bl);
+
sc_core::sc_time t;
p_sock->b_transport(tx, t);
// Check bus restored correct original address.
@@ -130,21 +136,14 @@ struct initiator : public sc_core::sc_module {
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();
+ oss << "tx.addr=0x" << std::hex << tx.get_address() << std::dec;
+ oss << ",tx.len=" << tx.get_data_length();
+ if (const bus_lock* ext = tx.get_extension<bus_lock>()) {
+ oss << ",tx.is_lock=" << ext->is_lock;
+ }
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,
@@ -159,6 +158,26 @@ MATCHER_P2(gp_addr_len,
arg.get_data_length() == arg_len.cast();
}
+// Custom generic payload (gp) address, length and lock matcher.
+MATCHER_P3(gp_addr_len_lock,
+ /* arg0 */ arg_addr,
+ /* arg1 */ arg_len,
+ /* arg2 */ arg_lock,
+ /* desc */ [](addr_t a, len_t l, lock_t lk) {
+ tlm::tlm_generic_payload tx;
+ tx.set_address(a.cast());
+ tx.set_data_length(l.cast());
+ auto* ext = new bus_lock;
+ ext->is_lock = lk.cast();
+ tx.set_extension(ext);
+ return tx_to_str(tx);
+ }(arg_addr, arg_len, arg_lock /* ign negation arg */)) {
+ const auto* ext = arg.template get_extension<bus_lock>();
+ return arg.get_address() == arg_addr.cast() &&
+ arg.get_data_length() == arg_len.cast() && ext &&
+ ext->is_lock == arg_lock.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
@@ -335,3 +354,22 @@ TEST_F(bus_test, invalidate_dmi) {
EXPECT_CALL(i2, invalidate_direct_mem_ptr(0xa80, 0xaff));
t2.inv_dmi(0x80, 0x101);
}
+
+TEST_F(bus_test, fwd_lock) {
+ bus.attach_target(t1.p_sock, 0x400, 0x7ff);
+
+ testing::InSequence seq;
+
+ // Unlocked access.
+ EXPECT_CALL(
+ t1,
+ b_transport(gp_addr_len_lock(addr_t(0x0), len_t(1), lock_t(false)), _));
+ ASSERT_TRUE(i1.transport(addr_t(0x400), len_t(1), lock_t(false)));
+
+ // Locked access -> invalidates DMI pointer.
+ EXPECT_CALL(i1, invalidate_direct_mem_ptr(0x0, -1ull));
+ EXPECT_CALL(
+ t1,
+ b_transport(gp_addr_len_lock(addr_t(0x100), len_t(1), lock_t(true)), _));
+ ASSERT_TRUE(i1.transport(addr_t(0x500), len_t(1), lock_t(true)));
+}
diff --git a/test/lt_bus_locked.cc b/test/lt_bus_locked.cc
new file mode 100644
index 0000000..55357a8
--- /dev/null
+++ b/test/lt_bus_locked.cc
@@ -0,0 +1,168 @@
+#include "models/lt_bus.h"
+#include "utils/log.h"
+
+#include <tlm_utils/simple_initiator_socket.h>
+#include <tlm_utils/simple_target_socket.h>
+
+using sc_core::SC_NS;
+using sc_core::sc_time;
+using sc_core::sc_time_stamp;
+using sc_core::SC_ZERO_TIME;
+
+// -- TARGET -------------------------------------------------------------------
+
+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);
+ p_sock.register_get_direct_mem_ptr(this, &target::get_direct_mem_ptr);
+ }
+
+ tlm_utils::simple_target_socket<target> p_sock{"sock"};
+
+ private:
+ void b_transport(tlm::tlm_generic_payload& tx, sc_core::sc_time&) {
+ CLOGM(YELLOW, "transport 0x%llx w: %d r: %d", tx.get_address(),
+ tx.is_write(), tx.is_read());
+
+ // Miss-use byte enable len for sleep duration.
+ if (u32 len = tx.get_byte_enable_length()) {
+ CLOGM(YELLOW, "wait(%u)", len);
+ wait(sc_time(len, SC_NS));
+ }
+
+ tx.set_response_status(tlm::TLM_OK_RESPONSE);
+ }
+
+ bool get_direct_mem_ptr(tlm::tlm_generic_payload&, tlm::tlm_dmi&) {
+ return true;
+ }
+};
+
+// -- INITIATOR ----------------------------------------------------------------
+
+struct initiator : public sc_core::sc_module {
+ SC_HAS_PROCESS(initiator);
+
+ explicit initiator(sc_core::sc_module_name nm) : sc_module(std::move(nm)) {
+ SC_THREAD(run0);
+ SC_THREAD(run1);
+ SC_THREAD(run2);
+ }
+
+ tlm_utils::simple_initiator_socket<initiator> p_sock0{"sock0"};
+ tlm_utils::simple_initiator_socket<initiator> p_sock1{"sock1"};
+ tlm_utils::simple_initiator_socket<initiator> p_sock2{"sock2"};
+
+ private:
+ void setup_tx(tlm::tlm_generic_payload& tx, u64 addr, u32 len) const {
+ tx.set_command(tlm::TLM_WRITE_COMMAND);
+ tx.set_address(addr);
+ tx.set_data_ptr(nullptr);
+ tx.set_data_length(4);
+ tx.set_byte_enable_ptr(nullptr);
+ tx.set_byte_enable_length(len);
+ tx.set_response_status(tlm::TLM_INCOMPLETE_RESPONSE);
+ tx.set_dmi_allowed(false);
+ }
+
+ void send_tx(tlm_utils::simple_initiator_socket<initiator>& sock,
+ u64 addr,
+ u32 len,
+ bool lock = false) {
+ tlm::tlm_generic_payload tx;
+ setup_tx(tx, addr, len);
+
+ auto* bl = new bus_lock;
+ bl->is_lock = lock;
+ tx.set_extension(bl);
+
+ CLOGM(CYAN, "[%s] ACCESS @0x%lx lock=%d", sock.name(), addr, lock);
+
+ sc_core::sc_time t;
+ sock->b_transport(tx, t);
+
+ CLOGM(CYAN, "[%s] ACCESS ok: %d (%s)", sock.name(), tx.is_response_ok(),
+ tx.get_response_string().c_str());
+ }
+
+ bool get_dmi(tlm_utils::simple_initiator_socket<initiator>& sock, u64 addr) {
+ tlm::tlm_generic_payload tx;
+ setup_tx(tx, addr, 1 /* len */);
+
+ tlm::tlm_dmi dmi;
+ return sock->get_direct_mem_ptr(tx, dmi);
+ }
+
+ void run0() {
+ // Lock the bus.
+ send_tx(p_sock0, 0x1000, 0, true); // @0ns
+ // Spend some time, keep the bus locked.
+ wait(500, SC_NS);
+ // Unlock the bus.
+ send_tx(p_sock0, 0x1000, 0, false); // @500ns
+ assert(sc_time_stamp() == sc_time(500, SC_NS));
+
+ // -- 500ns --
+
+ wait(10, SC_NS);
+ LOGM("------------------------------------------------------------");
+ wait(90, SC_NS);
+
+ // Waiting for bus lock, as run1 & run2 have currently an outstanding tx.
+ assert(sc_time_stamp() == sc_time(600, SC_NS));
+ send_tx(p_sock0, 0x1000, 0, true); // @600ns
+ assert(sc_time_stamp() == sc_time(750, SC_NS));
+ }
+
+ void run1() {
+ wait(10, SC_NS);
+ // No dmi while bus is locked.
+ assert(get_dmi(p_sock1, 0x2000) == false);
+
+ send_tx(p_sock1, 0x2000, 0); // @10ns
+ assert(sc_time_stamp() == sc_time(500, SC_NS));
+
+ // -- 500ns --
+
+ wait(50, SC_NS);
+ send_tx(p_sock1, 0x2000, 100); // @550ns
+ assert(sc_time_stamp() == sc_time(650, SC_NS));
+ }
+
+ void run2() {
+ wait(20, SC_NS);
+ // No dmi while bus is locked.
+ assert(get_dmi(p_sock2, 0x3000) == false);
+
+ send_tx(p_sock2, 0x3000, 0);
+ assert(sc_time_stamp() == sc_time(500, SC_NS));
+
+ // -- 500ns --
+
+ wait(50, SC_NS);
+ send_tx(p_sock1, 0x3000, 200); // @550ns
+ assert(sc_time_stamp() == sc_time(750, SC_NS));
+ }
+};
+
+// -- SC_MAIN ------------------------------------------------------------------
+
+extern "C" int sc_main(int, char*[]) {
+ lt_bus bus{"bus"};
+
+ target target1{"target1"};
+
+ initiator init1{"init1"};
+
+ bus.attach_target(target1.p_sock, 0x0000, 0xffff);
+
+ bus.attach_initiator(init1.p_sock0);
+ bus.attach_initiator(init1.p_sock1);
+ bus.attach_initiator(init1.p_sock2);
+
+ bus.show_mmap();
+
+ sc_core::sc_start();
+
+ return 0;
+}