From 025d8bcc7686ce83a5e3c171ba5289d54bdc292b Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Mon, 11 Sep 2023 10:43:05 +0530
Subject: [PATCH 1/7] metrics aggregation starting
---
.../VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs b/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs
index 8e374347b3..8a40201326 100644
--- a/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs
@@ -386,6 +386,8 @@ await this.fileSystem.File.ReplaceInFileAsync(
await this.fileSystem.File.ReplaceInFileAsync(
makeFilePath, @"MPlib *=", $"MPlib = /usr/lib/{architecture}-linux-gnu/openmpi/lib/libmpi.so", cancellationToken);
+ // /usr/lib/x86_64-linux-gnu/openmpi
+
await this.fileSystem.File.ReplaceInFileAsync(
makeFilePath, @"LAinc *=", $"LAinc = -I/usr/lib/{architecture}-linux-gnu", cancellationToken);
}
From cff5d59f2639df886cac3cfc53d68516415c7dd4 Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Thu, 26 Oct 2023 10:09:09 +0530
Subject: [PATCH 2/7] Adding aggregate metrics logic
---
.../Memtier/MemtierBenchmarkClientExecutor.cs | 117 +++++++++++++++++-
.../profiles/PERF-REDIS.json | 12 +-
2 files changed, 119 insertions(+), 10 deletions(-)
diff --git a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
index fc36496ea6..f46a148355 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
@@ -6,6 +6,7 @@ namespace VirtualClient.Actions
using System;
using System.Collections.Generic;
using System.Diagnostics;
+ using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
@@ -13,6 +14,7 @@ namespace VirtualClient.Actions
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
+ using Microsoft.Identity.Client;
using Polly;
using VirtualClient.Common;
using VirtualClient.Common.Contracts;
@@ -20,6 +22,7 @@ namespace VirtualClient.Actions
using VirtualClient.Common.Telemetry;
using VirtualClient.Contracts;
using VirtualClient.Contracts.Metadata;
+ using LogLevel = Microsoft.Extensions.Logging.LogLevel;
/// <summary>
/// Redis/Memcached Memtier Client Executor.
@@ -34,6 +37,8 @@ public class MemtierBenchmarkClientExecutor : MemcachedExecutor
new Regex(@"connection\s+refused", RegexOptions.IgnoreCase | RegexOptions.Compiled)
};
+ private List<Metric> aggregatedMetrics = new List<Metric>();
+
/// <summary>
/// Initializes a new instance of the <see cref="MemtierBenchmarkClientExecutor"/> class.
/// </summary>
@@ -57,7 +62,7 @@ public MemtierBenchmarkClientExecutor(IServiceCollection dependencies, IDictiona
/// <summary>
/// Parameter defines the number of Memtier benchmark instances to execute against
- /// each server instance. Default = # of logical cores/vCPUs on system.
+ /// each server instance. Default = 1.
/// </summary>
public int ClientInstances
{
@@ -104,6 +109,18 @@ public bool WarmUp
}
}
+ /// <summary>
+ /// Parameter defines true/false whether the client action should also emit metric per each server process separately.
+ /// Default value is false and collects only aggregate metrics across all the redis/memcached server processes running in the system.
+ /// </summary>
+ public bool PerProcessMetric
+ {
+ get
+ {
+ return this.Parameters.GetValue<bool>(nameof(this.PerProcessMetric), false);
+ }
+ }
+
/// <summary>
/// yes if TLS is enabled.
/// </summary>
@@ -304,8 +321,8 @@ protected override bool IsSupported()
return isSupported;
}
-
- private void CaptureMetrics(string results, string commandArguments, DateTime startTime, DateTime endTime, EventContext telemetryContext, CancellationToken cancellationToken)
+
+ private void AggregateAndCapturePerProcessMetrics(string results, string commandArguments, DateTime startTime, DateTime endTime, EventContext telemetryContext, CancellationToken cancellationToken)
{
if (!cancellationToken.IsCancellationRequested)
{
@@ -326,8 +343,11 @@ private void CaptureMetrics(string results, string commandArguments, DateTime st
{
MemtierMetricsParser resultsParser = new MemtierMetricsParser(results);
IList<Metric> workloadMetrics = resultsParser.Parse();
+ this.aggregatedMetrics.AddRange(workloadMetrics);
- this.Logger.LogMetrics(
+ if (this.PerProcessMetric)
+ {
+ this.Logger.LogMetrics(
$"Memtier-{this.Benchmark}",
this.Scenario,
startTime,
@@ -337,6 +357,8 @@ private void CaptureMetrics(string results, string commandArguments, DateTime st
commandArguments,
this.Tags,
telemetryContext);
+ }
+
}
}
catch (SchemaException exc)
@@ -346,6 +368,85 @@ private void CaptureMetrics(string results, string commandArguments, DateTime st
}
}
+ private void CaptureAggregateMetrics(string commandArguments, DateTime startTime, DateTime endTime, EventContext telemetryContext, CancellationToken cancellationToken)
+ {
+ if (!cancellationToken.IsCancellationRequested)
+ {
+ try
+ {
+ this.MetadataContract.AddForScenario(
+ "Memtier",
+ commandArguments,
+ toolVersion: null);
+
+ this.MetadataContract.Apply(telemetryContext);
+
+ Dictionary<string, List<double>> metricNameValueListDict = new Dictionary<string, List<double>>();
+ Dictionary<string, List<Metric>> metricNameMetricsListDict = new Dictionary<string, List<Metric>>();
+
+ foreach (var metric in this.aggregatedMetrics)
+ {
+ if (metricNameMetricsListDict.ContainsKey(metric.Name))
+ {
+ metricNameValueListDict[metric.Name].Add(metric.Value);
+ }
+ else
+ {
+ metricNameValueListDict.Add(metric.Name, new List<double>() { metric.Value });
+ }
+
+ if (metricNameMetricsListDict.ContainsKey(metric.Name))
+ {
+ metricNameMetricsListDict[metric.Name].Add(metric);
+ }
+ else
+ {
+ metricNameMetricsListDict.Add(metric.Name, new List<Metric>() { metric });
+ }
+ }
+
+ List<Metric> newAggregateListOfMetrics = new List<Metric>();
+
+ foreach (var metricKeyValuePair in metricNameValueListDict)
+ {
+ double avgValue = metricKeyValuePair.Value.Average();
+ double minValue = metricKeyValuePair.Value.Min();
+ double maxValue = metricKeyValuePair.Value.Max();
+ double stdevValue = Math.Sqrt(metricKeyValuePair.Value.Select(x => Math.Pow(x - avgValue, 2)).Average());
+ List<double> sortedValues = metricKeyValuePair.Value.OrderBy(x => x).ToList();
+ double p80Value = sortedValues[(int)Math.Ceiling(sortedValues.Count * 0.8) - 1];
+
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Avg", avgValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Min", minValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Max", maxValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Stdev", stdevValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_P80", p80Value, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ if (metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit != MetricUnit.Milliseconds)
+ {
+ // For throughput and bandwidth related metrics only.
+ double sumValue = metricKeyValuePair.Value.Sum();
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Sum", sumValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ }
+ }
+
+ this.Logger.LogMetrics(
+ $"Memtier-{this.Benchmark}",
+ this.Scenario,
+ startTime,
+ endTime,
+ newAggregateListOfMetrics,
+ null,
+ commandArguments,
+ this.Tags,
+ telemetryContext);
+ }
+ catch (SchemaException exc)
+ {
+ throw new WorkloadResultsException($"Failed to aggregate workload results.", exc, ErrorReason.WorkloadResultsParsingFailed);
+ }
+ }
+ }
+
private Task ExecuteWorkloadsAsync(IPAddress serverIPAddress, ServerState serverState, EventContext telemetryContext, CancellationToken cancellationToken)
{
EventContext relatedContext = telemetryContext.Clone()
@@ -366,6 +467,9 @@ private Task ExecuteWorkloadsAsync(IPAddress serverIPAddress, ServerState server
relatedContext.AddContext("workingDirectory", workingDirectory);
List<Task> workloadProcesses = new List<Task>();
+
+ DateTime startTime = DateTime.UtcNow;
+
foreach (int serverPort in serverState.Ports)
{
for (int i = 0; i < this.ClientInstances; i++)
@@ -394,6 +498,9 @@ private Task ExecuteWorkloadsAsync(IPAddress serverIPAddress, ServerState server
}
await Task.WhenAll(workloadProcesses);
+ DateTime endTime = DateTime.UtcNow;
+
+ this.CaptureAggregateMetrics(commandArguments, startTime, endTime, telemetryContext, cancellationToken);
}
});
}
@@ -432,7 +539,7 @@ private async Task ExecuteWorkloadAsync(int serverPort, string command, string c
{
string output = process.StandardOutput.ToString();
string parsedCommandArguments = this.ParseCommand(process.FullCommand());
- this.CaptureMetrics(output, parsedCommandArguments, startTime, DateTime.UtcNow, telemetryContext, cancellationToken);
+ this.AggregateAndCapturePerProcessMetrics(output, parsedCommandArguments, startTime, DateTime.UtcNow, telemetryContext, cancellationToken);
}
}
}
diff --git a/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json b/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json
index 3d2b5df887..66211b6e1f 100644
--- a/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json
+++ b/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json
@@ -11,8 +11,9 @@
"ServerThreadCount": 4,
"ServerInstances": "{LogicalCoreCount}",
"ClientInstances": 1,
- "IsTLSEnabled": "no",
- "Duration": "00:02:00"
+ "IsTLSEnabled": "no",
+ "Duration": "00:02:00",
+ "PerProcessMetric": false
},
"Actions": [
{
@@ -36,10 +37,11 @@
"Scenario": "warmup_32b_pool",
"PackageName": "memtier",
"CommandLine": "--protocol redis --threads 1 --clients 1 --ratio 1:0 --data-size 32 --pipeline 32 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern S:S --run-count 1 --requests=allkeys",
- "ClientInstances": 1,
+ "ClientInstances": "$.Parameters.ClientInstances",
"WarmUp": true,
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -49,7 +51,7 @@
"Scenario": "warmup_1kb_pool",
"PackageName": "memtier",
"CommandLine": "--protocol redis --threads 1 --clients 1 --ratio 1:0 --data-size 1024 --pipeline 32 --key-minimum 1 --key-maximum 500000 --key-prefix med --key-pattern S:S --run-count 1 --requests=allkeys",
- "ClientInstances": 1,
+ "ClientInstances": "$.Parameters.ClientInstances",
"WarmUp": true,
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
@@ -62,7 +64,7 @@
"Scenario": "warmup_10kb_pool",
"PackageName": "memtier",
"CommandLine": "--protocol redis --threads 1 --clients 1 --ratio 1:0 --data-size 10240 --pipeline 32 --key-minimum 1 --key-maximum 50000 --key-prefix lg --key-pattern S:S --run-count 1 --requests=allkeys",
- "ClientInstances": 1,
+ "ClientInstances": "$.Parameters.ClientInstances",
"WarmUp": true,
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
From 02c3803c5cbb64d1ee8c9bc1a1b03260ecb28503 Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Thu, 2 Nov 2023 10:23:57 +0530
Subject: [PATCH 3/7] Updating aggregation logic and adding vpuid for each
process in metricsmetadata as part of commandline
---
.../Memtier/MemtierMetricsParserTests.cs | 396 +++++++++++++++---
.../Redis/RedisExecutorTests.cs | 20 +
.../HPLinpack/HPLinpackExecutor.cs | 2 -
.../Memcached/MemcachedExecutor.cs | 19 +-
.../Memtier/MemtierBenchmarkClientExecutor.cs | 153 ++-----
.../Memtier/MemtierMetricsParser.cs | 136 ++++--
.../Redis/RedisExecutor.cs | 18 +-
.../profiles/PERF-MEMCACHED.json | 219 +++++-----
.../profiles/PERF-REDIS.json | 11 +
9 files changed, 648 insertions(+), 326 deletions(-)
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs b/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
index a405165d86..f94494a18b 100644
--- a/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
@@ -7,6 +7,7 @@ namespace VirtualClient.Actions
using System.IO;
using System.Linq;
using System.Reflection;
+ using System.Runtime.Intrinsics.X86;
using NUnit.Framework;
using VirtualClient.Contracts;
@@ -15,16 +16,148 @@ namespace VirtualClient.Actions
public class MemtierMetricsParserTests
{
[Test]
- public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrectly_1()
+ public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrectlyWithoutPerProcessMetric_1()
{
+ List<string> resultsList = new List<string>();
string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\MemcachedResults_1.txt"));
- var parser = new MemtierMetricsParser(results);
+ resultsList.Add(results);
+ var parser = new MemtierMetricsParser(false, resultsList);
IList<Metric> metrics = parser.Parse();
- Assert.AreEqual(26, metrics.Count);
+ Assert.AreEqual(138, metrics.Count);
+ MetricAssert.Exists(metrics, "Throughput_Avg", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Min", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Max", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Stdev", 0, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_P80", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Sum", 48271.29, MetricUnit.RequestsPerSec);
+
+ MetricAssert.Exists(metrics, "Hits/sec_Avg", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Min", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Max", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Stdev", 0);
+ MetricAssert.Exists(metrics, "Hits/sec_P80", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Sum", 43444.12);
+
+ MetricAssert.Exists(metrics, "Misses/sec_Avg", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Min", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Max", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Stdev", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_P80", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Sum", 0);
+
+ MetricAssert.Exists(metrics, "Latency-Avg_Avg", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Min", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Max", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_P80", 2.62213, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P50_Avg", 2.75100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Min", 2.75100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Max", 2.75100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_P80", 2.75100, MetricUnit.Milliseconds);
+
+
+ MetricAssert.Exists(metrics, "Latency-P90_Avg", 3.90300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Min", 3.90300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Max", 3.90300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_P80", 3.90300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P95_Avg", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Min", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Max", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_P80", 4.41500, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P99_Avg", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Min", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Max", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_P80", 7.42300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Min", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Max", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_P80", 29.31100, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Throughput_Avg", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Min", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Max", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Stdev", 0, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_P80", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Sum", 43444.12, MetricUnit.RequestsPerSec);
+
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Min", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Max", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Stdev", 0, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_P80", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Sum", 3724.01, MetricUnit.KilobytesPerSecond);
+
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Min", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Max", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_P80", 2.61979, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 2.73500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Min", 2.73500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Max", 2.73500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_P80", 2.73500, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 3.88700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Min", 3.88700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Max", 3.88700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_P80", 3.88700, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Min", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Max", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_P80", 4.41500, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Min", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Max", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_P80", 7.42300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Min", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Max", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_P80", 29.31100, MetricUnit.Milliseconds);
+
+
+ MetricAssert.Exists(metrics, "SET_Throughput_Avg", 4827.17, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 329.45, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 2.64323, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 2.83100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 3.93500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 4.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 7.45500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 29.56700, MetricUnit.Milliseconds);
+ }
+
+ [Test]
+ public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrectlyWithPerProcessMetric_1()
+ {
+ List<string> resultsList = new List<string>();
+ string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\MemcachedResults_1.txt"));
+ resultsList.Add(results);
+ var parser = new MemtierMetricsParser(true, resultsList);
+
+ IList<Metric> metrics = parser.Parse();
+
+ Assert.AreEqual(164, metrics.Count);
+
MetricAssert.Exists(metrics, "Throughput", 48271.29, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Bandwidth", 4053.46, MetricUnit.KilobytesPerSecond);
MetricAssert.Exists(metrics, "Hits/sec", 43444.12);
MetricAssert.Exists(metrics, "Misses/sec", 0);
MetricAssert.Exists(metrics, "Latency-Avg", 2.62213, MetricUnit.Milliseconds);
@@ -51,108 +184,233 @@ public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrec
MetricAssert.Exists(metrics, "SET_Latency-P95", 4.47900, MetricUnit.Milliseconds);
MetricAssert.Exists(metrics, "SET_Latency-P99", 7.45500, MetricUnit.Milliseconds);
MetricAssert.Exists(metrics, "SET_Latency-P99.9", 29.56700, MetricUnit.Milliseconds);
- }
+ MetricAssert.Exists(metrics, "Throughput_Avg", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Min", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Max", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Stdev", 0, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_P80", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Sum", 48271.29, MetricUnit.RequestsPerSec);
+
+ MetricAssert.Exists(metrics, "Hits/sec_Avg", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Min", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Max", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Stdev", 0);
+ MetricAssert.Exists(metrics, "Hits/sec_P80", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Sum", 43444.12);
+
+ MetricAssert.Exists(metrics, "Misses/sec_Avg", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Min", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Max", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Stdev", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_P80", 0);
+ MetricAssert.Exists(metrics, "Misses/sec_Sum", 0);
+
+ MetricAssert.Exists(metrics, "Latency-Avg_Avg", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Min", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Max", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_P80", 2.62213, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P50_Avg", 2.75100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Min", 2.75100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Max", 2.75100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_P80", 2.75100, MetricUnit.Milliseconds);
+
+
+ MetricAssert.Exists(metrics, "Latency-P90_Avg", 3.90300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Min", 3.90300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Max", 3.90300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_P80", 3.90300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P95_Avg", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Min", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Max", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_P80", 4.41500, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P99_Avg", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Min", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Max", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_P80", 7.42300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Min", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Max", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_P80", 29.31100, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Throughput_Avg", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Min", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Max", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Stdev", 0, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_P80", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Sum", 43444.12, MetricUnit.RequestsPerSec);
+
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Min", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Max", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Stdev", 0, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_P80", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Sum", 3724.01, MetricUnit.KilobytesPerSecond);
+
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Min", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Max", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_P80", 2.61979, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 2.73500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Min", 2.73500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Max", 2.73500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_P80", 2.73500, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 3.88700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Min", 3.88700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Max", 3.88700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_P80", 3.88700, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Min", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Max", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_P80", 4.41500, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Min", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Max", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_P80", 7.42300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Min", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Max", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Stdev", 0, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_P80", 29.31100, MetricUnit.Milliseconds);
+
+
+ MetricAssert.Exists(metrics, "SET_Throughput_Avg", 4827.17, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 329.45, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 2.64323, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 2.83100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 3.93500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 4.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 7.45500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 29.56700, MetricUnit.Milliseconds);
+ }
[Test]
public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrectly_2()
{
+ List<string> resultsList = new List<string>();
string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\MemcachedResults_2.txt"));
- var parser = new MemtierMetricsParser(results);
+ resultsList.Add(results);
+ var parser = new MemtierMetricsParser(false, resultsList);
IList<Metric> metrics = parser.Parse();
- Assert.AreEqual(26, metrics.Count);
- MetricAssert.Exists(metrics, "Throughput", 48041.840000000004, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Bandwidth", 4034.1975, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "Hits/sec", 43237.6225);
- MetricAssert.Exists(metrics, "Misses/sec", 0);
- MetricAssert.Exists(metrics, "Latency-Avg", 2.636375, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P50", 2.763, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P90", 3.931, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P95", 4.439, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99", 7.423, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9", 29.278999999999996, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Throughput", 43237.6225, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "GET_Bandwidth", 3706.31, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "GET_Latency-Avg", 2.6338675, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P50", 2.759, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P90", 3.919, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P95", 4.439, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99", 7.4149999999999991, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99.9", 29.214999999999996, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "SET_Throughput", 4804.2175000000007, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "SET_Bandwidth", 327.885, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "SET_Latency-Avg", 2.6589324999999997, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P50", 2.831, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P90", 3.959, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P95", 4.495, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P99", 7.551, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P99.9", 29.598999999999997, MetricUnit.Milliseconds);
+ Assert.AreEqual(138, metrics.Count);
+ MetricAssert.Exists(metrics, "Throughput_Avg", 48041.840000000004, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Bandwidth_Avg", 4034.1975, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "Hits/sec_Avg", 43237.6225);
+ MetricAssert.Exists(metrics, "Misses/sec_Avg", 0);
+ MetricAssert.Exists(metrics, "Latency-Avg_Avg", 2.636375, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Avg", 2.763, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Avg", 3.931, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Avg", 4.439, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Avg", 7.423, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 29.278999999999996, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Throughput_Avg", 43237.6225, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 3706.31, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 2.6338675, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 2.759, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 3.919, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 4.439, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 7.4149999999999991, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 29.214999999999996, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "SET_Throughput_Avg", 4804.2175000000007, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 327.885, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 2.6589324999999997, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 2.831, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 3.959, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 4.495, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 7.551, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 29.598999999999997, MetricUnit.Milliseconds);
}
[Test]
public void MemtierMetricsParserParsesTheExpectedMetricsFromRedisResultsCorrectly_1()
{
+ List<string> resultsList = new List<string>();
string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\RedisResults_1.txt"));
- var parser = new MemtierMetricsParser(results);
+ resultsList.Add(results);
+ var parser = new MemtierMetricsParser(false, resultsList);
IList<Metric> metrics = parser.Parse();
- Assert.AreEqual(26, metrics.Count);
- MetricAssert.Exists(metrics, "Throughput", 355987.03, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Bandwidth", 25860.83, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "Hits/sec", 320388.28);
- MetricAssert.Exists(metrics, "Misses/sec", 0);
- MetricAssert.Exists(metrics, "Latency-Avg", 0.34301, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P50", 0.33500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P90", 0.47900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P95", 0.55900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99", 0.83900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9", 1.54300, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Throughput", 320388.28, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "GET_Bandwidth", 23118.30, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "GET_Latency-Avg", 0.34300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P50", 0.33500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P90", 0.47900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P95", 0.55900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99", 0.83900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99.9", 1.54300, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "SET_Throughput", 35598.74, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "SET_Bandwidth", 2742.53, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "SET_Latency-Avg", 0.34304, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P50", 0.33500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P90", 0.47900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P95", 0.55900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P99", 0.83900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P99.9", 1.54300, MetricUnit.Milliseconds);
+ Assert.AreEqual(138, metrics.Count);
+ MetricAssert.Exists(metrics, "Throughput_Avg", 355987.03, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Bandwidth_Avg", 25860.83, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "Hits/sec_Avg", 320388.28);
+ MetricAssert.Exists(metrics, "Misses/sec_Avg", 0);
+ MetricAssert.Exists(metrics, "Latency-Avg_Avg", 0.34301, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Avg", 0.33500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Avg", 0.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Avg", 0.55900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Avg", 0.83900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Throughput_Avg", 320388.28, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 23118.30, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 0.34300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 0.33500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 0.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 0.55900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 0.83900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "SET_Throughput_Avg", 35598.74, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 2742.53, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 0.34304, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 0.33500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 0.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 0.55900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 0.83900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
}
[Test]
public void MemtierMetricsParserAssociatesTheCorrectRelativityToTheMetrics()
{
+ List<string> resultsList = new List<string>();
string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\RedisResults_1.txt"));
- var parser = new MemtierMetricsParser(results);
+ resultsList.Add(results);
+ var parser = new MemtierMetricsParser(false, resultsList);
IList<Metric> metrics = parser.Parse();
- if (metrics.Count != 26)
+ if (metrics.Count != 138)
{
Assert.Inconclusive();
}
- Assert.IsTrue(metrics.Where(m => m.Name.EndsWith("Throughput") || m.Name.EndsWith("Bandwidth")).All(m => m.Relativity == MetricRelativity.HigherIsBetter));
+ Assert.IsTrue(metrics.Where(m => m.Name.Contains("Throughput") || m.Name.Contains("Bandwidth")).All(m => m.Relativity == MetricRelativity.HigherIsBetter));
Assert.IsTrue(metrics.Where(m => m.Name.Contains("Latency")).All(m => m.Relativity == MetricRelativity.LowerIsBetter));
}
[Test]
public void MemtierMetricsParserThrowIfInvalidResultsAreProvided()
{
+ List<string> resultsList = new List<string>();
string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\MemcachedInvalidResults_1.txt"));
- var parser = new MemtierMetricsParser(results);
+ resultsList.Add(results);
+ var parser = new MemtierMetricsParser(false, resultsList);
WorkloadResultsException exception = Assert.Throws<WorkloadResultsException>(() => parser.Parse());
Assert.AreEqual(ErrorReason.InvalidResults, exception.Reason);
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs b/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
index 0d46056cc0..7e6c913217 100644
--- a/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
@@ -5,6 +5,7 @@ namespace VirtualClient.Actions
{
using System;
using System.Collections.Generic;
+ using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
@@ -66,12 +67,31 @@ public void RedisExecutorThrowsOnUnsupportedDistroAsync()
}
}
+ [Test]
+ [TestCase(PlatformID.Unix, Architecture.X64)]
+ public void RedisExecutorDoesnotThrowOnSupportedPLatform(PlatformID platform, Architecture architecture)
+ {
+ this.SetupDefaultMockBehavior(platform, architecture);
+ using (TestRedisExecutorExecutor executor = new TestRedisExecutorExecutor(this.fixture.Dependencies, this.fixture.Parameters))
+ {
+ Exception exception = Assert.ThrowsAsync<Exception>(
+ () => executor.ExecuteAsync(CancellationToken.None));
+ }
+ }
+
private void SetupDefaultMockBehavior(PlatformID platformID)
{
this.fixture.Setup(platformID);
this.fixture.File.Setup(f => f.Exists(It.IsAny<string>())).Returns(true);
this.fixture.ProcessManager.OnCreateProcess = (cmd, args, wd) => this.fixture.Process;
}
+ private void SetupDefaultMockBehavior(PlatformID platformID, Architecture architecture)
+ {
+ this.fixture.Setup(platformID, architecture);
+ this.fixture.File.Setup(f => f.Exists(It.IsAny<string>())).Returns(true);
+ this.fixture.ProcessManager.OnCreateProcess = (cmd, args, wd) => this.fixture.Process;
+ }
+
private class TestRedisExecutorExecutor : RedisExecutor
{
diff --git a/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs b/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs
index 8a40201326..8e374347b3 100644
--- a/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/HPLinpack/HPLinpackExecutor.cs
@@ -386,8 +386,6 @@ await this.fileSystem.File.ReplaceInFileAsync(
await this.fileSystem.File.ReplaceInFileAsync(
makeFilePath, @"MPlib *=", $"MPlib = /usr/lib/{architecture}-linux-gnu/openmpi/lib/libmpi.so", cancellationToken);
- // /usr/lib/x86_64-linux-gnu/openmpi
-
await this.fileSystem.File.ReplaceInFileAsync(
makeFilePath, @"LAinc *=", $"LAinc = -I/usr/lib/{architecture}-linux-gnu", cancellationToken);
}
diff --git a/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedExecutor.cs
index 07b8bfc3ac..657e8c0de4 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedExecutor.cs
@@ -213,16 +213,23 @@ protected void InitializeApiClients()
/// </summary>
protected override bool IsSupported()
{
- bool isSupported = base.IsSupported()
- && (this.Platform == PlatformID.Unix)
+ if (base.IsSupported())
+ {
+ bool isSupported = (this.Platform == PlatformID.Unix)
&& (this.CpuArchitecture == Architecture.X64 || this.CpuArchitecture == Architecture.Arm64);
- if (!isSupported)
+ if (!isSupported)
+ {
+ this.Logger.LogNotSupported("Memcached", this.Platform, this.CpuArchitecture, EventContext.Persisted());
+ }
+
+ return isSupported;
+ }
+ else
{
- this.Logger.LogNotSupported("Memcached", this.Platform, this.CpuArchitecture, EventContext.Persisted());
+ return false;
}
-
- return isSupported;
+
}
private async Task ValidatePlatformSupportAsync(CancellationToken cancellationToken)
diff --git a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
index f46a148355..85734806a3 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
@@ -12,9 +12,8 @@ namespace VirtualClient.Actions
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
+ using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
- using Microsoft.Extensions.Logging;
- using Microsoft.Identity.Client;
using Polly;
using VirtualClient.Common;
using VirtualClient.Common.Contracts;
@@ -38,6 +37,9 @@ public class MemtierBenchmarkClientExecutor : MemcachedExecutor
};
private List<Metric> aggregatedMetrics = new List<Metric>();
+ private List<string> perProcessOutputList = new List<string>();
+ private List<string> perProcessCommandList = new List<string>();
+ private int startingServerPort;
/// <summary>
/// Initializes a new instance of the <see cref="MemtierBenchmarkClientExecutor"/> class.
@@ -310,137 +312,60 @@ protected override void Validate()
/// </summary>
protected override bool IsSupported()
{
- bool isSupported = base.IsSupported()
- && (this.Platform == PlatformID.Unix)
+ if (base.IsSupported())
+ {
+ bool isSupported = (this.Platform == PlatformID.Unix)
&& (this.CpuArchitecture == Architecture.X64 || this.CpuArchitecture == Architecture.Arm64);
- if (!isSupported)
+ if (!isSupported)
+ {
+ this.Logger.LogNotSupported("MemtierBenchmark", this.Platform, this.CpuArchitecture, EventContext.Persisted());
+ }
+
+ return isSupported;
+ }
+ else
{
- this.Logger.LogNotSupported("MemtierBenchmark", this.Platform, this.CpuArchitecture, EventContext.Persisted());
+ return false;
}
-
- return isSupported;
+
}
-
- private void AggregateAndCapturePerProcessMetrics(string results, string commandArguments, DateTime startTime, DateTime endTime, EventContext telemetryContext, CancellationToken cancellationToken)
+
+ private void CaptureMetrics(DateTime startTime, DateTime endTime, EventContext telemetryContext, CancellationToken cancellationToken)
{
if (!cancellationToken.IsCancellationRequested)
{
- results.ThrowIfNullOrWhiteSpace(nameof(results));
-
try
{
this.MetadataContract.AddForScenario(
"Memtier",
- commandArguments,
+ null,
toolVersion: null);
this.MetadataContract.Apply(telemetryContext);
- // The Memtier workloads run multi-threaded. The lock is meant to ensure we do not have
- // race conditions that affect the parsing of the results.
- lock (this.lockObject)
- {
- MemtierMetricsParser resultsParser = new MemtierMetricsParser(results);
- IList<Metric> workloadMetrics = resultsParser.Parse();
- this.aggregatedMetrics.AddRange(workloadMetrics);
+ MemtierMetricsParser memtierMetricsAggregateParser = new MemtierMetricsParser(this.PerProcessMetric, this.perProcessOutputList, this.perProcessCommandList);
+ IList<Metric> metrics = memtierMetricsAggregateParser.Parse();
+ string commandline = "commandline";
- if (this.PerProcessMetric)
- {
- this.Logger.LogMetrics(
+ foreach (Metric metric in metrics)
+ {
+ this.Logger.LogMetrics(
$"Memtier-{this.Benchmark}",
this.Scenario,
startTime,
endTime,
- workloadMetrics,
+ metric.Name,
+ metric.Value,
+ metric.Unit,
null,
- commandArguments,
+ (string)metric.Metadata[commandline],
this.Tags,
- telemetryContext);
- }
-
+ telemetryContext,
+ metric.Relativity);
}
}
catch (SchemaException exc)
- {
- throw new WorkloadResultsException($"Failed to parse workload results file.", exc, ErrorReason.WorkloadResultsParsingFailed);
- }
- }
- }
-
- private void CaptureAggregateMetrics(string commandArguments, DateTime startTime, DateTime endTime, EventContext telemetryContext, CancellationToken cancellationToken)
- {
- if (!cancellationToken.IsCancellationRequested)
- {
- try
- {
- this.MetadataContract.AddForScenario(
- "Memtier",
- commandArguments,
- toolVersion: null);
-
- this.MetadataContract.Apply(telemetryContext);
-
- Dictionary<string, List<double>> metricNameValueListDict = new Dictionary<string, List<double>>();
- Dictionary<string, List<Metric>> metricNameMetricsListDict = new Dictionary<string, List<Metric>>();
-
- foreach (var metric in this.aggregatedMetrics)
- {
- if (metricNameMetricsListDict.ContainsKey(metric.Name))
- {
- metricNameValueListDict[metric.Name].Add(metric.Value);
- }
- else
- {
- metricNameValueListDict.Add(metric.Name, new List<double>() { metric.Value });
- }
-
- if (metricNameMetricsListDict.ContainsKey(metric.Name))
- {
- metricNameMetricsListDict[metric.Name].Add(metric);
- }
- else
- {
- metricNameMetricsListDict.Add(metric.Name, new List<Metric>() { metric });
- }
- }
-
- List<Metric> newAggregateListOfMetrics = new List<Metric>();
-
- foreach (var metricKeyValuePair in metricNameValueListDict)
- {
- double avgValue = metricKeyValuePair.Value.Average();
- double minValue = metricKeyValuePair.Value.Min();
- double maxValue = metricKeyValuePair.Value.Max();
- double stdevValue = Math.Sqrt(metricKeyValuePair.Value.Select(x => Math.Pow(x - avgValue, 2)).Average());
- List<double> sortedValues = metricKeyValuePair.Value.OrderBy(x => x).ToList();
- double p80Value = sortedValues[(int)Math.Ceiling(sortedValues.Count * 0.8) - 1];
-
- newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Avg", avgValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
- newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Min", minValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
- newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Max", maxValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
- newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Stdev", stdevValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
- newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_P80", p80Value, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
- if (metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit != MetricUnit.Milliseconds)
- {
- // For throughput and bandwidth related metrics only.
- double sumValue = metricKeyValuePair.Value.Sum();
- newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Sum", sumValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
- }
- }
-
- this.Logger.LogMetrics(
- $"Memtier-{this.Benchmark}",
- this.Scenario,
- startTime,
- endTime,
- newAggregateListOfMetrics,
- null,
- commandArguments,
- this.Tags,
- telemetryContext);
- }
- catch (SchemaException exc)
{
throw new WorkloadResultsException($"Failed to aggregate workload results.", exc, ErrorReason.WorkloadResultsParsingFailed);
}
@@ -470,8 +395,9 @@ private Task ExecuteWorkloadsAsync(IPAddress serverIPAddress, ServerState server
DateTime startTime = DateTime.UtcNow;
+ this.startingServerPort = serverState.Ports.First();
foreach (int serverPort in serverState.Ports)
- {
+ {
for (int i = 0; i < this.ClientInstances; i++)
{
// memtier_benchmark Documentation:
@@ -500,7 +426,7 @@ private Task ExecuteWorkloadsAsync(IPAddress serverIPAddress, ServerState server
await Task.WhenAll(workloadProcesses);
DateTime endTime = DateTime.UtcNow;
- this.CaptureAggregateMetrics(commandArguments, startTime, endTime, telemetryContext, cancellationToken);
+ this.CaptureMetrics(startTime, endTime, telemetryContext, cancellationToken);
}
});
}
@@ -538,8 +464,9 @@ private async Task ExecuteWorkloadAsync(int serverPort, string command, string c
if (!this.WarmUp)
{
string output = process.StandardOutput.ToString();
- string parsedCommandArguments = this.ParseCommand(process.FullCommand());
- this.AggregateAndCapturePerProcessMetrics(output, parsedCommandArguments, startTime, DateTime.UtcNow, telemetryContext, cancellationToken);
+ string parsedCommandArguments = this.ParseCommand(process.FullCommand(), serverPort);
+ this.perProcessOutputList.Add(output);
+ this.perProcessCommandList.Add(parsedCommandArguments);
}
}
}
@@ -586,7 +513,7 @@ private async Task<ServerState> GetServerStateAsync(IApiClient serverApiClient,
return state.Definition;
}
- private string ParseCommand(string command)
+ private string ParseCommand(string command, int serverPort)
{
List<string> excludingRegexList = new List<string>
{
@@ -607,6 +534,8 @@ private string ParseCommand(string command)
command = Regex.Replace(command, @"\s+", " "); // Removes extra spaces
+ // get the port on which this command is running and
+ command += @$"--VCpuID {serverPort - this.startingServerPort}";
return command.Trim();
}
}
diff --git a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs
index 36c5b1a8eb..4f77c16ad7 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs
@@ -7,7 +7,9 @@ namespace VirtualClient.Actions
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
+ using System.Threading;
using VirtualClient;
+ using VirtualClient.Common.Telemetry;
using VirtualClient.Contracts;
/// <summary>
@@ -16,6 +18,7 @@ namespace VirtualClient.Actions
public class MemtierMetricsParser : MetricsParser
{
private const string SplitAtSpace = @"\s{1,}";
+ private const string ProcessResultSectionDelimiter = @"*{6}";
// ============================================================================================================================================================
// Type Ops/sec Hits/sec Misses/sec Avg.Latency p50 Latency p90 Latency p95 Latency p99 Latency p99.9 Latency KB/sec
@@ -28,15 +31,17 @@ public class MemtierMetricsParser : MetricsParser
private static readonly Regex SetsExpression = new Regex(@"(?<=Sets).*(?=\n)", RegexOptions.IgnoreCase);
private static readonly Regex TotalsExpression = new Regex(@"(?<=Totals).*(?=\n)", RegexOptions.IgnoreCase);
- private string memtierCommandLine;
+ private bool perProcessMetric = false;
+ private List<string> memtierCommandLines = new List<string>();
/// <summary>
/// Initializes a new instance of the <see cref="MemtierMetricsParser"/> class.
/// </summary>
- public MemtierMetricsParser(string rawText, string commandLine = null)
- : base(rawText)
+ public MemtierMetricsParser(bool perProcessMetric, List<string> rawText, List<string> commandLines = null)
+ : base(string.Join(ProcessResultSectionDelimiter, rawText))
{
- this.memtierCommandLine = commandLine;
+ this.perProcessMetric = perProcessMetric;
+ this.memtierCommandLines = commandLines;
}
/// <inheritdoc/>
@@ -45,35 +50,52 @@ public override IList<Metric> Parse()
try
{
this.ThrowIfInvalidOutputFormat();
+ List<Metric> aggregateMetrics = new List<Metric>();
+ List<Metric> combinedMetrics = new List<Metric>();
+ List<string> rawTextList = this.RawText.Split(ProcessResultSectionDelimiter).Select(s => s.Trim()).ToList();
- // Example Format:
- //
- // ALL STATS
- // ============================================================================================================================================================
- // Type Ops/sec Hits/sec Misses/sec Avg. Latency p50 Latency p90 Latency p95 Latency p99 Latency p99.9 Latency KB/sec
- // ------------------------------------------------------------------------------------------------------------------------------------------------------------
- // Sets 4827.17 --- --- 2.64323 2.83100 3.93500 4.47900 7.45500 29.56700 329.45
- // Gets 43444.12 43444.12 0.00 2.61979 2.73500 3.88700 4.41500 7.42300 29.31100 3724.01
- // Waits 0.00 --- --- --- --- --- --- --- --- ---
- // Totals 48271.29 43444.12 0.00 2.62213 2.75100 3.90300 4.41500 7.42300 29.31100 4053.46
-
- List<Metric> metrics = new List<Metric>();
-
- var totals = MemtierMetricsParser.TotalsExpression.Matches(this.RawText);
- MemtierMetricsParser.AddMetrics(metrics, totals);
-
- var getsResults = MemtierMetricsParser.GetsExpression.Matches(this.RawText);
- MemtierMetricsParser.AddMetrics(metrics, getsResults, "GET");
+ for (int i = 0; i < rawTextList.Count; i++)
+ {
+ string rawText = rawTextList[i];
+ // Example Format:
+ //
+ // ALL STATS
+ // ============================================================================================================================================================
+ // Type Ops/sec Hits/sec Misses/sec Avg. Latency p50 Latency p90 Latency p95 Latency p99 Latency p99.9 Latency KB/sec
+ // ------------------------------------------------------------------------------------------------------------------------------------------------------------
+ // Sets 4827.17 --- --- 2.64323 2.83100 3.93500 4.47900 7.45500 29.56700 329.45
+ // Gets 43444.12 43444.12 0.00 2.61979 2.73500 3.88700 4.41500 7.42300 29.31100 3724.01
+ // Waits 0.00 --- --- --- --- --- --- --- --- ---
+ // Totals 48271.29 43444.12 0.00 2.62213 2.75100 3.90300 4.41500 7.42300 29.31100 4053.46
+
+ List<Metric> perProcessMetrics = new List<Metric>();
+
+ var totals = MemtierMetricsParser.TotalsExpression.Matches(rawText);
+ MemtierMetricsParser.AddMetrics(perProcessMetrics, totals);
+
+ var getsResults = MemtierMetricsParser.GetsExpression.Matches(rawText);
+ MemtierMetricsParser.AddMetrics(perProcessMetrics, getsResults, "GET");
+
+ var setsResults = MemtierMetricsParser.SetsExpression.Matches(rawText);
+ MemtierMetricsParser.AddMetrics(perProcessMetrics, setsResults, "SET");
+
+ if (this.memtierCommandLines != null)
+ {
+ string memtiercommandLine = this.memtierCommandLines[i];
+ perProcessMetrics.AddMetadata(MemtierMetricsParser.GetMetadata(memtiercommandLine));
+ }
- var setsResults = MemtierMetricsParser.SetsExpression.Matches(this.RawText);
- MemtierMetricsParser.AddMetrics(metrics, setsResults, "SET");
+ combinedMetrics.AddRange(perProcessMetrics);
- if (!string.IsNullOrWhiteSpace(this.memtierCommandLine))
- {
- metrics.AddMetadata(MemtierMetricsParser.GetMetadata(this.memtierCommandLine));
+ if (this.perProcessMetric)
+ {
+ aggregateMetrics.AddRange(perProcessMetrics);
+ }
}
- return metrics;
+ aggregateMetrics.AddRange(MemtierMetricsParser.AggregateMetrics(combinedMetrics));
+
+ return aggregateMetrics;
}
catch (Exception exc)
{
@@ -262,6 +284,11 @@ private static IDictionary<string, IConvertible> GetMetadata(string commandLine)
{
IDictionary<string, IConvertible> metadata = new Dictionary<string, IConvertible>();
+ if (!string.IsNullOrWhiteSpace(commandLine))
+ {
+ metadata["commandline"] = commandLine;
+ }
+
Match protocol = Regex.Match(commandLine, @"--protocol\s*=*([a-z0-9_-]+)", RegexOptions.IgnoreCase);
if (protocol.Success)
{
@@ -319,6 +346,59 @@ private static IDictionary<string, IConvertible> GetMetadata(string commandLine)
return metadata;
}
+ private static List<Metric> AggregateMetrics(List<Metric> combinedMetrics)
+ {
+ Dictionary<string, List<double>> metricNameValueListDict = new Dictionary<string, List<double>>();
+ Dictionary<string, List<Metric>> metricNameMetricsListDict = new Dictionary<string, List<Metric>>();
+
+ foreach (var metric in combinedMetrics)
+ {
+ if (metricNameMetricsListDict.ContainsKey(metric.Name))
+ {
+ metricNameValueListDict[metric.Name].Add(metric.Value);
+ }
+ else
+ {
+ metricNameValueListDict.Add(metric.Name, new List<double>() { metric.Value });
+ }
+
+ if (metricNameMetricsListDict.ContainsKey(metric.Name))
+ {
+ metricNameMetricsListDict[metric.Name].Add(metric);
+ }
+ else
+ {
+ metricNameMetricsListDict.Add(metric.Name, new List<Metric>() { metric });
+ }
+ }
+
+ List<Metric> newAggregateListOfMetrics = new List<Metric>();
+
+ foreach (var metricKeyValuePair in metricNameValueListDict)
+ {
+ double avgValue = metricKeyValuePair.Value.Average();
+ double minValue = metricKeyValuePair.Value.Min();
+ double maxValue = metricKeyValuePair.Value.Max();
+ double stdevValue = Math.Sqrt(metricKeyValuePair.Value.Select(x => Math.Pow(x - avgValue, 2)).Average());
+ List<double> sortedValues = metricKeyValuePair.Value.OrderBy(x => x).ToList();
+ double p80Value = sortedValues[(int)Math.Ceiling(sortedValues.Count * 0.8) - 1];
+
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Avg", avgValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Min", minValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Max", maxValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Stdev", stdevValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_P80", p80Value, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ if (metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit != MetricUnit.Milliseconds)
+ {
+ // For throughput and bandwidth related metrics only.
+ double sumValue = metricKeyValuePair.Value.Sum();
+ newAggregateListOfMetrics.Add(new Metric($"{metricKeyValuePair.Key}_Sum", sumValue, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Unit, metricNameMetricsListDict[metricKeyValuePair.Key].ElementAt(0).Relativity));
+ }
+ }
+
+ return newAggregateListOfMetrics;
+ }
+
private void ThrowIfInvalidOutputFormat()
{
if (this.RawText == string.Empty || this.RawText == null || !this.RawText.Contains("Totals"))
diff --git a/src/VirtualClient/VirtualClient.Actions/Redis/RedisExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Redis/RedisExecutor.cs
index 4c4fb99eda..9746bab5cd 100644
--- a/src/VirtualClient/VirtualClient.Actions/Redis/RedisExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Redis/RedisExecutor.cs
@@ -145,16 +145,22 @@ protected override async Task InitializeAsync(EventContext telemetryContext, Can
/// </summary>
protected override bool IsSupported()
{
- bool isSupported = base.IsSupported()
- && (this.Platform == PlatformID.Unix)
+ if (base.IsSupported())
+ {
+ bool isSupported = (this.Platform == PlatformID.Unix)
&& (this.CpuArchitecture == Architecture.X64 || this.CpuArchitecture == Architecture.Arm64);
- if (!isSupported)
+ if (!isSupported)
+ {
+ this.Logger.LogNotSupported("Redis", this.Platform, this.CpuArchitecture, EventContext.Persisted());
+ }
+
+ return isSupported;
+ }
+ else
{
- this.Logger.LogNotSupported("Redis", this.Platform, this.CpuArchitecture, EventContext.Persisted());
+ return false;
}
-
- return isSupported;
}
/// <summary>
diff --git a/src/VirtualClient/VirtualClient.Main/profiles/PERF-MEMCACHED.json b/src/VirtualClient/VirtualClient.Main/profiles/PERF-MEMCACHED.json
index 088d57cb57..4c22909ae5 100644
--- a/src/VirtualClient/VirtualClient.Main/profiles/PERF-MEMCACHED.json
+++ b/src/VirtualClient/VirtualClient.Main/profiles/PERF-MEMCACHED.json
@@ -6,13 +6,14 @@
"SupportedOperatingSystems": "Ubuntu",
"Notes_ConnectionLimits": "Each Memtier benchmark action will establish (--threads x --clients) connections against the Memcached server for each client instance/process. Ensure that the server-side OS does not place a limit on connections that might exceed this (e.g. ulimit -Sn on Linux)."
},
- "Parameters": {
- "ServerPort": 6379,
- "ServerMaxConnections": 16384,
- "ClientInstances": 8,
- "Duration": "00:02:00",
- "Username": null
- },
+ "Parameters": {
+ "ServerPort": 6379,
+ "ServerMaxConnections": 16384,
+ "ClientInstances": 8,
+ "Duration": "00:02:00",
+ "Username": null,
+ "PerProcessMetric": false
+ },
"Actions": [
{
"Type": "MemcachedServerExecutor",
@@ -30,135 +31,147 @@
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "warmup_32b_pool",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 1 --clients 1 --ratio 1:0 --data-size 32 --pipeline 32 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern S:S --run-count 1 --requests=allkeys",
- "ClientInstances": 1,
- "WarmUp": true,
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "warmup_32b_pool",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 1 --clients 1 --ratio 1:0 --data-size 32 --pipeline 32 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern S:S --run-count 1 --requests=allkeys",
+ "ClientInstances": 1,
+ "WarmUp": true,
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "warmup_1kb_pool",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 1 --clients 1 --ratio 1:0 --data-size 1024 --pipeline 32 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern S:S --run-count 1 --requests=allkeys",
- "ClientInstances": 1,
- "WarmUp": true,
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "warmup_1kb_pool",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 1 --clients 1 --ratio 1:0 --data-size 1024 --pipeline 32 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern S:S --run-count 1 --requests=allkeys",
+ "ClientInstances": 1,
+ "WarmUp": true,
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "warmup_10kb_pool",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 1 --clients 1 --ratio 1:0 --data-size 10240 --pipeline 32 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern S:S --run-count 1 --requests=allkeys",
- "ClientInstances": 1,
- "WarmUp": true,
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "warmup_10kb_pool",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 1 --clients 1 --ratio 1:0 --data-size 10240 --pipeline 32 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern S:S --run-count 1 --requests=allkeys",
+ "ClientInstances": 1,
+ "WarmUp": true,
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_8t_16c_32b_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 8 --clients 16 --ratio 1:1 --data-size 32 --pipeline 100 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_8t_16c_32b_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 8 --clients 16 --ratio 1:1 --data-size 32 --pipeline 100 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_8t_16c_1kb_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 8 --clients 16 --ratio 1:1 --data-size 1024 --pipeline 100 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_8t_16c_1kb_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 8 --clients 16 --ratio 1:1 --data-size 1024 --pipeline 100 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_8t_16c_10kb_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 8 --clients 16 --ratio 1:1 --data-size 10240 --pipeline 100 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_8t_16c_10kb_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 8 --clients 16 --ratio 1:1 --data-size 10240 --pipeline 100 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_16t_16c_32b_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 16 --clients 16 --ratio 1:1 --data-size 32 --pipeline 100 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_16t_16c_32b_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 16 --clients 16 --ratio 1:1 --data-size 32 --pipeline 100 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_16t_16c_1kb_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 16 --clients 16 --ratio 1:1 --data-size 1024 --pipeline 100 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_16t_16c_1kb_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 16 --clients 16 --ratio 1:1 --data-size 1024 --pipeline 100 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_16t_16c_10kb_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 16 --clients 16 --ratio 1:1 --data-size 10240 --pipeline 100 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_16t_16c_10kb_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 16 --clients 16 --ratio 1:1 --data-size 10240 --pipeline 100 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_32t_16c_32b_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 32 --clients 16 --ratio 1:1 --data-size 32 --pipeline 100 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_32t_16c_32b_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 32 --clients 16 --ratio 1:1 --data-size 32 --pipeline 100 --key-minimum 1 --key-maximum 10000000 --key-prefix sm --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_32t_16c_1kb_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 32 --clients 16 --ratio 1:1 --data-size 1024 --pipeline 100 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_32t_16c_1kb_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 32 --clients 16 --ratio 1:1 --data-size 1024 --pipeline 100 --key-minimum 1 --key-maximum 1000000 --key-prefix med --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
},
{
"Type": "MemtierBenchmarkClientExecutor",
- "Parameters": {
- "Scenario": "memtier_32t_16c_10kb_r1:1",
- "PackageName": "memtier",
- "CommandLine": "--protocol memcache_text --threads 32 --clients 16 --ratio 1:1 --data-size 10240 --pipeline 100 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
- "ClientInstances": "$.Parameters.ClientInstances",
- "Duration": "$.Parameters.Duration",
- "Role": "Client"
- }
+ "Parameters": {
+ "Scenario": "memtier_32t_16c_10kb_r1:1",
+ "PackageName": "memtier",
+ "CommandLine": "--protocol memcache_text --threads 32 --clients 16 --ratio 1:1 --data-size 10240 --pipeline 100 --key-minimum 1 --key-maximum 100000 --key-prefix lg --key-pattern R:R --run-count 1 --print-percentiles 50,90,95,99,99.9 --random-data --test-time {Duration}",
+ "ClientInstances": "$.Parameters.ClientInstances",
+ "Duration": "$.Parameters.Duration",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
+ "Role": "Client"
+ }
}
],
"Dependencies": [
diff --git a/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json b/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json
index 66211b6e1f..08fd79a206 100644
--- a/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json
+++ b/src/VirtualClient/VirtualClient.Main/profiles/PERF-REDIS.json
@@ -55,6 +55,7 @@
"WarmUp": true,
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -68,6 +69,7 @@
"WarmUp": true,
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -81,6 +83,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -94,6 +97,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -107,6 +111,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -120,6 +125,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -133,6 +139,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -146,6 +153,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -159,6 +167,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -172,6 +181,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
},
@@ -185,6 +195,7 @@
"Duration": "$.Parameters.Duration",
"IsTLSEnabled": "$.Parameters.IsTLSEnabled",
"RedisResourcesPackageName": "redisresources",
+ "PerProcessMetric": "$.Parameters.PerProcessMetric",
"Role": "Client"
}
}
From 407e6df942be70fce9123b72dc53fe09d0e52faf Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Fri, 3 Nov 2023 02:49:49 +0530
Subject: [PATCH 4/7] resolving functional testing, adding documentation,
resolving issue with transient error at server side
---
.../Examples/Memtier/RedisResults_3.txt | 392 ++++++++++++++++++
.../Memtier/MemtierMetricsParserTests.cs | 43 ++
.../Memcached/MemcachedServerExecutor.cs | 2 +
.../Memtier/MemtierBenchmarkClientExecutor.cs | 26 +-
.../Memtier/MemtierMetricsParser.cs | 8 +-
.../Redis/RedisServerExecutor.cs | 2 +
website/docs/workloads/memcached/memcached.md | 233 +++++++----
.../docs/workloads/redis/redis-profiles.md | 2 +
website/docs/workloads/redis/redis.md | 320 +++++++-------
9 files changed, 744 insertions(+), 284 deletions(-)
create mode 100644 src/VirtualClient/VirtualClient.Actions.UnitTests/Examples/Memtier/RedisResults_3.txt
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Examples/Memtier/RedisResults_3.txt b/src/VirtualClient/VirtualClient.Actions.UnitTests/Examples/Memtier/RedisResults_3.txt
new file mode 100644
index 0000000000..68e21c1e3f
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Examples/Memtier/RedisResults_3.txt
@@ -0,0 +1,392 @@
+6379
+4 Threads
+1 Connections per thread
+30 Seconds
+
+
+ALL STATS
+============================================================================================================================================================
+Type Ops/sec Hits/sec Misses/sec Avg. Latency p50 Latency p90 Latency p95 Latency p99 Latency p99.9 Latency KB/sec
+------------------------------------------------------------------------------------------------------------------------------------------------------------
+Sets 35598.74 --- --- 0.34304 0.33500 0.47900 0.55900 0.83900 1.54300 2742.53
+Gets 320388.28 320388.28 0.00 0.34300 0.33500 0.47900 0.55900 0.83900 1.54300 23118.30
+Waits 0.00 --- --- --- --- --- --- --- --- ---
+Totals 355987.03 320388.28 0.00 0.34301 0.33500 0.47900 0.55900 0.83900 1.54300 25860.83
+
+
+Request Latency Distribution
+Type <= msec Percent
+------------------------------------------------------------------------
+SET 0.119 0.000
+SET 0.207 5.000
+SET 0.215 10.000
+SET 0.231 15.000
+SET 0.239 20.000
+SET 0.255 25.000
+SET 0.263 30.000
+SET 0.271 35.000
+SET 0.287 40.000
+SET 0.295 45.000
+SET 0.335 50.000
+SET 0.343 52.500
+SET 0.351 55.000
+SET 0.351 57.500
+SET 0.359 60.000
+SET 0.359 62.500
+SET 0.367 65.000
+SET 0.367 67.500
+SET 0.375 70.000
+SET 0.375 72.500
+SET 0.383 75.000
+SET 0.399 76.250
+SET 0.423 77.500
+SET 0.439 78.750
+SET 0.447 80.000
+SET 0.447 81.250
+SET 0.455 82.500
+SET 0.455 83.750
+SET 0.463 85.000
+SET 0.463 86.250
+SET 0.463 87.500
+SET 0.471 88.125
+SET 0.471 88.750
+SET 0.471 89.375
+SET 0.479 90.000
+SET 0.487 90.625
+SET 0.511 91.250
+SET 0.527 91.875
+SET 0.535 92.500
+SET 0.543 93.125
+SET 0.543 93.750
+SET 0.551 94.062
+SET 0.551 94.375
+SET 0.551 94.688
+SET 0.559 95.000
+SET 0.559 95.312
+SET 0.567 95.625
+SET 0.583 95.938
+SET 0.599 96.250
+SET 0.607 96.562
+SET 0.615 96.875
+SET 0.615 97.031
+SET 0.623 97.188
+SET 0.623 97.344
+SET 0.631 97.500
+SET 0.639 97.656
+SET 0.655 97.812
+SET 0.671 97.969
+SET 0.695 98.125
+SET 0.719 98.281
+SET 0.743 98.438
+SET 0.751 98.516
+SET 0.759 98.594
+SET 0.767 98.672
+SET 0.783 98.750
+SET 0.799 98.828
+SET 0.823 98.906
+SET 0.839 98.984
+SET 0.855 99.062
+SET 0.863 99.141
+SET 0.887 99.219
+SET 0.895 99.258
+SET 0.911 99.297
+SET 0.919 99.336
+SET 0.927 99.375
+SET 0.935 99.414
+SET 0.943 99.453
+SET 0.951 99.492
+SET 0.959 99.531
+SET 0.975 99.570
+SET 0.991 99.609
+SET 0.999 99.629
+SET 1.007 99.648
+SET 1.015 99.668
+SET 1.023 99.688
+SET 1.039 99.707
+SET 1.047 99.727
+SET 1.055 99.746
+SET 1.071 99.766
+SET 1.087 99.785
+SET 1.111 99.805
+SET 1.119 99.814
+SET 1.127 99.824
+SET 1.143 99.834
+SET 1.167 99.844
+SET 1.199 99.854
+SET 1.223 99.863
+SET 1.271 99.873
+SET 1.335 99.883
+SET 1.415 99.893
+SET 1.575 99.902
+SET 1.671 99.907
+SET 1.743 99.912
+SET 1.815 99.917
+SET 1.887 99.922
+SET 1.935 99.927
+SET 2.031 99.932
+SET 2.095 99.937
+SET 2.207 99.941
+SET 2.303 99.946
+SET 2.399 99.951
+SET 2.431 99.954
+SET 2.463 99.956
+SET 2.511 99.958
+SET 2.543 99.961
+SET 2.575 99.963
+SET 2.655 99.966
+SET 2.831 99.968
+SET 2.911 99.971
+SET 3.103 99.973
+SET 3.215 99.976
+SET 3.455 99.977
+SET 3.727 99.978
+SET 3.903 99.979
+SET 4.031 99.980
+SET 4.191 99.982
+SET 4.255 99.983
+SET 4.287 99.984
+SET 4.319 99.985
+SET 4.351 99.987
+SET 4.383 99.988
+SET 4.479 99.988
+SET 4.767 99.989
+SET 4.863 99.990
+SET 5.087 99.990
+SET 5.151 99.991
+SET 5.247 99.991
+SET 5.343 99.992
+SET 5.503 99.993
+SET 5.567 99.993
+SET 5.599 99.994
+SET 5.759 99.994
+SET 5.791 99.995
+SET 6.079 99.995
+SET 6.111 99.995
+SET 6.143 99.995
+SET 6.335 99.996
+SET 6.463 99.996
+SET 6.463 99.996
+SET 6.527 99.997
+SET 7.231 99.997
+SET 7.231 99.997
+SET 7.263 99.997
+SET 7.263 99.997
+SET 7.263 99.998
+SET 7.743 99.998
+SET 7.775 99.998
+SET 7.775 99.998
+SET 7.935 99.998
+SET 7.935 99.998
+SET 7.935 99.998
+SET 8.255 99.999
+SET 8.255 99.999
+SET 8.255 99.999
+SET 8.255 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 8.319 99.999
+SET 10.943 99.999
+SET 10.943 99.999
+SET 10.943 99.999
+SET 10.943 99.999
+SET 10.943 100.000
+SET 10.943 100.000
+SET 10.943 100.000
+SET 10.943 100.000
+SET 11.327 100.000
+SET 11.327 100.000
+---
+GET 0.119 0.000
+GET 0.207 5.000
+GET 0.215 10.000
+GET 0.231 15.000
+GET 0.239 20.000
+GET 0.255 25.000
+GET 0.263 30.000
+GET 0.271 35.000
+GET 0.287 40.000
+GET 0.295 45.000
+GET 0.335 50.000
+GET 0.343 52.500
+GET 0.351 55.000
+GET 0.351 57.500
+GET 0.359 60.000
+GET 0.359 62.500
+GET 0.367 65.000
+GET 0.367 67.500
+GET 0.375 70.000
+GET 0.375 72.500
+GET 0.383 75.000
+GET 0.399 76.250
+GET 0.423 77.500
+GET 0.439 78.750
+GET 0.447 80.000
+GET 0.447 81.250
+GET 0.455 82.500
+GET 0.455 83.750
+GET 0.463 85.000
+GET 0.463 86.250
+GET 0.463 87.500
+GET 0.471 88.125
+GET 0.471 88.750
+GET 0.471 89.375
+GET 0.479 90.000
+GET 0.487 90.625
+GET 0.511 91.250
+GET 0.527 91.875
+GET 0.535 92.500
+GET 0.543 93.125
+GET 0.543 93.750
+GET 0.551 94.062
+GET 0.551 94.375
+GET 0.551 94.688
+GET 0.559 95.000
+GET 0.559 95.312
+GET 0.567 95.625
+GET 0.583 95.938
+GET 0.599 96.250
+GET 0.607 96.562
+GET 0.615 96.875
+GET 0.615 97.031
+GET 0.623 97.188
+GET 0.623 97.344
+GET 0.631 97.500
+GET 0.647 97.656
+GET 0.655 97.812
+GET 0.671 97.969
+GET 0.695 98.125
+GET 0.719 98.281
+GET 0.743 98.438
+GET 0.751 98.516
+GET 0.759 98.594
+GET 0.767 98.672
+GET 0.783 98.750
+GET 0.799 98.828
+GET 0.823 98.906
+GET 0.839 98.984
+GET 0.855 99.062
+GET 0.863 99.141
+GET 0.887 99.219
+GET 0.895 99.258
+GET 0.911 99.297
+GET 0.919 99.336
+GET 0.927 99.375
+GET 0.935 99.414
+GET 0.943 99.453
+GET 0.951 99.492
+GET 0.959 99.531
+GET 0.975 99.570
+GET 0.991 99.609
+GET 0.999 99.629
+GET 1.007 99.648
+GET 1.015 99.668
+GET 1.023 99.688
+GET 1.039 99.707
+GET 1.047 99.727
+GET 1.055 99.746
+GET 1.071 99.766
+GET 1.087 99.785
+GET 1.111 99.805
+GET 1.119 99.814
+GET 1.127 99.824
+GET 1.143 99.834
+GET 1.167 99.844
+GET 1.199 99.854
+GET 1.223 99.863
+GET 1.271 99.873
+GET 1.335 99.883
+GET 1.415 99.893
+GET 1.575 99.902
+GET 1.679 99.907
+GET 1.743 99.912
+GET 1.831 99.917
+GET 1.895 99.922
+GET 1.935 99.927
+GET 2.039 99.932
+GET 2.127 99.937
+GET 2.207 99.941
+GET 2.303 99.946
+GET 2.399 99.951
+GET 2.447 99.954
+GET 2.479 99.956
+GET 2.527 99.958
+GET 2.543 99.961
+GET 2.607 99.963
+GET 2.687 99.966
+GET 2.847 99.968
+GET 2.943 99.971
+GET 3.135 99.973
+GET 3.295 99.976
+GET 3.503 99.977
+GET 3.823 99.978
+GET 3.919 99.979
+GET 4.031 99.980
+GET 4.223 99.982
+GET 4.287 99.983
+GET 4.319 99.984
+GET 4.319 99.985
+GET 4.351 99.987
+GET 4.383 99.988
+GET 4.479 99.988
+GET 4.767 99.989
+GET 4.863 99.990
+GET 5.087 99.990
+GET 5.151 99.991
+GET 5.247 99.991
+GET 5.343 99.992
+GET 5.503 99.993
+GET 5.567 99.993
+GET 5.599 99.994
+GET 5.759 99.994
+GET 5.791 99.995
+GET 6.079 99.995
+GET 6.111 99.995
+GET 6.143 99.995
+GET 6.335 99.996
+GET 6.463 99.996
+GET 6.463 99.996
+GET 6.495 99.997
+GET 6.527 99.997
+GET 7.231 99.997
+GET 7.231 99.997
+GET 7.263 99.997
+GET 7.263 99.998
+GET 7.743 99.998
+GET 7.743 99.998
+GET 7.775 99.998
+GET 7.775 99.998
+GET 7.935 99.998
+GET 7.935 99.998
+GET 8.255 99.999
+GET 8.255 99.999
+GET 8.255 99.999
+GET 8.255 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 8.319 99.999
+GET 10.943 99.999
+GET 10.943 99.999
+GET 10.943 100.000
+GET 10.943 100.000
+GET 10.943 100.000
+GET 10.943 100.000
+GET 10.943 100.000
+GET 10.943 100.000
+GET 10.943 100.000
+GET 10.943 100.000
+GET 11.327 100.000
+GET 11.327 100.000
+---
+WAIT 0.000 100.000
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs b/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
index f94494a18b..382d1d8582 100644
--- a/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
@@ -385,6 +385,49 @@ public void MemtierMetricsParserParsesTheExpectedMetricsFromRedisResultsCorrectl
MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
}
+ [Test]
+ public void MemtierMetricsParserParsesTheExpectedMetricsFromRedisForMoreThan1RedisServerInstancesResultsCorrectly_1()
+ {
+ List<string> resultsList = new List<string>();
+ string results1 = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\RedisResults_1.txt"));
+ resultsList.Add(results1);
+ string results2 = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\RedisResults_3.txt"));
+ resultsList.Add(results2);
+ var parser = new MemtierMetricsParser(false, resultsList);
+
+ IList<Metric> metrics = parser.Parse();
+
+ Assert.AreEqual(138, metrics.Count);
+ MetricAssert.Exists(metrics, "Throughput_Avg", 355987.03, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Bandwidth_Avg", 25860.83, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "Hits/sec_Avg", 320388.28);
+ MetricAssert.Exists(metrics, "Misses/sec_Avg", 0);
+ MetricAssert.Exists(metrics, "Latency-Avg_Avg", 0.34301, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Avg", 0.33500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Avg", 0.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Avg", 0.55900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Avg", 0.83900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Throughput_Avg", 320388.28, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 23118.30, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 0.34300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 0.33500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 0.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 0.55900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 0.83900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "SET_Throughput_Avg", 35598.74, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 2742.53, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 0.34304, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 0.33500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 0.47900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 0.55900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 0.83900, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 1.54300, MetricUnit.Milliseconds);
+ }
+
[Test]
public void MemtierMetricsParserAssociatesTheCorrectRelativityToTheMetrics()
{
diff --git a/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedServerExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedServerExecutor.cs
index d8452f1f70..dd94bdd871 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedServerExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memcached/MemcachedServerExecutor.cs
@@ -170,6 +170,8 @@ protected override Task ExecuteAsync(EventContext telemetryContext, Cancellation
{
this.SetServerOnline(false);
+ await this.ServerApiClient.PollForHeartbeatAsync(TimeSpan.FromMinutes(5), cancellationToken);
+
if (this.ResetServer(telemetryContext))
{
await this.DeleteStateAsync(telemetryContext, cancellationToken);
diff --git a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
index 85734806a3..8ab841e406 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierBenchmarkClientExecutor.cs
@@ -5,14 +5,12 @@ namespace VirtualClient.Actions
{
using System;
using System.Collections.Generic;
- using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
- using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Polly;
using VirtualClient.Common;
@@ -36,9 +34,9 @@ public class MemtierBenchmarkClientExecutor : MemcachedExecutor
new Regex(@"connection\s+refused", RegexOptions.IgnoreCase | RegexOptions.Compiled)
};
- private List<Metric> aggregatedMetrics = new List<Metric>();
- private List<string> perProcessOutputList = new List<string>();
- private List<string> perProcessCommandList = new List<string>();
+ private List<Metric> aggregatedMetrics;
+ private List<string> perProcessOutputList;
+ private List<string> perProcessCommandList;
private int startingServerPort;
/// <summary>
@@ -60,6 +58,9 @@ public MemtierBenchmarkClientExecutor(IServiceCollection dependencies, IDictiona
// Ensure the duration is in integer (seconds) form.
int duration = this.Duration;
this.Parameters[nameof(this.Duration)] = duration;
+ this.aggregatedMetrics = new List<Metric>();
+ this.perProcessOutputList = new List<string>();
+ this.perProcessCommandList = new List<string>();
}
/// <summary>
@@ -359,7 +360,7 @@ private void CaptureMetrics(DateTime startTime, DateTime endTime, EventContext t
metric.Value,
metric.Unit,
null,
- (string)metric.Metadata[commandline],
+ metric.Metadata.ContainsKey(commandline) ? (string)metric.Metadata[commandline] : null,
this.Tags,
telemetryContext,
metric.Relativity);
@@ -426,7 +427,15 @@ private Task ExecuteWorkloadsAsync(IPAddress serverIPAddress, ServerState server
await Task.WhenAll(workloadProcesses);
DateTime endTime = DateTime.UtcNow;
- this.CaptureMetrics(startTime, endTime, telemetryContext, cancellationToken);
+ if (!this.WarmUp)
+ {
+ foreach (string output in this.perProcessOutputList)
+ {
+ Console.WriteLine($"output is : {output}");
+ }
+
+ this.CaptureMetrics(startTime, endTime, telemetryContext, cancellationToken);
+ }
}
});
}
@@ -534,8 +543,7 @@ private string ParseCommand(string command, int serverPort)
command = Regex.Replace(command, @"\s+", " "); // Removes extra spaces
- // get the port on which this command is running and
- command += @$"--VCpuID {serverPort - this.startingServerPort}";
+ command += @$" --VCpuID {serverPort - this.startingServerPort}";
return command.Trim();
}
}
diff --git a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs
index 4f77c16ad7..aad3a8ca91 100644
--- a/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Memtier/MemtierMetricsParser.cs
@@ -18,7 +18,7 @@ namespace VirtualClient.Actions
public class MemtierMetricsParser : MetricsParser
{
private const string SplitAtSpace = @"\s{1,}";
- private const string ProcessResultSectionDelimiter = @"*{6}";
+ private const string ProcessResultSectionDelimiter = @"^\*{6}$";
// ============================================================================================================================================================
// Type Ops/sec Hits/sec Misses/sec Avg.Latency p50 Latency p90 Latency p95 Latency p99 Latency p99.9 Latency KB/sec
@@ -37,8 +37,8 @@ public class MemtierMetricsParser : MetricsParser
/// <summary>
/// Initializes a new instance of the <see cref="MemtierMetricsParser"/> class.
/// </summary>
- public MemtierMetricsParser(bool perProcessMetric, List<string> rawText, List<string> commandLines = null)
- : base(string.Join(ProcessResultSectionDelimiter, rawText))
+ public MemtierMetricsParser(bool perProcessMetric, List<string> rawTextList, List<string> commandLines = null)
+ : base(string.Join(ProcessResultSectionDelimiter, rawTextList))
{
this.perProcessMetric = perProcessMetric;
this.memtierCommandLines = commandLines;
@@ -54,9 +54,11 @@ public override IList<Metric> Parse()
List<Metric> combinedMetrics = new List<Metric>();
List<string> rawTextList = this.RawText.Split(ProcessResultSectionDelimiter).Select(s => s.Trim()).ToList();
+ Console.WriteLine($"rawTextListLength: {rawTextList.Count}");
for (int i = 0; i < rawTextList.Count; i++)
{
string rawText = rawTextList[i];
+ Console.WriteLine($"rawText {i}: {rawText}");
// Example Format:
//
// ALL STATS
diff --git a/src/VirtualClient/VirtualClient.Actions/Redis/RedisServerExecutor.cs b/src/VirtualClient/VirtualClient.Actions/Redis/RedisServerExecutor.cs
index 6d458d0cfb..7fa0cadc07 100644
--- a/src/VirtualClient/VirtualClient.Actions/Redis/RedisServerExecutor.cs
+++ b/src/VirtualClient/VirtualClient.Actions/Redis/RedisServerExecutor.cs
@@ -184,6 +184,8 @@ protected override Task ExecuteAsync(EventContext telemetryContext, Cancellation
{
this.SetServerOnline(false);
+ await this.ServerApiClient.PollForHeartbeatAsync(TimeSpan.FromMinutes(5), cancellationToken);
+
if (this.ResetServer(telemetryContext))
{
await this.DeleteStateAsync(telemetryContext, cancellationToken);
diff --git a/website/docs/workloads/memcached/memcached.md b/website/docs/workloads/memcached/memcached.md
index 83d6aab0ec..2b773a5a6d 100644
--- a/website/docs/workloads/memcached/memcached.md
+++ b/website/docs/workloads/memcached/memcached.md
@@ -19,95 +19,144 @@ and gives percentile latency distributions and throughput.
The following metrics are examples of those captured by the Virtual Client when running the Memtier workload against a
Memcached server.
-| Scenario Name | Metric Name | Example Value (min) | Example Value (max) | Example Value (avg) | Unit |
-|-----------------|-------------|---------------------|---------------------|---------------------|------|
-| Memtier_4t_1c | p50lat | 0.159 | 4.095 | 0.2965735294117649 | milliseconds |
-| Memtier_4t_1c | p90lat | 2.799 | 7.807 | 3.6170735294117639 | milliseconds |
-| Memtier_4t_1c | p95lat | 3.743 | 9.535 | 4.346150735294118 | milliseconds |
-| Memtier_4t_1c | p99.9lat | 11.519 | 61.951 | 16.81158823529412 | milliseconds |
-| Memtier_4t_1c | p99lat | 5.023 | 16.319 | 6.137676470588234 | milliseconds |
-| Memtier_4t_1c | throughput | 58417.19 | 815710.22 | 235439.3486305147 | operations/sec |
-| Memtier_4t_1c | throughput_1 | 29092.65 | 203673.3 | 111331.60009650735 | operations/sec |
-| Memtier_4t_1c | throughput_2 | 29315.66 | 206249.97 | 113622.22872585096 | operations/sec |
-| Memtier_4t_1c | throughput_3 | 176794.47 | 206504.79 | 193725.01733333333 | operations/sec |
-| Memtier_4t_1c | throughput_4 | 179516.37 | 203843.86 | 190337.24200000004 | operations/sec |
-| Memtier_4t_2c | p50lat | 0.335 | 4.415 | 1.52554930875576 | milliseconds |
-| Memtier_4t_2c | p90lat | 3.951 | 18.943 | 4.581628571428574 | milliseconds |
-| Memtier_4t_2c | p95lat | 4.223 | 21.759 | 5.332559447004607 | milliseconds |
-| Memtier_4t_2c | p99.9lat | 12.671 | 72.703 | 19.31950875576037 | milliseconds |
-| Memtier_4t_2c | p99lat | 5.439 | 29.439 | 7.0393244239631349 | milliseconds |
-| Memtier_4t_2c | throughput | 65999.11 | 797961.14 | 245532.84887788018 | operations/sec |
-| Memtier_4t_2c | throughput_1 | 32380.33 | 202134.5 | 119005.53673041475 | operations/sec |
-| Memtier_4t_2c | throughput_2 | 33331.74 | 204258.16 | 117608.7032130384 | operations/sec |
-| Memtier_4t_2c | throughput_3 | 169854.02 | 200916.3 | 185826.25166666663 | operations/sec |
-| Memtier_4t_2c | throughput_4 | 167405.91 | 194783.81 | 180833.36850000005 | operations/sec |
-| Memtier_4t_4c | p50lat | 1.183 | 15.359 | 2.7599138090824835 | milliseconds |
-| Memtier_4t_4c | p90lat | 4.799 | 26.367 | 11.749524559777568 | milliseconds |
-| Memtier_4t_4c | p95lat | 5.215 | 30.719 | 13.026113994439293 | milliseconds |
-| Memtier_4t_4c | p99.9lat | 20.735 | 83.967 | 33.21849953660797 | milliseconds |
-| Memtier_4t_4c | p99lat | 6.335 | 41.471 | 18.379381835032434 | milliseconds |
-| Memtier_4t_4c | throughput | 68264.98 | 817778.44 | 255551.02398053756 | operations/sec |
-| Memtier_4t_4c | throughput_1 | 32987.04 | 210675.5 | 122982.00023864689 | operations/sec |
-| Memtier_4t_4c | throughput_2 | 34447.69 | 206027.13 | 121898.65999073001 | operations/sec |
-| Memtier_4t_4c | throughput_3 | 176203.54 | 209177.93 | 193846.44791666664 | operations/sec |
-| Memtier_4t_4c | throughput_4 | 172918.81 | 203408.28 | 190946.7905 | operations/sec |
-| Memtier_8t_2c | p50lat | 0.631 | 15.487 | 1.052861552853134 | milliseconds |
-| Memtier_8t_2c | p90lat | 5.503 | 50.943 | 13.044298409728715 | milliseconds |
-| Memtier_8t_2c | p95lat | 13.055 | 59.647 | 14.339385406922359 | milliseconds |
-| Memtier_8t_2c | p99.9lat | 28.671 | 180.223 | 36.93806339181287 | milliseconds |
-| Memtier_8t_2c | p99lat | 17.535 | 91.135 | 22.5084705332086 | milliseconds |
-| Memtier_8t_2c | throughput | 57703.76 | 827385.88 | 257429.3466534144 | operations/sec |
-| Memtier_8t_2c | throughput_1 | 32527.37 | 209887.17 | 124380.40026426566 | operations/sec |
-| Memtier_8t_2c | throughput_2 | 23625.1 | 212309.54 | 122170.78199344877 | operations/sec |
-| Memtier_8t_2c | throughput_3 | 181544.04 | 212802.62 | 197401.76108333336 | operations/sec |
-| Memtier_8t_2c | throughput_4 | 179479.72 | 207057.14 | 192259.67658333336 | operations/sec |
-| Memtier_8t_4c | p50lat | 1.231 | 30.463 | 7.030075523202911 | milliseconds |
-| Memtier_8t_4c | p90lat | 14.143 | 59.391 | 16.208703366697 | milliseconds |
-| Memtier_8t_4c | p95lat | 17.791 | 101.375 | 19.43780133454656 | milliseconds |
-| Memtier_8t_4c | p99.9lat | 32.767 | 251.903 | 43.959487716105559 | milliseconds |
-| Memtier_8t_4c | p99lat | 25.727 | 160.767 | 28.69444919623901 | milliseconds |
-| Memtier_8t_4c | throughput | 60685.85 | 842329.67 | 265907.298343949 | operations/sec |
-| Memtier_8t_4c | throughput_1 | 28006.45 | 215109.34 | 127300.9799454049 | operations/sec |
-| Memtier_8t_4c | throughput_2 | 32502.93 | 217147.87 | 124150.41247801029 | operations/sec |
-| Memtier_8t_4c | throughput_3 | 184452.87 | 211285.71 | 197710.7305 | operations/sec |
-| Memtier_8t_4c | throughput_4 | 186077.54 | 213718.07 | 199465.28466666668 | operations/sec |
-| Memtier_8t_8c | p50lat | 2.383 | 57.343 | 15.538551766138858 | milliseconds |
-| Memtier_8t_8c | p90lat | 19.455 | 96.255 | 24.308904993909864 | milliseconds |
-| Memtier_8t_8c | p95lat | 23.039 | 132.095 | 29.86248355663824 | milliseconds |
-| Memtier_8t_8c | p99.9lat | 38.399 | 258.047 | 60.335019488428759 | milliseconds |
-| Memtier_8t_8c | p99lat | 31.743 | 186.367 | 43.09107308160779 | milliseconds |
-| Memtier_8t_8c | throughput | 64212.8 | 888657.03 | 270229.023270402 | operations/sec |
-| Memtier_8t_8c | throughput_1 | 31641.23 | 230826.34 | 127721.14527405605 | operations/sec |
-| Memtier_8t_8c | throughput_2 | 32303.92 | 227859.12 | 127505.81609584858 | operations/sec |
-| Memtier_8t_8c | throughput_3 | 194345.26 | 221087.21 | 207721.54641666666 | operations/sec |
-| Memtier_8t_8c | throughput_4 | 195513.22 | 224525.73 | 211335.26866666668 | operations/sec |
-| Memtier_16t_4c | p50lat | 2.479 | 63.999 | 15.867709396390792 | milliseconds |
-| Memtier_16t_4c | p90lat | 19.583 | 109.055 | 25.70262663347853 | milliseconds |
-| Memtier_16t_4c | p95lat | 23.807 | 128.511 | 29.745658369632858 | milliseconds |
-| Memtier_16t_4c | p99.9lat | 38.655 | 309.247 | 62.71748662103298 | milliseconds |
-| Memtier_16t_4c | p99lat | 31.871 | 179.199 | 43.3985668948351 | milliseconds |
-| Memtier_16t_4c | throughput | 58580.34 | 845621.72 | 253393.12167081517 | operations/sec |
-| Memtier_16t_4c | throughput_1 | 28743.1 | 215014.62 | 121465.76731176104 | operations/sec |
-| Memtier_16t_4c | throughput_2 | 29794.02 | 216446.78 | 124715.36404115996 | operations/sec |
-| Memtier_16t_4c | throughput_3 | 183022.18 | 215183.61 | 199985.7881666667 | operations/sec |
-| Memtier_16t_4c | throughput_4 | 188305.88 | 214475.28 | 200886.619 | operations/sec |
-| Memtier_16t_8c | p50lat | 20.607 | 133.119 | 32.126001871490959 | milliseconds |
-| Memtier_16t_8c | p90lat | 32.767 | 233.471 | 47.07609045539612 | milliseconds |
-| Memtier_16t_8c | p95lat | 33.279 | 268.287 | 55.38091890205864 | milliseconds |
-| Memtier_16t_8c | p99.9lat | 49.407 | 622.591 | 112.8486868371803 | milliseconds |
-| Memtier_16t_8c | p99lat | 42.239 | 317.439 | 78.94473674360575 | milliseconds |
-| Memtier_16t_8c | throughput | 55016.71 | 887996.49 | 250613.5241048035 | operations/sec |
-| Memtier_16t_8c | throughput_1 | 27740.86 | 224915.68 | 122564.99112913289 | operations/sec |
-| Memtier_16t_8c | throughput_2 | 27275.85 | 224914.49 | 120324.29177756951 | operations/sec |
-| Memtier_16t_8c | throughput_3 | 199133.29 | 220958.03 | 209582.30199999998 | operations/sec |
-| Memtier_16t_8c | throughput_4 | 198042.78 | 224867.07 | 213176.67700000006 | operations/sec |
-| Memtier_16t_16c | p50lat | 33.535 | 344.063 | 64.34645722344094 | milliseconds |
-| Memtier_16t_16c | p90lat | 52.991 | 518.143 | 91.89321247257914 | milliseconds |
-| Memtier_16t_16c | p95lat | 57.343 | 557.055 | 111.11832309620807 | milliseconds |
-| Memtier_16t_16c | p99.9lat | 69.631 | 978.943 | 204.75744312127865 | milliseconds |
-| Memtier_16t_16c | p99lat | 62.975 | 724.991 | 151.58678063303038 | milliseconds |
-| Memtier_16t_16c | throughput | 45402.08 | 903296.37 | 248871.23561892825 | operations/sec |
-| Memtier_16t_16c | throughput_1 | 22297.41 | 230097.93 | 120755.43762770292 | operations/sec |
-| Memtier_16t_16c | throughput_2 | 23104.67 | 231646.96 | 120205.79481632651 | operations/sec |
-| Memtier_16t_16c | throughput_3 | 204582.28 | 230185.17 | 217630.71233333337 | operations/sec |
-| Memtier_16t_16c | throughput_4 | 200293.43 | 232077.36 | 215070.2026666667 | operations/sec |
\ No newline at end of file
+
+| ScenarioName | Metric Name | Example Value | Unit |
+|-------------------------|--------------|---------------|-------|
+|memtier_16t_16c_1kb_r1:1|Throughput_Avg | 96143.676666666681| requests/sec|
+|memtier_16t_16c_1kb_r1:1|Throughput_Max |99310.66 | requests/sec|
+|memtier_16t_16c_1kb_r1:1|Throughput_Min |93126.7 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|Throughput_Stdev| 1756.3137622699699| requests/sec|
+|memtier_16t_16c_1kb_r1:1|Throughput_P80 |98123.77 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|Throughput_Sum |1153724.12 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|Hits/sec_Avg |48070.774999999994 | |
+|memtier_16t_16c_1kb_r1:1|Hits/sec_Max |49654.27 | |
+|memtier_16t_16c_1kb_r1:1|Hits/sec_Min |46562.29 | |
+|memtier_16t_16c_1kb_r1:1|Hits/sec_Stdev |878.156472669686 | |
+|memtier_16t_16c_1kb_r1:1|Hits/sec_P80 |49060.82 | |
+|memtier_16t_16c_1kb_r1:1|Hits/sec_Sum |576849.29999999993 | |
+|memtier_16t_16c_1kb_r1:1|Misses/sec_Avg |0 | |
+|memtier_16t_16c_1kb_r1:1|Misses/sec_Min |0 | |
+|memtier_16t_16c_1kb_r1:1|Misses/sec_Max |0 | |
+|memtier_16t_16c_1kb_r1:1|Misses/sec_Stdev| 0 | |
+|memtier_16t_16c_1kb_r1:1|Misses/sec_P80 |0 | |
+|memtier_16t_16c_1kb_r1:1|Misses/sec_Sum |0 | |
+|memtier_16t_16c_1kb_r1:1|Latency-Avg_Avg |265.929245 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-Avg_Min |257.37339 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-Avg_Max |274.49494 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-Avg_Stdev| 4.8649509314371953 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-Avg_P80 |268.37573 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P50_Avg |258.4736666666667 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P50_Min |252.927 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P50_Max |266.239 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P50_Stdev| 3.9095334191634046| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P50_P80 |260.095 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P90_Min |331.775 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P90_Avg |337.74833333333333| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P90_P80 |339.967 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P90_Max |348.159 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P90_Stdev| 4.6894529413236388| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P95_Min |346.111 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P95_Avg |354.4736666666667 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P95_Max |364.543 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P95_Stdev| 4.6894529413236388| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P95_P80 |356.351 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99_Avg |385.36433333333338| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99_Min |376.831 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99_Max |397.311 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99_Stdev| 5.3427117542394855| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99_P80 |389.119 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99.9_Avg| 442.02566666666667| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99.9_Min| 411.647 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99.9_Max| 532.479 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99.9_Stdev |32.01080706400402| milliseconds|
+|memtier_16t_16c_1kb_r1:1|Latency-P99.9_P80 |452.607 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|Bandwidth_Avg |99831.145833333328| kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|Bandwidth_Min |96698.49 | kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|Bandwidth_Stdev |1823.6575402628735| kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|Bandwidth_Max |103119.55 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|Bandwidth_P80 |101887.18 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Throughput_Avg| 48070.774999999994| requests/sec|
+|memtier_16t_16c_1kb_r1:1|Bandwidth_Sum |1197973.75 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Throughput_Min| 46562.29 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Throughput_Max| 49654.27 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Throughput_P80| 49060.82 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Throughput_Stdev| 878.156472669686 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Throughput_Sum |576849.29999999993 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Avg |265.9334425 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Min |257.37776 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_P80 |268.38027 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Max |274.49896 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Stdev| 4.8649389483855519| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Avg |258.4736666666667 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Min |252.927 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Max |266.239 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Avg |337.74833333333333| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Stdev| 4.6894529413236388| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Min |331.775 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Max |348.159 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Stdev| 3.9095334191634046| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P50_P80 |260.095 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P90_P80 |339.967 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Avg |354.81500000000005| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Min |346.111 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Max |364.543 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Stdev| 5.0252567430265076| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P95_P80 |356.351 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Avg |386.047 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Min |376.831 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Max |397.311 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Stdev| 5.3208600808515767| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99_P80 |391.167 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Avg| 442.87900000000008| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Min| 411.647 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Max| 532.479 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Stdev| 31.706816932640848| milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_P80 |454.655 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Avg |49797.129166666673| kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Stdev |909.68510072129129| kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Min |48234.48 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Max |51437.47 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Bandwidth_P80 |50822.73 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Throughput_Avg |48072.902499999989| requests/sec|
+|memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Sum |597565.55 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Throughput_Min |46564.42 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Throughput_Max |49656.39 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Throughput_P80 |49062.95 |requests/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Throughput_Stdev |878.15536932182385| requests/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Throughput_Sum |576874.82999999984| requests/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Avg |265.92504749999995| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Min |257.36902 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Max |274.49091 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_P80 |268.37118 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Avg |258.4736666666667| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Stdev| 4.8649615272924267| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Min |252.927 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Max |266.239 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P50_P80 |260.095 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Avg |337.74833333333333| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Stdev| 3.9095334191634046| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Min |331.775 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Max |348.159 |milli0seconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Stdev| 4.6894529413236388| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P90_P80 |339.967 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Avg |354.30299999999994| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Min |346.111 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Max |364.543 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Stdev| 4.8029857380591956| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P95_P80 |356.351 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Stdev| 5.1850095039021333| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Min |374.783 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Avg |384.85233333333332| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99_P80 |389.119 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Max |395.263 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Avg| 441.17233333333337| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Min| 409.599 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Max| 536.575 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Stdev |33.438038432632723| milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Avg |50034.015833333331| kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_P80| 450.559 |milliseconds|
+|memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Min |48464.01 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Bandwidth_P80 |51064.45 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Stdev |913.97098802841549| kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Sum |600408.19 |kilobytes/sec|
+|memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Max |51682.07 |kilobytes/sec|
\ No newline at end of file
diff --git a/website/docs/workloads/redis/redis-profiles.md b/website/docs/workloads/redis/redis-profiles.md
index eb99791d89..a6c4dba06c 100644
--- a/website/docs/workloads/redis/redis-profiles.md
+++ b/website/docs/workloads/redis/redis-profiles.md
@@ -82,6 +82,7 @@ We have two profiles for Redis.One supports redis with TLS and one without TLS.
| ServerThreadCount | Optional. The number of threads to use by the Redis server to handle operations. | 4 |
| ServerPort | Optional. The initial port on which the Redis servers will listen for traffic. Additional ports will be used for each 1 server instance defined in a sequential manner (e.g. 6379, 6380, 6381) | 6379 |
| IsTLSEnabled | Optional. It defines if Redis server runs with TLS or not. "yes" for TLS, "no" for no TLS| no |
+ | PerProcessMetric | Optional. "True" if we want to emit telemtry metrics for each client server combination.Aggregated metrics are always collected.| false |
* **Component Parameters**
The following parameters describe the parameters within the profile components.
@@ -107,6 +108,7 @@ We have two profiles for Redis.One supports redis with TLS and one without TLS.
| PackageName | The name of the package that contains the Memtier benchmark binaries/scripts. | |
| WarmUp | True if the component/action is meant to be used to warmup the Memcached server. Metrics will not be captured in warmup steps. | false |
| IsTLSEnabled | It defines if Redis server runs with TLS or not. "yes" for TLS, "no" for no TLS| no |
+ | PerProcessMetric | Optional. "True" if we want to emit telemtry metrics for each client server combination.Aggregated metrics are always collected.| false |
* **Profile Runtimes**
diff --git a/website/docs/workloads/redis/redis.md b/website/docs/workloads/redis/redis.md
index d192e183fd..b093af2665 100644
--- a/website/docs/workloads/redis/redis.md
+++ b/website/docs/workloads/redis/redis.md
@@ -18,183 +18,143 @@ the Redis server and provides throughput and latency percentile distributions.
The following metrics are examples of those captured by the Virtual Client when running the Memtier workload against a
Redis server.
-| Metric Name | Example Value (min) | Example Value (max) | Example Value (avg) | Unit |
-|--------------|---------------------|---------------------|---------------------|------|
-| GET_Average_Latency | 0.04 | 32.005 | 0.48362615964930158 | milliSeconds |
-| GET_Max_Latency | 0.087 | 82.815 | 2.9978202671016409 | milliSeconds |
-| GET_Min_Latency | 0.016 | 18.512 | 0.06400326231012303 | milliSeconds |
-| GET_P50_Latency | 0.039 | 31.983 | 0.43099306759098818 | milliSeconds |
-| GET_P95_Latency | 0.055 | 44.031 | 1.0166923233764916 | milliSeconds |
-| GET_P99_Latency | 0.063 | 56.287 | 1.711716484860842 | milliSeconds |
-| GET_Requests/Sec | 7980.85 | 1515636.38 | 657043.5354113564 | requests/second |
-| HSET_Average_Latency | 0.046 | 32.141 | 0.4740447570984351 | milliSeconds |
-| HSET_Max_Latency | 0.095 | 77.567 | 2.9574821328439619 | milliSeconds |
-| HSET_Min_Latency | 0.024 | 11.952 | 0.06351511444155553 | milliSeconds |
-| HSET_P50_Latency | 0.047 | 31.983 | 0.4103505632869458 | milliSeconds |
-| HSET_P95_Latency | 0.055 | 36.063 | 0.9638419228220432 | milliSeconds |
-| HSET_P99_Latency | 0.079 | 66.559 | 1.612821481368201 | milliSeconds |
-| HSET_Requests/Sec | 7849.53 | 1136727.25 | 569987.1470433805 | requests/second |
-| INCR_Average_Latency | 0.041 | 32.09 | 0.4909997961056173 | milliSeconds |
-| INCR_Max_Latency | 0.087 | 103.935 | 3.1033001325313487 | milliSeconds |
-| INCR_Min_Latency | 0.024 | 23.936 | 0.06726842695483709 | milliSeconds |
-| INCR_P50_Latency | 0.039 | 31.983 | 0.429000203894383 | milliSeconds |
-| INCR_P95_Latency | 0.055 | 42.111 | 1.0510322153124685 | milliSeconds |
-| INCR_P99_Latency | 0.071 | 92.095 | 1.7620013253134879 | milliSeconds |
-| INCR_Requests/Sec | 7960.53 | 1430857.12 | 631131.4617376895 | requests/second |
-| LPOP_Average_Latency | 0.049 | 33.015 | 0.4860578550310941 | milliSeconds |
-| LPOP_Max_Latency | 0.103 | 107.199 | 3.0467243207422145 | milliSeconds |
-| LPOP_Min_Latency | 0.024 | 25.968 | 0.0682613925986336 | milliSeconds |
-| LPOP_P50_Latency | 0.047 | 31.983 | 0.4283811805484766 | milliSeconds |
-| LPOP_P95_Latency | 0.063 | 43.935 | 1.0061803445815075 | milliSeconds |
-| LPOP_P99_Latency | 0.079 | 62.495 | 1.6812478462557988 | milliSeconds |
-| LPOP_Requests/Sec | 7645.8 | 1163162.75 | 554949.0140090728 | requests/second |
-| LPUSH (needed to benchmark LRANGE)_Average_Latency | 0.047 | 32.331 | 0.4680763152528547 | milliSeconds |
-| LPUSH (needed to benchmark LRANGE)_Max_Latency | 0.103 | 89.151 | 3.0183870309951059 | milliSeconds |
-| LPUSH (needed to benchmark LRANGE)_Min_Latency | 0.024 | 23.92 | 0.0674498368678627 | milliSeconds |
-| LPUSH (needed to benchmark LRANGE)_P50_Latency | 0.047 | 31.983 | 0.4168964110929859 | milliSeconds |
-| LPUSH (needed to benchmark LRANGE)_P95_Latency | 0.063 | 43.935 | 0.9477659053833611 | milliSeconds |
-| LPUSH (needed to benchmark LRANGE)_P99_Latency | 0.079 | 62.207 | 1.6001190864600324 | milliSeconds |
-| LPUSH (needed to benchmark LRANGE)_Requests/Sec | 7806.7 | 1112888.88 | 552787.2849683929 | requests/second |
-| LPUSH_Average_Latency | 0.049 | 32.39 | 0.5174908247527781 | milliSeconds |
-| LPUSH_Max_Latency | 0.095 | 80.447 | 3.14175991436436 | milliSeconds |
-| LPUSH_Min_Latency | 0.024 | 27.888 | 0.06941176470588206 | milliSeconds |
-| LPUSH_P50_Latency | 0.047 | 31.983 | 0.46588184320522027 | milliSeconds |
-| LPUSH_P95_Latency | 0.063 | 38.975 | 1.0646764196146397 | milliSeconds |
-| LPUSH_P99_Latency | 0.079 | 66.623 | 1.7610980731980833 | milliSeconds |
-| LPUSH_Requests/Sec | 7800.62 | 1112888.88 | 546899.8452446729 | requests/second |
-| LRANGE_100 (first 100 elements)_Average_Latency | 0.219 | 31.556 | 2.1469685460848288 | milliSeconds |
-| LRANGE_100 (first 100 elements)_Max_Latency | 0.319 | 232.959 | 12.235842577487766 | milliSeconds |
-| LRANGE_100 (first 100 elements)_Min_Latency | 0.192 | 8.736 | 0.2514208809135396 | milliSeconds |
-| LRANGE_100 (first 100 elements)_P50_Latency | 0.207 | 31.567 | 1.8669212887438807 | milliSeconds |
-| LRANGE_100 (first 100 elements)_P95_Latency | 0.263 | 56.447 | 4.660227977161501 | milliSeconds |
-| LRANGE_100 (first 100 elements)_P99_Latency | 0.295 | 102.527 | 7.441752039151712 | milliSeconds |
-| LRANGE_100 (first 100 elements)_Requests/Sec | 7983.4 | 139111.11 | 61537.65344718601 | requests/second |
-| LRANGE_300 (first 300 elements)_Average_Latency | 0.657 | 36.091 | 3.5058012846655797 | milliSeconds |
-| LRANGE_300 (first 300 elements)_Max_Latency | 0.839 | 144.767 | 21.579035889070146 | milliSeconds |
-| LRANGE_300 (first 300 elements)_Min_Latency | 0.592 | 2.752 | 0.6773694942903761 | milliSeconds |
-| LRANGE_300 (first 300 elements)_P50_Latency | 0.615 | 33.631 | 3.4033213703099505 | milliSeconds |
-| LRANGE_300 (first 300 elements)_P95_Latency | 0.775 | 79.487 | 6.062862561174552 | milliSeconds |
-| LRANGE_300 (first 300 elements)_P99_Latency | 0.807 | 105.919 | 12.36377732463295 | milliSeconds |
-| LRANGE_300 (first 300 elements)_Requests/Sec | 3586.68 | 31933.59 | 18214.11462530588 | requests/second |
-| LRANGE_500 (first 450 elements)_Average_Latency | 0.989 | 41.284 | 4.857378721451877 | milliSeconds |
-| LRANGE_500 (first 450 elements)_Max_Latency | 1.199 | 142.975 | 23.548218597063625 | milliSeconds |
-| LRANGE_500 (first 450 elements)_Min_Latency | 0.88 | 5.92 | 1.0238686786296896 | milliSeconds |
-| LRANGE_500 (first 450 elements)_P50_Latency | 0.911 | 42.111 | 4.821265497553018 | milliSeconds |
-| LRANGE_500 (first 450 elements)_P95_Latency | 1.119 | 75.967 | 7.64909665579119 | milliSeconds |
-| LRANGE_500 (first 450 elements)_P99_Latency | 1.167 | 110.527 | 13.705281810766719 | milliSeconds |
-| LRANGE_500 (first 450 elements)_Requests/Sec | 2631.63 | 21726.68 | 12339.182366435563 | requests/second |
-| LRANGE_600 (first 600 elements)_Average_Latency | 1.307 | 47.115 | 5.649815456769985 | milliSeconds |
-| LRANGE_600 (first 600 elements)_Max_Latency | 1.567 | 451.839 | 26.307774877650905 | milliSeconds |
-| LRANGE_600 (first 600 elements)_Min_Latency | 1.176 | 7.904 | 1.3783254486133792 | milliSeconds |
-| LRANGE_600 (first 600 elements)_P50_Latency | 1.231 | 48.735 | 5.666452691680261 | milliSeconds |
-| LRANGE_600 (first 600 elements)_P95_Latency | 1.479 | 104.511 | 8.99248735725938 | milliSeconds |
-| LRANGE_600 (first 600 elements)_P99_Latency | 1.559 | 133.759 | 15.49082096247961 | milliSeconds |
-| LRANGE_600 (first 600 elements)_Requests/Sec | 1844.91 | 16207.12 | 9321.784952589722 | requests/second |
-| MSET (10 keys)_Average_Latency | 0.108 | 31.115 | 1.018267536704731 | milliSeconds |
-| MSET (10 keys)_Max_Latency | 0.183 | 116.543 | 5.104883768352365 | milliSeconds |
-| MSET (10 keys)_Min_Latency | 0.088 | 15.584 | 0.18198939641109289 | milliSeconds |
-| MSET (10 keys)_P50_Latency | 0.103 | 31.983 | 0.91268515497553 | milliSeconds |
-| MSET (10 keys)_P95_Latency | 0.135 | 44.127 | 1.9114253670473083 | milliSeconds |
-| MSET (10 keys)_P99_Latency | 0.151 | 66.367 | 3.06757911908646 | milliSeconds |
-| MSET (10 keys)_Requests/Sec | 8211.46 | 333866.69 | 232481.1612709011 | requests/second |
-| P50lat | 0.175 | 77.823 | 15.913107353397399 | msec |
-| P90lat | 0.223 | 134.143 | 20.048949115730684 | msec |
-| P95lat | 0.231 | 179.199 | 24.911873409866585 | msec |
-| P99_9lat | 0.311 | 311.295 | 46.154507291343488 | msec |
-| P99lat | 0.271 | 239.615 | 34.136540179956579 | msec |
-| PING_INLINE_Average_Latency | 0.031 | 32.654 | 0.8576825874197166 | milliSeconds |
-| PING_INLINE_Max_Latency | 0.071 | 116.223 | 4.955231624018758 | milliSeconds |
-| PING_INLINE_Min_Latency | 0.024 | 31.696 | 0.06140850239575872 | milliSeconds |
-| PING_INLINE_P50_Latency | 0.031 | 31.983 | 0.843882454888369 | milliSeconds |
-| PING_INLINE_P95_Latency | 0.047 | 43.935 | 1.82383678254664 | milliSeconds |
-| PING_INLINE_P99_Latency | 0.063 | 63.967 | 3.040517789784892 | milliSeconds |
-| PING_INLINE_Requests/Sec | 7752.32 | 1252000.0 | 581094.6461810576 | requests/second |
-| PING_MBULK_Average_Latency | 0.03 | 32.952 | 0.715390049954124 | milliSeconds |
-| PING_MBULK_Max_Latency | 0.063 | 151.423 | 4.454256193291875 | milliSeconds |
-| PING_MBULK_Min_Latency | 0.016 | 31.728 | 0.06472831073503899 | milliSeconds |
-| PING_MBULK_P50_Latency | 0.031 | 31.983 | 0.6089410745233973 | milliSeconds |
-| PING_MBULK_P95_Latency | 0.047 | 42.495 | 1.6596985421551618 | milliSeconds |
-| PING_MBULK_P99_Latency | 0.047 | 70.143 | 2.810248853094097 | milliSeconds |
-| PING_MBULK_Requests/Sec | 7680.98 | 1724689.75 | 693490.7826455291 | requests/second |
-| RPOP_Average_Latency | 0.048 | 32.67 | 0.4743477086200745 | milliSeconds |
-| RPOP_Max_Latency | 0.087 | 87.359 | 2.9461633787021466 | milliSeconds |
-| RPOP_Min_Latency | 0.024 | 31.792 | 0.06490900749350025 | milliSeconds |
-| RPOP_P50_Latency | 0.047 | 31.983 | 0.4230913493398589 | milliSeconds |
-| RPOP_P95_Latency | 0.063 | 43.903 | 0.9695402457052563 | milliSeconds |
-| RPOP_P99_Latency | 0.079 | 68.095 | 1.6080631595045119 | milliSeconds |
-| RPOP_Requests/Sec | 7728.4 | 1252000.0 | 574482.0906270068 | requests/second |
-| RPUSH_Average_Latency | 0.047 | 32.51 | 0.4755399123254154 | milliSeconds |
-| RPUSH_Max_Latency | 0.103 | 80.703 | 3.0799974513202166 | milliSeconds |
-| RPUSH_Min_Latency | 0.032 | 19.888 | 0.06624487715363413 | milliSeconds |
-| RPUSH_P50_Latency | 0.047 | 31.983 | 0.4171364053420334 | milliSeconds |
-| RPUSH_P95_Latency | 0.055 | 42.271 | 1.010727189315935 | milliSeconds |
-| RPUSH_P99_Latency | 0.071 | 60.607 | 1.6829286369660515 | milliSeconds |
-| RPUSH_Requests/Sec | 7770.36 | 1252000.0 | 571089.7713635434 | requests/second |
-| SADD_Average_Latency | 0.041 | 32.461 | 0.4328111332007951 | milliSeconds |
-| SADD_Max_Latency | 0.079 | 88.639 | 2.8693630524545035 | milliSeconds |
-| SADD_Min_Latency | 0.024 | 19.984 | 0.06152418820410837 | milliSeconds |
-| SADD_P50_Latency | 0.039 | 31.967 | 0.38828725085385126 | milliSeconds |
-| SADD_P95_Latency | 0.047 | 35.999 | 0.9137253912422898 | milliSeconds |
-| SADD_P99_Latency | 0.063 | 70.463 | 1.5430375184788703 | milliSeconds |
-| SADD_Requests/Sec | 7776.4 | 1430857.12 | 635851.0720176373 | requests/second |
-| SET_Average_Latency | 0.04 | 32.145 | 0.6898151187684778 | milliSeconds |
-| SET_Max_Latency | 0.087 | 89.983 | 3.641637169945968 | milliSeconds |
-| SET_Min_Latency | 0.024 | 19.968 | 0.06945458252625107 | milliSeconds |
-| SET_P50_Latency | 0.039 | 31.983 | 0.6662162299928638 | milliSeconds |
-| SET_P95_Latency | 0.055 | 41.823 | 1.3665498012029769 | milliSeconds |
-| SET_P99_Latency | 0.071 | 62.399 | 2.2267908043633399 | milliSeconds |
-| SET_Requests/Sec | 7945.35 | 1252000.0 | 572498.2329707408 | requests/second |
-| SPOP_Average_Latency | 0.037 | 32.491 | 0.3794379364836622 | milliSeconds |
-| SPOP_Max_Latency | 0.079 | 97.279 | 2.638165579119087 | milliSeconds |
-| SPOP_Min_Latency | 0.016 | 13.544 | 0.054340622929091839 | milliSeconds |
-| SPOP_P50_Latency | 0.039 | 31.983 | 0.33848531810766677 | milliSeconds |
-| SPOP_P95_Latency | 0.047 | 33.343 | 0.8019090538336049 | milliSeconds |
-| SPOP_P99_Latency | 0.063 | 85.247 | 1.3729359706362153 | milliSeconds |
-| SPOP_Requests/Sec | 7800.62 | 1669333.38 | 706734.1855013502 | requests/second |
-| Throughput | 17241.1 | 17831817.36 | 420260.31174061438 | req/sec |
-| Throughput_1 | 7991.8 | 725154.18 | 121838.8537220757 | req/sec |
-| Throughput_2 | 7978.87 | 692205.02 | 125506.61857237639 | req/sec |
-| Throughput_3 | 7978.82 | 682122.49 | 226745.34571946169 | req/sec |
-| Throughput_4 | 7987.6 | 686825.72 | 222295.19148550728 | req/sec |
-| Throughput_5 | 7997.75 | 598232.21 | 365697.4250622406 | req/sec |
-| Throughput_6 | 8069.37 | 601568.91 | 361309.62545643156 | req/sec |
-| Throughput_7 | 7990.86 | 599252.78 | 359559.5156846473 | req/sec |
-| Throughput_8 | 7848.25 | 603902.39 | 355645.1763692946 | req/sec |
-| Throughput_9 | 7959.36 | 601072.71 | 366984.76313278006 | req/sec |
-| Throughput_10 | 8077.92 | 600753.97 | 359649.95155601666 | req/sec |
-| Throughput_11 | 11259.51 | 606504.23 | 371196.62074688795 | req/sec |
-| Throughput_12 | 12927.96 | 604422.16 | 366911.36591286308 | req/sec |
-| Throughput_13 | 15823.17 | 600497.42 | 370432.29354771788 | req/sec |
-| Throughput_14 | 9425.41 | 631362.58 | 367812.6839004149 | req/sec |
-| Throughput_15 | 7938.37 | 600614.93 | 365751.3786307054 | req/sec |
-| Throughput_16 | 8040.45 | 620613.9 | 364617.5147717842 | req/sec |
-| Throughput_17 | 24216.81 | 597151.65 | 521581.0625 | req/sec |
-| Throughput_18 | 14095.34 | 588297.44 | 503727.2914444444 | req/sec |
-| Throughput_19 | 40187.53 | 588862.04 | 510501.55233333338 | req/sec |
-| Throughput_20 | 7966.28 | 612374.9 | 516058.48594444445 | req/sec |
-| Throughput_21 | 7968.36 | 595201.63 | 507762.146 | req/sec |
-| Throughput_22 | 11257.82 | 585266.7 | 513529.0027777778 | req/sec |
-| Throughput_23 | 14063.64 | 606528.09 | 500516.64094444448 | req/sec |
-| Throughput_24 | 106473.13 | 586454.49 | 519954.47449999998 | req/sec |
-| Throughput_25 | 37818.15 | 601838.71 | 525582.0592222222 | req/sec |
-| Throughput_26 | 32977.5 | 596654.97 | 524031.9821111111 | req/sec |
-| Throughput_27 | 72817.5 | 599946.86 | 540320.1502777778 | req/sec |
-| Throughput_28 | 30742.39 | 603668.89 | 525381.3121111111 | req/sec |
-| Throughput_29 | 18079.89 | 594704.31 | 527886.6923333333 | req/sec |
-| Throughput_30 | 8059.06 | 598590.76 | 536338.2217777777 | req/sec |
-| Throughput_31 | 7862.62 | 604166.52 | 526071.3032222221 | req/sec |
-| Throughput_32 | 173970.91 | 612097.88 | 545605.0684444446 | req/sec |
-| ZADD_Average_Latency | 0.049 | 32.278 | 0.47239202691680268 | milliSeconds |
-| ZADD_Max_Latency | 0.095 | 76.287 | 2.975741027732463 | milliSeconds |
-| ZADD_Min_Latency | 0.032 | 19.952 | 0.07185685154975509 | milliSeconds |
-| ZADD_P50_Latency | 0.047 | 31.983 | 0.4249959216965742 | milliSeconds |
-| ZADD_P95_Latency | 0.063 | 41.695 | 0.948325856443719 | milliSeconds |
-| ZADD_P99_Latency | 0.079 | 55.935 | 1.5922194127243066 | milliSeconds |
-| ZADD_Requests/Sec | 7911.42 | 1112888.88 | 537931.0682534662 | requests/second |
-| ZPOPMIN_Average_Latency | 0.036 | 24.386 | 0.3803461969820555 | milliSeconds |
-| ZPOPMIN_Max_Latency | 0.079 | 109.695 | 2.6673927406199025 | milliSeconds |
-| ZPOPMIN_Min_Latency | 0.016 | 13.448 | 0.05634461663947769 | milliSeconds |
-| ZPOPMIN_P50_Latency | 0.039 | 31.935 | 0.33162479608482828 | milliSeconds |
-| ZPOPMIN_P95_Latency | 0.047 | 39.935 | 0.8215623980424145 | milliSeconds |
-| ZPOPMIN_P99_Latency | 0.063 | 86.527 | 1.403702691680261 | milliSeconds |
-| ZPOPMIN_Requests/Sec | 10461.41 | 1669333.38 | 700640.1472772221 | requests/second |
+|ToolName | ScenarioName | Metric Name | Example Value | Unit |
+|--------------|-------------------------|--------------|---------------|-------|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Throughput_Avg | 96143.676666666681| requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Throughput_Max |99310.66 | requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Throughput_Min |93126.7 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Throughput_Stdev| 1756.3137622699699| requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Throughput_P80 |98123.77 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Throughput_Sum |1153724.12 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Hits/sec_Avg |48070.774999999994 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Hits/sec_Max |49654.27 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Hits/sec_Min |46562.29 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Hits/sec_Stdev |878.156472669686 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Hits/sec_P80 |49060.82 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Hits/sec_Sum |576849.29999999993 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Misses/sec_Avg |0 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Misses/sec_Min |0 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Misses/sec_Max |0 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Misses/sec_Stdev| 0 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Misses/sec_P80 |0 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Misses/sec_Sum |0 | |
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-Avg_Avg |265.929245 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-Avg_Min |257.37339 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-Avg_Max |274.49494 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-Avg_Stdev| 4.8649509314371953 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-Avg_P80 |268.37573 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P50_Avg |258.4736666666667 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P50_Min |252.927 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P50_Max |266.239 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P50_Stdev| 3.9095334191634046| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P50_P80 |260.095 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P90_Min |331.775 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P90_Avg |337.74833333333333| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P90_P80 |339.967 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P90_Max |348.159 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P90_Stdev| 4.6894529413236388| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P95_Min |346.111 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P95_Avg |354.4736666666667 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P95_Max |364.543 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P95_Stdev| 4.6894529413236388| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P95_P80 |356.351 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99_Avg |385.36433333333338| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99_Min |376.831 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99_Max |397.311 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99_Stdev| 5.3427117542394855| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99_P80 |389.119 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99.9_Avg| 442.02566666666667| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99.9_Min| 411.647 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99.9_Max| 532.479 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99.9_Stdev |32.01080706400402| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Latency-P99.9_P80 |452.607 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Bandwidth_Avg |99831.145833333328| kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Bandwidth_Min |96698.49 | kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Bandwidth_Stdev |1823.6575402628735| kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Bandwidth_Max |103119.55 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1||Bandwidth_P80 |101887.18 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Throughput_Avg| 48070.774999999994| requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|Bandwidth_Sum |1197973.75 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Throughput_Min| 46562.29 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Throughput_Max| 49654.27 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Throughput_P80| 49060.82 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Throughput_Stdev| 878.156472669686 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Throughput_Sum |576849.29999999993 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Avg |265.9334425 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Min |257.37776 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_P80 |268.38027 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Max |274.49896 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-Avg_Stdev| 4.8649389483855519| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Avg |258.4736666666667 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Min |252.927 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Max |266.239 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Avg |337.74833333333333| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Stdev| 4.6894529413236388| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Min |331.775 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P90_Max |348.159 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P50_Stdev| 3.9095334191634046| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P50_P80 |260.095 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P90_P80 |339.967 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Avg |354.81500000000005| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Min |346.111 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Max |364.543 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P95_Stdev| 5.0252567430265076| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P95_P80 |356.351 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Avg |386.047 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Min |376.831 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Max |397.311 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99_Stdev| 5.3208600808515767| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99_P80 |391.167 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Avg| 442.87900000000008| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Min| 411.647 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Max| 532.479 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_Stdev| 31.706816932640848| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Latency-P99.9_P80 |454.655 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Avg |49797.129166666673| kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Stdev |909.68510072129129| kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Min |48234.48 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Max |51437.47 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Bandwidth_P80 |50822.73 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Throughput_Avg |48072.902499999989| requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|GET_Bandwidth_Sum |597565.55 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Throughput_Min |46564.42 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Throughput_Max |49656.39 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Throughput_P80 |49062.95 |requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Throughput_Stdev |878.15536932182385| requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Throughput_Sum |576874.82999999984| requests/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Avg |265.92504749999995| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Min |257.36902 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Max |274.49091 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_P80 |268.37118 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Avg |258.4736666666667| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-Avg_Stdev| 4.8649615272924267| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Min |252.927 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Max |266.239 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P50_P80 |260.095 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Avg |337.74833333333333| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P50_Stdev| 3.9095334191634046| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Min |331.775 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Max |348.159 |milli0seconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P90_Stdev| 4.6894529413236388| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P90_P80 |339.967 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Avg |354.30299999999994| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Min |346.111 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Max |364.543 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P95_Stdev| 4.8029857380591956| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P95_P80 |356.351 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Stdev| 5.1850095039021333| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Min |374.783 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Avg |384.85233333333332| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99_P80 |389.119 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99_Max |395.263 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Avg| 441.17233333333337| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Min| 409.599 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Max| 536.575 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_Stdev |33.438038432632723| milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Avg |50034.015833333331| kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Latency-P99.9_P80| 450.559 |milliseconds|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Min |48464.01 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Bandwidth_P80 |51064.45 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Stdev |913.97098802841549| kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Sum |600408.19 |kilobytes/sec|
+|Memtier-Redis |memtier_16t_16c_1kb_r1:1|SET_Bandwidth_Max |51682.07 |kilobytes/sec|
From 19164fcd8fc4c0b05468d29ca0829a36cf8e3983 Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Mon, 6 Nov 2023 21:20:07 +0530
Subject: [PATCH 5/7] resolving UTs
---
.../Redis/RedisExecutorTests.cs | 13 +------------
1 file changed, 1 insertion(+), 12 deletions(-)
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs b/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
index 7e6c913217..3c62dc36a0 100644
--- a/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
@@ -67,24 +67,13 @@ public void RedisExecutorThrowsOnUnsupportedDistroAsync()
}
}
- [Test]
- [TestCase(PlatformID.Unix, Architecture.X64)]
- public void RedisExecutorDoesnotThrowOnSupportedPLatform(PlatformID platform, Architecture architecture)
- {
- this.SetupDefaultMockBehavior(platform, architecture);
- using (TestRedisExecutorExecutor executor = new TestRedisExecutorExecutor(this.fixture.Dependencies, this.fixture.Parameters))
- {
- Exception exception = Assert.ThrowsAsync<Exception>(
- () => executor.ExecuteAsync(CancellationToken.None));
- }
- }
-
private void SetupDefaultMockBehavior(PlatformID platformID)
{
this.fixture.Setup(platformID);
this.fixture.File.Setup(f => f.Exists(It.IsAny<string>())).Returns(true);
this.fixture.ProcessManager.OnCreateProcess = (cmd, args, wd) => this.fixture.Process;
}
+
private void SetupDefaultMockBehavior(PlatformID platformID, Architecture architecture)
{
this.fixture.Setup(platformID, architecture);
From 55c86027a3607cea0b5ea3af36cddc516af6e7ce Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Thu, 9 Nov 2023 01:08:19 +0530
Subject: [PATCH 6/7] clean up code
---
.../Redis/RedisExecutorTests.cs | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs b/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
index 3c62dc36a0..0d46056cc0 100644
--- a/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Redis/RedisExecutorTests.cs
@@ -5,7 +5,6 @@ namespace VirtualClient.Actions
{
using System;
using System.Collections.Generic;
- using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
@@ -74,14 +73,6 @@ private void SetupDefaultMockBehavior(PlatformID platformID)
this.fixture.ProcessManager.OnCreateProcess = (cmd, args, wd) => this.fixture.Process;
}
- private void SetupDefaultMockBehavior(PlatformID platformID, Architecture architecture)
- {
- this.fixture.Setup(platformID, architecture);
- this.fixture.File.Setup(f => f.Exists(It.IsAny<string>())).Returns(true);
- this.fixture.ProcessManager.OnCreateProcess = (cmd, args, wd) => this.fixture.Process;
- }
-
-
private class TestRedisExecutorExecutor : RedisExecutor
{
public TestRedisExecutorExecutor(IServiceCollection dependencies, IDictionary<string, IConvertible> parameters = null)
From 7df089ec3beaed925b799e7aff8f21ebd00d336e Mon Sep 17 00:00:00 2001
From: nikhitha malkapuram <nmalkapuram@microsoft.com>
Date: Wed, 15 Nov 2023 10:13:31 +0530
Subject: [PATCH 7/7] updating Unit tests
---
.../Memtier/MemtierMetricsParserTests.cs | 185 +++++++++---------
1 file changed, 93 insertions(+), 92 deletions(-)
diff --git a/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs b/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
index 382d1d8582..b680ecdbf1 100644
--- a/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
+++ b/src/VirtualClient/VirtualClient.Actions.UnitTests/Memtier/MemtierMetricsParserTests.cs
@@ -20,25 +20,28 @@ public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrec
{
List<string> resultsList = new List<string>();
string results = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\MemcachedResults_1.txt"));
+ string results1 = File.ReadAllText(Path.Combine(MockFixture.ExamplesDirectory, @"Memtier\MemcachedResults_2.txt"));
resultsList.Add(results);
+ resultsList.Add(results1);
var parser = new MemtierMetricsParser(false, resultsList);
IList<Metric> metrics = parser.Parse();
Assert.AreEqual(138, metrics.Count);
- MetricAssert.Exists(metrics, "Throughput_Avg", 48271.29, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Throughput_Min", 48271.29, MetricUnit.RequestsPerSec);
+
+ MetricAssert.Exists(metrics, "Throughput_Avg", 48156.565, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Min", 48041.840000000004, MetricUnit.RequestsPerSec);
MetricAssert.Exists(metrics, "Throughput_Max", 48271.29, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Throughput_Stdev", 0, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Stdev", 114.72499999999854, MetricUnit.RequestsPerSec);
MetricAssert.Exists(metrics, "Throughput_P80", 48271.29, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Throughput_Sum", 48271.29, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "Throughput_Sum", 96313.13, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "Hits/sec_Avg", 43444.12);
- MetricAssert.Exists(metrics, "Hits/sec_Min", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Avg", 43340.87125);
+ MetricAssert.Exists(metrics, "Hits/sec_Min", 43237.6225);
MetricAssert.Exists(metrics, "Hits/sec_Max", 43444.12);
- MetricAssert.Exists(metrics, "Hits/sec_Stdev", 0);
+ MetricAssert.Exists(metrics, "Hits/sec_Stdev", 103.24875000000247);
MetricAssert.Exists(metrics, "Hits/sec_P80", 43444.12);
- MetricAssert.Exists(metrics, "Hits/sec_Sum", 43444.12);
+ MetricAssert.Exists(metrics, "Hits/sec_Sum", 86681.7425);
MetricAssert.Exists(metrics, "Misses/sec_Avg", 0);
MetricAssert.Exists(metrics, "Misses/sec_Min", 0);
@@ -47,102 +50,100 @@ public void MemtierMetricsParserParsesTheExpectedMetricsFromMemtierResultsCorrec
MetricAssert.Exists(metrics, "Misses/sec_P80", 0);
MetricAssert.Exists(metrics, "Misses/sec_Sum", 0);
- MetricAssert.Exists(metrics, "Latency-Avg_Avg", 2.62213, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Avg", 2.6292524999999998, MetricUnit.Milliseconds);
MetricAssert.Exists(metrics, "Latency-Avg_Min", 2.62213, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-Avg_Max", 2.62213, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-Avg_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-Avg_P80", 2.62213, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "Latency-P50_Avg", 2.75100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P50_Min", 2.75100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P50_Max", 2.75100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P50_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P50_P80", 2.75100, MetricUnit.Milliseconds);
-
-
- MetricAssert.Exists(metrics, "Latency-P90_Avg", 3.90300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P90_Min", 3.90300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P90_Max", 3.90300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P90_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P90_P80", 3.90300, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "Latency-P95_Avg", 4.41500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P95_Min", 4.41500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P95_Max", 4.41500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P95_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P95_P80", 4.41500, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Max", 2.636375, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_Stdev", 0.007122500000000143, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-Avg_P80", 2.636375, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P50_Avg", 2.7569999999999997, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Min", 2.751, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Max", 2.763, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_Stdev", 0.006000000000000005, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P50_P80", 2.763, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P90_Avg", 3.917, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Min", 3.903, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Max", 3.931, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_Stdev", 0.014000000000000012, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P90_P80", 3.931, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "Latency-P95_Avg", 4.427, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Min", 4.415, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Max", 4.439, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_Stdev", 0.01200000000000001, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P95_P80", 4.439, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99_Avg", 7.42300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99_Min", 7.42300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99_Max", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Avg", 7.423, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Min", 7.423, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_Max", 7.423, MetricUnit.Milliseconds);
MetricAssert.Exists(metrics, "Latency-P99_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99_P80", 7.42300, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99_P80", 7.423, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 29.31100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9_Min", 29.31100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9_Max", 29.31100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "Latency-P99.9_P80", 29.31100, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Avg", 29.294999999999998, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Min", 29.278999999999996, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Max", 29.311, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_Stdev", 0.01600000000000179, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "Latency-P99.9_P80", 29.311, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Throughput_Avg", 43444.12, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "GET_Throughput_Min", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Avg", 43340.87125, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Min", 43237.6225, MetricUnit.RequestsPerSec);
MetricAssert.Exists(metrics, "GET_Throughput_Max", 43444.12, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "GET_Throughput_Stdev", 0, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Stdev", 103.24875000000247, MetricUnit.RequestsPerSec);
MetricAssert.Exists(metrics, "GET_Throughput_P80", 43444.12, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "GET_Throughput_Sum", 43444.12, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "GET_Throughput_Sum", 86681.7425, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 3724.01, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "GET_Bandwidth_Min", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Avg", 3715.16, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Min", 3706.31, MetricUnit.KilobytesPerSecond);
MetricAssert.Exists(metrics, "GET_Bandwidth_Max", 3724.01, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "GET_Bandwidth_Stdev", 0, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Stdev", 8.850000000000136, MetricUnit.KilobytesPerSecond);
MetricAssert.Exists(metrics, "GET_Bandwidth_P80", 3724.01, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "GET_Bandwidth_Sum", 3724.01, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "GET_Bandwidth_Sum", 7430.32, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 2.61979, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Avg", 2.62682875, MetricUnit.Milliseconds);
MetricAssert.Exists(metrics, "GET_Latency-Avg_Min", 2.61979, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-Avg_Max", 2.61979, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-Avg_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-Avg_P80", 2.61979, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 2.73500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P50_Min", 2.73500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P50_Max", 2.73500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P50_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P50_P80", 2.73500, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 3.88700, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P90_Min", 3.88700, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P90_Max", 3.88700, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P90_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P90_P80", 3.88700, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 4.41500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P95_Min", 4.41500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P95_Max", 4.41500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P95_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P95_P80", 4.41500, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 7.42300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99_Min", 7.42300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99_Max", 7.42300, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99_P80", 7.42300, MetricUnit.Milliseconds);
-
- MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 29.31100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99.9_Min", 29.31100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99.9_Max", 29.31100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99.9_Stdev", 0, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "GET_Latency-P99.9_P80", 29.31100, MetricUnit.Milliseconds);
-
-
- MetricAssert.Exists(metrics, "SET_Throughput_Avg", 4827.17, MetricUnit.RequestsPerSec);
- MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 329.45, MetricUnit.KilobytesPerSecond);
- MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 2.64323, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 2.83100, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 3.93500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 4.47900, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 7.45500, MetricUnit.Milliseconds);
- MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 29.56700, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Max", 2.6338675, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_Stdev", 0.0070387499999999825, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-Avg_P80", 2.6338675, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Avg", 2.747, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Min", 2.735, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Max", 2.759, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_Stdev", 0.01200000000000001, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P50_P80", 2.759, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Avg", 3.903, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Min", 3.887, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Max", 3.919, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_Stdev", 0.016000000000000014, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P90_P80", 3.919, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Avg", 4.427, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Min", 4.415, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Max", 4.439, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_Stdev", 0.01200000000000001, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P95_P80", 4.439, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Avg", 7.419, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Min", 7.414999999999999, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Max", 7.423, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_Stdev", 0.004000000000000448, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99_P80", 7.423, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Avg", 29.262999999999998, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Min", 29.214999999999996, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Max", 29.311, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_Stdev", 0.04800000000000182, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "GET_Latency-P99.9_P80", 29.311, MetricUnit.Milliseconds);
+
+ MetricAssert.Exists(metrics, "SET_Throughput_Avg", 4815.69375, MetricUnit.RequestsPerSec);
+ MetricAssert.Exists(metrics, "SET_Bandwidth_Avg", 328.6675, MetricUnit.KilobytesPerSecond);
+ MetricAssert.Exists(metrics, "SET_Latency-Avg_Avg", 2.65108125, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P50_Avg", 2.831, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P90_Avg", 3.947, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P95_Avg", 4.487, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99_Avg", 7.503, MetricUnit.Milliseconds);
+ MetricAssert.Exists(metrics, "SET_Latency-P99.9_Avg", 29.583, MetricUnit.Milliseconds);
}
[Test]