VRT unit testing

.github/workflows/vrt-unit-test.yml

@@ -0,0 +1,74 @@
+# ##################################################################################################
+#  The MIT License (MIT)
+#  Copyright (c) 2025 Advanced Micro Devices, Inc. All rights reserved.
+# 
+#  Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+#  and associated documentation files (the "Software"), to deal in the Software without restriction,
+#  including without limitation the rights to use, copy, modify, merge, publish, distribute,
+#  sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+# 
+#  The above copyright notice and this permission notice shall be included in all copies or
+#  substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# ##################################################################################################
+
+name: VRT unit testing
+
+on:
+  push:
+    branches:
+    - main
+    - dev
+  pull_request:
+
+jobs:
+  vrt_unit_tests:
+    runs-on: ubuntu-24.04
+    permissions: { contents: read }
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with: 
+          submodules: "true"
+
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt upgrade -y
+          sudo apt install -y cmake pkg-config ninja-build \
+          libxml2-dev libzmq3-dev libjsoncpp-dev zlib1g-dev \
+          libsystemd-dev libinih-dev libcli11-dev lcov python3-zmq
+
+      - name: Build and run VRT unit tests
+        run: |
+          mkdir vrt/build
+          cd vrt/build
+          cmake -DVRT_INCLUDE_VRTD=1 -DVRTD_INCLUDE_LIBSLASH=1 -DENABLE_COVERAGE=1 ..
+          make unit_tests -j$(nproc)
+          cd tests && ctest --output-on-failure
+
+      - name: Generate coverage report
+        run: |
+          cd vrt/build
+          lcov --capture --directory . --output-file coverage.info \
+            --ignore-errors mismatch --ignore-errors negative
+          lcov --remove coverage.info \
+            '/usr/*' '*/build/_deps/*' '*/vrtd/*' '*/tests/*' \
+            --output-file coverage.filtered.info \
+            --ignore-errors unused
+          genhtml coverage.filtered.info --output-directory coverage-report
+          lcov --list coverage.filtered.info
+
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: vrt-coverage-report
+          path: vrt/build/coverage-report/
+

.gitignore

@@ -62,6 +62,7 @@ Thumbs.db
 
 __pycache__/
 *.pyc
+.venv/
 
 # Build files for package
 /pbuild/

requirements.txt

@@ -1,3 +1,4 @@
+pyzmq
 jinja2
 pytest
 pytest-cov

vrt/CMakeLists.txt

@@ -43,6 +43,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 option(VRT_INCLUDE_VRTD "Include vrtd subdirectory instead of building from system" OFF)
+option(VRT_BUILD_TESTS "Build unit tests" OFF)
 
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
@@ -55,6 +56,15 @@ if(ENABLE_SANITIZERS)
   add_link_options(-fsanitize=address,undefined)
 endif()
 
+option(ENABLE_COVERAGE "Build with gcov coverage instrumentation" OFF)
+if(ENABLE_COVERAGE)
+  if(ENABLE_SANITIZERS)
+    message(FATAL_ERROR "ENABLE_COVERAGE and ENABLE_SANITIZERS cannot be used together")
+  endif()
+  add_compile_options(--coverage -fno-inline)
+  add_link_options(--coverage)
+endif()
+
 # Generate the header
 configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/vrt_version.hpp.in"
@@ -131,6 +141,13 @@ target_link_libraries(vrt
     PkgConfig::PC_ZMQ
 )
 
