210 lines
10 KiB
C#
210 lines
10 KiB
C#
using System.Diagnostics;
|
|
using System.Net.Http.Headers;
|
|
using System.Net.Http.Json;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
|
|
// Генератор нагрузки для трека 1 (цена масштабирования). Замкнутый цикл: каждый из --clients потоков шлёт запрос,
|
|
// ждёт ответ и сразу шлёт следующий. Профиль: --write-ratio доля POST сообщения (уникальный Idempotency-Key),
|
|
// остальное — GET страницы истории (limit=50). У каждого пользователя свой чат с --history сообщений,
|
|
// поэтому записи разных клиентов не сериализуются на одной строке чата.
|
|
//
|
|
// Запуск (стенд поднят):
|
|
// dotnet run -c Release --project tools/ScaleLoad -- --url http://localhost:8081 --clients 64 --duration 20 \
|
|
// --label A-2x1.0 --output evidence/track1/results.jsonl
|
|
// Загрузка CPU контейнеров снимается `docker stats` во время измерения (если доступен docker CLI).
|
|
var o = ParseArguments(args);
|
|
string Get(string k, string d) => o.TryGetValue(k, out var v) ? v : d;
|
|
var url = Get("url", "http://localhost:8080");
|
|
var clients = int.Parse(Get("clients", "32"));
|
|
var users = int.Parse(Get("users", "32"));
|
|
var history = int.Parse(Get("history", "200"));
|
|
var duration = TimeSpan.FromSeconds(double.Parse(Get("duration", "20")));
|
|
var warmup = TimeSpan.FromSeconds(double.Parse(Get("warmup", "5")));
|
|
var writeRatio = double.Parse(Get("write-ratio", "0.2"), System.Globalization.CultureInfo.InvariantCulture);
|
|
var label = Get("label", "run");
|
|
var output = o.GetValueOrDefault("output");
|
|
var project = Get("compose-project", "messenger-lab3");
|
|
|
|
var handler = new SocketsHttpHandler { MaxConnectionsPerServer = clients * 2, PooledConnectionLifetime = TimeSpan.FromMinutes(5) };
|
|
using var http = new HttpClient(handler) { BaseAddress = new Uri(url), Timeout = TimeSpan.FromSeconds(30) };
|
|
|
|
Console.Error.WriteLine($"[1/4] prepare: {users} users, {history} messages per chat");
|
|
var actors = await Prepare(http, users, history);
|
|
|
|
Console.Error.WriteLine($"[2/4] warm-up {warmup.TotalSeconds}s, {clients} clients");
|
|
await Measure(http, actors, clients, warmup, writeRatio);
|
|
|
|
Console.Error.WriteLine($"[3/4] measure {duration.TotalSeconds}s");
|
|
using var statsCts = new CancellationTokenSource();
|
|
var statsTask = Task.Run(() => SampleDockerStats(project, statsCts.Token));
|
|
var r = await Measure(http, actors, clients, duration, writeRatio);
|
|
statsCts.Cancel();
|
|
var stats = await statsTask;
|
|
|
|
Console.Error.WriteLine("[4/4] results");
|
|
var lat = r.Latencies.OrderBy(x => x).ToArray();
|
|
double P(double p) => lat.Length == 0 ? double.NaN : Math.Round(lat[Math.Max(0, (int)Math.Ceiling(p * lat.Length) - 1)], 2);
|
|
var report = new Dictionary<string, object?>
|
|
{
|
|
["label"] = label,
|
|
["timestamp"] = DateTimeOffset.UtcNow.ToString("O"),
|
|
["clients"] = clients, ["users"] = users, ["history"] = history, ["write_ratio"] = writeRatio,
|
|
["duration_s"] = Math.Round(r.Elapsed, 2),
|
|
["ok"] = lat.Length, ["errors"] = r.Errors, ["ok_get"] = r.OkGet, ["ok_post"] = r.OkPost,
|
|
["rps"] = Math.Round(lat.Length / r.Elapsed, 1),
|
|
["p50_ms"] = P(0.50), ["p95_ms"] = P(0.95), ["p99_ms"] = P(0.99),
|
|
["cpu_pct"] = stats,
|
|
};
|
|
var line = JsonSerializer.Serialize(report);
|
|
Console.WriteLine(line);
|
|
if (output is not null)
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output))!);
|
|
File.AppendAllText(output, line + Environment.NewLine);
|
|
}
|
|
return r.Errors == 0 ? 0 : 1;
|
|
|
|
static async Task<Actor[]> Prepare(HttpClient http, int users, int history)
|
|
{
|
|
var result = new Actor[users];
|
|
await Parallel.ForEachAsync(Enumerable.Range(0, users), new ParallelOptions { MaxDegreeOfParallelism = 4 }, async (i, ct) =>
|
|
{
|
|
var username = "sl" + Guid.NewGuid().ToString("N")[..14];
|
|
var password = "Load-" + Guid.NewGuid().ToString("N");
|
|
using var reg = await http.PostAsJsonAsync("/api/v1/users", new { username, display_name = "Load", password }, ct);
|
|
reg.EnsureSuccessStatusCode();
|
|
var me = (await reg.Content.ReadFromJsonAsync<JsonElement>(ct)).GetProperty("id").GetGuid();
|
|
using var login = new HttpRequestMessage(HttpMethod.Post, "/api/v1/auth/sessions");
|
|
login.Headers.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}")));
|
|
using var loginResponse = await http.SendAsync(login, ct);
|
|
loginResponse.EnsureSuccessStatusCode();
|
|
var token = (await loginResponse.Content.ReadFromJsonAsync<JsonElement>(ct)).GetProperty("token").GetString()!;
|
|
using var chatRequest = Authorized(HttpMethod.Post, "/api/v1/chats", token);
|
|
chatRequest.Content = JsonContent.Create(new { title = "Load", member_ids = new[] { me } });
|
|
using var chatResponse = await http.SendAsync(chatRequest, ct);
|
|
chatResponse.EnsureSuccessStatusCode();
|
|
var chatId = (await chatResponse.Content.ReadFromJsonAsync<JsonElement>(ct)).GetProperty("id").GetGuid();
|
|
for (var m = 0; m < history; m++)
|
|
{
|
|
using var post = PostMessage(chatId, token, $"history {m}");
|
|
using var response = await http.SendAsync(post, ct);
|
|
response.EnsureSuccessStatusCode();
|
|
}
|
|
result[i] = new Actor(token, chatId);
|
|
});
|
|
return result;
|
|
}
|
|
|
|
static HttpRequestMessage Authorized(HttpMethod method, string path, string token)
|
|
{
|
|
var request = new HttpRequestMessage(method, path);
|
|
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
|
|
return request;
|
|
}
|
|
|
|
static HttpRequestMessage PostMessage(Guid chatId, string token, string text)
|
|
{
|
|
var request = Authorized(HttpMethod.Post, $"/api/v1/chats/{chatId}/messages", token);
|
|
request.Headers.Add("Idempotency-Key", Guid.NewGuid().ToString("N"));
|
|
request.Content = JsonContent.Create(new { text });
|
|
return request;
|
|
}
|
|
|
|
static async Task<Result> Measure(HttpClient http, Actor[] actors, int clients, TimeSpan duration, double writeRatio)
|
|
{
|
|
var started = Stopwatch.GetTimestamp();
|
|
var deadline = started + (long)(duration.TotalSeconds * Stopwatch.Frequency);
|
|
var workers = Enumerable.Range(0, clients).Select(i => Task.Run(async () =>
|
|
{
|
|
var actor = actors[i % actors.Length];
|
|
var rnd = new Random(i * 7919 + Environment.TickCount);
|
|
var latencies = new List<double>();
|
|
int errors = 0, okGet = 0, okPost = 0;
|
|
while (Stopwatch.GetTimestamp() < deadline)
|
|
{
|
|
var write = rnd.NextDouble() < writeRatio;
|
|
var t = Stopwatch.GetTimestamp();
|
|
try
|
|
{
|
|
using var request = write
|
|
? PostMessage(actor.ChatId, actor.Token, "load " + Guid.NewGuid().ToString("N"))
|
|
: Authorized(HttpMethod.Get, $"/api/v1/chats/{actor.ChatId}/messages?limit=50", actor.Token);
|
|
using var response = await http.SendAsync(request);
|
|
await response.Content.ReadAsByteArrayAsync();
|
|
if (response.IsSuccessStatusCode)
|
|
{
|
|
latencies.Add(Stopwatch.GetElapsedTime(t).TotalMilliseconds);
|
|
if (write) okPost++; else okGet++;
|
|
}
|
|
else
|
|
{
|
|
errors++;
|
|
}
|
|
}
|
|
catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
|
|
{
|
|
errors++;
|
|
}
|
|
}
|
|
|
|
return (latencies, errors, okGet, okPost);
|
|
})).ToArray();
|
|
|
|
var results = await Task.WhenAll(workers);
|
|
return new Result(
|
|
results.SelectMany(x => x.latencies).ToList(), results.Sum(x => x.errors),
|
|
results.Sum(x => x.okGet), results.Sum(x => x.okPost), Stopwatch.GetElapsedTime(started).TotalSeconds);
|
|
}
|
|
|
|
// Средняя загрузка CPU (в % одного ядра, как в docker stats) по роли контейнера за время измерения.
|
|
static async Task<Dictionary<string, double>> SampleDockerStats(string project, CancellationToken ct)
|
|
{
|
|
var sums = new Dictionary<string, (double Sum, int N)>();
|
|
try
|
|
{
|
|
while (!ct.IsCancellationRequested)
|
|
{
|
|
var info = new ProcessStartInfo("docker", ["stats", "--no-stream", "--format", "{{.Name}} {{.CPUPerc}}"])
|
|
{ RedirectStandardOutput = true, RedirectStandardError = true };
|
|
using var p = Process.Start(info)!;
|
|
var text = await p.StandardOutput.ReadToEndAsync(ct);
|
|
await p.WaitForExitAsync(ct);
|
|
// Внутри одного снимка суммируем реплики одной роли, затем усредняем снимки.
|
|
var snapshot = new Dictionary<string, double>();
|
|
foreach (var line in text.Split('\n', StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
var parts = line.Trim().Split(' ');
|
|
if (parts.Length < 2 || !parts[0].StartsWith(project + "-")) continue;
|
|
var role = parts[0][(project.Length + 1)..];
|
|
role = role[..role.LastIndexOf('-')];
|
|
if (!double.TryParse(parts[1].TrimEnd('%'), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var cpu)) continue;
|
|
snapshot[role] = snapshot.GetValueOrDefault(role) + cpu;
|
|
}
|
|
|
|
foreach (var (role, cpu) in snapshot)
|
|
{
|
|
var (sum, n) = sums.GetValueOrDefault(role);
|
|
sums[role] = (sum + cpu, n + 1);
|
|
}
|
|
}
|
|
}
|
|
catch (OperationCanceledException) { }
|
|
catch (Exception) { }
|
|
return sums.ToDictionary(kv => kv.Key, kv => Math.Round(kv.Value.Sum / Math.Max(1, kv.Value.N), 1));
|
|
}
|
|
|
|
static Dictionary<string, string> ParseArguments(string[] args)
|
|
{
|
|
var result = new Dictionary<string, string>();
|
|
for (var i = 0; i < args.Length; i++)
|
|
{
|
|
if (!args[i].StartsWith("--") || i + 1 >= args.Length) throw new ArgumentException($"Bad argument: {args[i]}");
|
|
result[args[i][2..]] = args[++i];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal sealed record Actor(string Token, Guid ChatId);
|
|
internal sealed record Result(List<double> Latencies, int Errors, int OkGet, int OkPost, double Elapsed);
|