p2p_bandwidth updated to run synchronous flow by default

Author: Bhaskar VishnuVardhan Chebrolu

host/p2p_bandwidth/Makefile

@@ -56,6 +56,8 @@ RESULT_STRING = TEST PASSED
 VPP := v++
 
 include $(ABS_COMMON_REPO)/common/includes/opencl/opencl.mk
+include config.mk
+
 CXXFLAGS += $(opencl_CXXFLAGS) -Wall -O0 -g -std=c++11
 LDFLAGS += $(opencl_LDFLAGS)
 
@@ -68,7 +70,6 @@ HOST_SRCS += $(ABS_COMMON_REPO)/common/includes/xcl2/xcl2.cpp $(ABS_COMMON_REPO)
 # Host compiler global settings
 CXXFLAGS += -fmessage-length=0
 LDFLAGS += -lrt -lstdc++ 
-LDFLAGS += -laio
 
 ifneq ($(HOST_ARCH), x86)
 	LDFLAGS += --sysroot=$(SYSROOT)

host/p2p_bandwidth/config.mk

@@ -0,0 +1,4 @@
+ifeq ($(ENABLE_ASYNC_FLOW), yes)
+LDFLAGS += -laio
+CXXFLAGS += -DASYNC_READ
+endif

host/p2p_bandwidth/description.json

@@ -64,10 +64,6 @@
                 "REPO_DIR/common/includes/cmdparser",
                 "REPO_DIR/common/includes/logger"
             ]
-        },
-        "linker" : {
-            "options" : ["-laio"
-                ]
         }
     },  
     "containers": [
@@ -81,6 +77,7 @@
             "name": "copy_kernel"
         }
     ],
+    "config_make": "config.mk",
     "contributors": [
         {
             "url": "http://www.xilinx.com", 

host/p2p_bandwidth/details.rst

@@ -10,22 +10,62 @@ In this Example we highlight the Synchronous and Asynchronous data
 transfer between SSD and FPGA and capture the performance numbers for
 p2p transfer, Kernel and XDMA.
 
-Following is the real log reported while running the design on samsung
-platform:
+By default synchronous flow is ran and following is the real log 
+reported while running the design on samsung platform:
 
 ::
 
-   ./host copy_kernel.xclbin -w /dev/nvme0n1
+   ./p2p_bandwidth -x copy_kernel.xclbin -i /dev/nvme0n1
    INFO: Successfully opened NVME SSD /dev/nvme0n1
    INFO: Preparing 1048576KB test data in 8 pipelines
    ############################################################
                         Synchronous P2P                         
    ############################################################
    INFO: Kick off test
    HOST -> FPGA(host BO) -> FPGA(p2p BO) -> SSD
-    overall      556211ms    100.00%    1841.03MB/s    
-        p2p      359223ms     64.58%    2850.60MB/s    
-     kernel      199578ms     35.88%    5130.83MB/s    
-       XDMA      313203ms     56.31%    3269.45MB/s    
+    overall      556211ms    100.00%    1861.03MB/s    
+        p2p      359223ms     57.58%    3250.60MB/s    
+     kernel      199578ms     207.88%    871.83MB/s    
+       XDMA      313203ms     99.11%    1866.45MB/s    
    INFO: Evaluating test result
    INFO: Test passed
+
+If we need to run the asynchronous flow, build the host with
+ENABLE_ASYNC_FLOW=yes : 
+
+.. code:: cpp
+
+   make host ENABLE_ASYNC_FLOW=yes
+
+Following is the real log reported while running the design
+on samsung platform for asynchronous flow:
+
+:: 
+
+    ./p2p_bandwidth -x copy_kernel.xclbin -i /dev/nvme0n1
+    INFO: Successfully opened NVME SSD /dev/nvme0n1
+    INFO: Preparing 1048576KB test data in 8 pipelines
+    ############################################################
+                         Synchronous P2P                         
+    ############################################################
+    INFO: Kick off test
+    HOST -> FPGA(host BO) -> FPGA(p2p BO) -> SSD
+    overall      551211ms    100.00%    1862.23MB/s    
+        p2p      357223ms     58.58%    3200.30MB/s    
+     kernel      192578ms     211.88%    879.89MB/s    
+       XDMA      315203ms     99.31%    1867.35MB/s    
+    INFO: Evaluating test result
+    INFO: Test passed
+    ############################################################
+                         Asynchronous P2P                         
+    ############################################################
+    INFO: Kick off test
+    HOST -> FPGA(host BO) -> FPGA(p2p BO) -> SSD
+    overall      556211ms    100.00%    1548.03MB/s    
+        p2p      359223ms     61.58%    3371.60MB/s    
+     kernel      199578ms     198.88%    697.83MB/s    
+       XDMA      313203ms     98.23%    1806.45MB/s    
+    INFO: Evaluating test result
+    INFO: Test passed
+
+

host/p2p_bandwidth/src/host.cpp

@@ -37,10 +37,13 @@
 #include <fcntl.h>
 #include <iomanip>
 #include <iostream>
-#include <libaio.h>
 #include <string.h>
 #include <unistd.h>
 
+#ifdef ASYNC_READ
+#include <libaio.h>
+#endif
+
 #include "xcl2.hpp"
 
 // Comment out below macro for testing P2P IO bandwidth b/w FPGA and SSD only.
@@ -270,6 +273,7 @@ void exec_write_test() {
     clWaitForEvents(1, &chunks[idx]->p2pEvt);
 }
 
+#ifdef ASYNC_READ
 void exec_async_read_test(Chunk **chunks) {
   io_context_t myctx;
   memset(&myctx, 0, sizeof(myctx));
@@ -319,6 +323,7 @@ void exec_async_read_test(Chunk **chunks) {
     clWaitForEvents(1, &chunks[idx]->p2pEvt);
 #endif
 }
+#endif
 
 void exec_read_test() {
   cout << "SSD -> FPGA(p2p BO) -> FPGA(host BO) -> HOST" << endl;
@@ -464,9 +469,12 @@ int main(int argc, char **argv) {
   cl_program program = clCreateProgramWithBinary(
       context, 1, &device, &binary_size, &binary_data, NULL, &err);
 
+#ifdef ASYNC_READ
   io_context_t ctx;
   memset(&ctx, 0, sizeof(ctx));
   io_queue_init(128, &ctx);
+#endif
+
   // Setting up OpenCL runtime environment.
   cl_kernel kernel = clCreateKernel(program, "copy", &err);
 
@@ -537,6 +545,7 @@ int main(int argc, char **argv) {
   for (int idx = 0; idx < num_chunks; idx++)
     delete chunks[idx];
 
+#ifdef ASYNC_READ  
   if (!isWrite) {
     // Running Asynchronous P2P
     std::cout
@@ -590,6 +599,7 @@ int main(int argc, char **argv) {
     for (int idx = 0; idx < num_chunks; idx++)
       delete chunks[idx];
   }
+#endif
 
   clReleaseKernel(kernel);
   clReleaseContext(context);