Additional CLI parameters for ydb debug latency (#17672)

Author: eivanov89

ydb/apps/ydb/CHANGELOG.md

@@ -8,6 +8,8 @@
 * Fixed return code of command `ydb workload * run --check-canonical` for the case when benchmark query results differ from canonical ones.
 * Fixed scheme error in `ydb admin cluster dump` when specifying a domain database.
 * Fixed unauthorized error in `ydb admin database restore` when multiple database admins are in dump.
+* Added `--min-inflight` to `ydb debug latency` command.
+* Added support for multiple `-p` (percentile) params in `ydb debug latency` command.
 
 ## 2.20.0 ##
 

ydb/public/lib/ydb_cli/commands/ydb_latency.cpp

@@ -19,8 +19,9 @@ namespace {
 
 constexpr int DEFAULT_WARMUP_SECONDS = 1;
 constexpr int DEFAULT_INTERVAL_SECONDS = 5;
+constexpr int DEFAULT_MIN_INFLIGHT = 1;
 constexpr int DEFAULT_MAX_INFLIGHT = 128;
-constexpr int DEFAULT_PERCENTILE = 99.0;
+const std::vector<double> DEFAULT_PERCENTILES = {50.0, 90, 99.0};
 
 constexpr TCommandLatency::EFormat DEFAULT_FORMAT = TCommandLatency::EFormat::Plain;
 constexpr TCommandPing::EPingKind DEFAULT_RUN_KIND = TCommandPing::EPingKind::AllKinds;
@@ -36,9 +37,19 @@ using TRequestMaker = std::function<bool()>;
 using TCallableFactory = std::function<TRequestMaker()>;
 
 struct TResult {
+    TResult() = default;
+
+    TResult(TCommandPing::EPingKind kind, int threadCount, NHdr::THistogram&& hist, int throughput)
+        : Kind(kind)
+        , ThreadCount(threadCount)
+        , LatencyHistogramUs(std::move(hist))
+        , Throughput(throughput)
+    {
+    }
+
     TCommandPing::EPingKind Kind;
     int ThreadCount = 0;
-    int LatencyUs = 0;
+    NHdr::THistogram LatencyHistogramUs;
     int Throughput = 0;
 };
 
@@ -50,8 +61,6 @@ struct alignas(64) TEvaluateResult {
 
     ui64 OkCount = 0;
     ui64 ErrorCount = 0;
-    int LatencyUs = 0;
-
     NHdr::THistogram LatencyHistogramUs;
 };
 
@@ -60,8 +69,7 @@ void Evaluate(
     ui64 warmupSeconds,
     ui64 intervalSeconds,
     int threadCount,
-    TCallableFactory factory,
-    double percentile)
+    TCallableFactory factory)
 {
     std::atomic<bool> startMeasure{false};
     std::atomic<bool> stop{false};
@@ -133,19 +141,17 @@ void Evaluate(
         total.ErrorCount += result.ErrorCount;
         total.LatencyHistogramUs.Add(result.LatencyHistogramUs);
     }
-
-    total.LatencyUs = total.LatencyHistogramUs.GetValueAtPercentile(percentile);
 }
 
 } // anonymous
 
 TCommandLatency::TCommandLatency()
     : TYdbCommand("latency", {}, "Check basic latency with variable inflight")
     , IntervalSeconds(DEFAULT_INTERVAL_SECONDS)
+    , MinInflight(DEFAULT_MIN_INFLIGHT)
     , MaxInflight(DEFAULT_MAX_INFLIGHT)
     , Format(DEFAULT_FORMAT)
     , RunKind(DEFAULT_RUN_KIND)
-    , Percentile(DEFAULT_PERCENTILE)
     , ChainConfig(new NDebug::TActorChainPingSettings())
 {}
 
