feat(sgdma): get_next_packet() API

Author: patrislav1

inc/udmaio/UioMemSgdma.hpp

@@ -103,10 +103,17 @@ class UioMemSgdma : public UioIf {
     /// @return Address of first SGDMA descriptor
     uintptr_t get_first_desc_addr() const;
 
-    /// @brief Get full SGDMA buffers
-    /// @return Vector of indices of full buffers
+    /// @brief Get all full SGDMA buffers
+    /// @return Vector of buffer indices of full buffers
     std::vector<size_t> get_full_buffers();
 
+    /// @brief Get SGDMA buffers for next packet
+    /// @return Vector of buffer indices for next packet
+    /// Returns only complete packets
+    std::vector<size_t> get_next_packet();
+
+    /// @brief Read data from a set of buffers
+    /// @param indices Vector of buffer indices to read
     std::vector<uint8_t> read_buffers(const std::vector<size_t> indices);
 };
 

src/UioMemSgdma.cpp

@@ -13,12 +13,29 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
 
 #include "udmaio/DmaBufferAbstract.hpp"
+#include <boost/log/sources/severity_feature.hpp>
+
+namespace std {
+// To dump e.g. buffer indices
+// To look a operator up, it has to live in the same namespace as the type it is supposed to stream
+// We want to stream std::vector<size_t> so we have to put it into std namespace :-/
+ostream& operator<<(ostream& os, const vector<size_t>& vec) {
+    os << '[';
+    if (!vec.empty()) {
+        copy(vec.begin(), vec.end() - 1, ostream_iterator<size_t>(os, ", "));
+        os << vec.back();
+    }
+    os << ']';
+    return os;
+}
+};  // namespace std
 
 namespace udmaio {
 
@@ -117,10 +134,9 @@ std::vector<size_t> UioMemSgdma::get_full_buffers() {
             break;
         }
 
-        if ((!stat.rxeof && (stat.num_stored_bytes != _buf_size)) || stat.num_stored_bytes == 0) {
-            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) + ")");
+        if (stat.num_stored_bytes == 0) {
+            throw std::runtime_error("Descriptor #" + std::to_string(_next_readable_buf) +
+                                     " yields zero buffer length");
         }
 
         result.push_back(_next_readable_buf);
@@ -129,9 +145,55 @@ std::vector<size_t> UioMemSgdma::get_full_buffers() {
         _next_readable_buf %= _nr_cyc_desc;
     }
 
+    if (!result.empty()) {
+        BOOST_LOG_SEV(_lg, bls::trace) << "get_full_buffers() result: " << result;
+    }
     return result;
 }
 
