0Pricing
C# Academy · Leçon

Compromis entre débit et latence

Équilibrez le travail total par seconde (débit) et le temps par élément (latence) : comparez le traitement élément par élément, le traitement par lots et le réglage du degré de parallélisme.

Compromis entre débit et latence est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Débit et latence

Définitions :

  • Débit : nombre d’éléments par seconde
  • Latence : temps nécessaire pour terminer un élément
  • Compromis : le traitement par lots et un parallélisme accru peuvent augmenter le débit, mais retarder les éléments individuels

Traitement élément par élément

Traitez chaque élément dès son arrivée : l’attente par élément est minimale, mais les frais supplémentaires se répètent pour chaque élément.

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);
  }
}

Traitement par lots

Le traitement par lots réduit les frais supplémentaires répétés et augmente le débit, mais les premiers éléments attendent que le lot soit rempli, ce qui augmente la latence.

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);
  }
}

Réglage du parallélisme

Le réglage de MaxDegreeOfParallelism peut augmenter le débit des travaux limités par le CPU ; une valeur trop élevée peut le réduire en raison des changements de contexte.

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);
    }
  }
}

Principe des micro-lots

Les micro-lots peuvent concilier les deux objectifs : un meilleur débit que le traitement élément par élément et une latence plus faible que celle de lots très volumineux.

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);
  }
}

Conseils de réglage

Guide de réglage :

  • Mesurez à la fois les ms/élément et les éléments/s
  • Essayez d’abord les micro-lots
  • Augmentez progressivement le parallélisme ; surveillez le CPU et les changements de contexte
  • Limitez les files d’attente pour éviter les longues attentes et la croissance de la mémoire

Compromis entre débit et latence

Vérification rapide : quelle modification améliore généralement le débit, mais peut augmenter la latence par élément ?

Récapitulatif

Récapitulatif : élément par élément = faible latence, débit inférieur. Gros lots/degré de parallélisme élevé = débit supérieur, latence supérieure. Les micro-lots et un réglage prudent du DOP aident à équilibrer les deux.

Questions Fréquemment Posées

La leçon « Compromis entre débit et latence » est-elle gratuite ?

Oui — le texte complet de « Compromis entre débit et latence » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Compromis entre débit et latence » ?

Équilibrez le travail total par seconde (débit) et le temps par élément (latence) : comparez le traitement élément par élément, le traitement par lots et le réglage du degré de parallélisme. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.

Combien de temps prend la leçon « Compromis entre débit et latence » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Parallel.ForEach et PLINQ
  2. Producteur/consommateur avec Channels (vue d’ensemble)
  3. Compromis entre débit et latence
← Retour à C# Academy