Fpga test exe sem 1171

re/src/workers/fft_accel/data/fft_data.cpp

@@ -4,6 +4,8 @@
 
 #include "fft_data.hpp"
 
+#include <algorithm>
+
 using namespace sem::fft_accel::data;
 
 template<>
@@ -16,6 +18,10 @@ fft_data_packet<float>::fft_data_packet(SerializedPacket &serialized_data) :
     auto data_span = bytes.subspan(SerializedPacket::header_byte_length);
     fft_data_.resize(data_span.size() / sizeof(float));
     memcpy(&(*fft_data_.begin()), &(*data_span.begin()), data_span.size());
+
+    for (auto& sample_value : fft_data_) {
+        boost::endian::big_to_native_inplace(reinterpret_cast<uint32_t&>(sample_value));
+    }
 }
 
 template<>
@@ -24,5 +30,8 @@ uint8_t fft_data_packet<float>::sequence_number() const { return header_data_.se
 template<>
 uint8_t fft_data_packet<float>::request_id() const { return header_data_.request_id(); };
 
+template<>
+uint16_t fft_data_packet<float>::fft_size() const { return header_data_.fft_size(); };
+
 template<>
 const std::vector<float> &fft_data_packet<float>::payload_data() const { return fft_data_; };

re/src/workers/fft_accel/data/fft_data.hpp

@@ -13,6 +13,7 @@
 #include "packet_headers.hpp"
 
 #include <iostream>
+#include "boost/endian/conversion.hpp"
 
 namespace sem::fft_accel::data {
 
@@ -68,9 +69,9 @@ namespace sem::fft_accel::data {
         using SerializedPacket = serialized_fft_data<SampleType, max_elements>;
 
         fft_data_packet(const data::vector_range<SampleType> &data_range, uint8_t request_id,
-                        uint8_t sequence_num) :
+                        uint8_t sequence_num, uint16_t fft_request_size) :
                 fft_data_(data_range.begin(), data_range.end()),
-                header_data_(request_id, sequence_num, max_elements){
+                header_data_(request_id, sequence_num, fft_request_size){
             if (fft_data_.size() > max_elements) {
                 throw std::invalid_argument("Attempting to create fft_data_packet from vector that is too large");
             }
@@ -82,6 +83,8 @@ namespace sem::fft_accel::data {
 
         [[nodiscard]] uint8_t request_id() const;
 
+        [[nodiscard]] uint16_t fft_size() const;
+
         [[nodiscard]] const std::vector<SampleType> &payload_data() const;
 
     private:
@@ -123,10 +126,17 @@ namespace sem::fft_accel::data {
         data_.at(2) = static_cast<std::byte>(native_packet.request_id());
         // 3rd byte currently unused, formerly used for CSR
         // TODO: Thoroughly investigate endianness of remaining fields to be serialized
-        data_.at(4) = static_cast<std::byte>(native_packet.payload_data().size());
+        uint16_t size_as_big_endian = boost::endian::native_to_big(static_cast<uint16_t>(native_packet.fft_size()));
+        reinterpret_cast<uint16_t&>(data_.at(4)) = size_as_big_endian;
 
         constexpr auto payload_byte_length = NumElements * sizeof(SampleType);
         memcpy(&(*(data_.begin() + 6)), &(*native_packet.payload_data().begin()), payload_byte_length);
+
+        // Note: the &(*(iterator)) syntax is needed for MSVC compatibility
+        auto float_view = reinterpret_cast<std::array<uint32_t, NumElements>*>(&(*(data_.begin() + 6)));
+        for (auto& sample_value : *float_view) {
+            boost::endian::native_to_big_inplace(sample_value);
+        }
     }
 
     template<typename SampleType, size_t NumElements>

re/src/workers/fft_accel/data/fft_packet_group.hpp

@@ -77,7 +77,7 @@ namespace sem::fft_accel::data {
 
             data::vector_range<SampleType> data_segment{fft_data, segment_start, segment_end};
 
-            packets_.emplace_back(data_segment, request_id, cur_index);
+            packets_.emplace_back(data_segment, request_id, cur_index, fft_data.size()/2);
         }
     }
 

re/src/workers/fft_accel/data/test/data_test_util.hpp

@@ -34,7 +34,7 @@ namespace sem::fft_accel::data::test {
         static std::uniform_int_distribution<uint8_t> dis(
                 std::numeric_limits<uint8_t>::min(),
                 std::numeric_limits<uint8_t>::max()
-                );
+        );
 #endif
         return dis(e);
     }
@@ -66,16 +66,19 @@ namespace sem::fft_accel::data::test {
     }
 
     template<typename SampleType>
-    inline fft_data_packet <SampleType> generate_random_fft_data_packet() {
+    inline fft_data_packet<SampleType> generate_random_fft_data_packet() {
+        auto &&vec_data = generate_random_single_packet_fft_vec_data();
+        auto num_samples = static_cast<uint16_t>(vec_data.size() / 2);
         return {
-                generate_random_single_packet_fft_vec_data(),
+                vec_data,
+                get_random<uint8_t>(),
                 get_random<uint8_t>(),
-                get_random<uint8_t>()
+                num_samples,
         };
     }
 
     template<typename SampleType>
-    inline serialized_fft_data <SampleType> generate_random_serialized_data_packet() {
+    inline serialized_fft_data<SampleType> generate_random_serialized_data_packet() {
         return serialized_fft_data<SampleType>(
                 generate_random_array<std::byte, serialized_fft_data<SampleType>::packet_byte_size>()
         );

re/src/workers/fft_accel/data/test/fft_data_tests.cpp

@@ -20,7 +20,8 @@ TEST(fft_accel_worker_data_packet, constructor_nothrow) {
             data_packet = std::make_unique<fft_data_packet<float>>(
                     payload_range,
                     get_random<uint8_t>(),
-                    get_random<uint8_t>()
+                    get_random<uint8_t>(),
+                    payload_data.size()/2
             );
     );
     ASSERT_NE(data_packet, nullptr);

re/src/workers/fft_accel/runtime/fft_request_map.hpp

@@ -162,7 +162,8 @@ namespace sem::fft_accel::runtime {
             }
 
             if (request.remaining_packets() == 0) {
-                auto &&fulfilled_request = staged_packet_groups_.at(request_id);
+                auto fulfilled_request = std::move(staged_packet_groups_.at(request_id));
+                staged_packet_groups_.erase(request_id);
                 unfulfilled_promises_.at(request_id).set_value(fulfilled_request);
                 return {std::optional<fft_result<SampleType>>({request_id, fulfilled_request.to_vector()})};
             } else {

re/src/workers/fft_accel/runtime/single_thread_dispatcher.hpp

@@ -52,8 +52,9 @@ namespace sem::fft_accel::runtime {
 
     template<typename EventID, typename EventData>
     single_thread_dispatcher<EventID, EventData>::single_thread_dispatcher() :
-            should_continue_running_(true),
-            dispatch_thread_([this]() { run_dispatch_loop(); }) {}
+            should_continue_running_(true) {
+        dispatch_thread_ = std::thread([this]() { run_dispatch_loop(); });
+    }
 
     template<typename EventID, typename EventData>
     single_thread_dispatcher<EventID, EventData>::~single_thread_dispatcher() {
@@ -63,8 +64,10 @@ namespace sem::fft_accel::runtime {
 
     template<typename EventID, typename EventData>
     void single_thread_dispatcher<EventID, EventData>::stop() {
-        std::lock_guard queue_lock(queue_mutex_);
-        should_continue_running_ = false;
+        {
+            std::lock_guard queue_lock(queue_mutex_);
+            should_continue_running_ = false;
+        }
         // Ensure that the queue variable gets the signal to stop waiting for new events
         event_occurred_.notify_all();
     }
@@ -122,7 +125,7 @@ namespace sem::fft_accel::runtime {
     template<typename EventID, typename EventData>
     void single_thread_dispatcher<EventID, EventData>::run_dispatch_loop() {
 
-        while (should_continue_running_.load()) {
+        while (should_continue_running_) {
             std::unique_lock queue_lock(queue_mutex_);
 
             if (!event_queue_.empty()) {

re/src/workers/fft_accel/runtime/test/runtime_adapter_tests.cpp

@@ -143,7 +143,8 @@ AssertionResult map_can_construct_then_receive(size_t num_packets) {
         response_packets.emplace_back(
                 data::vector_range{data::test::generate_random_fft_data(packet_type::max_elements)},
                 constructed_request_id,
-                sequence_num);
+                sequence_num,
+                input_data.size()/2);
     }
 
     // Send responses for all packets apart from the last, expecting no error, but result should contain nullopt (request not yet fulfilled)

re/src/workers/fft_accel/sem_fft_accel_worker.cpp

@@ -30,6 +30,9 @@ sem::fft_accel::Worker::Worker(const BehaviourContainer &container, const std::s
     }
 }
 
+sem::fft_accel::Worker::~Worker() {
+    Terminate();
+}
 
 void sem::fft_accel::Worker::HandleConfigure() {
     auto endpoint = GetAttribute(std::string(AttrNames::accelerator_endpoint)).lock();

re/src/workers/fft_accel/sem_fft_accel_worker.hpp

@@ -16,6 +16,7 @@ class Worker : public ::Worker {
     using callback_func_type = std::function<callback_func_signature>;
 
     Worker(const BehaviourContainer &container, const std::string &inst_name);
+    ~Worker();
 
     const std::string &get_version() const override;
 

re/src/workers/fft_accel/test/CMakeLists.txt

@@ -47,4 +47,6 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_$<CONFIG> ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/$
 
 if(MSVC)
     set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-endif(MSVC)
+endif(MSVC)
+
+add_subdirectory(fpga_client)

re/src/workers/fft_accel/test/fpga_client/CMakeLists.txt

@@ -0,0 +1,21 @@
+
+find_package(Boost 1.67.0 REQUIRED COMPONENTS program_options filesystem)
+
+add_executable(fpga_fft_client)
+
+target_compile_features(fpga_fft_client
+        PUBLIC
+        cxx_std_17
+        )
+
+target_sources(fpga_fft_client
+        PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/fft_client.cpp
+        )
+
+target_link_libraries(fpga_fft_client
+        PRIVATE
+        sem_fft_accel_fpga_worker
+        Boost::program_options
+        Boost::filesystem
+)