RVS - Report test progress in realtime

Change-Id: Id9fea71f242f372f408ecd777c030465b7ef9989
Signed-off-by: Galantsev, Dmitrii <dmitrii.galantsev@amd.com>

include/rdc_modules/rdc_rvs/RvsBase.h

@@ -23,15 +23,60 @@ THE SOFTWARE.
 #define RDC_MODULES_RDC_RVS_RVSBASE_H_
 
 #include <cstddef>
+#include <cstdio>
+#include <string>
 
+#include "rdc/rdc.h"
 #include "rvs/rvs.h"
 
 namespace amd {
 namespace rdc {
 
-void session_callback(rvs_session_id_t session_id, const rvs_results_t* results);
+class RdcRVSBase {
+ public:
+  RdcRVSBase() { s_instance = this; };
+  ~RdcRVSBase() {
+    if (s_instance == this) {
+      s_instance = nullptr;
+    }
+  };
 
-rvs_status_t run_rvs_app(const char* config, size_t config_size);
+  // only one instance allowed
+  RdcRVSBase(const RdcRVSBase&) = delete;
+  RdcRVSBase& operator=(const RdcRVSBase&) = delete;
+
+  // no moving allowed
+  RdcRVSBase(RdcRVSBase&&) = delete;
+  RdcRVSBase& operator=(RdcRVSBase&&) = delete;
+
+  rvs_status_t run_rvs_app(const char* config, size_t config_size, cookie_t* cookie);
+
+ private:
+  static RdcRVSBase* s_instance;
+  volatile rvs_session_state_t _state = RVS_SESSION_STATE_IDLE;
+  cookie_t* _cookie = nullptr;
+  rvs_session_callback _rvs_callback = nullptr;
+
+  // Static callback function that the C API will call
+  static void static_callback(rvs_session_id_t session_id, const rvs_results_t* results) {
+    // Forward the call to the current instance if it exists
+    if (s_instance) {
+      s_instance->session_callback(session_id, results);
+    }
+  }
+  void session_callback(rvs_session_id_t session_id, const rvs_results_t* results) {
+    _state = results->state;
+    // std::string output = "\n";
+    // output += "session id -> " + std::to_string(session_id) + "\n";
+    // output += "  state  -> " + std::to_string(results->state) + "\n";
+    // output += "  status -> " + std::to_string(results->status) + "\n";
+    // output += "  output -> " + std::string(results->output_log);
+    std::string output = std::string(results->output_log);
+    if (_cookie != nullptr && _cookie->callback != nullptr && _cookie->writer != nullptr) {
+      _cookie->callback(_cookie->writer, output.data());
+    }
+  }
+};
 }  // namespace rdc
 }  // namespace amd
 

rdc_libs/rdc_client/src/RdcStandaloneHandler.cc

