Diagnóstico e Perfilamento - Aula Prática

Exemplo 1 — Benchmark com BenchmarkDotNet

Na aula de Performance comparamos concatenação de string com StringBuilder usando Stopwatch. O problema: uma única medição sofre com "ruído" (JIT, GC, outros programas abertos). O BenchmarkDotNet resolve isso: ele aquece o código, executa muitas vezes e entrega estatísticas confiáveis de tempo e memória.

using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkRunner.Run<TesteTexto>();

[MemoryDiagnoser]   // mostra também a memória alocada
[ShortRunJob]       // execução mais curta, boa para sala de aula
public class TesteTexto
{
    [Params(10, 1000)]  // roda cada método com N = 10 e N = 1000
    public int N;

    [Benchmark(Baseline = true)]
    public string Concatenando()
    {
        string texto = "";
        for (int i = 0; i < N; i++)
            texto += i;
        return texto;
    }

    [Benchmark]
    public string ComStringBuilder()
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++)
            sb.Append(i);
        return sb.ToString();
    }
}

Rode em modo Release (o BenchmarkDotNet se recusa a medir código em modo Debug):

dotnet run -c Release

Desafios:

• Com N = 10, a diferença entre os dois métodos é grande? E com N = 1000?
• Compare a coluna Allocated dos dois métodos com N = 1000. Por que a concatenação aloca tanto?
• Adicione um terceiro método com [Benchmark] usando new StringBuilder(N * 4) (capacidade inicial). Ele aloca menos?

Exemplo 2 — Por que a média engana: p95 e p99

Em sistemas reais, a maioria das requisições é rápida, mas algumas são muito lentas. A média esconde essas requisições lentas. Por isso usamos percentis:

• p50 (mediana) — metade das requisições foi mais rápida que esse valor.
• p95 — 95% foram mais rápidas; só 5% demoraram mais (de cada 100 usuários, 5 esperaram mais que isso).
• p99 — 99% foram mais rápidas; mostra a "cauda" de lentidão (1 em cada 100).

O código abaixo simula 1000 latências: 97% entre 20 e 40 ms e 3% bem lentas (300 a 800 ms). A meta do sistema é p95 ≤ 100 ms e p99 ≤ 300 ms.

Random rnd = new Random(42);   // semente fixa: todos veem os mesmos números
List<double> latencias = new List<double>();

for (int i = 0; i < 1000; i++)
{
    if (rnd.Next(100) < 3)                      // 3% das requisições são lentas
        latencias.Add(rnd.Next(300, 800));
    else
        latencias.Add(rnd.Next(20, 40));
}

double Percentil(List<double> valores, double p)
{
    List<double> ordenados = valores.OrderBy(v => v).ToList();
    int posicao = (int)Math.Ceiling(p / 100 * ordenados.Count) - 1;
    return ordenados[Math.Max(posicao, 0)];
}

double p95 = Percentil(latencias, 95);
double p99 = Percentil(latencias, 99);

Console.WriteLine($"Média: {latencias.Average():F1} ms");
Console.WriteLine($"p50:   {Percentil(latencias, 50)} ms");
Console.WriteLine($"p95:   {p95} ms  -> meta 100 ms: {(p95 <= 100 ? "OK" : "FALHOU")}");
Console.WriteLine($"p99:   {p99} ms  -> meta 300 ms: {(p99 <= 300 ? "OK" : "FALHOU")}");
Console.WriteLine($"Máx:   {latencias.Max()} ms");

dotnet run

Desafios:

• A média parece boa? Ela mostra que existem usuários esperando mais de meio segundo?
• Troque < 3 por < 6 (6% de requisições lentas). O que acontece com o p95? E com a média?
• Troque para < 1. As duas metas são cumpridas?

Exemplo 3 — Teste de carga

Um teste de carga simula vários usuários usando o sistema ao mesmo tempo e mede a latência de cada requisição. Aqui o "servidor" é simulado: ele atende 4 requisições por vez (um SemaphoreSlim(4), como na aula de Concorrência) e cada atendimento leva cerca de 50 ms. Cada usuário faz 10 requisições, uma após a outra.

using System.Diagnostics;

SemaphoreSlim servidor = new SemaphoreSlim(4);   // o servidor atende 4 por vez
List<double> latencias = new List<double>();

async Task RequisicaoAsync()
{
    Stopwatch relogio = Stopwatch.StartNew();
    await servidor.WaitAsync();                  // espera vaga (fila)
    try
    {
        await Task.Delay(50);                    // simula o processamento
    }
    finally
    {
        servidor.Release();
    }
    lock (latencias)                             // lista compartilhada: protege com lock
    {
        latencias.Add(relogio.Elapsed.TotalMilliseconds);   // latência = fila + processamento
    }
}

async Task UsuarioAsync()
{
    for (int i = 0; i < 10; i++)
        await RequisicaoAsync();
}

double Percentil(List<double> valores, double p)
{
    List<double> ordenados = valores.OrderBy(v => v).ToList();
    int posicao = (int)Math.Ceiling(p / 100 * ordenados.Count) - 1;
    return ordenados[Math.Max(posicao, 0)];
}

foreach (int usuarios in new[] { 1, 4, 10, 40 })
{
    latencias.Clear();
    Stopwatch total = Stopwatch.StartNew();

    List<Task> tarefas = new List<Task>();
    for (int u = 0; u < usuarios; u++)
        tarefas.Add(UsuarioAsync());
    await Task.WhenAll(tarefas);

    double vazao = latencias.Count / total.Elapsed.TotalSeconds;
    double p95 = Percentil(latencias, 95);
    Console.WriteLine($"{usuarios,3} usuários | {vazao,5:F0} req/s | " +
                      $"p50 {Percentil(latencias, 50),4:F0} ms | p95 {p95,4:F0} ms | " +
                      $"p99 {Percentil(latencias, 99),4:F0} ms | meta p95 ≤ 200 ms: {(p95 <= 200 ? "OK" : "FALHOU")}");
}

dotnet run

Desafios:

• A partir de quantos usuários a vazão para de crescer? O que acontece com o p95 a partir daí?
• Descubra (testando outros valores no new[] { ... }) o maior número de usuários que ainda cumpre a meta de p95 ≤ 200 ms.
• Mude o servidor para SemaphoreSlim(8). Quantos usuários ele aguenta agora dentro da meta?
• Mude o processamento para Task.Delay(25) (como se tivéssemos otimizado o código). Qual mudança teve mais efeito: dobrar o servidor ou deixar o código 2× mais rápido?