0Pricing
C# Academy · Lección

Compromisos entre throughput y latencia

Equilibre el trabajo total por segundo (throughput) frente al tiempo por elemento (latencia): compare el procesamiento individual, el procesamiento por lotes y el ajuste del grado de paralelismo.

Compromisos entre throughput y latencia es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Rendimiento frente a latencia

Definiciones:

  • Rendimiento: elementos por segundo
  • Latencia: tiempo necesario para finalizar un elemento
  • Compromiso: el procesamiento por lotes y un mayor paralelismo pueden aumentar el rendimiento, pero retrasar los elementos individuales

Procesamiento por elemento

Procesar cada elemento a medida que llega: espera mínima por elemento, pero la sobrecarga se repite para cada uno.

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  // Simulate small per-item cost
  static void HandleItem(int x)
  {
    // Fixed overhead per item
    Thread.SpinWait(20000); // tiny CPU work
  }

  public static void Main(string[] args)
  {
    int n = 200;
    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < n; i++)
    {
      HandleItem(i);         // process immediately (no batching)
      // emit result right away (low latency style)
    }
    sw.Stop();
    Console.WriteLine("Per-item style: {0} ms for {1} items", sw.ElapsedMilliseconds, n);
  }
}

Procesamiento por lotes

El procesamiento por lotes reduce la sobrecarga repetida y aumenta el rendimiento, pero los primeros elementos esperan a que el lote se complete (mayor latencia).

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

public class Program
{
  static void ProcessBatch(List<int> batch)
  {
    // Amortize overhead across the whole batch
    Thread.SpinWait(20000);        // one-time overhead
    for (int i = 0; i < batch.Count; i++)
    {
      // small per-record work
      int val = batch[i] * 2;
      if (val == int.MinValue) { } // keep compiler from dropping work
    }
  }

  public static void Main(string[] args)
  {
    int n = 200;
    int batchSize = 20;
    List<int> current = new List<int>(batchSize);

    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < n; i++)
    {
      current.Add(i);
      if (current.Count == batchSize)
      {
        ProcessBatch(current);
        current.Clear(); // emit results after the batch finishes
      }
    }
    if (current.Count > 0) ProcessBatch(current);
    sw.Stop();

    Console.WriteLine("Batch style: {0} ms for {1} items (batch={2})", sw.ElapsedMilliseconds, n, batchSize);
  }
}

Ajuste del paralelismo

Ajustar MaxDegreeOfParallelism puede aumentar el rendimiento en trabajos limitados por la CPU; un valor demasiado alto puede perjudicarlo debido a los cambios de contexto.

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  static void Work(int x)
  {
    // CPU-bound unit
    Thread.SpinWait(40000);
  }

  public static void Main(string[] args)
  {
    int[] data = new int[200];
    for (int i = 0; i < data.Length; i++) data[i] = i;

    foreach (int dop in new int[] { 1, 2, 4 })
    {
      var opt = new ParallelOptions();
      opt.MaxDegreeOfParallelism = dop;

      Stopwatch sw = Stopwatch.StartNew();
      Parallel.ForEach(data, opt, Work);
      sw.Stop();

      Console.WriteLine("DOP={0} -> {1} ms", dop, sw.ElapsedMilliseconds);
    }
  }
}

Concepto de microlotes

Los microlotes pueden equilibrar ambos objetivos: ofrecen más rendimiento que el procesamiento por elemento y menos latencia que los lotes enormes.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  static void ProcessBatch(List<int> batch)
  {
    Thread.SpinWait(15000); // small shared overhead
    for (int i = 0; i < batch.Count; i++) Thread.SpinWait(2000);
  }

  public static void Main(string[] args)
  {
    int n = 200;
    int micro = 5; // micro-batch size
    List<int> buf = new List<int>(micro);
    Stopwatch sw = Stopwatch.StartNew();

    for (int i = 0; i < n; i++)
    {
      buf.Add(i);
      if (buf.Count == micro)
      {
        ProcessBatch(buf);
        buf.Clear(); // emit more frequently than big batches
      }
    }
    if (buf.Count > 0) ProcessBatch(buf);

    sw.Stop();
    Console.WriteLine("Micro-batch (size={0}): {1} ms", micro, sw.ElapsedMilliseconds);
  }
}

Consejos de ajuste

Guía de ajuste:

  • Medir tanto ms/item como items/sec
  • Probar primero con microlotes
  • Aumentar el paralelismo gradualmente; observar la CPU y los cambios de contexto
  • Limitar las colas para evitar esperas prolongadas y el crecimiento de la memoria

Compromiso entre rendimiento y latencia

Comprobación rápida: ¿Qué cambio suele mejorar el rendimiento, pero puede aumentar la latencia por elemento?

Resumen

Resumen: Por elemento = baja latencia y menor rendimiento. Lotes grandes o un DOP alto = mayor rendimiento y mayor latencia. Los microlotes y un ajuste cuidadoso del DOP ayudan a equilibrar ambos aspectos.

Preguntas frecuentes

¿La lección «Compromisos entre throughput y latencia» es gratis?

Sí — el texto completo de «Compromisos entre throughput y latencia» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Compromisos entre throughput y latencia»?

Equilibre el trabajo total por segundo (throughput) frente al tiempo por elemento (latencia): compare el procesamiento individual, el procesamiento por lotes y el ajuste del grado de paralelismo. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Compromisos entre throughput y latencia»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Parallel.ForEach y PLINQ
  2. Productor/consumidor con Channels (visión general)
  3. Compromisos entre throughput y latencia
← Volver a C# Academy