@@ -578,8 +578,7 @@ rdc_status_t RdcStandaloneHandler::rdc_diagnostic_run(rdc_gpu_group_t group_id,
   // * response - delivered when the diagnostic run completes
   while (reader->Read(&reply)) {
     if (reply.has_log()) {
-      // TODO: Remove cout?
-      RDC_LOG(RDC_INFO, "LOG: " << reply.log());
+      // TODO: Add different logging levels
       std::cout << "LOG: " << reply.log() << std::endl;
       continue;
     }

rdc_libs/rdc_modules/rdc_rvs/RdcDiagnosticLib.cc

@@ -27,22 +27,12 @@ THE SOFTWARE.
 #include "rdc_lib/rdc_common.h"
 #include "rdc_modules/rdc_rvs/RvsBase.h"
 
-// TODO: Replace with client-side feedback channel
-#define RVS_LOG() RDC_LOG(RDC_DEBUG, "!HELLO_FROM_RVS! " << __FILE__ << ":" << __LINE__)
+rdc_status_t rdc_diag_init(uint64_t) { return RDC_ST_OK; }
 
-rdc_status_t rdc_diag_init(uint64_t) {
-  RVS_LOG();
-  return RDC_ST_OK;
-}
-
-rdc_status_t rdc_diag_destroy() {
-  RVS_LOG();
-  return RDC_ST_OK;
-}
+rdc_status_t rdc_diag_destroy() { return RDC_ST_OK; }
 
 rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
                                        uint32_t* test_case_count) {
-  RVS_LOG();
   if (test_case_count == nullptr) {
     return RDC_ST_BAD_PARAMETER;
   }
@@ -59,7 +49,6 @@ rdc_status_t rdc_diag_test_case_run(rdc_diag_test_cases_t test_case,
                                     const char* config, size_t config_size,
                                     rdc_diag_test_result_t* result, rdc_diag_callback_t* callback) {
   rvs_status_t rvs_status = RVS_STATUS_SUCCESS;
-  RVS_LOG();
   if (result == nullptr || gpu_count == 0) {
     return RDC_ST_BAD_PARAMETER;
   }
@@ -68,16 +57,22 @@ rdc_status_t rdc_diag_test_case_run(rdc_diag_test_cases_t test_case,
     return RDC_ST_BAD_PARAMETER;
   }
 
+  amd::rdc::RdcRVSBase rvs_base;
+
   // init the return data
   *result = {};
   result->test_case = test_case;
   result->status = RDC_DIAG_RESULT_PASS;
   result->per_gpu_result_count = 0;
 
+  if (cookie != nullptr && cookie->callback != nullptr && cookie->writer != nullptr) {
+    std::string str = "RVS test";
+    cookie->callback(cookie->writer, str.data());
+  }
   switch (test_case) {
     case RDC_DIAG_RVS_TEST:
-      strncpy_with_null(result->info, "Finished running RDC_DIAG_RVS_TEST!", MAX_DIAG_MSG_LENGTH);
-      rvs_status = amd::rdc::run_rvs_app(config, config_size);
+      strncpy_with_null(result->info, "Finished running RDC_DIAG_RVS_TEST", MAX_DIAG_MSG_LENGTH);
+      rvs_status = rvs_base.run_rvs_app(config, config_size, cookie);
       break;
     default:
       result->status = RDC_DIAG_RESULT_SKIP;

rdc_libs/rdc_modules/rdc_rvs/RvsBase.cc

@@ -25,19 +25,23 @@ THE SOFTWARE.
 
 #include "rdc_lib/RdcLogger.h"
 #include "rdc_lib/rdc_common.h"
+#include "rdc_modules/rdc_rvs/RvsBase.h"
 #include "rvs/rvs.h"
 
 // TODO: Make generic test
 // TODO: Allow for user to override defaults with a custom string
 static constexpr size_t MAX_CONFIG_LENGTH = 1024;
 
-volatile rvs_session_state_t state = RVS_SESSION_STATE_IDLE;
+amd::rdc::RdcRVSBase* amd::rdc::RdcRVSBase::s_instance = nullptr;
 
-rvs_status_t amd::rdc::run_rvs_app(const char* config, const size_t config_size) {
+rvs_status_t amd::rdc::RdcRVSBase::run_rvs_app(const char* config, const size_t config_size,
+                                               cookie_t* cookie) {
   char active_config[MAX_CONFIG_LENGTH];
   rvs_session_property_t session_property = {RVS_SESSION_TYPE_DEFAULT_CONF, {{RVS_MODULE_GST}}};
   rvs_session_id_t session_id;
   rvs_status_t status;
+  // NOTE: device_index is NOT set by RDC unless a custom config is provided.
+  // Meaning RDC index has no impact on RVS index.
   const char mem_config[MAX_CONFIG_LENGTH] =
       "{actions: [{name: action_1, device: all, module: mem, parallel: true, "
       "count: 1, wait: 100, mapped_memory: false, mem_blocks: 128, "
@@ -70,11 +74,12 @@ rvs_status_t amd::rdc::run_rvs_app(const char* config, const size_t config_size)
 
   /*******************************/
 
-  state = RVS_SESSION_STATE_IDLE;
+  _state = RVS_SESSION_STATE_IDLE;
 
   /* Using custom gst configuration in string format */
 
-  status = rvs_session_create(&session_id, amd::rdc::session_callback);
+  _cookie = cookie;
+  status = rvs_session_create(&session_id, &RdcRVSBase::static_callback);
 
   session_property.type = RVS_SESSION_TYPE_CUSTOM_ACTION;
   session_property.custom_action.config = active_config;
@@ -89,9 +94,11 @@ rvs_status_t amd::rdc::run_rvs_app(const char* config, const size_t config_size)
     return status;
   }
 
-  while (state != RVS_SESSION_STATE_COMPLETED) {
+  while (_state != RVS_SESSION_STATE_COMPLETED) {
   };
 
+  _cookie = nullptr;
+
   status = rvs_session_destroy(session_id);
   if (status != RVS_STATUS_SUCCESS) {
     RDC_LOG(RDC_ERROR, "RVS session destroy failed with status: " << status);
@@ -99,20 +106,3 @@ rvs_status_t amd::rdc::run_rvs_app(const char* config, const size_t config_size)
 
   return status;
 }
-
-void amd::rdc::session_callback(rvs_session_id_t session_id, const rvs_results_t* results) {
-  // NOTE: This is a placeholder!
-  // TODO: Use GRPC to send message back to client periodically
-  printf(
-      "/*******************************************************************/"
-      "\n");
-  printf("session id -> %d state -> %d\n", session_id, results->state);
-  printf("session id -> %d status -> %d\n", session_id, results->status);
-  printf("session id -> %d output -> %s\n", session_id, results->output_log);
-  printf(
-      "/*******************************************************************/"
-      "\n");
-
-  state = results->state;
-  printf("state -> %d\n", state);
-}