+# Testing
+if(VRT_BUILD_TESTS)
+  add_subdirectory(tests)
+endif()
+
+# Installation
+
 set_target_properties(vrt PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
 install(

vrt/include/vrt/kernel.hpp

@@ -229,6 +229,12 @@ class Kernel {
      */
     void setVrtdBar(const std::optional<vrtd::Bar>& bar);
 
+    /**
+     * @brief Sets the ZeroMQ server for emulation and simulation.
+     * @param server The ZeroMQ server handle.
+     */
+    void setServer(std::shared_ptr<ZmqServer> server);
+
     /**
      * @brief Writes a value to a register.
      * @param offset The offset of the register.

vrt/include/vrt/streaming_buffer.hpp

@@ -23,7 +23,7 @@
 
 #include <regex>
 
-#include "api/device.hpp"
+#include "device.hpp"
 #include "qdma/qdma_connection.hpp"
 #include "qdma/qdma_intf.hpp"
 #include "utils/platform.hpp"
@@ -110,7 +110,7 @@ template <typename T>
 StreamingBuffer<T>::StreamingBuffer(Device device, Kernel kernel, const std::string& portName,
                                     size_t size)
     : device(device), size(size), kernel(kernel), portName(portName) {
-    std::vector<QdmaConnection> qdmaConnections = device.getQdmaConnections();
+    std::vector<QdmaConnection> qdmaConnections = device.getHandle()->getQdmaConnections();
     bool gotQdma = false;
     for (const auto& con : qdmaConnections) {
         if (con.getKernel() == kernel.getName() && portName == con.getInterface()) {
@@ -162,7 +162,7 @@ template <typename T>
 void StreamingBuffer<T>::sync() {
     Platform platform = device.getPlatform();
     if (platform == Platform::EMULATION) {
-        ZmqServer* server = device.getHandle()->getZmqServer();
+        auto server = device.getHandle()->getZmqServer();
         if (syncType == StreamDirection::HOST_TO_DEVICE) {
             std::vector<uint8_t> sendData;
             std::size_t dataSize = size * sizeof(T);

vrt/src/device.cpp

@@ -306,12 +306,16 @@ void Device::parseSystemMap() {
     clockFreq = parser.getClockFrequency();
     this->platform = parser.getPlatform();
     kernels = parser.getKernels();
+
+    std::optional<vrtd::Bar> barHandle = std::nullopt;
     if (platform == Platform::HARDWARE && vrtdDevice.has_value()) {
-        std::optional<vrtd::Bar> barHandle = vrtdDevice->getBar(bar);
-        for (auto& kernel : kernels) {
-            kernel.second.setVrtdBar(barHandle);
-            kernel.second.setPlatform(platform);
-        }
+        barHandle = vrtdDevice->getBar(bar);
+    }
+
+    for (auto&kernel : kernels) {
+        kernel.second.setPlatform(platform);
+        kernel.second.setVrtdBar(barHandle);
+        kernel.second.setServer(zmqServer);
     }
     this->qdmaConnections = parser.getQdmaConnections();
 }

vrt/src/kernel.cpp

@@ -139,6 +139,8 @@ uint32_t Kernel::read(uint32_t offset) {
 
 void Kernel::setVrtdBar(const std::optional<vrtd::Bar>& bar) { this->vrtdBar = bar; }
 
+void Kernel::setServer(std::shared_ptr<ZmqServer> server) { this->server = server; }
+
 void Kernel::setFunctionalArgs(const std::vector<FunctionalArg>& args) {
     functionalArgs = args;
     std::sort(functionalArgs.begin(), functionalArgs.end(),

vrt/tests/CMakeLists.txt

@@ -0,0 +1,92 @@
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/refs/tags/v1.17.0.zip
+)
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+
+include(GoogleTest)
+
+add_custom_target(unit_tests)
+
+macro(add_vrt_test test_name test_source)
+  add_executable(${test_name} ${test_source})
+  target_link_libraries(${test_name} PRIVATE GTest::gtest_main GTest::gmock vrt::vrt)
+  gtest_discover_tests(${test_name})
+  add_dependencies(unit_tests ${test_name})
+endmacro()
+
+add_vrt_test(register_test register_test.cpp)
+add_vrt_test(qdma_connection_test qdma_connection_test.cpp)
+add_vrt_test(logger_test logger_test.cpp)
+add_vrt_test(utilization_data_test utilization_data_test.cpp)
+add_vrt_test(filesystem_cache_test filesystem_cache_test.cpp)
+add_vrt_test(xml_parser_test xml_parser_test.cpp)
+add_vrt_test(utilization_parser_test utilization_parser_test.cpp)
+add_vrt_test(kernel_test kernel_test.cpp)
+add_vrt_test(vrtbin_test vrtbin_test.cpp)
+
+# --- Stub VBIN generation ---
+set(STUB_VBIN_DIR ${CMAKE_CURRENT_SOURCE_DIR}/fixtures/stub_vbin)
+
+set(STUB_EMU_VBIN ${CMAKE_CURRENT_BINARY_DIR}/stub_emu.vbin)
+add_custom_command(
+  OUTPUT ${STUB_EMU_VBIN}
+  COMMAND ${CMAKE_COMMAND} -E rm -rf ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${STUB_VBIN_DIR}/system_map_emu.xml
+    ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging/system_map.xml
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${STUB_VBIN_DIR}/emu_manifest.json
+    ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging/emu_manifest.json
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${STUB_VBIN_DIR}/vrt_stub_server.py
+    ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging/vpp_emu
+  COMMAND chmod +x ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging/vpp_emu
+  COMMAND tar cf ${STUB_EMU_VBIN}
+    -C ${CMAKE_CURRENT_BINARY_DIR}/stub_emu_staging .
+  DEPENDS
+    ${STUB_VBIN_DIR}/system_map_emu.xml
+    ${STUB_VBIN_DIR}/emu_manifest.json
+    ${STUB_VBIN_DIR}/vrt_stub_server.py
+  COMMENT "Creating emulation stub VBIN"
+)
+
+set(STUB_SIM_VBIN ${CMAKE_CURRENT_BINARY_DIR}/stub_sim.vbin)
+add_custom_command(
+  OUTPUT ${STUB_SIM_VBIN}
+  COMMAND ${CMAKE_COMMAND} -E rm -rf ${CMAKE_CURRENT_BINARY_DIR}/stub_sim_staging
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/stub_sim_staging
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${STUB_VBIN_DIR}/system_map_sim.xml
+    ${CMAKE_CURRENT_BINARY_DIR}/stub_sim_staging/system_map.xml
+  COMMAND ${CMAKE_COMMAND} -E copy
+    ${STUB_VBIN_DIR}/vrt_stub_server.py
+    ${CMAKE_CURRENT_BINARY_DIR}/stub_sim_staging/vpp_sim
+  COMMAND chmod +x ${CMAKE_CURRENT_BINARY_DIR}/stub_sim_staging/vpp_sim
+  COMMAND tar cf ${STUB_SIM_VBIN}
+    -C ${CMAKE_CURRENT_BINARY_DIR}/stub_sim_staging .
+  DEPENDS
+    ${STUB_VBIN_DIR}/system_map_sim.xml
+    ${STUB_VBIN_DIR}/vrt_stub_server.py
+  COMMENT "Creating simulation stub VBIN"
+)
+
+add_custom_target(stub_vbins DEPENDS ${STUB_EMU_VBIN} ${STUB_SIM_VBIN})
+
+macro(add_vrt_vbin_test test_name test_source)
+  add_executable(${test_name} ${test_source})
+  target_link_libraries(${test_name} PRIVATE GTest::gtest_main GTest::gmock vrt::vrt)
+  target_compile_definitions(${test_name} PRIVATE
+    STUB_EMU_VBIN_PATH="${STUB_EMU_VBIN}"
+    STUB_SIM_VBIN_PATH="${STUB_SIM_VBIN}")
+  add_dependencies(${test_name} stub_vbins)
+  gtest_discover_tests(${test_name})
+  add_dependencies(unit_tests ${test_name})
+endmacro()
+
+add_vrt_vbin_test(vrtbin_integration_test vrtbin_integration_test.cpp)
+add_vrt_vbin_test(device_test device_test.cpp)