DPL: support strings and other metrics improvements

Each string metric has a limited history of 32 entries and values can
have up to 128 (including \0 termination).

This also introduces a new table view to display the last entries in the
string metrics and makes sure we do not die when visualizing strings.

We also add a benchmark for the metrics. Current results:

Run on (8 X 2500 MHz CPU s)
2018-11-09 21:11:01
--------------------------------------------------------------
Benchmark                       Time           CPU Iterations
--------------------------------------------------------------
BM_ParseIntMetric           22010 ns      21998 ns      31739
BM_ProcessIntMetric         22765 ns      22759 ns      28960
BM_ParseFloatMetric         23098 ns      23093 ns      30186
BM_ProcessFloatMetric       24515 ns      24511 ns      27653
BM_ProcessStringMetric      30352 ns      30348 ns      22827

Author: ktf

Framework/Core/CMakeLists.txt

@@ -257,7 +257,9 @@ set(TEST_SRCS
 set(BENCH_SRCS 
     test/benchmark_DataDescriptorMatcher.cxx
     test/benchmark_DataRelayer.cxx
-    test/benchmark_InputRecord.cxx)
+    test/benchmark_DeviceMetricsInfo.cxx
+    test/benchmark_InputRecord.cxx
+    )
 
 O2_GENERATE_TESTS(
   MODULE_LIBRARY_NAME ${LIBRARY_NAME}

Framework/Core/include/Framework/DeviceMetricsInfo.h

@@ -25,6 +25,7 @@ namespace framework
 
 enum class MetricType {
   Int,
+  String,
   Float,
   Unknown
 };
@@ -37,10 +38,19 @@ struct MetricInfo {
   size_t pos; // Last position in the circular buffer
 };
 
+// We keep only fixed lenght strings for metrics, as in the end this is not
+// really needed. They should be nevertheless 0 terminated.
+struct StringMetric {
+  char data[128];
+};
+
 /// This struct hold information about device metrics when running
 /// in standalone mode
 struct DeviceMetricsInfo {
+  // We keep the size of each metric to 4096 bytes. No need for more
+  // for the debug GUI
   std::vector<std::array<int, 1024>> intMetrics;
+  std::vector<std::array<StringMetric, 32>> stringMetrics; // We do not keep so many strings as metrics as history is less relevant.
   std::vector<std::array<float, 1024>> floatMetrics;
   std::vector<std::array<size_t, 1024>> timestamps;
   std::vector<float> max;

Framework/Core/src/DeviceMetricsInfo.cxx

@@ -28,7 +28,7 @@ namespace framework
 // [METRIC] <name>,<type> <value> <timestamp> [<tags>]
 bool DeviceMetricsHelper::parseMetric(const std::string& s, std::smatch& match)
 {
-  const static std::regex metricsRE(R"regex(\[METRIC\] ([a-zA-Z0-9/_-]+),(0|1|2|4) ([0-9.]+) ([0-9]+))regex", std::regex::optimize);
+  static std::regex metricsRE(R"regex(\[METRIC\] ([a-zA-Z0-9/_-]+),(0|1|2|4) ([0-9.a-zA-Z_/]+) ([0-9]+))regex", std::regex::optimize);
   return std::regex_search(s, match, metricsRE);
 }
 
@@ -43,27 +43,26 @@ bool DeviceMetricsHelper::processMetric(const std::smatch& match,
   if (ep == nullptr || *ep != '\0') {
     return false;
   }
-  auto stringValue = match[3];
+  auto valueMatch = match[3];
   size_t metricIndex = -1;
 
-  auto metricType = MetricType::Unknown;
-  if (type.str() == "0") {
-    metricType = MetricType::Int;
-  } else if (type.str() == "2") {
-    metricType = MetricType::Float;
-  }
+  auto metricType = static_cast<MetricType>(std::stoi(type.str(), 0, 10));
 
   int intValue = 0;
+  StringMetric stringValue;
   float floatValue = 0;
   switch (metricType) {
     case MetricType::Int:
-      intValue = strtol(stringValue.str().c_str(), &ep, 10);
+      intValue = strtol(valueMatch.str().c_str(), &ep, 10);
       if (!ep || *ep != '\0') {
         return false;
       }
       break;
+    case MetricType::String:
+      strncpy(stringValue.data, valueMatch.str().c_str(), sizeof(stringValue.data) - 1);
+      break;
     case MetricType::Float:
-      floatValue = strtof(stringValue.str().c_str(), &ep);
+      floatValue = strtof(valueMatch.str().c_str(), &ep);
       if (!ep || *ep != '\0') {
         return false;
       }
@@ -97,6 +96,10 @@ bool DeviceMetricsHelper::processMetric(const std::smatch& match,
         metricInfo.storeIdx = info.intMetrics.size();
         info.intMetrics.emplace_back(std::array<int, 1024>{});
         break;
+      case MetricType::String:
+        metricInfo.storeIdx = info.stringMetrics.size();
+        info.stringMetrics.emplace_back(std::array<StringMetric, 32>{});
+        break;
       case MetricType::Float:
         metricInfo.storeIdx = info.floatMetrics.size();
         info.floatMetrics.emplace_back(std::array<float, 1024>{});
@@ -132,39 +135,50 @@ bool DeviceMetricsHelper::processMetric(const std::smatch& match,
   // We are now guaranteed our metric is present at metricIndex.
   MetricInfo &metricInfo = info.metrics[metricIndex];
 
-  auto mod = info.timestamps[metricIndex].size();
+  //  auto mod = info.timestamps[metricIndex].size();
   info.minDomain[metricIndex] = std::min(info.minDomain[metricIndex], (size_t)timestamp);
   info.maxDomain[metricIndex] = std::max(info.maxDomain[metricIndex], (size_t)timestamp);
 
   switch(metricInfo.type) {
     case MetricType::Int: {
-      intValue = strtol(stringValue.str().c_str(), &ep, 10);
+      intValue = strtol(valueMatch.str().c_str(), &ep, 10);
       if (!ep || *ep != '\0') {
         return false;
       }
       info.intMetrics[metricInfo.storeIdx][metricInfo.pos] = intValue;
       info.max[metricIndex] = std::max(info.max[metricIndex], (float)intValue);
       info.min[metricIndex] = std::min(info.min[metricIndex], (float)intValue);
+      // Save the timestamp for the current metric we do it here
+      // so that we do not update timestamps for broken metrics
+      info.timestamps[metricIndex][metricInfo.pos] = timestamp;
+      // Update the position where to write the next metric
+      metricInfo.pos = (metricInfo.pos + 1) % info.intMetrics[metricInfo.storeIdx].size();
+    } break;
+    case MetricType::String: {
+      info.stringMetrics[metricInfo.storeIdx][metricInfo.pos] = stringValue;
+      // Save the timestamp for the current metric we do it here
+      // so that we do not update timestamps for broken metrics
+      info.timestamps[metricIndex][metricInfo.pos] = timestamp;
+      metricInfo.pos = (metricInfo.pos + 1) % info.stringMetrics[metricInfo.storeIdx].size();
     } break;
     case MetricType::Float: {
-      floatValue = strtof(stringValue.str().c_str(), &ep);
+      floatValue = strtof(valueMatch.str().c_str(), &ep);
       if (!ep || *ep != '\0') {
         return false;
       }
       info.floatMetrics[metricInfo.storeIdx][metricInfo.pos] = floatValue;
       info.max[metricIndex] = std::max(info.max[metricIndex], floatValue);
       info.min[metricIndex] = std::min(info.min[metricIndex], floatValue);
+      // Save the timestamp for the current metric we do it here
+      // so that we do not update timestamps for broken metrics
+      info.timestamps[metricIndex][metricInfo.pos] = timestamp;
+      metricInfo.pos = (metricInfo.pos + 1) % info.floatMetrics[metricInfo.storeIdx].size();
     } break;
     default:
       return false;
       break;
   };
 
-  // Save the timestamp for the current metric we do it here
-  // so that we do not update timestamps for broken metrics
-  info.timestamps[metricIndex][metricInfo.pos] = timestamp;
-  // Update the position where to write the next metric
-  metricInfo.pos = (metricInfo.pos + 1) % mod;
   return true;
 }
 
@@ -189,6 +203,9 @@ std::ostream& operator<<(std::ostream& oss, MetricType const& val)
     case MetricType::Float:
       oss << "float";
       break;
+    case MetricType::String:
+      oss << "string";
+      break;
     case MetricType::Int:
       oss << "float";
       break;