Apply map, dateutil, measurement

Author: Alan4506

tests/performance-tests/include/performance_tests/reporting/JsonReportingMetrics.h

@@ -10,27 +10,50 @@
 #include <aws/core/monitoring/CoreMetrics.h>
 #include <aws/core/monitoring/MonitoringFactory.h>
 #include <aws/core/monitoring/MonitoringInterface.h>
+#include <aws/core/utils/DateTime.h>
 #include <aws/core/utils/memory/AWSMemory.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
 #include <aws/core/utils/memory/stl/AWSSet.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
 #include <aws/core/utils/memory/stl/AWSVector.h>
 
 #include <cstdint>
 #include <memory>
-#include <utility>
 
 namespace PerformanceTest {
 namespace Reporting {
+/**
+ * A measurement value that supports different numeric types.
+ */
+class Measurement {
+ public:
+  enum Type { INTEGER, DOUBLE };
+
+  Measurement(int64_t value) : m_type(INTEGER) { m_data.i = value; }
+  Measurement(double value) : m_type(DOUBLE) { m_data.d = value; }
+  bool IsInt64() const { return m_type == INTEGER; }
+  bool IsDouble() const { return m_type == DOUBLE; }
+  int64_t AsInt64() const { return m_type == INTEGER ? m_data.i : static_cast<int64_t>(m_data.d); }
+  double AsDouble() const { return m_type == DOUBLE ? m_data.d : static_cast<double>(m_data.i); }
+
+ private:
+  Type m_type;
+  union {
+    int64_t i;
+    double d;
+  } m_data;
+};
+
 /**
  * Container for a single performance metric record that stores measurement data and associated metadata.
  */
 struct PerformanceMetricRecord {
   Aws::String name;
   Aws::String description;
   Aws::String unit;
-  int64_t date;
-  Aws::Vector<int64_t> measurements;
-  Aws::Vector<std::pair<Aws::String, Aws::String>> dimensions;
+  Aws::Utils::DateTime date;
+  Aws::Vector<Measurement> measurements;
+  Aws::Map<Aws::String, Aws::String> dimensions;
 };
 
 /**
@@ -101,7 +124,7 @@ class JsonReportingMetrics : public Aws::Monitoring::MonitoringInterface {
    * Sets test dimensions that will be included with all performance records.
    * @param dimensions Vector of key-value pairs representing test dimensions (e.g., size, bucket type)
    */
-  static void SetTestContext(const Aws::Vector<std::pair<Aws::String, Aws::String>>& dimensions);
+  static void SetTestContext(const Aws::Map<Aws::String, Aws::String>& dimensions);
 
   /**
    * Registers specific operations to monitor. If empty, all operations are monitored.
@@ -140,7 +163,7 @@ class JsonReportingMetrics : public Aws::Monitoring::MonitoringInterface {
   void DumpJson() const;
 
   mutable Aws::Vector<PerformanceMetricRecord> m_performanceRecords;
-  static Aws::Vector<std::pair<Aws::String, Aws::String>> TestDimensions;
+  static Aws::Map<Aws::String, Aws::String> TestDimensions;
   static Aws::Set<Aws::String> MonitoredOperations;
   static Aws::String ProductId;
   static Aws::String SdkVersion;

tests/performance-tests/src/reporting/JsonReportingMetrics.cpp

@@ -26,16 +26,14 @@
 
 using namespace PerformanceTest::Reporting;
 
-Aws::Vector<std::pair<Aws::String, Aws::String>> JsonReportingMetrics::TestDimensions;
+Aws::Map<Aws::String, Aws::String> JsonReportingMetrics::TestDimensions;
 Aws::Set<Aws::String> JsonReportingMetrics::MonitoredOperations;
 Aws::String JsonReportingMetrics::ProductId = "unknown";
 Aws::String JsonReportingMetrics::SdkVersion = "unknown";
 Aws::String JsonReportingMetrics::CommitId = "unknown";
 Aws::String JsonReportingMetrics::OutputFilename = "performance-test-results.json";
 
-void JsonReportingMetrics::SetTestContext(const Aws::Vector<std::pair<Aws::String, Aws::String>>& dimensions) {
-  TestDimensions = dimensions;
-}
+void JsonReportingMetrics::SetTestContext(const Aws::Map<Aws::String, Aws::String>& dimensions) { TestDimensions = dimensions; }
 
 void JsonReportingMetrics::RegisterOperationsToMonitor(const Aws::Vector<Aws::String>& operations) {
   MonitoredOperations.clear();
@@ -78,8 +76,8 @@ void JsonReportingMetrics::AddPerformanceRecord(const Aws::String& serviceName,
       Aws::Utils::StringUtils::ToLower(serviceName.c_str()) + "." + Aws::Utils::StringUtils::ToLower(requestName.c_str()) + ".latency";
   record.description = "Time to complete " + requestName + " operation";
   record.unit = "Milliseconds";
-  record.date = Aws::Utils::DateTime::Now().Seconds();
-  record.measurements.push_back(durationMs);
+  record.date = Aws::Utils::DateTime::Now();
+  record.measurements.emplace_back(durationMs);
   record.dimensions = TestDimensions;
 
   m_performanceRecords.push_back(record);
@@ -146,24 +144,29 @@ void JsonReportingMetrics::DumpJson() const {
     jsonMetric.WithString("name", record.name);
     jsonMetric.WithString("description", record.description);
     jsonMetric.WithString("unit", record.unit);
-    jsonMetric.WithInt64("date", record.date);
+    jsonMetric.WithInt64("date", record.date.Seconds());
 
     if (!record.dimensions.empty()) {
       Aws::Utils::Array<Aws::Utils::Json::JsonValue> dimensionsArray(record.dimensions.size());
-      for (size_t j = 0; j < record.dimensions.size(); ++j) {
+      size_t dimensionIndex = 0;
+      for (const auto& dim : record.dimensions) {
         Aws::Utils::Json::JsonValue dimension;
-        dimension.WithString("name", record.dimensions[j].first);
-        dimension.WithString("value", record.dimensions[j].second);
-        dimensionsArray[j] = std::move(dimension);
+        dimension.WithString("name", dim.first);
+        dimension.WithString("value", dim.second);
+        dimensionsArray[dimensionIndex++] = std::move(dimension);
       }
       jsonMetric.WithArray("dimensions", std::move(dimensionsArray));
     }
 
     Aws::Utils::Array<Aws::Utils::Json::JsonValue> measurementsArray(record.measurements.size());
-    for (size_t j = 0; j < record.measurements.size(); ++j) {
+    for (size_t measurementIndex = 0; measurementIndex < record.measurements.size(); ++measurementIndex) {
       Aws::Utils::Json::JsonValue measurementValue;
-      measurementValue.AsInt64(record.measurements[j]);
-      measurementsArray[j] = std::move(measurementValue);
+      if (record.measurements[measurementIndex].IsDouble()) {
+        measurementValue.AsDouble(record.measurements[measurementIndex].AsDouble());
+      } else {
+        measurementValue.AsInt64(record.measurements[measurementIndex].AsInt64());
+      }
+      measurementsArray[measurementIndex] = std::move(measurementValue);
     }
     jsonMetric.WithArray("measurements", std::move(measurementsArray));
 

tests/performance-tests/src/services/dynamodb/DynamoDBPerformanceTest.cpp

@@ -7,7 +7,6 @@
 #include <aws/core/utils/UUID.h>
 #include <aws/core/utils/memory/stl/AWSMap.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
-#include <aws/core/utils/memory/stl/AWSVector.h>
 #include <aws/dynamodb/DynamoDBClient.h>
 #include <aws/dynamodb/model/AttributeDefinition.h>
 #include <aws/dynamodb/model/AttributeValue.h>
@@ -28,11 +27,10 @@
 #include <iostream>
 #include <string>
 #include <thread>
-#include <utility>
 
 bool PerformanceTest::Services::DynamoDB::RunTest(Aws::DynamoDB::DynamoDBClient& dynamodb, const TestCase& config, int iterations) {
-  Aws::Vector<std::pair<Aws::String, Aws::String>> dimensions;
-  dimensions.emplace_back("Size", config.sizeLabel);
+  Aws::Map<Aws::String, Aws::String> dimensions;
+  dimensions["Size"] = config.sizeLabel;
   PerformanceTest::Reporting::JsonReportingMetrics::SetTestContext(dimensions);
 
   Aws::String tableName;

tests/performance-tests/src/services/s3/S3PerformanceTest.cpp

@@ -8,9 +8,9 @@
 #include <aws/core/utils/StringUtils.h>
 #include <aws/core/utils/UUID.h>
 #include <aws/core/utils/memory/stl/AWSAllocator.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
 #include <aws/core/utils/memory/stl/AWSStringStream.h>
-#include <aws/core/utils/memory/stl/AWSVector.h>
 #include <aws/s3/S3Client.h>
 #include <aws/s3/model/BucketInfo.h>
 #include <aws/s3/model/BucketType.h>
@@ -26,13 +26,12 @@
 
 #include <iostream>
 #include <string>
-#include <utility>
 
 bool PerformanceTest::Services::S3::RunTest(Aws::S3::S3Client& s3, const TestCase& config, const Aws::String& availabilityZoneId,
                                             int iterations) {
-  Aws::Vector<std::pair<Aws::String, Aws::String>> dimensions;
-  dimensions.emplace_back("Size", config.sizeLabel);
-  dimensions.emplace_back("BucketType", config.bucketTypeLabel);
+  Aws::Map<Aws::String, Aws::String> dimensions;
+  dimensions["Size"] = config.sizeLabel;
+  dimensions["BucketType"] = config.bucketTypeLabel;
   PerformanceTest::Reporting::JsonReportingMetrics::SetTestContext(dimensions);
 
   Aws::String bucketName;
@@ -87,7 +86,8 @@ bool PerformanceTest::Services::S3::RunTest(Aws::S3::S3Client& s3, const TestCas
   }
 
   for (int i = 0; i < iterations; i++) {
-    s3.DeleteObject(Aws::S3::Model::DeleteObjectRequest().WithBucket(bucketName).WithKey("test-object-" + Aws::Utils::StringUtils::to_string(i)));
+    s3.DeleteObject(
+        Aws::S3::Model::DeleteObjectRequest().WithBucket(bucketName).WithKey("test-object-" + Aws::Utils::StringUtils::to_string(i)));
   }
   s3.DeleteBucket(Aws::S3::Model::DeleteBucketRequest().WithBucket(bucketName));