Exercice – Apprivoiser la multiprogrammation (solutionnaire)

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

      const int N = 25_000;
      var tab = CréerTableau(N * N);
      for(int i = 1; i <= 16; ++i)
      {
         var (r0, dt0) = Tester(() => CompterSiMT(tab, n => n % 2 != 0, i));
         if(i < 10) // bof, mais je ne me souviens plus du code de formatage...
            Console.WriteLine($"Compté {r0} impairs avec  {i} fils en {dt0} ms");
         else
            Console.WriteLine($"Compté {r0} impairs avec {i} fils en {dt0} ms");
      }

static short[] CréerTableau(int n)
{
   short[] tab = new short[n];
   for (int i = 0; i != tab.Length; ++i)
      tab[i] = (short)(i * 2 + 1);
   return tab;
}
static (T rés, long dt) Tester<T>(Func<T> f)
{
   var sw = new Stopwatch();
   sw.Start();
   T rés = f();
   sw.Stop();
   return (rés, sw.ElapsedMilliseconds);
}

static int CompterSiMT(short[] tab, Func<short, bool> pred, int nthrs)
{
   var thrs = new Thread[nthrs-1]; // initialisés à null en C#
   var nimpairs = new int[nthrs]; // initialisés à 0 en C#
   int tailleBloc = tab.Length / nthrs;
   for(int i = 0; i < thrs.Length; ++i)
   {
      int monIndice = i;
      int début = i * tailleBloc; // inclus
      int fin = (i + 1) * tailleBloc; // exclue
      thrs[i] = new Thread(() =>
      {
         int m = 0;
         for (; début != fin; ++début)
            if (pred(tab[début]))
               ++m;
         nimpairs[monIndice] = m;
         //for (; début != fin; ++début)
         //   if (pred(tab[début]))
         //      ++nimpairs[monIndice];
      });
   }
   foreach (var th in thrs)
      th.Start();
   {
      int début = (nthrs - 1) * tailleBloc; // inclus
      int fin = tab.Length; // exclue
      int m = 0;
      for (; début != fin; ++début)
         if (pred(tab[début]))
            ++m;
      nimpairs[nthrs - 1] = m;
      //for (; début != fin; ++début)
      //   if (pred(tab[début]))
      //      ++nimpairs[nthrs - 1];
   }
   foreach (var th in thrs)
      th.Join();
   int cumul = 0;
   foreach (int n in nimpairs)
      cumul += n;
   return cumul;
}

// ...
class ZoneTransit<T>
{
   List<T> Data { get; } = new List<T>();
   object mutex = new object();
   public void Ajouter(List<T> elems)
   {
      lock (mutex)
         Data.AddRange(elems);
   }
   public List<T> Extraire()
   {
      var temp = new List<T>();
      lock (mutex)
      {
         temp.AddRange(Data);
         Data.Clear();
      }
      return temp;
   }
}
// ...

// ...
static void Permuter<T>(ref T a, ref T b)
{
   T temp = a;
   a = b;
   b = temp;
}
class ZoneTransit<T>
{
   List<T> data = new List<T>();
   object mutex = new object();
   public void Ajouter(List<T> elems)
   {
      lock (mutex)
         data.AddRange(elems);
   }
   public List<T> Extraire()
   {
      var temp = new List<T>();
      lock (mutex)
         Permuter(ref temp, ref data);
      return temp;
   }
}
// ...

const int N = 1_000_000;
{
   var zt = new ZoneTransit<string>();
   string msg = "J'aime mon prof";
   var (r0, dt0) = Tester(() =>
   {
      for (int i = 0; i != N; ++i)
         zt.Ajouter(msg);
      return zt;
   });
   Console.WriteLine($"Ajout un à un : {dt0} ms");
}
{
   var zt = new ZoneTransit<string>();
   string msg = "J'aime mon prof";
   var (r0, dt0) = Tester(() =>
   {
      var lst = new List<string>();
      for (int i = 0; i != N; ++i)
         lst.Add(msg);
      zt.Ajouter(lst);
      return zt;
   });
   Console.WriteLine($"Ajout en bloc : {dt0} ms");
}

// ...
static void Permuter<T>(ref T a, ref T b)
{
   T temp = a;
   a = b;
   b = temp;
}

static (T rés, long dt) Tester<T>(Func<T> f)
{
   var sw = new Stopwatch();
   sw.Start();
   T rés = f();
   sw.Stop();
   return (rés, sw.ElapsedMilliseconds);
}

class ZoneVideException : Exception { }

class ZoneTransit<T>
{
   List<T> data = new ();
   object mutex = new ();
   public void Ajouter(List<T> elems)
   {
      lock (mutex)
         data.AddRange(elems);
   }
   public List<T> Extraire()
   {
      var temp = new List<T>();
      lock (mutex)
         Permuter(ref temp, ref data);
      return temp;
   }
   // EX01.0 : est-ce une bonne idée?
   public void Ajouter(T elem)
   {
      lock (mutex)
         data.Add(elem);
   }
   public T ExtraireUn()
   {
      lock (mutex)
      {
         if (data.Count == 0)
            throw new ZoneVideException();
         T elem = data[0];
         data.RemoveAt(0);
         return elem;
      }
   }
   public int Count
   {
      get
      {
         lock (mutex)
            return data.Count;
      }
   }
   public bool EstVide => Count == 0;
}
// ...