intel_rdt: Use pqos_mon_get_value api to obtain event values

diff --git a/src/intel_rdt.c b/src/intel_rdt.c
index e79bdbea76a9cd3677ae40aafa8d91b081223c0f..2842d53dfb5c9259e64efbb963a3143ab71c79df 100644 (file)
--- a/src/intel_rdt.c
+++ b/src/intel_rdt.c
@@ -144,87 +144,133 @@ static void rdt_submit_gauge(const char *cgroup, const char *type,
   plugin_dispatch_values(&vl);
 }
 
+static int rdt_get_value(const struct pqos_mon_data *group,
+                         const enum pqos_mon_event event_id, uint64_t *value) {
+  int ret;
+
+#if PQOS_VERSION >= 40400
+  ret = pqos_mon_get_value(group, PQOS_PERF_EVENT_LLC_REF, value, NULL);
+
+#else
+  const struct pqos_event_values *values = &group->values;
+#if PQOS_VERSION < 40000
+  const enum pqos_mon_event events = group->event;
+#endif
+
+  ret = PQOS_RETVAL_OK;
+
+  switch (event_id) {
+  case PQOS_MON_EVENT_L3_OCCUP:
+    *value = values->llc;
+    break;
+  case PQOS_PERF_EVENT_LLC_MISS:
+    *value = values->llc_misses;
+    break;
+  case PQOS_MON_EVENT_LMEM_BW:
+    *value = values->mbm_local;
+    break;
+  case PQOS_MON_EVENT_TMEM_BW:
+    *value = values->mbm_total;
+    break;
+  case PQOS_MON_EVENT_RMEM_BW:
+#if PQOS_VERSION < 40000
+    if (events & (PQOS_MON_EVENT_TMEM_BW | PQOS_MON_EVENT_LMEM_BW))
+      *value = values->mbm_total - values->mbm_local;
+#else
+    *value = values->mbm_remote;
+#endif
+  default:
+    ret = PQOS_RETVAL_ERROR;
+    break;
+  }
+#endif
+
+  if (ret != PQOS_RETVAL_OK)
+    return ret;
+
+  // Apply scale factor
+  if (event_id == PQOS_MON_EVENT_LMEM_BW ||
+      event_id == PQOS_MON_EVENT_TMEM_BW ||
+      event_id == PQOS_MON_EVENT_RMEM_BW) {
+    const struct pqos_monitor *mon = NULL;
+
+    ret = pqos_cap_get_event(g_rdt->pqos_cap, event_id, &mon);
+    if (ret == PQOS_RETVAL_OK && mon->scale_factor != 0)
+      *value = *value * mon->scale_factor;
+  }
+
+  return ret;
+}
+
 static void rdt_submit(const struct pqos_mon_data *group) {
+#if PQOS_VERSION < 40400
   const struct pqos_event_values *values = &group->values;
+#endif
   const char *desc = (const char *)group->context;
   const enum pqos_mon_event events = group->event;
 
-  if (events & PQOS_MON_EVENT_L3_OCCUP)
-    rdt_submit_gauge(desc, "bytes", "llc", values->llc);
+  if (events & PQOS_MON_EVENT_L3_OCCUP) {
+    uint64_t value;
+
+    int ret = rdt_get_value(group, PQOS_MON_EVENT_L3_OCCUP, &value);
+    if (ret == PQOS_RETVAL_OK)
+      rdt_submit_gauge(desc, "bytes", "llc", value);
+  }
+
+  if (events & PQOS_PERF_EVENT_IPC) {
+    double value;
+    int ret = PQOS_RETVAL_OK;
+
+#if PQOS_VERSION >= 40400
+    ret = pqos_mon_get_ipc(group, &value);
+#else
+    value = values->ipc;
+#endif
 
-  if (events & PQOS_PERF_EVENT_IPC)
-    rdt_submit_gauge(desc, "ipc", NULL, values->ipc);
+    if (ret == PQOS_RETVAL_OK)
+      rdt_submit_gauge(desc, "ipc", NULL, value);
+  }
 
 #if PQOS_VERSION >= 40400
   if (events & PQOS_PERF_EVENT_LLC_REF) {
     uint64_t value;
 
-    int ret = pqos_mon_get_value(group, PQOS_PERF_EVENT_LLC_REF, &value, NULL);
+    int ret = rdt_get_value(group, PQOS_PERF_EVENT_LLC_REF, &value);
     if (ret == PQOS_RETVAL_OK)
       rdt_submit_derive(desc, "bytes", "llc_ref", value);
   }
 #endif
 
   if (events & PQOS_PERF_EVENT_LLC_MISS) {
-#if PQOS_VERSION >= 40400
     uint64_t value;
 
-    int ret = pqos_mon_get_value(group, PQOS_PERF_EVENT_LLC_MISS, &value, NULL);
+    int ret = rdt_get_value(group, PQOS_PERF_EVENT_LLC_MISS, &value);
     if (ret == PQOS_RETVAL_OK)
       rdt_submit_derive(desc, "bytes", "llc_miss", value);
-#else
-    rdt_submit_derive(desc, "bytes", "llc_miss", values->llc_misses);
-#endif
   }
 
   if (events & PQOS_MON_EVENT_LMEM_BW) {
-    const struct pqos_monitor *mon = NULL;
-
-    int retval =
-        pqos_cap_get_event(g_rdt->pqos_cap, PQOS_MON_EVENT_LMEM_BW, &mon);
-    if (retval == PQOS_RETVAL_OK) {
-      uint64_t value = values->mbm_local;
-
-      if (mon->scale_factor != 0)
-        value = value * mon->scale_factor;
+    uint64_t value;
 
+    int ret = rdt_get_value(group, PQOS_MON_EVENT_LMEM_BW, &value);
+    if (ret == PQOS_RETVAL_OK)
       rdt_submit_derive(desc, "memory_bandwidth", "local", value);
-    }
   }
 
   if (events & PQOS_MON_EVENT_TMEM_BW) {
-    const struct pqos_monitor *mon = NULL;
-
-    int retval =
-        pqos_cap_get_event(g_rdt->pqos_cap, PQOS_MON_EVENT_TMEM_BW, &mon);
-    if (retval == PQOS_RETVAL_OK) {
-      uint64_t value = values->mbm_total;
-
-      if (mon->scale_factor != 0)
-        value = value * mon->scale_factor;
+    uint64_t value;
 
+    int ret = rdt_get_value(group, PQOS_MON_EVENT_TMEM_BW, &value);
+    if (ret == PQOS_RETVAL_OK)
       rdt_submit_derive(desc, "memory_bandwidth", "total", value);
-    }
   }
 
   if (events & PQOS_MON_EVENT_RMEM_BW) {
-    const struct pqos_monitor *mon = NULL;
-
-    int retval =
-        pqos_cap_get_event(g_rdt->pqos_cap, PQOS_MON_EVENT_RMEM_BW, &mon);
-    if (retval == PQOS_RETVAL_OK) {
-      uint64_t value = values->mbm_remote;
-
-#if PQOS_VERSION < 40000
-      if (events & (PQOS_MON_EVENT_TMEM_BW | PQOS_MON_EVENT_LMEM_BW))
-        value = values->mbm_total - values->mbm_local;
-#endif
-
-      if (mon->scale_factor != 0)
-        value = value * mon->scale_factor;
+    uint64_t value;
 
+    int ret = rdt_get_value(group, PQOS_MON_EVENT_RMEM_BW, &value);
+    if (ret == PQOS_RETVAL_OK)
       rdt_submit_derive(desc, "memory_bandwidth", "remote", value);
-    }
   }
 }