@@ -161,12 +167,15 @@ void TCommandLatency::Config(TConfig& config) {
     config.Opts->AddLongOption(
         'i', "interval", TStringBuilder() << "Seconds for each latency kind")
             .RequiredArgument("INT").StoreResult(&IntervalSeconds).DefaultValue(DEFAULT_INTERVAL_SECONDS);
+    config.Opts->AddLongOption(
+        "min-inflight", TStringBuilder() << "Min inflight")
+            .RequiredArgument("INT").StoreResult(&MinInflight).DefaultValue(DEFAULT_MIN_INFLIGHT);
     config.Opts->AddLongOption(
         'm', "max-inflight", TStringBuilder() << "Max inflight")
             .RequiredArgument("INT").StoreResult(&MaxInflight).DefaultValue(DEFAULT_MAX_INFLIGHT);
     config.Opts->AddLongOption(
         'p', "percentile", TStringBuilder() << "Latency percentile")
-            .RequiredArgument("DOUBLE").StoreResult(&Percentile).DefaultValue(DEFAULT_PERCENTILE);
+            .RequiredArgument("DOUBLE").AppendTo(&Percentiles);
     config.Opts->AddLongOption(
         'f', "format", TStringBuilder() << "Output format. Available options: " << availableFormats)
             .OptionalArgument("STRING").StoreResult(&Format).DefaultValue(DEFAULT_FORMAT);
@@ -188,6 +197,10 @@ void TCommandLatency::Config(TConfig& config) {
 
 void TCommandLatency::Parse(TConfig& config) {
     TClientCommand::Parse(config);
+
+    if (Percentiles.empty()) {
+        Percentiles = DEFAULT_PERCENTILES;
+    }
 }
 
 int TCommandLatency::Run(TConfig& config) {
@@ -272,9 +285,9 @@ int TCommandLatency::Run(TConfig& config) {
 
     std::vector<TResult> results;
     for (const auto& [taskKind, factory]: runTasks) {
-        for (int threadCount = 1; threadCount <= MaxInflight && !IsInterrupted(); ) {
+        for (int threadCount = MinInflight; threadCount <= MaxInflight && !IsInterrupted(); ) {
             TEvaluateResult result;
-            Evaluate(result, DEFAULT_WARMUP_SECONDS, IntervalSeconds, threadCount, factory, Percentile);
+            Evaluate(result, DEFAULT_WARMUP_SECONDS, IntervalSeconds, threadCount, factory);
 
             bool skip = false;
             if (result.ErrorCount) {
@@ -290,18 +303,20 @@ int TCommandLatency::Run(TConfig& config) {
             if (!skip) {
                 ui64 throughput = result.OkCount / IntervalSeconds;
                 ui64 throughputPerThread = throughput / threadCount;
-                ui64 latencyUsec = result.LatencyUs;
-
-                results.emplace_back(taskKind, threadCount, latencyUsec, throughput);
 
                 if (Format == EFormat::Plain) {
                     Cout << taskKind << " threads=" << threadCount
                         << ", throughput: " << throughput
-                        << ", per thread: " << throughputPerThread
-                        << ", latency p" << Percentile << " usec: " << latencyUsec
-                        << ", ok: " << result.OkCount
-                        << ", error: " << result.ErrorCount << Endl;
+                        << ", per thread: " << throughputPerThread;
+                    for (size_t i = 0; i < Percentiles.size(); ++i) {
+                        Cout << ", p" << Percentiles[i]
+                            << " usec: " << result.LatencyHistogramUs.GetValueAtPercentile(Percentiles[i]);
+                    }
+                    Cout << ", ok: " << result.OkCount << ", error: " << result.ErrorCount << Endl;
                 }
+
+                // note the move
+                results.emplace_back(taskKind, threadCount, std::move(result.LatencyHistogramUs), throughput);
             }
 
             if (threadCount < INCREMENT_UNTIL_THREAD_COUNT) {
@@ -316,18 +331,17 @@ int TCommandLatency::Run(TConfig& config) {
         return 0;
     }
 
-    TMap<TCommandPing::EPingKind, std::vector<int>> latencies;
+    TMap<TCommandPing::EPingKind, std::vector<const NHdr::THistogram*>> latencies;
     TMap<TCommandPing::EPingKind, std::vector<int>> throughputs;
     for (const auto& result: results) {
-        latencies[result.Kind].push_back(result.LatencyUs);
+        latencies[result.Kind].push_back(&result.LatencyHistogramUs);
         throughputs[result.Kind].push_back(result.Throughput);
     }
 
     if (Format == EFormat::CSV) {
         const int maxThreadsMeasured = results.back().ThreadCount;
 
         Cout << Endl;
-        Cout << "Latencies" << Endl;
 
         TStringStream ss;
         ss << "Kind";
@@ -342,17 +356,21 @@ int TCommandLatency::Run(TConfig& config) {
         ss << Endl;
         TString header = ss.Str();
 
-        Cout << header;
-        for (const auto& [kind, vec]: latencies) {
-            Cout << kind;
-            for (auto value: vec) {
-                Cout << "," << value;
+        for (auto percentile: Percentiles) {
+            Cout << "Latencies, p" << percentile << Endl;
+
+            Cout << header;
+            for (const auto& [kind, histVec]: latencies) {
+                Cout << kind;
+                for (const auto& hist: histVec) {
+                    Cout << "," << hist->GetValueAtPercentile(percentile);
+                }
+                Cout << Endl;
             }
             Cout << Endl;
         }
-        Cout << Endl;
 
-        Cout << "Througputs" << Endl;
+        Cout << "Throughputs" << Endl;
         Cout << header;
         for (const auto& [kind, vec]: throughputs) {
             Cout << kind;

ydb/public/lib/ydb_cli/commands/ydb_latency.h

@@ -38,10 +38,11 @@ class TCommandLatency
 
 private:
     int IntervalSeconds;
+    int MinInflight;
     int MaxInflight;
     EFormat Format;
     TCommandPing::EPingKind RunKind;
-    double Percentile;
+    std::vector<double> Percentiles;
 
     std::unique_ptr<NDebug::TActorChainPingSettings> ChainConfig;
 };