change(sgdma): get_full_buffers(), add read_buffers()

Author: patrislav1

example/demo_cpp/src/axi_dma_demo.cpp

@@ -118,12 +118,12 @@ int main(int argc, char* argv[]) {
     auto mem_sgdma = std::make_unique<UioMemSgdma>(target_hw_consts::axi_bram_ctrl);
     auto traffic_gen = std::make_unique<UioTrafficGen>(target_hw_consts::axi_traffic_gen);
 
-    std::unique_ptr<DmaBufferAbstract> udmabuf;
+    std::shared_ptr<DmaBufferAbstract> udmabuf;
     if (mode == DmaMode::UIO) {
-        udmabuf = std::make_unique<UDmaBuf>();
+        udmabuf = std::make_shared<UDmaBuf>();
     } else {
         udmabuf =
-            std::make_unique<FpgaMemBufferOverXdma>(dev_path, target_hw_consts::fpga_mem_phys_addr);
+            std::make_shared<FpgaMemBufferOverXdma>(dev_path, target_hw_consts::fpga_mem_phys_addr);
     }
 
     const size_t pkt_size = pkt_len * target_hw_consts::lfsr_bytes_per_beat;
@@ -136,7 +136,7 @@ int main(int argc, char* argv[]) {
     auto fut = std::async(std::launch::async, std::ref(data_handler));
 
     constexpr int nr_buffers = 32;
-    mem_sgdma->init_buffers(*udmabuf, nr_buffers, pkt_size);
+    mem_sgdma->init_buffers(udmabuf, nr_buffers, pkt_size);
 
     uintptr_t first_desc = mem_sgdma->get_first_desc_addr();
     axi_dma->start(first_desc);

inc/udmaio/UioMemSgdma.hpp

@@ -12,6 +12,7 @@
 #pragma once
 
 #include <cstddef>
+#include <memory>
 
 #include "DmaBufferAbstract.hpp"
 #include "RegAccessor.hpp"
@@ -78,6 +79,8 @@ class UioMemSgdma : public UioIf {
     std::vector<uint64_t> _buf_addrs;
     size_t _buf_size;
 
+    std::shared_ptr<DmaBufferAbstract> _mem;
+
     void write_cyc_mode(const std::vector<UioRegion>& dst_bufs);
 
   public:
@@ -87,7 +90,7 @@ class UioMemSgdma : public UioIf {
     /// @param mem Memory receiving the SGDMA data
     /// @param num_buffers Number of descriptors / SGDMA blocks
     /// @param buf_size Size of each SGDMA block
-    void init_buffers(DmaBufferAbstract& mem, size_t num_buffers, size_t buf_size);
+    void init_buffers(std::shared_ptr<DmaBufferAbstract> mem, size_t num_buffers, size_t buf_size);
 
     /// @brief Print SGDMA descriptor
     /// @param desc SGDMA descriptor
@@ -101,8 +104,10 @@ class UioMemSgdma : public UioIf {
     uintptr_t get_first_desc_addr() const;
 
     /// @brief Get full SGDMA buffers
-    /// @return Vector of UioRegion pointing into full buffers
-    std::vector<UioRegion> get_full_buffers();
+    /// @return Vector of indices of full buffers
+    std::vector<size_t> get_full_buffers();
+
+    std::vector<uint8_t> read_buffers(const std::vector<size_t> indices);
 };
 
 std::ostream& operator<<(std::ostream& os, const UioRegion& buf_info);

src/DataHandlerAbstract.cpp

@@ -58,25 +58,14 @@ void DataHandlerAbstract::_handle_input(const boost::system::error_code& ec) {
     uint32_t irq_count = _dma.clear_interrupt();
     BOOST_LOG_SEV(_lg, bls::trace) << "irq count = " << irq_count;
 
-    std::vector<UioRegion> full_bufs = _desc.get_full_buffers();
-    std::vector<uint8_t> bytes;
-
+    auto full_bufs = _desc.get_full_buffers();
     if (full_bufs.empty()) {
         BOOST_LOG_SEV(_lg, bls::trace) << "spurious event, got no data";
-        goto done;
+    } else {
+        auto bytes = _desc.read_buffers(full_bufs);
+        process_data(std::move(bytes));
     }
 
-    // Assuming all buffers are equally big, we need number of buffers times buffer size
-    // Reserving enough space in advance to avoid re-allocation / copying
-    bytes.reserve(full_bufs.size() * full_bufs[0].size);
-
-    for (auto& buf : full_bufs) {
-        _mem.append_from_buf(buf, bytes);
-    }
-
-    process_data(std::move(bytes));
-
-done:
     _start_read();
 }
 

src/UioMemSgdma.cpp

@@ -11,7 +11,14 @@
 
 #include "udmaio/UioMemSgdma.hpp"
 
+#include <cstddef>
 #include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "udmaio/DmaBufferAbstract.hpp"
 
 namespace udmaio {
 
@@ -43,12 +50,16 @@ void UioMemSgdma::write_cyc_mode(const std::vector<UioRegion>& dst_bufs) {
     }
 }
 
-void UioMemSgdma::init_buffers(DmaBufferAbstract& mem, size_t num_buffers, size_t buf_size) {
+void UioMemSgdma::init_buffers(std::shared_ptr<DmaBufferAbstract> mem,
+                               size_t num_buffers,
+                               size_t buf_size) {
+    _mem = mem;
+
     // FIXME: enforce alignment constraints?
     std::vector<UioRegion> dst_bufs;
     _buf_addrs.clear();
     for (size_t i = 0; i < num_buffers; i++) {
-        uint64_t addr = mem.get_phys_region().addr + i * buf_size;
+        uint64_t addr = mem->get_phys_region().addr + i * buf_size;
         dst_bufs.push_back({
             .addr = addr,
             .size = buf_size,
@@ -97,8 +108,8 @@ std::ostream& operator<<(std::ostream& os, const UioRegion& buf_info) {
     return os;
 }
 
-std::vector<UioRegion> UioMemSgdma::get_full_buffers() {
-    std::vector<UioRegion> bufs;
+std::vector<size_t> UioMemSgdma::get_full_buffers() {
+    std::vector<size_t> result;
 
     for (size_t i = 0; i < _nr_cyc_desc; i++) {
         auto stat = desc_statuses[_next_readable_buf].rd();
@@ -107,29 +118,42 @@ std::vector<UioRegion> UioMemSgdma::get_full_buffers() {
         }
 
         if ((!stat.rxeof && (stat.num_stored_bytes != _buf_size)) || stat.num_stored_bytes == 0) {
-            BOOST_LOG_SEV(_lg, bls::error)
-                << "Descriptor #" << i << " size mismatch (expected " << _buf_size << ", received "
-                << stat.num_stored_bytes << "), skipping";
-
-            print_desc(descriptors[_next_readable_buf].rd());
-            continue;
+            throw std::runtime_error("Descriptor #" + std::to_string(i) +
+                                     " size mismatch (expected " + std::to_string(_buf_size) +
+                                     ", received " + std::to_string(stat.num_stored_bytes) + ")");
         }
 
-        stat.cmplt = 0;
-        desc_statuses[_next_readable_buf].wr(stat);
-
-        const uint64_t buf_addr = _buf_addrs[_next_readable_buf];
-        bufs.emplace_back(UioRegion{static_cast<uintptr_t>(buf_addr), stat.num_stored_bytes});
-
-        BOOST_LOG_SEV(_lg, bls::trace)
-            << "save buf #" << _next_readable_buf << " (" << stat.num_stored_bytes << " bytes) @ 0x"
-            << std::hex << buf_addr;
+        result.push_back(_next_readable_buf);
 
         _next_readable_buf++;
         _next_readable_buf %= _nr_cyc_desc;
     }
 
-    return bufs;
+    return result;
+}
+
+std::vector<uint8_t> UioMemSgdma::read_buffers(const std::vector<size_t> indices) {
+    // Read statuses for all buffers
+    std::vector<S2mmDescStatus> stats{indices.size()};
+    size_t result_size = 0;
+    for (size_t i = 0; i < indices.size(); i++) {
+        stats[i] = desc_statuses[indices[i]].rd();
+        result_size += stats[i].num_stored_bytes;
+    }
+
+    std::vector<uint8_t> result;
+    // Reserve enough space in advance to avoid re-allocation / copying
+    result.reserve(result_size);
+    for (size_t i = 0; i < indices.size(); i++) {
+        auto region = UioRegion{_buf_addrs[indices[i]], stats[i].num_stored_bytes};
+        BOOST_LOG_SEV(_lg, bls::trace) << "save buf #" << indices[i] << " (" << region.size
+                                       << " bytes) @ 0x" << std::hex << region.addr;
+        _mem->append_from_buf(region, result);
+        // Clear complete flag after having read the data
+        stats[i].cmplt = 0;
+        desc_statuses[indices[i]].wr(stats[i]);
+    }
+    return result;
 }
 
 }  // namespace udmaio

tests/test_UioMemSgdma.cpp

@@ -19,13 +19,13 @@ struct UioMemSgdmaTest : public Logger {
     UioMemSgdma sgdma;
 
     HwAccessorPtr hw_fpga_mem;
-    FpgaMemBufferOverAxi fpga_mem;
+    std::shared_ptr<FpgaMemBufferOverAxi> fpga_mem;
 
     UioMemSgdmaTest()
         : hw_sgdma{std::make_shared<udmaio::HwAccessorMock>(16 * 1024)}
         , sgdma{UioDeviceLocation{hw_sgdma}}
         , hw_fpga_mem{std::make_shared<HwAccessorMock>(16 * 1024)}
-        , fpga_mem{UioDeviceLocation{hw_fpga_mem}}
+        , fpga_mem{std::make_shared<FpgaMemBufferOverAxi>(UioDeviceLocation{hw_fpga_mem})}
         , descriptors{sgdma.descriptors}
         , Logger("UioMemSgdmaTest") {}
     ~UioMemSgdmaTest() {}
@@ -81,8 +81,7 @@ BOOST_FIXTURE_TEST_CASE(full_buffers, UioMemSgdmaTest) {
     auto bufs = sgdma.get_full_buffers();
     BOOST_CHECK_MESSAGE(bufs.size() == 1, "Expected one full buffer, received " << bufs.size());
 
-    std::vector<uint8_t> data;
-    fpga_mem.append_from_buf(bufs[0], data);
+    std::vector<uint8_t> data = sgdma.read_buffers(bufs);
     BOOST_CHECK_MESSAGE(data.size() == buf_size, "Buffer size mismatch");
     check_buffer(data);
 }