PERFTEST/FT Add validation mode for pingpong tests

Author: william-gallagher-nv

src/tools/perf/lib/ucp_tests.cc

@@ -16,6 +16,7 @@
 
 #include <ucs/sys/preprocessor.h>
 #include <ucs/sys/string.h>
+#include "ucs/type/status.h"
 #include <limits>
 
 
@@ -733,6 +734,21 @@ class ucp_perf_test_runner : public ucp_perf_test_runner_base<uint8_t> {
                  m_perf.ucp.self_recv_rkey);
     }
 
+    ucs_status_t validate_buffers(void *send_buffer, void *recv_buffer,
+                                  size_t length)
+    {
+        if (CMD == UCX_PERF_CMD_PUT) {
+            fence();
+        }
+
+        if (memcmp(send_buffer, recv_buffer, length)) {
+            ucs_error("data mismatch between send and receive buffers");
+            return UCS_ERR_IO_ERROR;
+        }
+
+        return UCS_OK;
+    }
+
     ucs_status_t run_pingpong()
     {
         unsigned my_index;
@@ -744,21 +760,25 @@ class ucp_perf_test_runner : public ucp_perf_test_runner_base<uint8_t> {
         ucp_rkey_h rkey;
         size_t length, send_length, recv_length;
         psn_t sn;
+        bool validate;
+        ucs_status_t status;
 
         send_buffer = m_perf.send_buffer;
         recv_buffer = m_perf.recv_buffer;
         worker      = m_perf.ucp.worker;
         ep          = m_perf.ucp.ep;
         remote_addr = m_perf.ucp.remote_addr;
         rkey        = m_perf.ucp.rkey;
-        sn          = 0;
+        sn          = 1;
 
         ucp_perf_init_common_params(&length, &send_length, &send_datatype,
                                     &send_buffer, &recv_length, &recv_datatype,
                                     &recv_buffer);
 
         reset_buffers(length, UNKNOWN_SN);
 
+        validate = m_perf.params.flags & UCX_PERF_TEST_FLAG_VALIDATE;
+
         ucp_perf_barrier(&m_perf);
 
         my_index = rte_call(&m_perf, group_index);
@@ -769,16 +789,35 @@ class ucp_perf_test_runner : public ucp_perf_test_runner_base<uint8_t> {
 
         if (my_index == 0) {
             UCX_PERF_TEST_FOREACH(&m_perf) {
+
+                if (validate) {
+                    memset(send_buffer, sn, send_length);
+                }
+
                 send(ep, send_buffer, send_length, send_datatype, sn, remote_addr, rkey);
                 recv(worker, ep, recv_buffer, recv_length, recv_datatype, sn);
                 wait_recv_window(m_max_outstanding);
+
+                if (validate) {
+                    status = validate_buffers(send_buffer, recv_buffer,
+                                              send_length);
+                    if (status != UCS_OK) {
+                        return status;
+                    }
+                }
+
                 ucx_perf_update(&m_perf, 1, 1, length);
                 ++sn;
             }
         } else if (my_index == 1) {
             UCX_PERF_TEST_FOREACH(&m_perf) {
                 recv(worker, ep, recv_buffer, recv_length, recv_datatype, sn);
                 wait_recv_window(m_max_outstanding);
+
+                if (validate) {
+                    memcpy(send_buffer, recv_buffer, send_length);
+                }
+
                 send(ep, send_buffer, send_length, send_datatype, sn,
                      remote_addr, rkey, m_perf.current.iters == 0);
                 ucx_perf_update(&m_perf, 1, 1, length);
@@ -834,7 +873,7 @@ class ucp_perf_test_runner : public ucp_perf_test_runner_base<uint8_t> {
         if (m_perf.params.flags & UCX_PERF_TEST_FLAG_LOOPBACK) {
             UCX_PERF_TEST_FOREACH(&m_perf) {
                 send(ep, send_buffer, send_length, send_datatype,
-                     sn, remote_addr, rkey);
+                    sn, remote_addr, rkey);
                 recv(worker, ep, recv_buffer, recv_length, recv_datatype, sn);
                 ucx_perf_update(&m_perf, 1, 1, length);
                 ++sn;

src/tools/perf/perftest_params.c

@@ -8,8 +8,10 @@
 #  include "config.h"
 #endif
 
+#include "api/libperf.h"
 #include "perftest.h"
 
+#include "ucs/memory/memory_type.h"
 #include <ucs/sys/string.h>
 #include <ucs/sys/sys.h>
 #include <ucs/sys/sock.h>
@@ -173,6 +175,7 @@ static void usage(const struct perftest_context *ctx, const char *program)
                                 ctx->params.super.ucp.am_hdr_size);
     printf("     -y             do additional memcopy to the user memory in active message receive handler\n");
     printf("     -z             pass pre-registered memory handle\n");
+    printf("     -V             validate data correctness for pingpong tests\n");
     printf("     -g <IP>[:<port>], --daemon-local <IP>[:<port>]\n");
     printf("                    IP address and port of the local daemon to offload UCP operations to\n");
     printf("                    Port is optional, by default daemon port is (%d)\n",
@@ -771,6 +774,9 @@ ucs_status_t parse_test_params(perftest_params_t *params, char opt,
     case 'z':
         params->super.flags |= UCX_PERF_TEST_FLAG_PREREG;
         return UCS_OK;
+    case 'V':
+        params->super.flags |= UCX_PERF_TEST_FLAG_VALIDATE;
+        return UCS_OK;
     default:
        return UCS_ERR_INVALID_PARAM;
     }
@@ -819,6 +825,31 @@ ucs_status_t clone_params(perftest_params_t *dest,
     return UCS_OK;
 }
 
+ucs_status_t check_validation_params(const ucx_perf_params_t *params)
+{
+    if (!(params->flags & UCX_PERF_TEST_FLAG_VALIDATE)) {
+        return UCS_OK;
+    }
+
+    if (params->api == UCX_PERF_API_UCT) {
+        ucs_error("validation mode is not compatible with UCT tests");
+        return UCS_ERR_INVALID_PARAM;
+    }
+   
+    if (params->test_type != UCX_PERF_TEST_TYPE_PINGPONG) {
+        ucs_error("validation mode requires using a PingPong test");
+        return UCS_ERR_INVALID_PARAM;
+    }
+
+    if ((params->send_mem_type != UCS_MEMORY_TYPE_HOST) || 
+        (params->recv_mem_type != UCS_MEMORY_TYPE_HOST)) {
+        ucs_error("validation mode requires send and recv buffers to use host memory");
+        return UCS_ERR_INVALID_PARAM;
+    }
+
+    return UCS_OK;
+}
+
 ucs_status_t check_params(const perftest_params_t *params)
 {
     ucs_status_t status;
@@ -828,6 +859,11 @@ ucs_status_t check_params(const perftest_params_t *params)
         return status;
     }
 
+    status = check_validation_params(&params->super);
+    if (status != UCS_OK) {
+        return status;
+    }
+
     switch (params->super.api) {
     case UCX_PERF_API_UCT:
         if (!strcmp(params->super.uct.dev_name, TL_RESOURCE_NAME_NONE)) {
@@ -916,7 +952,7 @@ ucs_status_t parse_opts(struct perftest_context *ctx, int mpi_initialized,
 
     optind = 1;
     while ((c = getopt_long(argc, argv,
-                            "p:b:6NfvXc:P:hK:g:G:k" TEST_PARAMS_ARGS,
+                            "p:b:6NfvXc:P:hK:g:G:kV" TEST_PARAMS_ARGS,
                             TEST_PARAMS_ARGS_LONG, NULL)) != -1) {
         switch (c) {
         case 'p':