+std::vector<size_t> UioMemSgdma::get_next_packet() {
+    std::vector<size_t> result;
+
+    bool has_sof = false;
+    size_t n = _next_readable_buf;
+
+    for (size_t i = 0; i < _nr_cyc_desc; i++) {
+        auto stat = desc_statuses[n].rd();
+        if (!stat.cmplt) {
+            break;
+        }
+
+        if (stat.num_stored_bytes == 0) {
+            throw std::runtime_error("Descriptor #" + std::to_string(n) +
+                                     " yields zero buffer length");
+        }
+        if (!has_sof && !stat.rxsof) {
+            BOOST_LOG_SEV(_lg, bls::warning) << "buffer #" << n << " has no SOF, skipping";
+            n++;
+            n %= _nr_cyc_desc;
+            _next_readable_buf = n;
+            continue;
+        }
+        if (stat.rxsof) {
+            if (!has_sof) {
+                has_sof = true;
+            } else {
+                BOOST_LOG_SEV(_lg, bls::warning) << "buffer #" << n << ": duplicate SOF";
+            }
+        }
+        result.push_back(n);
+        n++;
+        n %= _nr_cyc_desc;
+        if (stat.rxeof) {
+            _next_readable_buf = n;
+            BOOST_LOG_SEV(_lg, bls::trace) << "get_next_packet() result: " << result;
+            return result;
+        }
+    }
+
+    return {};
+}
+
 std::vector<uint8_t> UioMemSgdma::read_buffers(const std::vector<size_t> indices) {
     // Read statuses for all buffers
     std::vector<S2mmDescStatus> stats{indices.size()};

tests/test_UioMemSgdma.cpp

@@ -162,4 +162,101 @@ BOOST_FIXTURE_TEST_CASE(buffer_read, UioMemSgdmaTest) {
     BOOST_CHECK_MESSAGE(cmplt_reset, "Complete flags are not reset");
 }
 
+BOOST_FIXTURE_TEST_CASE(packets_read, UioMemSgdmaTest) {
+    // Make a packet filling up the first buffer
+    fill_buffer(hw_fpga_mem, buf_size * 0, 0, buf_size);
+
+    auto desc = descriptors[0].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = true;
+    desc.status.rxeof = true;
+    desc.status.num_stored_bytes = buf_size;
+    descriptors[0].wr(desc);
+
+    auto bufs = sgdma.get_next_packet();
+    BOOST_CHECK_MESSAGE(bufs.size() == 1, "Expected one full buffer, received " << bufs.size());
+    BOOST_CHECK_MESSAGE(bufs[0] == 0, "Expected first buffer to be full, received " << bufs[0]);
+
+    std::vector<uint8_t> data = sgdma.read_buffers(bufs);
+    BOOST_CHECK_MESSAGE(data.size() == buf_size, "Buffer size mismatch");
+    check_buffer(data);
+
+    bool cmplt_reset = !descriptors[0].rd().status.cmplt;
+    BOOST_CHECK_MESSAGE(cmplt_reset, "Complete flag is not reset");
+
+    // Make a packet spanning 1.5 buffers
+    fill_buffer(hw_fpga_mem, buf_size * 1, 0, buf_size * 3 / 2);
+    desc = descriptors[1].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = true;
+    desc.status.rxeof = false;
+    desc.status.num_stored_bytes = buf_size;
+    descriptors[1].wr(desc);
+    desc = descriptors[2].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = false;
+    desc.status.rxeof = true;
+    desc.status.num_stored_bytes = buf_size / 2;
+    descriptors[2].wr(desc);
+
+    bufs = sgdma.get_next_packet();
+    BOOST_CHECK_MESSAGE((bufs == std::vector<size_t>{1, 2}), "Buffer indices mismatch");
+
+    data = sgdma.read_buffers(bufs);
+    BOOST_CHECK_MESSAGE(data.size() == buf_size * 3 / 2, "Data size mismatch");
+    check_buffer(data);
+
+    cmplt_reset = !descriptors[1].rd().status.cmplt && !descriptors[2].rd().status.cmplt;
+    BOOST_CHECK_MESSAGE(cmplt_reset, "Complete flags are not reset");
+
+    // Make two packets spanning 4 buffers
+    fill_buffer(hw_fpga_mem, buf_size * 3, 1234, buf_size * 3 / 2);
+    desc = descriptors[3].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = true;
+    desc.status.rxeof = false;
+    desc.status.num_stored_bytes = buf_size;
+    descriptors[3].wr(desc);
+
+    // Try to read a packet; ensure it doesn't return anything yet w/o EOF
+    bufs = sgdma.get_next_packet();
+    BOOST_CHECK_MESSAGE(bufs.empty(), "Packet is not full yet");
+
+    desc = descriptors[4].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = false;
+    desc.status.rxeof = true;
+    desc.status.num_stored_bytes = buf_size / 2;
+    descriptors[4].wr(desc);
+
+    fill_buffer(hw_fpga_mem, buf_size * 5, 5678, buf_size * 2);
+    desc = descriptors[5].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = true;
+    desc.status.rxeof = false;
+    desc.status.num_stored_bytes = buf_size;
+    descriptors[5].wr(desc);
+    desc = descriptors[6].rd();
+    desc.status.cmplt = true;
+    desc.status.rxsof = false;
+    desc.status.rxeof = true;
+    desc.status.num_stored_bytes = buf_size;
+    descriptors[6].wr(desc);
+
+    bufs = sgdma.get_next_packet();
+    BOOST_CHECK_MESSAGE((bufs == std::vector<size_t>{3, 4}), "Buffer indices mismatch");
+    data = sgdma.read_buffers(bufs);
+    BOOST_CHECK_MESSAGE(data.size() == buf_size * 3 / 2, "Data size mismatch");
+    check_buffer(data, 1234);
+    cmplt_reset = !descriptors[3].rd().status.cmplt && !descriptors[4].rd().status.cmplt;
+    BOOST_CHECK_MESSAGE(cmplt_reset, "Complete flags are not reset");
+
+    bufs = sgdma.get_next_packet();
+    BOOST_CHECK_MESSAGE((bufs == std::vector<size_t>{5, 6}), "Buffer indices mismatch");
+    data = sgdma.read_buffers(bufs);
+    BOOST_CHECK_MESSAGE(data.size() == buf_size * 2, "Data size mismatch");
+    check_buffer(data, 5678);
+    cmplt_reset = !descriptors[3].rd().status.cmplt && !descriptors[4].rd().status.cmplt;
+    BOOST_CHECK_MESSAGE(cmplt_reset, "Complete flags are not reset");
+}
 }  // namespace udmaio