feat[shared_library]: Can load test data from python to the host code

Author: Djokzer

hls4ml/templates/vitis_accelerator/Makefile

@@ -118,6 +118,10 @@ INCLUDES += -I$(PWD)/libs/ -I$(PWD)/firmware/ -I$(PWD)/firmware/nnet_utils/
 host: $(KERNEL_NAME)_host_cl.cpp libs/xcl2.cpp $(wildcard libs/*.hpp)
 	$(CXX) $(CXXFLAGS) $(KERNEL_NAME)_host_cl.cpp libs/xcl2.cpp -o $@ $(INCLUDES) $(LDFLAGS)
 
+# Host shared library compilation #################################################
+host_shared: $(KERNEL_NAME)_host_cl.cpp libs/xcl2.cpp $(wildcard libs/*.hpp)
+	$(CXX) -shared -fPIC $(CXXFLAGS) $(KERNEL_NAME)_host_cl.cpp libs/xcl2.cpp -o lib_host.so $(INCLUDES) $(LDFLAGS)
+
 # Execute program #############################################################
 
 run: ./host $(BUILD_DIR)/$(WRAPPER_NAME).xclbin

hls4ml/templates/vitis_accelerator/libs/DataBatcher.hpp

@@ -70,6 +70,34 @@ template <class T, class U> class DataBatcher {
         }
     }
 
+    /**
+     * \brief Read in data from a shared buffer.
+     * \param data Pointer to the shared buffer containing input data
+     * \param size Size of the shared buffer in bytes
+     */
+    void readSharedData(const double* data, uint64_t size)
+    {
+        if (size == 0) {
+            throw std::runtime_error("No data to load");
+        }
+
+        std::cout << "Loading data from memory buffer" << std::endl;
+        originalSampleCount = size / _sampleInputSize;
+        inputData.resize(size);
+        for (uint64_t i = 0; i < size; i++) {
+            inputData[i] = static_cast<T>(data[i]);
+        }
+
+        // Zero-pad
+        numBatches = std::ceil(static_cast<double>(originalSampleCount) / _batchsize);
+        size_t finalSampleCount = numBatches * _batchsize;
+        if (finalSampleCount > originalSampleCount) {
+            std::cout << "Padding with " << (finalSampleCount - originalSampleCount) << " empty samples for a total of "
+                      << numBatches << " batches of " << _batchsize << " samples" << std::endl;
+            inputData.resize(finalSampleCount * _sampleInputSize, (T)0);
+        }
+    }
+
     bool readReference(const std::string &filename) {
 
         std::ifstream fref(filename);

hls4ml/templates/vitis_accelerator/libs/FpgaObj.hpp

@@ -142,6 +142,29 @@ template <class T, class U> class FpgaObj {
         db->batch(batchedData);
     }
 
+    /**
+     * \brief Loads data from a shared buffer into batches and distribute evenly
+     * amongst Workers.
+     * \param data Pointer to the shared buffer containing input data
+     * \param size Size of the shared buffer in bytes
+     * \param profilingDataRepeat Additional number of times the given data is iterated
+     * over. Profiling is enabled if this is greater than 0.
+     */
+    void loadSharedData(const double* data, uint64_t size, int profilingDataRepeat = 0) {
+        // Set-up containers for each Worker's batches/workload
+        batchedData.reserve(_numCU * _workersPerCU * _numDevice);
+        for (int i = 0; i < _numCU * _workersPerCU * _numDevice; i++) {
+            batchedData.emplace_back();
+        }
+
+        // Batch and distribute data
+        db = new DataBatcher<T, U>(_batchsize, _sampleInputSize, _sampleOutputSize, _numCU * _workersPerCU * _numDevice,
+            profilingDataRepeat);
+        db->readSharedData(data, size);
+        db->createResultBuffers();
+        db->batch(batchedData);
+    }
+
     /**
      * \brief Workers evaluate all loaded data. Each worker uses a separate thread.
      */

hls4ml/templates/vitis_accelerator/myproject_host_cl.cpp

@@ -6,10 +6,24 @@
 #include "kernel_wrapper.h"
 #include "xcl2.hpp"
 
-void predict(double *input, uint64_t input_size, double *output, uint64_t output_size) {
-    // TODO : Modify the databatcher so it can take those arrays instead of reading and writing files.
+extern "C" void predict(double *input, uint64_t input_size, double *output, uint64_t output_size) {
 
-    return;
+    int argc = 2;
+    char *argv[] = {const_cast<char *>("host"), const_cast<char *>("myproject.xclbin")};
+
+    Params params(argc, argv);
+
+    FpgaObj<in_buffer_t, out_buffer_t> fpga(params);
+
+    fpga.createWorkers(params.numWorker);
+
+    fpga.loadSharedData(input, input_size);
+
+    fpga.evaluateAll();
+
+    fpga.checkResults(params.referenceFilename);
+
+    fpga.saveResults(params.outputFilename);
 }
 
 int main(int argc, char **argv) {