mirror of
https://github.com/esiur/esiur-dotnet.git
synced 2026-06-13 14:38:43 +00:00
new tests
This commit is contained in:
@@ -0,0 +1,14 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\..\..\Libraries\Esiur\Esiur.csproj" OutputItemType="Analyzer"/>
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,278 @@
|
||||
// ============================================================
|
||||
// Scalability Extension: Concurrent Attach Sweep
|
||||
// ------------------------------------------------------------
|
||||
// Extends Tests/Distribution/ConcurrentAttach with:
|
||||
// - Sweep over a wider range of concurrent request counts A.
|
||||
// - More rounds per A for confidence-interval reporting.
|
||||
// - Auto-stop when timeouts or failures appear (the
|
||||
// saturation signal for concurrent attach is different
|
||||
// from fan-out: it's *correctness* failure, not slowdown).
|
||||
// - Unified CSV output suitable for direct plotting.
|
||||
//
|
||||
// Server: re-use the existing
|
||||
// Tests/Distribution/ConcurrentAttach with --mode server.
|
||||
// Or run this binary with --mode both.
|
||||
// ------------------------------------------------------------
|
||||
// Usage:
|
||||
// dotnet run -- --mode both --resources 200 \
|
||||
// --a-values 10,25,50,100,250,500,1000,2000 \
|
||||
// --rounds 10 --timeout 10000
|
||||
// ============================================================
|
||||
|
||||
using Esiur.Protocol;
|
||||
using Esiur.Resource;
|
||||
using Esiur.Stores;
|
||||
using Esiur.Tests.ConcurrentAttachSweep;
|
||||
using System.Data.Common;
|
||||
using System.Diagnostics;
|
||||
using System.Globalization;
|
||||
|
||||
var mode = GetArg(args, "--mode", "both");
|
||||
var host = GetArg(args, "--host", "127.0.0.1");
|
||||
var port = int.Parse(GetArg(args, "--port", "10902"));
|
||||
var resources = int.Parse(GetArg(args, "--resources", "200"));
|
||||
var timeoutMs = int.Parse(GetArg(args, "--timeout", "10000"));
|
||||
var rounds = int.Parse(GetArg(args, "--rounds", "10"));
|
||||
var aValStr = GetArg(args, "--a-values", "10,25,50,100,250,500,1000,2000");
|
||||
var outCsv = GetArg(args, "--output", "concurrent_attach_sweep.csv");
|
||||
var aValues = aValStr.Split(',').Select(int.Parse).ToArray();
|
||||
|
||||
var serverWh = new Warehouse();
|
||||
var clientWh = new Warehouse();
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
// SERVER SIDE
|
||||
// ----------------------------------------------------------------
|
||||
if (mode == "server" || mode == "both")
|
||||
{
|
||||
await serverWh.Put("sys", new MemoryStore());
|
||||
await serverWh.Put("sys/server", new EpServer() { Port = (ushort)port });
|
||||
|
||||
for (int i = 0; i < resources; i++)
|
||||
{
|
||||
await serverWh.Put($"sys/sensor_{i}", new SensorResource { SensorId = i, Value = i });
|
||||
}
|
||||
|
||||
await serverWh.Open();
|
||||
Console.WriteLine($"[Server-T3+] Ready: {resources} resources on port {port}");
|
||||
|
||||
if (mode == "server")
|
||||
{
|
||||
Console.WriteLine("Press ENTER to stop.");
|
||||
Console.ReadLine();
|
||||
await serverWh.Close();
|
||||
return;
|
||||
}
|
||||
|
||||
await Task.Delay(500);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
// CLIENT SIDE: sweep over A values
|
||||
// ----------------------------------------------------------------
|
||||
Console.WriteLine($"[Client-T3+] resources={resources} timeout={timeoutMs}ms rounds={rounds}");
|
||||
Console.WriteLine($"[Client-T3+] A values: {string.Join(",", aValues)}");
|
||||
|
||||
var summary = new List<ASummary>();
|
||||
bool failureDetected = false;
|
||||
|
||||
foreach (int A in aValues)
|
||||
{
|
||||
if (failureDetected)
|
||||
{
|
||||
Console.WriteLine($"\n[Client-T3+] A={A}: SKIPPED (failure at lower A)");
|
||||
continue;
|
||||
}
|
||||
|
||||
Console.WriteLine($"\n[Client-T3+] === A={A} ===");
|
||||
var roundResults = new List<RoundResult>();
|
||||
|
||||
for (int round = 0; round < rounds; round++)
|
||||
{
|
||||
var rng = new Random(round * 1000 + A);
|
||||
var targets = Enumerable.Range(0, A)
|
||||
.Select(_ => rng.Next(resources))
|
||||
.ToArray();
|
||||
|
||||
long succeeded = 0, failed = 0, timedOut = 0;
|
||||
var latencies = new double[A];
|
||||
var roundSw = Stopwatch.StartNew();
|
||||
|
||||
// One shared connection per round, matching the existing test methodology
|
||||
var connection = await clientWh.Get<EpConnection>($"ep://{host}:{port}");
|
||||
|
||||
var tasks = targets.Select((resourceIdx, taskIdx) => Task.Run(async () =>
|
||||
{
|
||||
var sw = Stopwatch.StartNew();
|
||||
using var cts = new CancellationTokenSource(timeoutMs);
|
||||
try
|
||||
{
|
||||
var proxy = await connection.Get($"sys/sensor_{resourceIdx}");
|
||||
sw.Stop();
|
||||
latencies[taskIdx] = sw.Elapsed.TotalMilliseconds;
|
||||
if (proxy != null) Interlocked.Increment(ref succeeded);
|
||||
else Interlocked.Increment(ref failed);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
sw.Stop();
|
||||
latencies[taskIdx] = timeoutMs;
|
||||
Interlocked.Increment(ref timedOut);
|
||||
}
|
||||
catch
|
||||
{
|
||||
sw.Stop();
|
||||
latencies[taskIdx] = sw.Elapsed.TotalMilliseconds;
|
||||
Interlocked.Increment(ref failed);
|
||||
}
|
||||
})).ToArray();
|
||||
|
||||
await Task.WhenAll(tasks);
|
||||
roundSw.Stop();
|
||||
|
||||
var sorted = latencies.OrderBy(x => x).ToArray();
|
||||
int n = sorted.Length;
|
||||
|
||||
var rr = new RoundResult
|
||||
{
|
||||
Round = round + 1,
|
||||
A = A,
|
||||
Succeeded = succeeded,
|
||||
Failed = failed,
|
||||
TimedOut = timedOut,
|
||||
WallMs = roundSw.Elapsed.TotalMilliseconds,
|
||||
P50 = sorted[Math.Min(n - 1, (int)(n * 0.50))],
|
||||
P95 = sorted[Math.Min(n - 1, (int)(n * 0.95))],
|
||||
P99 = sorted[Math.Min(n - 1, (int)(n * 0.99))],
|
||||
Max = sorted[n - 1],
|
||||
};
|
||||
roundResults.Add(rr);
|
||||
|
||||
Console.WriteLine($" round {round + 1}/{rounds}: ok={succeeded}/{A} fail={failed} "
|
||||
+ $"timeout={timedOut} wall={rr.WallMs:F0}ms p50={rr.P50:F0} p99={rr.P99:F0}");
|
||||
|
||||
// Round 1 of each A is conventionally excluded from latency
|
||||
// aggregation due to connection-establishment overhead (matches
|
||||
// the existing test methodology).
|
||||
|
||||
GC.Collect();
|
||||
await Task.Delay(500);
|
||||
}
|
||||
|
||||
var steady = roundResults.Skip(1).ToList(); // exclude round 1
|
||||
if (steady.Count == 0) steady = roundResults;
|
||||
|
||||
var anyFailure = roundResults.Any(r => r.Failed > 0 || r.TimedOut > 0);
|
||||
|
||||
var s = new ASummary
|
||||
{
|
||||
A = A,
|
||||
Rounds = roundResults.Count,
|
||||
AnyFailures = anyFailure,
|
||||
TotalSucceeded = roundResults.Sum(r => r.Succeeded),
|
||||
TotalFailed = roundResults.Sum(r => r.Failed),
|
||||
TotalTimedOut = roundResults.Sum(r => r.TimedOut),
|
||||
MeanP50 = steady.Average(r => r.P50),
|
||||
Ci95P50 = ConfidenceIntervalHalfWidth95(steady.Select(r => r.P50).ToArray()),
|
||||
MeanP99 = steady.Average(r => r.P99),
|
||||
Ci95P99 = ConfidenceIntervalHalfWidth95(steady.Select(r => r.P99).ToArray()),
|
||||
MeanWall = steady.Average(r => r.WallMs),
|
||||
Ci95Wall = ConfidenceIntervalHalfWidth95(steady.Select(r => r.WallMs).ToArray()),
|
||||
};
|
||||
summary.Add(s);
|
||||
|
||||
Console.WriteLine($" [A={A}] SUMMARY: "
|
||||
+ $"p50={s.MeanP50:F1}±{s.Ci95P50:F1} "
|
||||
+ $"p99={s.MeanP99:F1}±{s.Ci95P99:F1} "
|
||||
+ $"wall={s.MeanWall:F0}±{s.Ci95Wall:F0}ms "
|
||||
+ $"failures={s.TotalFailed + s.TotalTimedOut}/{s.TotalSucceeded + s.TotalFailed + s.TotalTimedOut}");
|
||||
|
||||
if (anyFailure)
|
||||
{
|
||||
Console.WriteLine($" [A={A}] *** FAILURE DETECTED: stopping sweep ***");
|
||||
failureDetected = true;
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
// CSV output
|
||||
// ----------------------------------------------------------------
|
||||
var sb = new System.Text.StringBuilder();
|
||||
sb.AppendLine("a,rounds,any_failures,total_succeeded,total_failed,total_timed_out," +
|
||||
"mean_p50_ms,ci95_p50,mean_p99_ms,ci95_p99,mean_wall_ms,ci95_wall");
|
||||
foreach (var r in summary)
|
||||
{
|
||||
sb.AppendLine(string.Create(CultureInfo.InvariantCulture,
|
||||
$"{r.A},{r.Rounds},{r.AnyFailures},{r.TotalSucceeded},{r.TotalFailed},{r.TotalTimedOut}," +
|
||||
$"{r.MeanP50:F2},{r.Ci95P50:F2},{r.MeanP99:F2},{r.Ci95P99:F2}," +
|
||||
$"{r.MeanWall:F2},{r.Ci95Wall:F2}"));
|
||||
}
|
||||
await File.WriteAllTextAsync(outCsv, sb.ToString());
|
||||
Console.WriteLine($"\n[Client-T3+] Results written to {outCsv}");
|
||||
|
||||
if (mode == "server" || mode == "both") await serverWh.Close();
|
||||
if (mode == "client" || mode == "both") await clientWh.Close();
|
||||
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
// Helpers
|
||||
// ----------------------------------------------------------------
|
||||
static double ConfidenceIntervalHalfWidth95(double[] xs)
|
||||
{
|
||||
int n = xs.Length;
|
||||
if (n < 2) return 0;
|
||||
double mean = xs.Average();
|
||||
double sumSq = xs.Sum(x => (x - mean) * (x - mean));
|
||||
double std = Math.Sqrt(sumSq / (n - 1));
|
||||
double sem = std / Math.Sqrt(n);
|
||||
double t = (n - 1) switch
|
||||
{
|
||||
1 => 12.706,
|
||||
2 => 4.303,
|
||||
3 => 3.182,
|
||||
4 => 2.776,
|
||||
5 => 2.571,
|
||||
6 => 2.447,
|
||||
7 => 2.365,
|
||||
8 => 2.306,
|
||||
9 => 2.262,
|
||||
_ => 1.960
|
||||
};
|
||||
return t * sem;
|
||||
}
|
||||
|
||||
static string GetArg(string[] args, string key, string def)
|
||||
{
|
||||
int i = Array.IndexOf(args, key);
|
||||
return (i >= 0 && i + 1 < args.Length) ? args[i + 1] : def;
|
||||
}
|
||||
|
||||
record RoundResult
|
||||
{
|
||||
public int Round;
|
||||
public int A;
|
||||
public long Succeeded;
|
||||
public long Failed;
|
||||
public long TimedOut;
|
||||
public double WallMs;
|
||||
public double P50;
|
||||
public double P95;
|
||||
public double P99;
|
||||
public double Max;
|
||||
}
|
||||
|
||||
record ASummary
|
||||
{
|
||||
public int A;
|
||||
public int Rounds;
|
||||
public bool AnyFailures;
|
||||
public long TotalSucceeded;
|
||||
public long TotalFailed;
|
||||
public long TotalTimedOut;
|
||||
public double MeanP50;
|
||||
public double Ci95P50;
|
||||
public double MeanP99;
|
||||
public double Ci95P99;
|
||||
public double MeanWall;
|
||||
public double Ci95Wall;
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace Esiur.Tests.ConcurrentAttachSweep;
|
||||
|
||||
using Esiur.Resource;
|
||||
|
||||
[Resource]
|
||||
public partial class SensorResource : Resource
|
||||
{
|
||||
public int SensorId { get; set; }
|
||||
|
||||
[Export]
|
||||
public double value;
|
||||
}
|
||||
Reference in New Issue
Block a user