udnyttelse af tråde på den multi processor maskiner

En multitrådet process kan udnytte flere processorer hvis styre systemet understøtter det.

Og Windows NT/2000/XP/2003/Vista/2008 understøtter det.

Ligesom Linux, MacOS X, diverse Unix etc.etc..

Ok, så er der jo ikke mere i det spørgsmål - lægger du et svar? og tak, selvfølgelig

svar

Hvis du vil have en praktisk demo, så har jeg en multithreaded quicksort der kan vise det (forudsætter naturligvis at du har en multi processor men multi core er jo standard idag).

Takker, jeg tror jeg springer din quicksort over idag, men tak for tilbuddet

Jeg vil gerne have en demo, hvis du stadig ligger inde med den :)

using System;
using System.Threading;

namespace E
{
  public class ThreadSort
  {
      private const int N = 10000000;
      private const int REP = 3;
      public static void Main(String[] args)
      {
          Random rng = new Random(1234567);
          int[] ia = new int[N];
          for (int i = 0; i < ia.Length; i++)
          {
            ia[i] = rng.Next();
          }
          for (int j = 0; j < REP; j++)
          {
            int[] ia1 = (int[]) ia.Clone();
            long t1 = DateTime.Now.Ticks;
            QSInt(ia1);
            long t2 = DateTime.Now.Ticks;
            Console.WriteLine("Single threaded qsort : " + (t2 - t1));
            //Console.WriteLine(ia1[0] + " " + ia1[N / 2] + " " + ia1[N - 1]);
            int[] ia2 = (int[]) ia.Clone();
            long t3 = DateTime.Now.Ticks;
            TQSInt(ia2, 1);
            long t4 = DateTime.Now.Ticks;
            Console.WriteLine("Double threaded qsort : " + (t4 - t3));
            //Console.WriteLine(ia2[0] + " " + ia2[N / 2] + " " + ia2[N - 1]);
            int[] ia3 = (int[]) ia.Clone();
            long t5 = DateTime.Now.Ticks;
            TQSInt(ia3, 2);
            long t6 = DateTime.Now.Ticks;
            Console.WriteLine("Quadrouple threaded qsort : " + (t6 - t5));
            //Console.WriteLine(ia2[0] + " " + ia2[N / 2] + " " + ia2[N - 1]);
          }
      }
      public static void QSInt(int[] ia)
      {
          QSInt_help(0, ia.Length - 1, ia);
          return;
      }
      public static void QSInt_help(int n1, int n2, int[] ia)
      {
          int tmp;
          int l = n1;
          int r = n2;
          int pivot = ia[(n1 + n2) / 2];
          do
          {
            while (ia[l] < pivot)
                l++;
            while (ia[r] > pivot)
                r--;
            if (l <= r)
            {
                tmp = ia[l];
                ia[l] = ia[r];
                ia[r] = tmp;
                l++;
                r--;
            }
          }
          while (l <= r);
          if (n1 < r)
            QSInt_help(n1, r, ia);
          if (l < n2)
            QSInt_help(l, n2, ia);
          return;
      }
      public static void TQSInt(int[] ia, int tdepth)
      {
          TQSInt_help(0, ia.Length - 1, ia, 0, tdepth);
          return;
      }
      public static void TQSInt_help(int n1, int n2, int[] ia, int depth, int tdepth)
      {
          int tmp;
          int l = n1;
          int r = n2;
          int pivot = ia[(n1 + n2) / 2];
          do
          {
            while (ia[l] < pivot)
                l++;
            while (ia[r] > pivot)
                r--;
            if (l <= r) {
                tmp = ia[l];
                ia[l] = ia[r];
                ia[r] = tmp;
                l++;
                r--;
            }
          }
          while (l <= r);
          if (depth >= tdepth)
          {
            if (n1 < r)
                TQSInt_help(n1, r, ia, depth + 1, tdepth);
            if (l < n2)
                TQSInt_help(l, n2, ia, depth + 1, tdepth);
          }
          else
          {
            Thread h1 = new Thread(new ThreadStart((new ThreadSortHelp(n1, r, ia, depth + 1, tdepth)).Run));
            Thread h2 = new Thread(new ThreadStart((new ThreadSortHelp(l, n2, ia, depth + 1, tdepth)).Run));
            h1.Start();
            h2.Start();
            h1.Join();
            h2.Join();
          }
          return;
      }
    }
   
    public class ThreadSortHelp
    {
      private int n1;
      private int n2;
      private int[] ia;
      private int depth;
      private int tdepth;
      public ThreadSortHelp(int n1, int n2, int[] ia, int depth, int tdepth)
      {
          this.n1 = n1;
          this.n2 = n2;
          this.ia = ia;
          this.depth = depth;
          this.tdepth = tdepth;
      }
      public void Run()
      {
          ThreadSort.TQSInt_help(n1, n2, ia, depth, tdepth);
      }
    }
}

Fra .NET 2.0 kunne koden bruge generics.

Fra .NET 4.0 kan kode bruge det nye parallel framework.

Men formaalet var kun at vise at man kan udnytte flere CPU'er/kerner.